From b5e659f09f19602a3fc4c0c2f8fab46cd326bf45 Mon Sep 17 00:00:00 2001 From: Jeff Date: Sun, 22 Oct 2023 14:48:34 -0400 Subject: [PATCH] Implement random tools --- examples/clue_solver.ds | 2 +- src/abstract_tree/tool.rs | 26 + tree-sitter-dust/grammar.js | 6 + tree-sitter-dust/src/grammar.json | 16 + tree-sitter-dust/src/node-types.json | 16 + tree-sitter-dust/src/parser.c | 3606 +++++++++++++------------- 6 files changed, 1928 insertions(+), 1744 deletions(-) diff --git a/examples/clue_solver.ds b/examples/clue_solver.ds index 21833bf..0e3ba97 100644 --- a/examples/clue_solver.ds +++ b/examples/clue_solver.ds @@ -15,7 +15,7 @@ remove_card = function { } } - if removed == 'empty' { + if (type removed) == 'empty' { (output 'Card not found.') } } diff --git a/src/abstract_tree/tool.rs b/src/abstract_tree/tool.rs index de15ba7..3f44124 100644 --- a/src/abstract_tree/tool.rs +++ b/src/abstract_tree/tool.rs @@ -5,6 +5,7 @@ use std::{ process::Command, }; +use rand::{random, thread_rng, Rng}; use serde::{Deserialize, Serialize}; use tree_sitter::Node; @@ -40,6 +41,12 @@ pub enum Tool { Raw(Vec), Sh(Vec), Zsh(Vec), + + // Random + Random(Vec), + RandomBoolean, + RandomInteger, + RandomFloat, } impl AbstractTree for Tool { @@ -188,6 +195,14 @@ impl AbstractTree for Tool { Tool::Zsh(expressions) } + "random" => { + let expressions = parse_expressions(source, node)?; + + Tool::Random(expressions) + } + "random_boolean" => Tool::RandomBoolean, + "random_float" => Tool::RandomFloat, + "random_integer" => Tool::RandomInteger, _ => { return Err(Error::UnexpectedSyntaxNode { expected: "built-in tool", @@ -460,6 +475,17 @@ impl AbstractTree for Tool { Ok(Value::String(String::from_utf8(output)?)) } + Tool::Random(expressions) => { + let range = 0..expressions.len(); + let random_index = thread_rng().gen_range(range); + let random_expression = expressions.get(random_index).unwrap(); + let value = random_expression.run(source, context)?; + + Ok(value) + } + Tool::RandomBoolean => Ok(Value::Boolean(random())), + Tool::RandomFloat => Ok(Value::Float(random())), + Tool::RandomInteger => Ok(Value::Integer(random())), } } } diff --git a/tree-sitter-dust/grammar.js b/tree-sitter-dust/grammar.js index d6f00af..cca9b0d 100644 --- a/tree-sitter-dust/grammar.js +++ b/tree-sitter-dust/grammar.js @@ -287,6 +287,12 @@ module.exports = grammar({ 'raw', 'sh', 'zsh', + + // Random + 'random', + 'random_boolean', + 'random_float', + 'random_integer', ), } }); \ No newline at end of file diff --git a/tree-sitter-dust/src/grammar.json b/tree-sitter-dust/src/grammar.json index a2543aa..b551543 100644 --- a/tree-sitter-dust/src/grammar.json +++ b/tree-sitter-dust/src/grammar.json @@ -1149,6 +1149,22 @@ { "type": "STRING", "value": "zsh" + }, + { + "type": "STRING", + "value": "random" + }, + { + "type": "STRING", + "value": "random_boolean" + }, + { + "type": "STRING", + "value": "random_float" + }, + { + "type": "STRING", + "value": "random_integer" } ] } diff --git a/tree-sitter-dust/src/node-types.json b/tree-sitter-dust/src/node-types.json index 3c48841..7b5b629 100644 --- a/tree-sitter-dust/src/node-types.json +++ b/tree-sitter-dust/src/node-types.json @@ -821,6 +821,22 @@ "type": "output_error", "named": false }, + { + "type": "random", + "named": false + }, + { + "type": "random_boolean", + "named": false + }, + { + "type": "random_float", + "named": false + }, + { + "type": "random_integer", + "named": false + }, { "type": "raw", "named": false diff --git a/tree-sitter-dust/src/parser.c b/tree-sitter-dust/src/parser.c index 2f1bfa3..71d3307 100644 --- a/tree-sitter-dust/src/parser.c +++ b/tree-sitter-dust/src/parser.c @@ -8,9 +8,9 @@ #define LANGUAGE_VERSION 14 #define STATE_COUNT 262 #define LARGE_STATE_COUNT 2 -#define SYMBOL_COUNT 108 +#define SYMBOL_COUNT 112 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 68 +#define TOKEN_COUNT 72 #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 0 #define MAX_ALIAS_SEQUENCE_LENGTH 9 @@ -84,46 +84,50 @@ enum { anon_sym_raw = 65, anon_sym_sh = 66, anon_sym_zsh = 67, - sym_root = 68, - sym_item = 69, - sym_statement = 70, - sym_comment = 71, - sym_expression = 72, - sym__expression_kind = 73, - sym_value = 74, - sym_boolean = 75, - sym_list = 76, - sym_function = 77, - sym_table = 78, - sym_map = 79, - sym_math = 80, - sym_math_operator = 81, - sym_logic = 82, - sym_logic_operator = 83, - sym_assignment = 84, - sym_assignment_operator = 85, - sym_if_else = 86, - sym_if = 87, - sym_else_if = 88, - sym_else = 89, - sym_function_call = 90, - sym_while = 91, - sym_for = 92, - sym_transform = 93, - sym_filter = 94, - sym_find = 95, - sym_remove = 96, - sym_select = 97, - sym_insert = 98, - sym_async = 99, - sym_tool = 100, - sym__tool_kind = 101, - aux_sym_root_repeat1 = 102, - aux_sym_item_repeat1 = 103, - aux_sym_list_repeat1 = 104, - aux_sym_function_repeat1 = 105, - aux_sym_map_repeat1 = 106, - aux_sym_if_else_repeat1 = 107, + anon_sym_random = 68, + anon_sym_random_boolean = 69, + anon_sym_random_float = 70, + anon_sym_random_integer = 71, + sym_root = 72, + sym_item = 73, + sym_statement = 74, + sym_comment = 75, + sym_expression = 76, + sym__expression_kind = 77, + sym_value = 78, + sym_boolean = 79, + sym_list = 80, + sym_function = 81, + sym_table = 82, + sym_map = 83, + sym_math = 84, + sym_math_operator = 85, + sym_logic = 86, + sym_logic_operator = 87, + sym_assignment = 88, + sym_assignment_operator = 89, + sym_if_else = 90, + sym_if = 91, + sym_else_if = 92, + sym_else = 93, + sym_function_call = 94, + sym_while = 95, + sym_for = 96, + sym_transform = 97, + sym_filter = 98, + sym_find = 99, + sym_remove = 100, + sym_select = 101, + sym_insert = 102, + sym_async = 103, + sym_tool = 104, + sym__tool_kind = 105, + aux_sym_root_repeat1 = 106, + aux_sym_item_repeat1 = 107, + aux_sym_list_repeat1 = 108, + aux_sym_function_repeat1 = 109, + aux_sym_map_repeat1 = 110, + aux_sym_if_else_repeat1 = 111, }; static const char * const ts_symbol_names[] = { @@ -195,6 +199,10 @@ static const char * const ts_symbol_names[] = { [anon_sym_raw] = "raw", [anon_sym_sh] = "sh", [anon_sym_zsh] = "zsh", + [anon_sym_random] = "random", + [anon_sym_random_boolean] = "random_boolean", + [anon_sym_random_float] = "random_float", + [anon_sym_random_integer] = "random_integer", [sym_root] = "root", [sym_item] = "item", [sym_statement] = "statement", @@ -306,6 +314,10 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_raw] = anon_sym_raw, [anon_sym_sh] = anon_sym_sh, [anon_sym_zsh] = anon_sym_zsh, + [anon_sym_random] = anon_sym_random, + [anon_sym_random_boolean] = anon_sym_random_boolean, + [anon_sym_random_float] = anon_sym_random_float, + [anon_sym_random_integer] = anon_sym_random_integer, [sym_root] = sym_root, [sym_item] = sym_item, [sym_statement] = sym_statement, @@ -621,6 +633,22 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_random] = { + .visible = true, + .named = false, + }, + [anon_sym_random_boolean] = { + .visible = true, + .named = false, + }, + [anon_sym_random_float] = { + .visible = true, + .named = false, + }, + [anon_sym_random_integer] = { + .visible = true, + .named = false, + }, [sym_root] = { .visible = true, .named = true, @@ -803,29 +831,29 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [8] = 8, [9] = 5, [10] = 6, - [11] = 6, + [11] = 11, [12] = 8, [13] = 5, - [14] = 14, + [14] = 11, [15] = 15, - [16] = 16, + [16] = 8, [17] = 17, [18] = 18, [19] = 19, - [20] = 8, + [20] = 11, [21] = 21, [22] = 22, [23] = 23, - [24] = 16, + [24] = 24, [25] = 25, [26] = 26, - [27] = 27, - [28] = 28, + [27] = 26, + [28] = 26, [29] = 29, - [30] = 26, + [30] = 30, [31] = 31, - [32] = 31, - [33] = 31, + [32] = 29, + [33] = 33, [34] = 34, [35] = 35, [36] = 36, @@ -915,15 +943,15 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [120] = 110, [121] = 111, [122] = 122, - [123] = 34, + [123] = 35, [124] = 37, [125] = 36, - [126] = 35, + [126] = 34, [127] = 54, [128] = 36, - [129] = 35, + [129] = 34, [130] = 53, - [131] = 34, + [131] = 35, [132] = 132, [133] = 56, [134] = 44, @@ -932,40 +960,40 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [137] = 137, [138] = 55, [139] = 139, - [140] = 43, + [140] = 50, [141] = 51, - [142] = 50, - [143] = 38, + [142] = 52, + [143] = 39, [144] = 48, [145] = 49, [146] = 45, - [147] = 46, + [147] = 43, [148] = 148, [149] = 42, [150] = 150, - [151] = 40, + [151] = 38, [152] = 47, - [153] = 39, + [153] = 41, [154] = 154, [155] = 155, - [156] = 41, - [157] = 52, - [158] = 50, + [156] = 46, + [157] = 40, + [158] = 52, [159] = 51, [160] = 42, - [161] = 40, - [162] = 43, + [161] = 38, + [162] = 50, [163] = 45, [164] = 49, [165] = 47, [166] = 48, - [167] = 46, + [167] = 43, [168] = 44, [169] = 169, - [170] = 38, - [171] = 39, - [172] = 52, - [173] = 41, + [170] = 39, + [171] = 41, + [172] = 40, + [173] = 46, [174] = 174, [175] = 174, [176] = 174, @@ -1553,395 +1581,471 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { if (lookahead == 't') ADVANCE(57); END_STATE(); case 29: - if (lookahead == 'w') ADVANCE(58); + if (lookahead == 'n') ADVANCE(58); + if (lookahead == 'w') ADVANCE(59); END_STATE(); case 30: - if (lookahead == 'a') ADVANCE(59); - if (lookahead == 'm') ADVANCE(60); + if (lookahead == 'a') ADVANCE(60); + if (lookahead == 'm') ADVANCE(61); END_STATE(); case 31: - if (lookahead == 'l') ADVANCE(61); + if (lookahead == 'l') ADVANCE(62); END_STATE(); case 32: ACCEPT_TOKEN(anon_sym_sh); END_STATE(); case 33: - if (lookahead == 'b') ADVANCE(62); + if (lookahead == 'b') ADVANCE(63); END_STATE(); case 34: - if (lookahead == '_') ADVANCE(63); + if (lookahead == '_') ADVANCE(64); END_STATE(); case 35: - if (lookahead == 'a') ADVANCE(64); - if (lookahead == 'u') ADVANCE(65); + if (lookahead == 'a') ADVANCE(65); + if (lookahead == 'u') ADVANCE(66); END_STATE(); case 36: - if (lookahead == 'p') ADVANCE(66); + if (lookahead == 'p') ADVANCE(67); END_STATE(); case 37: - if (lookahead == 'i') ADVANCE(67); - END_STATE(); - case 38: if (lookahead == 'i') ADVANCE(68); END_STATE(); + case 38: + if (lookahead == 'i') ADVANCE(69); + END_STATE(); case 39: - if (lookahead == 'h') ADVANCE(69); + if (lookahead == 'h') ADVANCE(70); END_STATE(); case 40: - if (lookahead == 'e') ADVANCE(70); - END_STATE(); - case 41: if (lookahead == 'e') ADVANCE(71); END_STATE(); + case 41: + if (lookahead == 'e') ADVANCE(72); + END_STATE(); case 42: - if (lookahead == 'n') ADVANCE(72); + if (lookahead == 'n') ADVANCE(73); END_STATE(); case 43: - if (lookahead == 'h') ADVANCE(73); + if (lookahead == 'h') ADVANCE(74); END_STATE(); case 44: - if (lookahead == 's') ADVANCE(74); + if (lookahead == 's') ADVANCE(75); END_STATE(); case 45: - if (lookahead == 't') ADVANCE(75); + if (lookahead == 't') ADVANCE(76); END_STATE(); case 46: - if (lookahead == 'd') ADVANCE(76); + if (lookahead == 'd') ADVANCE(77); END_STATE(); case 47: - if (lookahead == 'h') ADVANCE(77); + if (lookahead == 'h') ADVANCE(78); END_STATE(); case 48: ACCEPT_TOKEN(anon_sym_for); END_STATE(); case 49: - if (lookahead == 'm') ADVANCE(78); + if (lookahead == 'm') ADVANCE(79); END_STATE(); case 50: - if (lookahead == 'c') ADVANCE(79); + if (lookahead == 'c') ADVANCE(80); END_STATE(); case 51: - if (lookahead == 'p') ADVANCE(80); + if (lookahead == 'p') ADVANCE(81); END_STATE(); case 52: - if (lookahead == 'e') ADVANCE(81); + if (lookahead == 'e') ADVANCE(82); END_STATE(); case 53: - if (lookahead == 'o') ADVANCE(82); + if (lookahead == 'o') ADVANCE(83); END_STATE(); case 54: - if (lookahead == 'g') ADVANCE(83); + if (lookahead == 'g') ADVANCE(84); END_STATE(); case 55: - if (lookahead == 'a') ADVANCE(84); + if (lookahead == 'a') ADVANCE(85); END_STATE(); case 56: - if (lookahead == 'e') ADVANCE(85); + if (lookahead == 'e') ADVANCE(86); END_STATE(); case 57: - if (lookahead == 'p') ADVANCE(86); + if (lookahead == 'p') ADVANCE(87); END_STATE(); case 58: - ACCEPT_TOKEN(anon_sym_raw); + if (lookahead == 'd') ADVANCE(88); END_STATE(); case 59: - if (lookahead == 'd') ADVANCE(87); + ACCEPT_TOKEN(anon_sym_raw); END_STATE(); case 60: - if (lookahead == 'o') ADVANCE(88); + if (lookahead == 'd') ADVANCE(89); END_STATE(); case 61: - if (lookahead == 'e') ADVANCE(89); + if (lookahead == 'o') ADVANCE(90); END_STATE(); case 62: - if (lookahead == 'l') ADVANCE(90); + if (lookahead == 'e') ADVANCE(91); END_STATE(); case 63: - if (lookahead == 'j') ADVANCE(91); - if (lookahead == 's') ADVANCE(92); + if (lookahead == 'l') ADVANCE(92); END_STATE(); case 64: - if (lookahead == 'n') ADVANCE(93); + if (lookahead == 'j') ADVANCE(93); + if (lookahead == 's') ADVANCE(94); END_STATE(); case 65: - if (lookahead == 'e') ADVANCE(94); + if (lookahead == 'n') ADVANCE(95); END_STATE(); case 66: - if (lookahead == 'e') ADVANCE(95); + if (lookahead == 'e') ADVANCE(96); END_STATE(); case 67: - if (lookahead == 'l') ADVANCE(96); + if (lookahead == 'e') ADVANCE(97); END_STATE(); case 68: - if (lookahead == 't') ADVANCE(97); + if (lookahead == 'l') ADVANCE(98); END_STATE(); case 69: - ACCEPT_TOKEN(anon_sym_zsh); + if (lookahead == 't') ADVANCE(99); END_STATE(); case 70: - if (lookahead == 'n') ADVANCE(98); + ACCEPT_TOKEN(anon_sym_zsh); END_STATE(); case 71: - if (lookahead == 'r') ADVANCE(99); + if (lookahead == 'n') ADVANCE(100); END_STATE(); case 72: - if (lookahead == 'c') ADVANCE(100); + if (lookahead == 'r') ADVANCE(101); END_STATE(); case 73: - ACCEPT_TOKEN(anon_sym_bash); + if (lookahead == 'c') ADVANCE(102); END_STATE(); case 74: - if (lookahead == 'e') ADVANCE(101); + ACCEPT_TOKEN(anon_sym_bash); END_STATE(); case 75: - if (lookahead == 'e') ADVANCE(102); + if (lookahead == 'e') ADVANCE(103); END_STATE(); case 76: - ACCEPT_TOKEN(anon_sym_find); + if (lookahead == 'e') ADVANCE(104); END_STATE(); case 77: - ACCEPT_TOKEN(anon_sym_fish); + ACCEPT_TOKEN(anon_sym_find); END_STATE(); case 78: - ACCEPT_TOKEN(anon_sym_from); - if (lookahead == '_') ADVANCE(103); + ACCEPT_TOKEN(anon_sym_fish); END_STATE(); case 79: - if (lookahead == 't') ADVANCE(104); + ACCEPT_TOKEN(anon_sym_from); + if (lookahead == '_') ADVANCE(105); END_STATE(); case 80: - ACCEPT_TOKEN(anon_sym_help); - END_STATE(); - case 81: - if (lookahead == 'r') ADVANCE(105); - END_STATE(); - case 82: - ACCEPT_TOKEN(anon_sym_into); - END_STATE(); - case 83: if (lookahead == 't') ADVANCE(106); END_STATE(); + case 81: + ACCEPT_TOKEN(anon_sym_help); + END_STATE(); + case 82: + if (lookahead == 'r') ADVANCE(107); + END_STATE(); + case 83: + ACCEPT_TOKEN(anon_sym_into); + END_STATE(); case 84: - if (lookahead == 'd') ADVANCE(107); + if (lookahead == 't') ADVANCE(108); END_STATE(); case 85: - ACCEPT_TOKEN(anon_sym_move); + if (lookahead == 'd') ADVANCE(109); END_STATE(); case 86: - if (lookahead == 'u') ADVANCE(108); + ACCEPT_TOKEN(anon_sym_move); END_STATE(); case 87: - ACCEPT_TOKEN(anon_sym_read); + if (lookahead == 'u') ADVANCE(110); END_STATE(); case 88: - if (lookahead == 'v') ADVANCE(109); + if (lookahead == 'o') ADVANCE(111); END_STATE(); case 89: - if (lookahead == 'c') ADVANCE(110); + ACCEPT_TOKEN(anon_sym_read); END_STATE(); case 90: - if (lookahead == 'e') ADVANCE(111); + if (lookahead == 'v') ADVANCE(112); END_STATE(); case 91: - if (lookahead == 's') ADVANCE(112); + if (lookahead == 'c') ADVANCE(113); END_STATE(); case 92: - if (lookahead == 't') ADVANCE(113); + if (lookahead == 'e') ADVANCE(114); END_STATE(); case 93: - if (lookahead == 's') ADVANCE(114); + if (lookahead == 's') ADVANCE(115); END_STATE(); case 94: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 't') ADVANCE(116); END_STATE(); case 95: - ACCEPT_TOKEN(anon_sym_type); + if (lookahead == 's') ADVANCE(117); END_STATE(); case 96: - if (lookahead == 'e') ADVANCE(115); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 97: - if (lookahead == 'e') ADVANCE(116); + ACCEPT_TOKEN(anon_sym_type); END_STATE(); case 98: - if (lookahead == 'd') ADVANCE(117); + if (lookahead == 'e') ADVANCE(118); END_STATE(); case 99: - if (lookahead == 't') ADVANCE(118); + if (lookahead == 'e') ADVANCE(119); END_STATE(); case 100: - ACCEPT_TOKEN(anon_sym_async); + if (lookahead == 'd') ADVANCE(120); END_STATE(); case 101: - ACCEPT_TOKEN(anon_sym_false); + if (lookahead == 't') ADVANCE(121); END_STATE(); case 102: - if (lookahead == 'r') ADVANCE(119); + ACCEPT_TOKEN(anon_sym_async); END_STATE(); case 103: - if (lookahead == 'j') ADVANCE(120); + ACCEPT_TOKEN(anon_sym_false); END_STATE(); case 104: - if (lookahead == 'i') ADVANCE(121); + if (lookahead == 'r') ADVANCE(122); END_STATE(); case 105: - if (lookahead == 't') ADVANCE(122); + if (lookahead == 'j') ADVANCE(123); END_STATE(); case 106: - if (lookahead == 'h') ADVANCE(123); + if (lookahead == 'i') ADVANCE(124); END_STATE(); case 107: - if (lookahead == 'a') ADVANCE(124); - END_STATE(); - case 108: if (lookahead == 't') ADVANCE(125); END_STATE(); + case 108: + if (lookahead == 'h') ADVANCE(126); + END_STATE(); case 109: - if (lookahead == 'e') ADVANCE(126); + if (lookahead == 'a') ADVANCE(127); END_STATE(); case 110: - if (lookahead == 't') ADVANCE(127); + if (lookahead == 't') ADVANCE(128); END_STATE(); case 111: - ACCEPT_TOKEN(anon_sym_table); + if (lookahead == 'm') ADVANCE(129); END_STATE(); case 112: - if (lookahead == 'o') ADVANCE(128); + if (lookahead == 'e') ADVANCE(130); END_STATE(); case 113: - if (lookahead == 'r') ADVANCE(129); + if (lookahead == 't') ADVANCE(131); END_STATE(); case 114: - if (lookahead == 'f') ADVANCE(130); + ACCEPT_TOKEN(anon_sym_table); END_STATE(); case 115: - ACCEPT_TOKEN(anon_sym_while); + if (lookahead == 'o') ADVANCE(132); END_STATE(); case 116: - ACCEPT_TOKEN(anon_sym_write); + if (lookahead == 'r') ADVANCE(133); END_STATE(); case 117: - ACCEPT_TOKEN(anon_sym_append); + if (lookahead == 'f') ADVANCE(134); END_STATE(); case 118: - ACCEPT_TOKEN(anon_sym_assert); - if (lookahead == '_') ADVANCE(131); + ACCEPT_TOKEN(anon_sym_while); END_STATE(); case 119: - ACCEPT_TOKEN(anon_sym_filter); + ACCEPT_TOKEN(anon_sym_write); END_STATE(); case 120: - if (lookahead == 's') ADVANCE(132); + ACCEPT_TOKEN(anon_sym_append); END_STATE(); case 121: - if (lookahead == 'o') ADVANCE(133); - END_STATE(); - case 122: - ACCEPT_TOKEN(anon_sym_insert); - END_STATE(); - case 123: - ACCEPT_TOKEN(anon_sym_length); - END_STATE(); - case 124: - if (lookahead == 't') ADVANCE(134); - END_STATE(); - case 125: - ACCEPT_TOKEN(anon_sym_output); + ACCEPT_TOKEN(anon_sym_assert); if (lookahead == '_') ADVANCE(135); END_STATE(); + case 122: + ACCEPT_TOKEN(anon_sym_filter); + END_STATE(); + case 123: + if (lookahead == 's') ADVANCE(136); + END_STATE(); + case 124: + if (lookahead == 'o') ADVANCE(137); + END_STATE(); + case 125: + ACCEPT_TOKEN(anon_sym_insert); + END_STATE(); case 126: - ACCEPT_TOKEN(anon_sym_remove); + ACCEPT_TOKEN(anon_sym_length); END_STATE(); case 127: - ACCEPT_TOKEN(anon_sym_select); + if (lookahead == 't') ADVANCE(138); END_STATE(); case 128: - if (lookahead == 'n') ADVANCE(136); + ACCEPT_TOKEN(anon_sym_output); + if (lookahead == '_') ADVANCE(139); END_STATE(); case 129: - if (lookahead == 'i') ADVANCE(137); + ACCEPT_TOKEN(anon_sym_random); + if (lookahead == '_') ADVANCE(140); END_STATE(); case 130: - if (lookahead == 'o') ADVANCE(138); + ACCEPT_TOKEN(anon_sym_remove); END_STATE(); case 131: - if (lookahead == 'e') ADVANCE(139); + ACCEPT_TOKEN(anon_sym_select); END_STATE(); case 132: - if (lookahead == 'o') ADVANCE(140); - END_STATE(); - case 133: if (lookahead == 'n') ADVANCE(141); END_STATE(); + case 133: + if (lookahead == 'i') ADVANCE(142); + END_STATE(); case 134: - if (lookahead == 'a') ADVANCE(142); + if (lookahead == 'o') ADVANCE(143); END_STATE(); case 135: - if (lookahead == 'e') ADVANCE(143); + if (lookahead == 'e') ADVANCE(144); END_STATE(); case 136: - ACCEPT_TOKEN(anon_sym_to_json); + if (lookahead == 'o') ADVANCE(145); END_STATE(); case 137: - if (lookahead == 'n') ADVANCE(144); + if (lookahead == 'n') ADVANCE(146); END_STATE(); case 138: - if (lookahead == 'r') ADVANCE(145); + if (lookahead == 'a') ADVANCE(147); END_STATE(); case 139: - if (lookahead == 'q') ADVANCE(146); + if (lookahead == 'e') ADVANCE(148); END_STATE(); case 140: - if (lookahead == 'n') ADVANCE(147); + if (lookahead == 'b') ADVANCE(149); + if (lookahead == 'f') ADVANCE(150); + if (lookahead == 'i') ADVANCE(151); END_STATE(); case 141: - ACCEPT_TOKEN(anon_sym_function); + ACCEPT_TOKEN(anon_sym_to_json); END_STATE(); case 142: - ACCEPT_TOKEN(anon_sym_metadata); + if (lookahead == 'n') ADVANCE(152); END_STATE(); case 143: - if (lookahead == 'r') ADVANCE(148); + if (lookahead == 'r') ADVANCE(153); END_STATE(); case 144: - if (lookahead == 'g') ADVANCE(149); + if (lookahead == 'q') ADVANCE(154); END_STATE(); case 145: - if (lookahead == 'm') ADVANCE(150); + if (lookahead == 'n') ADVANCE(155); END_STATE(); case 146: - if (lookahead == 'u') ADVANCE(151); + ACCEPT_TOKEN(anon_sym_function); END_STATE(); case 147: - ACCEPT_TOKEN(anon_sym_from_json); + ACCEPT_TOKEN(anon_sym_metadata); END_STATE(); case 148: - if (lookahead == 'r') ADVANCE(152); - END_STATE(); - case 149: - ACCEPT_TOKEN(anon_sym_to_string); - END_STATE(); - case 150: - ACCEPT_TOKEN(anon_sym_transform); - END_STATE(); - case 151: - if (lookahead == 'a') ADVANCE(153); - END_STATE(); - case 152: - if (lookahead == 'o') ADVANCE(154); - END_STATE(); - case 153: - if (lookahead == 'l') ADVANCE(155); - END_STATE(); - case 154: if (lookahead == 'r') ADVANCE(156); END_STATE(); + case 149: + if (lookahead == 'o') ADVANCE(157); + END_STATE(); + case 150: + if (lookahead == 'l') ADVANCE(158); + END_STATE(); + case 151: + if (lookahead == 'n') ADVANCE(159); + END_STATE(); + case 152: + if (lookahead == 'g') ADVANCE(160); + END_STATE(); + case 153: + if (lookahead == 'm') ADVANCE(161); + END_STATE(); + case 154: + if (lookahead == 'u') ADVANCE(162); + END_STATE(); case 155: - ACCEPT_TOKEN(anon_sym_assert_equal); + ACCEPT_TOKEN(anon_sym_from_json); END_STATE(); case 156: + if (lookahead == 'r') ADVANCE(163); + END_STATE(); + case 157: + if (lookahead == 'o') ADVANCE(164); + END_STATE(); + case 158: + if (lookahead == 'o') ADVANCE(165); + END_STATE(); + case 159: + if (lookahead == 't') ADVANCE(166); + END_STATE(); + case 160: + ACCEPT_TOKEN(anon_sym_to_string); + END_STATE(); + case 161: + ACCEPT_TOKEN(anon_sym_transform); + END_STATE(); + case 162: + if (lookahead == 'a') ADVANCE(167); + END_STATE(); + case 163: + if (lookahead == 'o') ADVANCE(168); + END_STATE(); + case 164: + if (lookahead == 'l') ADVANCE(169); + END_STATE(); + case 165: + if (lookahead == 'a') ADVANCE(170); + END_STATE(); + case 166: + if (lookahead == 'e') ADVANCE(171); + END_STATE(); + case 167: + if (lookahead == 'l') ADVANCE(172); + END_STATE(); + case 168: + if (lookahead == 'r') ADVANCE(173); + END_STATE(); + case 169: + if (lookahead == 'e') ADVANCE(174); + END_STATE(); + case 170: + if (lookahead == 't') ADVANCE(175); + END_STATE(); + case 171: + if (lookahead == 'g') ADVANCE(176); + END_STATE(); + case 172: + ACCEPT_TOKEN(anon_sym_assert_equal); + END_STATE(); + case 173: ACCEPT_TOKEN(anon_sym_output_error); END_STATE(); + case 174: + if (lookahead == 'a') ADVANCE(177); + END_STATE(); + case 175: + ACCEPT_TOKEN(anon_sym_random_float); + END_STATE(); + case 176: + if (lookahead == 'e') ADVANCE(178); + END_STATE(); + case 177: + if (lookahead == 'n') ADVANCE(179); + END_STATE(); + case 178: + if (lookahead == 'r') ADVANCE(180); + END_STATE(); + case 179: + ACCEPT_TOKEN(anon_sym_random_boolean); + END_STATE(); + case 180: + ACCEPT_TOKEN(anon_sym_random_integer); + END_STATE(); default: return false; } @@ -2282,26 +2386,30 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_raw] = ACTIONS(1), [anon_sym_sh] = ACTIONS(1), [anon_sym_zsh] = ACTIONS(1), + [anon_sym_random] = ACTIONS(1), + [anon_sym_random_boolean] = ACTIONS(1), + [anon_sym_random_float] = ACTIONS(1), + [anon_sym_random_integer] = ACTIONS(1), }, [1] = { [sym_root] = STATE(226), [sym_item] = STATE(3), - [sym_statement] = STATE(24), + [sym_statement] = STATE(10), [sym_comment] = STATE(85), [sym_expression] = STATE(56), - [sym__expression_kind] = STATE(39), - [sym_value] = STATE(39), - [sym_boolean] = STATE(41), - [sym_list] = STATE(41), - [sym_function] = STATE(41), - [sym_table] = STATE(41), - [sym_map] = STATE(41), - [sym_math] = STATE(39), - [sym_logic] = STATE(39), + [sym__expression_kind] = STATE(41), + [sym_value] = STATE(41), + [sym_boolean] = STATE(46), + [sym_list] = STATE(46), + [sym_function] = STATE(46), + [sym_table] = STATE(46), + [sym_map] = STATE(46), + [sym_math] = STATE(41), + [sym_logic] = STATE(41), [sym_assignment] = STATE(85), [sym_if_else] = STATE(85), [sym_if] = STATE(60), - [sym_function_call] = STATE(39), + [sym_function_call] = STATE(41), [sym_while] = STATE(85), [sym_for] = STATE(85), [sym_transform] = STATE(85), @@ -2311,9 +2419,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_select] = STATE(85), [sym_insert] = STATE(85), [sym_async] = STATE(85), - [sym_tool] = STATE(39), + [sym_tool] = STATE(41), [aux_sym_root_repeat1] = STATE(3), - [aux_sym_item_repeat1] = STATE(24), + [aux_sym_item_repeat1] = STATE(10), [sym_identifier] = ACTIONS(3), [aux_sym_comment_token1] = ACTIONS(5), [anon_sym_LPAREN] = ACTIONS(7), @@ -2392,16 +2500,16 @@ static const uint16_t ts_small_parse_table[] = { STATE(2), 2, sym_item, aux_sym_root_repeat1, - STATE(24), 2, + STATE(10), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2473,16 +2581,16 @@ static const uint16_t ts_small_parse_table[] = { STATE(2), 2, sym_item, aux_sym_root_repeat1, - STATE(24), 2, + STATE(10), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2555,13 +2663,13 @@ static const uint16_t ts_small_parse_table[] = { STATE(4), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2630,16 +2738,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2696,28 +2804,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_insert, ACTIONS(41), 1, anon_sym_async, + ACTIONS(169), 1, + anon_sym_RBRACE, STATE(56), 1, sym_expression, STATE(60), 1, sym_if, - STATE(235), 1, - sym_item, ACTIONS(11), 2, sym_float, sym_string, ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(4), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2774,7 +2882,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_insert, ACTIONS(41), 1, anon_sym_async, - ACTIONS(169), 1, + ACTIONS(171), 1, anon_sym_RBRACE, STATE(56), 1, sym_expression, @@ -2786,16 +2894,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(18), 2, + STATE(24), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2864,16 +2972,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2942,16 +3050,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -2971,71 +3079,35 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [849] = 27, - ACTIONS(3), 1, - sym_identifier, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(7), 1, - anon_sym_LPAREN, - ACTIONS(9), 1, - sym_integer, - ACTIONS(15), 1, - anon_sym_LBRACK, - ACTIONS(17), 1, - anon_sym_function, - ACTIONS(19), 1, - anon_sym_LBRACE, - ACTIONS(21), 1, - anon_sym_table, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_insert, - ACTIONS(41), 1, - anon_sym_async, + [849] = 8, STATE(56), 1, sym_expression, STATE(60), 1, sym_if, - STATE(211), 1, - sym_item, - ACTIONS(11), 2, - sym_float, - sym_string, - ACTIONS(13), 2, - anon_sym_true, - anon_sym_false, - STATE(16), 2, + STATE(4), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, + ACTIONS(169), 7, + ts_builtin_sym_end, + aux_sym_comment_token1, + anon_sym_LPAREN, + sym_float, + sym_string, + anon_sym_LBRACK, + anon_sym_LBRACE, STATE(85), 12, sym_comment, sym_assignment, @@ -3049,7 +3121,24 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [954] = 27, + ACTIONS(173), 16, + sym_identifier, + sym_integer, + anon_sym_true, + anon_sym_false, + anon_sym_function, + anon_sym_table, + anon_sym_if, + anon_sym_while, + anon_sym_for, + anon_sym_transform, + anon_sym_filter, + anon_sym_find, + anon_sym_remove, + anon_sym_select, + anon_sym_insert, + anon_sym_async, + [916] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3098,16 +3187,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3127,7 +3216,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [1059] = 27, + [1021] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3176,16 +3265,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3205,7 +3294,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [1164] = 27, + [1126] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3254,16 +3343,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3283,7 +3372,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [1269] = 27, + [1231] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3324,7 +3413,7 @@ static const uint16_t ts_small_parse_table[] = { sym_expression, STATE(60), 1, sym_if, - STATE(259), 1, + STATE(211), 1, sym_item, ACTIONS(11), 2, sym_float, @@ -3332,16 +3421,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3361,7 +3450,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [1374] = 27, + [1336] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3410,16 +3499,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3439,319 +3528,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [1479] = 27, - ACTIONS(3), 1, - sym_identifier, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(7), 1, - anon_sym_LPAREN, - ACTIONS(9), 1, - sym_integer, - ACTIONS(15), 1, - anon_sym_LBRACK, - ACTIONS(17), 1, - anon_sym_function, - ACTIONS(19), 1, - anon_sym_LBRACE, - ACTIONS(21), 1, - anon_sym_table, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_insert, - ACTIONS(41), 1, - anon_sym_async, - ACTIONS(171), 1, - anon_sym_RBRACE, - STATE(56), 1, - sym_expression, - STATE(60), 1, - sym_if, - ACTIONS(11), 2, - sym_float, - sym_string, - ACTIONS(13), 2, - anon_sym_true, - anon_sym_false, - STATE(4), 2, - sym_statement, - aux_sym_item_repeat1, - STATE(41), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(39), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - STATE(85), 12, - sym_comment, - sym_assignment, - sym_if_else, - sym_while, - sym_for, - sym_transform, - sym_filter, - sym_find, - sym_remove, - sym_select, - sym_insert, - sym_async, - [1584] = 27, - ACTIONS(3), 1, - sym_identifier, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(7), 1, - anon_sym_LPAREN, - ACTIONS(9), 1, - sym_integer, - ACTIONS(15), 1, - anon_sym_LBRACK, - ACTIONS(17), 1, - anon_sym_function, - ACTIONS(19), 1, - anon_sym_LBRACE, - ACTIONS(21), 1, - anon_sym_table, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_insert, - ACTIONS(41), 1, - anon_sym_async, - STATE(56), 1, - sym_expression, - STATE(60), 1, - sym_if, - STATE(248), 1, - sym_item, - ACTIONS(11), 2, - sym_float, - sym_string, - ACTIONS(13), 2, - anon_sym_true, - anon_sym_false, - STATE(16), 2, - sym_statement, - aux_sym_item_repeat1, - STATE(41), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(39), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - STATE(85), 12, - sym_comment, - sym_assignment, - sym_if_else, - sym_while, - sym_for, - sym_transform, - sym_filter, - sym_find, - sym_remove, - sym_select, - sym_insert, - sym_async, - [1689] = 27, - ACTIONS(3), 1, - sym_identifier, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(7), 1, - anon_sym_LPAREN, - ACTIONS(9), 1, - sym_integer, - ACTIONS(15), 1, - anon_sym_LBRACK, - ACTIONS(17), 1, - anon_sym_function, - ACTIONS(19), 1, - anon_sym_LBRACE, - ACTIONS(21), 1, - anon_sym_table, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_insert, - ACTIONS(41), 1, - anon_sym_async, - ACTIONS(173), 1, - anon_sym_RBRACE, - STATE(56), 1, - sym_expression, - STATE(60), 1, - sym_if, - ACTIONS(11), 2, - sym_float, - sym_string, - ACTIONS(13), 2, - anon_sym_true, - anon_sym_false, - STATE(4), 2, - sym_statement, - aux_sym_item_repeat1, - STATE(41), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(39), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - STATE(85), 12, - sym_comment, - sym_assignment, - sym_if_else, - sym_while, - sym_for, - sym_transform, - sym_filter, - sym_find, - sym_remove, - sym_select, - sym_insert, - sym_async, - [1794] = 27, - ACTIONS(3), 1, - sym_identifier, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(7), 1, - anon_sym_LPAREN, - ACTIONS(9), 1, - sym_integer, - ACTIONS(15), 1, - anon_sym_LBRACK, - ACTIONS(17), 1, - anon_sym_function, - ACTIONS(19), 1, - anon_sym_LBRACE, - ACTIONS(21), 1, - anon_sym_table, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_insert, - ACTIONS(41), 1, - anon_sym_async, - STATE(56), 1, - sym_expression, - STATE(60), 1, - sym_if, - STATE(246), 1, - sym_item, - ACTIONS(11), 2, - sym_float, - sym_string, - ACTIONS(13), 2, - anon_sym_true, - anon_sym_false, - STATE(16), 2, - sym_statement, - aux_sym_item_repeat1, - STATE(41), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(39), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - STATE(85), 12, - sym_comment, - sym_assignment, - sym_if_else, - sym_while, - sym_for, - sym_transform, - sym_filter, - sym_find, - sym_remove, - sym_select, - sym_insert, - sym_async, - [1899] = 27, + [1441] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3800,16 +3577,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3829,7 +3606,319 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2004] = 27, + [1546] = 27, + ACTIONS(3), 1, + sym_identifier, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(7), 1, + anon_sym_LPAREN, + ACTIONS(9), 1, + sym_integer, + ACTIONS(15), 1, + anon_sym_LBRACK, + ACTIONS(17), 1, + anon_sym_function, + ACTIONS(19), 1, + anon_sym_LBRACE, + ACTIONS(21), 1, + anon_sym_table, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, + anon_sym_remove, + ACTIONS(37), 1, + anon_sym_select, + ACTIONS(39), 1, + anon_sym_insert, + ACTIONS(41), 1, + anon_sym_async, + STATE(56), 1, + sym_expression, + STATE(60), 1, + sym_if, + STATE(248), 1, + sym_item, + ACTIONS(11), 2, + sym_float, + sym_string, + ACTIONS(13), 2, + anon_sym_true, + anon_sym_false, + STATE(6), 2, + sym_statement, + aux_sym_item_repeat1, + STATE(46), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(41), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + STATE(85), 12, + sym_comment, + sym_assignment, + sym_if_else, + sym_while, + sym_for, + sym_transform, + sym_filter, + sym_find, + sym_remove, + sym_select, + sym_insert, + sym_async, + [1651] = 27, + ACTIONS(3), 1, + sym_identifier, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(7), 1, + anon_sym_LPAREN, + ACTIONS(9), 1, + sym_integer, + ACTIONS(15), 1, + anon_sym_LBRACK, + ACTIONS(17), 1, + anon_sym_function, + ACTIONS(19), 1, + anon_sym_LBRACE, + ACTIONS(21), 1, + anon_sym_table, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, + anon_sym_remove, + ACTIONS(37), 1, + anon_sym_select, + ACTIONS(39), 1, + anon_sym_insert, + ACTIONS(41), 1, + anon_sym_async, + STATE(56), 1, + sym_expression, + STATE(60), 1, + sym_if, + STATE(259), 1, + sym_item, + ACTIONS(11), 2, + sym_float, + sym_string, + ACTIONS(13), 2, + anon_sym_true, + anon_sym_false, + STATE(6), 2, + sym_statement, + aux_sym_item_repeat1, + STATE(46), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(41), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + STATE(85), 12, + sym_comment, + sym_assignment, + sym_if_else, + sym_while, + sym_for, + sym_transform, + sym_filter, + sym_find, + sym_remove, + sym_select, + sym_insert, + sym_async, + [1756] = 27, + ACTIONS(3), 1, + sym_identifier, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(7), 1, + anon_sym_LPAREN, + ACTIONS(9), 1, + sym_integer, + ACTIONS(15), 1, + anon_sym_LBRACK, + ACTIONS(17), 1, + anon_sym_function, + ACTIONS(19), 1, + anon_sym_LBRACE, + ACTIONS(21), 1, + anon_sym_table, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, + anon_sym_remove, + ACTIONS(37), 1, + anon_sym_select, + ACTIONS(39), 1, + anon_sym_insert, + ACTIONS(41), 1, + anon_sym_async, + STATE(56), 1, + sym_expression, + STATE(60), 1, + sym_if, + STATE(246), 1, + sym_item, + ACTIONS(11), 2, + sym_float, + sym_string, + ACTIONS(13), 2, + anon_sym_true, + anon_sym_false, + STATE(6), 2, + sym_statement, + aux_sym_item_repeat1, + STATE(46), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(41), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + STATE(85), 12, + sym_comment, + sym_assignment, + sym_if_else, + sym_while, + sym_for, + sym_transform, + sym_filter, + sym_find, + sym_remove, + sym_select, + sym_insert, + sym_async, + [1861] = 27, + ACTIONS(3), 1, + sym_identifier, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(7), 1, + anon_sym_LPAREN, + ACTIONS(9), 1, + sym_integer, + ACTIONS(15), 1, + anon_sym_LBRACK, + ACTIONS(17), 1, + anon_sym_function, + ACTIONS(19), 1, + anon_sym_LBRACE, + ACTIONS(21), 1, + anon_sym_table, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, + anon_sym_remove, + ACTIONS(37), 1, + anon_sym_select, + ACTIONS(39), 1, + anon_sym_insert, + ACTIONS(41), 1, + anon_sym_async, + STATE(56), 1, + sym_expression, + STATE(60), 1, + sym_if, + STATE(235), 1, + sym_item, + ACTIONS(11), 2, + sym_float, + sym_string, + ACTIONS(13), 2, + anon_sym_true, + anon_sym_false, + STATE(6), 2, + sym_statement, + aux_sym_item_repeat1, + STATE(46), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(41), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + STATE(85), 12, + sym_comment, + sym_assignment, + sym_if_else, + sym_while, + sym_for, + sym_transform, + sym_filter, + sym_find, + sym_remove, + sym_select, + sym_insert, + sym_async, + [1966] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3878,16 +3967,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3907,7 +3996,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2109] = 27, + [2071] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -3956,16 +4045,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -3985,7 +4074,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2214] = 27, + [2176] = 27, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -4034,16 +4123,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -4063,35 +4152,71 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2319] = 8, + [2281] = 27, + ACTIONS(3), 1, + sym_identifier, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(7), 1, + anon_sym_LPAREN, + ACTIONS(9), 1, + sym_integer, + ACTIONS(15), 1, + anon_sym_LBRACK, + ACTIONS(17), 1, + anon_sym_function, + ACTIONS(19), 1, + anon_sym_LBRACE, + ACTIONS(21), 1, + anon_sym_table, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, + anon_sym_remove, + ACTIONS(37), 1, + anon_sym_select, + ACTIONS(39), 1, + anon_sym_insert, + ACTIONS(41), 1, + anon_sym_async, + ACTIONS(175), 1, + anon_sym_RBRACE, STATE(56), 1, sym_expression, STATE(60), 1, sym_if, + ACTIONS(11), 2, + sym_float, + sym_string, + ACTIONS(13), 2, + anon_sym_true, + anon_sym_false, STATE(4), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - ACTIONS(171), 7, - ts_builtin_sym_end, - aux_sym_comment_token1, - anon_sym_LPAREN, - sym_float, - sym_string, - anon_sym_LBRACK, - anon_sym_LBRACE, STATE(85), 12, sym_comment, sym_assignment, @@ -4105,23 +4230,6 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - ACTIONS(175), 16, - sym_identifier, - sym_integer, - anon_sym_true, - anon_sym_false, - anon_sym_function, - anon_sym_table, - anon_sym_if, - anon_sym_while, - anon_sym_for, - anon_sym_transform, - anon_sym_filter, - anon_sym_find, - anon_sym_remove, - anon_sym_select, - anon_sym_insert, - anon_sym_async, [2386] = 27, ACTIONS(3), 1, sym_identifier, @@ -4171,16 +4279,16 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(16), 2, + STATE(6), 2, sym_statement, aux_sym_item_repeat1, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -4200,7 +4308,199 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2491] = 26, + [2491] = 14, + ACTIONS(177), 1, + sym_identifier, + ACTIONS(179), 1, + anon_sym_LPAREN, + ACTIONS(181), 1, + sym_integer, + ACTIONS(187), 1, + anon_sym_LBRACK, + ACTIONS(189), 1, + anon_sym_function, + ACTIONS(191), 1, + anon_sym_LBRACE, + ACTIONS(193), 1, + anon_sym_table, + STATE(69), 1, + sym__tool_kind, + STATE(169), 1, + sym_expression, + ACTIONS(183), 2, + sym_float, + sym_string, + ACTIONS(185), 2, + anon_sym_true, + anon_sym_false, + STATE(156), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(174), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + ACTIONS(195), 25, + anon_sym_remove, + anon_sym_assert, + anon_sym_assert_equal, + anon_sym_help, + anon_sym_length, + anon_sym_output, + anon_sym_output_error, + anon_sym_type, + anon_sym_append, + anon_sym_metadata, + anon_sym_move, + anon_sym_read, + anon_sym_write, + anon_sym_from_json, + anon_sym_to_json, + anon_sym_to_string, + anon_sym_bash, + anon_sym_fish, + anon_sym_raw, + anon_sym_sh, + anon_sym_zsh, + anon_sym_random, + anon_sym_random_boolean, + anon_sym_random_float, + anon_sym_random_integer, + [2569] = 14, + ACTIONS(179), 1, + anon_sym_LPAREN, + ACTIONS(181), 1, + sym_integer, + ACTIONS(187), 1, + anon_sym_LBRACK, + ACTIONS(189), 1, + anon_sym_function, + ACTIONS(191), 1, + anon_sym_LBRACE, + ACTIONS(193), 1, + anon_sym_table, + ACTIONS(197), 1, + sym_identifier, + STATE(74), 1, + sym__tool_kind, + STATE(169), 1, + sym_expression, + ACTIONS(183), 2, + sym_float, + sym_string, + ACTIONS(185), 2, + anon_sym_true, + anon_sym_false, + STATE(156), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(175), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + ACTIONS(199), 25, + anon_sym_remove, + anon_sym_assert, + anon_sym_assert_equal, + anon_sym_help, + anon_sym_length, + anon_sym_output, + anon_sym_output_error, + anon_sym_type, + anon_sym_append, + anon_sym_metadata, + anon_sym_move, + anon_sym_read, + anon_sym_write, + anon_sym_from_json, + anon_sym_to_json, + anon_sym_to_string, + anon_sym_bash, + anon_sym_fish, + anon_sym_raw, + anon_sym_sh, + anon_sym_zsh, + anon_sym_random, + anon_sym_random_boolean, + anon_sym_random_float, + anon_sym_random_integer, + [2647] = 14, + ACTIONS(179), 1, + anon_sym_LPAREN, + ACTIONS(181), 1, + sym_integer, + ACTIONS(187), 1, + anon_sym_LBRACK, + ACTIONS(189), 1, + anon_sym_function, + ACTIONS(191), 1, + anon_sym_LBRACE, + ACTIONS(193), 1, + anon_sym_table, + ACTIONS(201), 1, + sym_identifier, + STATE(67), 1, + sym__tool_kind, + STATE(169), 1, + sym_expression, + ACTIONS(183), 2, + sym_float, + sym_string, + ACTIONS(185), 2, + anon_sym_true, + anon_sym_false, + STATE(156), 5, + sym_boolean, + sym_list, + sym_function, + sym_table, + sym_map, + STATE(176), 6, + sym__expression_kind, + sym_value, + sym_math, + sym_logic, + sym_function_call, + sym_tool, + ACTIONS(203), 25, + anon_sym_remove, + anon_sym_assert, + anon_sym_assert_equal, + anon_sym_help, + anon_sym_length, + anon_sym_output, + anon_sym_output_error, + anon_sym_type, + anon_sym_append, + anon_sym_metadata, + anon_sym_move, + anon_sym_read, + anon_sym_write, + anon_sym_from_json, + anon_sym_to_json, + anon_sym_to_string, + anon_sym_bash, + anon_sym_fish, + anon_sym_raw, + anon_sym_sh, + anon_sym_zsh, + anon_sym_random, + anon_sym_random_boolean, + anon_sym_random_float, + anon_sym_random_integer, + [2725] = 26, ACTIONS(5), 1, aux_sym_comment_token1, ACTIONS(23), 1, @@ -4219,8 +4519,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_remove, ACTIONS(41), 1, anon_sym_async, - ACTIONS(177), 1, - sym_identifier, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -4233,9 +4531,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(193), 1, anon_sym_table, - ACTIONS(195), 1, + ACTIONS(205), 1, + sym_identifier, + ACTIONS(207), 1, anon_sym_select, - ACTIONS(197), 1, + ACTIONS(209), 1, anon_sym_insert, STATE(60), 1, sym_if, @@ -4275,7 +4575,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2592] = 26, + [2826] = 26, ACTIONS(5), 1, aux_sym_comment_token1, ACTIONS(23), 1, @@ -4294,8 +4594,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_remove, ACTIONS(41), 1, anon_sym_async, - ACTIONS(177), 1, - sym_identifier, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -4308,84 +4606,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(193), 1, anon_sym_table, - ACTIONS(195), 1, - anon_sym_select, - ACTIONS(197), 1, - anon_sym_insert, - STATE(60), 1, - sym_if, - STATE(133), 1, - sym_expression, - STATE(260), 1, - sym_statement, - ACTIONS(183), 2, - sym_float, - sym_string, - ACTIONS(185), 2, - anon_sym_true, - anon_sym_false, - STATE(156), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(153), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - STATE(85), 12, - sym_comment, - sym_assignment, - sym_if_else, - sym_while, - sym_for, - sym_transform, - sym_filter, - sym_find, - sym_remove, - sym_select, - sym_insert, - sym_async, - [2693] = 26, - ACTIONS(5), 1, - aux_sym_comment_token1, - ACTIONS(23), 1, - anon_sym_if, - ACTIONS(25), 1, - anon_sym_while, - ACTIONS(27), 1, - anon_sym_for, - ACTIONS(29), 1, - anon_sym_transform, - ACTIONS(31), 1, - anon_sym_filter, - ACTIONS(33), 1, - anon_sym_find, - ACTIONS(35), 1, - anon_sym_remove, - ACTIONS(41), 1, - anon_sym_async, - ACTIONS(177), 1, + ACTIONS(205), 1, sym_identifier, - ACTIONS(179), 1, - anon_sym_LPAREN, - ACTIONS(181), 1, - sym_integer, - ACTIONS(187), 1, - anon_sym_LBRACK, - ACTIONS(189), 1, - anon_sym_function, - ACTIONS(191), 1, - anon_sym_LBRACE, - ACTIONS(193), 1, - anon_sym_table, - ACTIONS(195), 1, + ACTIONS(207), 1, anon_sym_select, - ACTIONS(197), 1, + ACTIONS(209), 1, anon_sym_insert, STATE(60), 1, sym_if, @@ -4425,7 +4650,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2794] = 26, + [2927] = 26, ACTIONS(5), 1, aux_sym_comment_token1, ACTIONS(23), 1, @@ -4444,8 +4669,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_remove, ACTIONS(41), 1, anon_sym_async, - ACTIONS(177), 1, - sym_identifier, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -4458,9 +4681,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(193), 1, anon_sym_table, - ACTIONS(195), 1, + ACTIONS(205), 1, + sym_identifier, + ACTIONS(207), 1, anon_sym_select, - ACTIONS(197), 1, + ACTIONS(209), 1, anon_sym_insert, STATE(60), 1, sym_if, @@ -4500,7 +4725,7 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2895] = 26, + [3028] = 26, ACTIONS(3), 1, sym_identifier, ACTIONS(5), 1, @@ -4549,13 +4774,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -4575,67 +4800,25 @@ static const uint16_t ts_small_parse_table[] = { sym_select, sym_insert, sym_async, - [2996] = 14, - ACTIONS(179), 1, - anon_sym_LPAREN, - ACTIONS(181), 1, - sym_integer, - ACTIONS(187), 1, - anon_sym_LBRACK, - ACTIONS(189), 1, - anon_sym_function, - ACTIONS(191), 1, - anon_sym_LBRACE, - ACTIONS(193), 1, - anon_sym_table, - ACTIONS(199), 1, - sym_identifier, - STATE(67), 1, - sym__tool_kind, - STATE(169), 1, - sym_expression, - ACTIONS(183), 2, - sym_float, - sym_string, - ACTIONS(185), 2, - anon_sym_true, - anon_sym_false, - STATE(156), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(176), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - ACTIONS(201), 21, + [3129] = 26, + ACTIONS(5), 1, + aux_sym_comment_token1, + ACTIONS(23), 1, + anon_sym_if, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_for, + ACTIONS(29), 1, + anon_sym_transform, + ACTIONS(31), 1, + anon_sym_filter, + ACTIONS(33), 1, + anon_sym_find, + ACTIONS(35), 1, anon_sym_remove, - anon_sym_assert, - anon_sym_assert_equal, - anon_sym_help, - anon_sym_length, - anon_sym_output, - anon_sym_output_error, - anon_sym_type, - anon_sym_append, - anon_sym_metadata, - anon_sym_move, - anon_sym_read, - anon_sym_write, - anon_sym_from_json, - anon_sym_to_json, - anon_sym_to_string, - anon_sym_bash, - anon_sym_fish, - anon_sym_raw, - anon_sym_sh, - anon_sym_zsh, - [3070] = 14, + ACTIONS(41), 1, + anon_sym_async, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -4648,72 +4831,18 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(193), 1, anon_sym_table, - ACTIONS(203), 1, + ACTIONS(205), 1, sym_identifier, - STATE(74), 1, - sym__tool_kind, - STATE(169), 1, - sym_expression, - ACTIONS(183), 2, - sym_float, - sym_string, - ACTIONS(185), 2, - anon_sym_true, - anon_sym_false, - STATE(156), 5, - sym_boolean, - sym_list, - sym_function, - sym_table, - sym_map, - STATE(175), 6, - sym__expression_kind, - sym_value, - sym_math, - sym_logic, - sym_function_call, - sym_tool, - ACTIONS(205), 21, - anon_sym_remove, - anon_sym_assert, - anon_sym_assert_equal, - anon_sym_help, - anon_sym_length, - anon_sym_output, - anon_sym_output_error, - anon_sym_type, - anon_sym_append, - anon_sym_metadata, - anon_sym_move, - anon_sym_read, - anon_sym_write, - anon_sym_from_json, - anon_sym_to_json, - anon_sym_to_string, - anon_sym_bash, - anon_sym_fish, - anon_sym_raw, - anon_sym_sh, - anon_sym_zsh, - [3144] = 14, - ACTIONS(179), 1, - anon_sym_LPAREN, - ACTIONS(181), 1, - sym_integer, - ACTIONS(187), 1, - anon_sym_LBRACK, - ACTIONS(189), 1, - anon_sym_function, - ACTIONS(191), 1, - anon_sym_LBRACE, - ACTIONS(193), 1, - anon_sym_table, ACTIONS(207), 1, - sym_identifier, - STATE(69), 1, - sym__tool_kind, - STATE(169), 1, + anon_sym_select, + ACTIONS(209), 1, + anon_sym_insert, + STATE(60), 1, + sym_if, + STATE(133), 1, sym_expression, + STATE(260), 1, + sym_statement, ACTIONS(183), 2, sym_float, sym_string, @@ -4726,36 +4855,27 @@ static const uint16_t ts_small_parse_table[] = { sym_function, sym_table, sym_map, - STATE(174), 6, + STATE(153), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - ACTIONS(209), 21, - anon_sym_remove, - anon_sym_assert, - anon_sym_assert_equal, - anon_sym_help, - anon_sym_length, - anon_sym_output, - anon_sym_output_error, - anon_sym_type, - anon_sym_append, - anon_sym_metadata, - anon_sym_move, - anon_sym_read, - anon_sym_write, - anon_sym_from_json, - anon_sym_to_json, - anon_sym_to_string, - anon_sym_bash, - anon_sym_fish, - anon_sym_raw, - anon_sym_sh, - anon_sym_zsh, - [3218] = 8, + STATE(85), 12, + sym_comment, + sym_assignment, + sym_if_else, + sym_while, + sym_for, + sym_transform, + sym_filter, + sym_find, + sym_remove, + sym_select, + sym_insert, + sym_async, + [3230] = 8, ACTIONS(219), 1, anon_sym_DASH, STATE(112), 1, @@ -4806,7 +4926,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3277] = 8, + [3289] = 8, ACTIONS(219), 1, anon_sym_DASH, STATE(112), 1, @@ -4857,7 +4977,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3336] = 4, + [3348] = 4, STATE(112), 1, sym_math_operator, STATE(113), 1, @@ -4904,10 +5024,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3387] = 5, + [3399] = 5, ACTIONS(235), 1, anon_sym_EQ, - STATE(30), 1, + STATE(32), 1, sym_assignment_operator, ACTIONS(237), 2, anon_sym_PLUS_EQ, @@ -4951,7 +5071,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3439] = 2, + [3451] = 2, ACTIONS(239), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -4994,7 +5114,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3484] = 2, + [3496] = 2, ACTIONS(243), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5037,7 +5157,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3529] = 2, + [3541] = 2, ACTIONS(247), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5080,7 +5200,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3574] = 2, + [3586] = 2, ACTIONS(251), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5123,7 +5243,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3619] = 2, + [3631] = 2, ACTIONS(255), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5166,7 +5286,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3664] = 2, + [3676] = 2, ACTIONS(259), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5209,7 +5329,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3709] = 2, + [3721] = 2, ACTIONS(263), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5252,7 +5372,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3754] = 2, + [3766] = 2, ACTIONS(267), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5295,7 +5415,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3799] = 2, + [3811] = 2, ACTIONS(271), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5338,7 +5458,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3844] = 2, + [3856] = 2, ACTIONS(275), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5381,7 +5501,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3889] = 2, + [3901] = 2, ACTIONS(279), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5424,7 +5544,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3934] = 2, + [3946] = 2, ACTIONS(283), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5467,7 +5587,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [3979] = 2, + [3991] = 2, ACTIONS(287), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5510,7 +5630,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4024] = 2, + [4036] = 2, ACTIONS(291), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5553,7 +5673,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4069] = 2, + [4081] = 2, ACTIONS(295), 20, ts_builtin_sym_end, aux_sym_comment_token1, @@ -5596,7 +5716,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4114] = 9, + [4126] = 9, ACTIONS(219), 1, anon_sym_DASH, ACTIONS(303), 1, @@ -5645,7 +5765,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4172] = 9, + [4184] = 9, ACTIONS(219), 1, anon_sym_DASH, ACTIONS(309), 1, @@ -5694,7 +5814,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4230] = 8, + [4242] = 8, ACTIONS(219), 1, anon_sym_DASH, STATE(112), 1, @@ -5742,7 +5862,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4286] = 8, + [4298] = 8, ACTIONS(219), 1, anon_sym_DASH, STATE(112), 1, @@ -5790,7 +5910,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4342] = 16, + [4354] = 16, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -5822,13 +5942,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_DASH, anon_sym_PIPE_PIPE, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -5845,7 +5965,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [4413] = 16, + [4425] = 16, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -5877,13 +5997,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_DASH, anon_sym_PIPE_PIPE, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -5900,7 +6020,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [4484] = 16, + [4496] = 16, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -5932,13 +6052,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_DASH, anon_sym_PIPE_PIPE, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, @@ -5955,7 +6075,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [4555] = 6, + [4567] = 6, ACTIONS(331), 1, anon_sym_elseif, ACTIONS(333), 1, @@ -5991,7 +6111,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4597] = 9, + [4609] = 9, ACTIONS(219), 1, anon_sym_DASH, ACTIONS(339), 1, @@ -6030,7 +6150,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_LBRACE, - [4645] = 6, + [4657] = 6, ACTIONS(331), 1, anon_sym_elseif, ACTIONS(333), 1, @@ -6066,7 +6186,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4687] = 4, + [4699] = 4, ACTIONS(349), 1, anon_sym_elseif, STATE(63), 2, @@ -6099,7 +6219,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4724] = 2, + [4736] = 2, ACTIONS(352), 9, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6128,7 +6248,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4755] = 14, + [4767] = 14, ACTIONS(356), 1, sym_identifier, ACTIONS(359), 1, @@ -6156,20 +6276,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(370), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [4810] = 2, + [4822] = 2, ACTIONS(385), 9, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6198,7 +6318,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [4841] = 14, + [4853] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6225,20 +6345,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [4895] = 14, + [4907] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6265,20 +6385,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [4949] = 14, + [4961] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6305,20 +6425,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5003] = 14, + [5015] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6345,20 +6465,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5057] = 14, + [5069] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6385,20 +6505,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5111] = 14, + [5123] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6425,20 +6545,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5165] = 14, + [5177] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6465,20 +6585,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5219] = 14, + [5231] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6505,20 +6625,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5273] = 14, + [5285] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6545,20 +6665,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5327] = 14, + [5339] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6585,20 +6705,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5381] = 14, + [5393] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6625,20 +6745,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5435] = 14, + [5447] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6665,20 +6785,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5489] = 14, + [5501] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6705,20 +6825,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5543] = 14, + [5555] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6745,20 +6865,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5597] = 14, + [5609] = 14, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -6785,20 +6905,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [5651] = 2, + [5663] = 2, ACTIONS(341), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6825,7 +6945,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5680] = 2, + [5692] = 2, ACTIONS(419), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6852,7 +6972,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5709] = 2, + [5721] = 2, ACTIONS(423), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6879,7 +6999,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5738] = 2, + [5750] = 2, ACTIONS(315), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6906,7 +7026,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5767] = 2, + [5779] = 2, ACTIONS(427), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6933,7 +7053,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5796] = 2, + [5808] = 2, ACTIONS(431), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6960,7 +7080,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5825] = 2, + [5837] = 2, ACTIONS(435), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -6987,7 +7107,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5854] = 2, + [5866] = 2, ACTIONS(439), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7014,7 +7134,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5883] = 2, + [5895] = 2, ACTIONS(443), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7041,7 +7161,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5912] = 2, + [5924] = 2, ACTIONS(447), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7068,7 +7188,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5941] = 2, + [5953] = 2, ACTIONS(451), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7095,7 +7215,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5970] = 2, + [5982] = 2, ACTIONS(455), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7122,7 +7242,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [5999] = 2, + [6011] = 2, ACTIONS(459), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7149,7 +7269,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [6028] = 2, + [6040] = 2, ACTIONS(463), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7176,7 +7296,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [6057] = 2, + [6069] = 2, ACTIONS(467), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7203,7 +7323,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [6086] = 2, + [6098] = 2, ACTIONS(471), 8, ts_builtin_sym_end, aux_sym_comment_token1, @@ -7230,7 +7350,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [6115] = 12, + [6127] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7266,7 +7386,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6163] = 12, + [6175] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7302,7 +7422,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6211] = 12, + [6223] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7325,20 +7445,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [6259] = 12, + [6271] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7374,7 +7494,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6307] = 12, + [6319] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7410,7 +7530,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6355] = 12, + [6367] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7446,7 +7566,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6403] = 12, + [6415] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7482,7 +7602,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6451] = 12, + [6463] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7518,7 +7638,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6499] = 12, + [6511] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7541,20 +7661,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [6547] = 12, + [6559] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7590,7 +7710,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6595] = 12, + [6607] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7626,7 +7746,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6643] = 12, + [6655] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7641,7 +7761,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_table, ACTIONS(319), 1, sym_identifier, - STATE(34), 1, + STATE(35), 1, sym_expression, ACTIONS(11), 2, sym_float, @@ -7649,20 +7769,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [6691] = 12, + [6703] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7698,7 +7818,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6739] = 12, + [6751] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7734,7 +7854,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6787] = 12, + [6799] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7757,20 +7877,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [6835] = 12, + [6847] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7785,7 +7905,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_table, ACTIONS(319), 1, sym_identifier, - STATE(35), 1, + STATE(34), 1, sym_expression, ACTIONS(11), 2, sym_float, @@ -7793,20 +7913,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [6883] = 12, + [6895] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7842,7 +7962,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6931] = 12, + [6943] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7878,7 +7998,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [6979] = 12, + [6991] = 12, ACTIONS(477), 1, sym_identifier, ACTIONS(479), 1, @@ -7914,7 +8034,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [7027] = 12, + [7039] = 12, ACTIONS(7), 1, anon_sym_LPAREN, ACTIONS(9), 1, @@ -7937,20 +8057,20 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(13), 2, anon_sym_true, anon_sym_false, - STATE(41), 5, + STATE(46), 5, sym_boolean, sym_list, sym_function, sym_table, sym_map, - STATE(39), 6, + STATE(41), 6, sym__expression_kind, sym_value, sym_math, sym_logic, sym_function_call, sym_tool, - [7075] = 12, + [7087] = 12, ACTIONS(179), 1, anon_sym_LPAREN, ACTIONS(181), 1, @@ -7986,7 +8106,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [7123] = 12, + [7135] = 12, ACTIONS(477), 1, sym_identifier, ACTIONS(479), 1, @@ -8022,7 +8142,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [7171] = 12, + [7183] = 12, ACTIONS(477), 1, sym_identifier, ACTIONS(479), 1, @@ -8058,7 +8178,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [7219] = 12, + [7231] = 12, ACTIONS(477), 1, sym_identifier, ACTIONS(479), 1, @@ -8094,7 +8214,7 @@ static const uint16_t ts_small_parse_table[] = { sym_logic, sym_function_call, sym_tool, - [7267] = 2, + [7279] = 2, ACTIONS(497), 6, aux_sym_comment_token1, anon_sym_LPAREN, @@ -8119,79 +8239,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_select, anon_sym_insert, anon_sym_async, - [7294] = 6, - STATE(110), 1, - sym_logic_operator, - STATE(111), 1, - sym_math_operator, - ACTIONS(215), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(211), 3, - anon_sym_RPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - ACTIONS(217), 5, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(221), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7325] = 5, - ACTIONS(235), 1, - anon_sym_EQ, - STATE(26), 1, - sym_assignment_operator, - ACTIONS(237), 2, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - ACTIONS(233), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(231), 10, - anon_sym_RBRACE, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7354] = 4, - STATE(110), 1, - sym_logic_operator, - STATE(111), 1, - sym_math_operator, - ACTIONS(229), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(227), 14, - anon_sym_RPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7381] = 6, + [7306] = 6, STATE(110), 1, sym_logic_operator, STATE(111), 1, @@ -8216,7 +8264,79 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7412] = 7, + [7337] = 5, + ACTIONS(235), 1, + anon_sym_EQ, + STATE(29), 1, + sym_assignment_operator, + ACTIONS(237), 2, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + ACTIONS(233), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(231), 10, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7366] = 4, + STATE(110), 1, + sym_logic_operator, + STATE(111), 1, + sym_math_operator, + ACTIONS(229), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(227), 14, + anon_sym_RPAREN, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7393] = 6, + STATE(110), 1, + sym_logic_operator, + STATE(111), 1, + sym_math_operator, + ACTIONS(215), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(211), 3, + anon_sym_RPAREN, + anon_sym_LBRACE, + anon_sym_RBRACE, + ACTIONS(217), 5, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(221), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7424] = 7, ACTIONS(305), 1, anon_sym_RBRACE, ACTIONS(309), 1, @@ -8241,7 +8361,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7444] = 4, + [7456] = 4, STATE(120), 1, sym_logic_operator, STATE(121), 1, @@ -8263,57 +8383,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7470] = 7, - ACTIONS(223), 1, - anon_sym_RBRACE, - ACTIONS(225), 1, - sym_identifier, - STATE(120), 1, - sym_logic_operator, - STATE(121), 1, - sym_math_operator, - ACTIONS(215), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_PIPE_PIPE, - ACTIONS(217), 5, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(221), 5, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7502] = 7, - ACTIONS(299), 1, - anon_sym_RBRACE, - ACTIONS(303), 1, - anon_sym_LBRACE, - STATE(110), 1, - sym_logic_operator, - STATE(111), 1, - sym_math_operator, - ACTIONS(215), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(217), 5, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(221), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7534] = 7, + [7482] = 7, ACTIONS(211), 1, anon_sym_RBRACE, ACTIONS(213), 1, @@ -8338,7 +8408,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7566] = 7, + [7514] = 7, + ACTIONS(299), 1, + anon_sym_RBRACE, + ACTIONS(303), 1, + anon_sym_LBRACE, + STATE(110), 1, + sym_logic_operator, + STATE(111), 1, + sym_math_operator, + ACTIONS(215), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(217), 5, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(221), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7546] = 7, + ACTIONS(223), 1, + anon_sym_RBRACE, + ACTIONS(225), 1, + sym_identifier, + STATE(120), 1, + sym_logic_operator, + STATE(121), 1, + sym_math_operator, + ACTIONS(215), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE_PIPE, + ACTIONS(217), 5, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(221), 5, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7578] = 7, ACTIONS(499), 1, sym_identifier, ACTIONS(501), 1, @@ -8363,7 +8483,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7598] = 6, + [7610] = 6, ACTIONS(315), 1, anon_sym_RBRACE, STATE(110), 1, @@ -8386,7 +8506,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7627] = 2, + [7639] = 2, ACTIONS(265), 2, anon_sym_LT, anon_sym_GT, @@ -8405,7 +8525,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7648] = 6, + [7660] = 6, ACTIONS(503), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8428,7 +8548,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7677] = 6, + [7689] = 6, ACTIONS(505), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8451,7 +8571,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7706] = 6, + [7718] = 6, ACTIONS(507), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8474,7 +8594,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7735] = 6, + [7747] = 6, ACTIONS(311), 1, anon_sym_RBRACE, STATE(110), 1, @@ -8497,7 +8617,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7764] = 6, + [7776] = 6, ACTIONS(509), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8520,45 +8640,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7793] = 2, - ACTIONS(261), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(259), 14, - anon_sym_RPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7814] = 2, - ACTIONS(293), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(291), 14, - anon_sym_RPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [7835] = 2, + [7805] = 2, ACTIONS(289), 2, anon_sym_LT, anon_sym_GT, @@ -8577,11 +8659,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7856] = 2, - ACTIONS(241), 2, + [7826] = 2, + ACTIONS(293), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(239), 14, + ACTIONS(291), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8596,7 +8678,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7877] = 2, + [7847] = 2, + ACTIONS(297), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(295), 14, + anon_sym_RPAREN, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7868] = 2, + ACTIONS(245), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(243), 14, + anon_sym_RPAREN, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [7889] = 2, ACTIONS(281), 2, anon_sym_LT, anon_sym_GT, @@ -8615,7 +8735,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7898] = 2, + [7910] = 2, ACTIONS(285), 2, anon_sym_LT, anon_sym_GT, @@ -8634,7 +8754,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7919] = 2, + [7931] = 2, ACTIONS(269), 2, anon_sym_LT, anon_sym_GT, @@ -8653,11 +8773,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7940] = 2, - ACTIONS(273), 2, + [7952] = 2, + ACTIONS(261), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(271), 14, + ACTIONS(259), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8672,7 +8792,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7961] = 6, + [7973] = 6, ACTIONS(511), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8695,7 +8815,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [7990] = 2, + [8002] = 2, ACTIONS(257), 2, anon_sym_LT, anon_sym_GT, @@ -8714,7 +8834,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8011] = 6, + [8023] = 6, ACTIONS(513), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8737,11 +8857,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8040] = 2, - ACTIONS(249), 2, + [8052] = 2, + ACTIONS(241), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(247), 14, + ACTIONS(239), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8756,7 +8876,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8061] = 2, + [8073] = 2, ACTIONS(277), 2, anon_sym_LT, anon_sym_GT, @@ -8775,11 +8895,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8082] = 2, - ACTIONS(245), 2, + [8094] = 2, + ACTIONS(253), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(243), 14, + ACTIONS(251), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8794,7 +8914,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8103] = 6, + [8115] = 6, ACTIONS(515), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8817,7 +8937,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8132] = 6, + [8144] = 6, ACTIONS(517), 1, anon_sym_LBRACE, STATE(110), 1, @@ -8840,11 +8960,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8161] = 2, - ACTIONS(253), 2, + [8173] = 2, + ACTIONS(273), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(251), 14, + ACTIONS(271), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8859,11 +8979,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8182] = 2, - ACTIONS(297), 2, + [8194] = 2, + ACTIONS(249), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(295), 14, + ACTIONS(247), 14, anon_sym_RPAREN, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8878,13 +8998,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8203] = 2, - ACTIONS(289), 4, + [8215] = 2, + ACTIONS(297), 4, sym_identifier, anon_sym_LT, anon_sym_GT, anon_sym_PIPE_PIPE, - ACTIONS(287), 11, + ACTIONS(295), 11, anon_sym_RBRACE, anon_sym_PLUS, anon_sym_DASH, @@ -8896,7 +9016,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8223] = 2, + [8235] = 2, ACTIONS(293), 4, sym_identifier, anon_sym_LT, @@ -8914,7 +9034,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8243] = 2, + [8255] = 2, ACTIONS(257), 4, sym_identifier, anon_sym_LT, @@ -8932,13 +9052,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8263] = 2, - ACTIONS(249), 4, + [8275] = 2, + ACTIONS(241), 4, sym_identifier, anon_sym_LT, anon_sym_GT, anon_sym_PIPE_PIPE, - ACTIONS(247), 11, + ACTIONS(239), 11, anon_sym_RBRACE, anon_sym_PLUS, anon_sym_DASH, @@ -8950,13 +9070,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8283] = 2, - ACTIONS(261), 4, + [8295] = 2, + ACTIONS(289), 4, sym_identifier, anon_sym_LT, anon_sym_GT, anon_sym_PIPE_PIPE, - ACTIONS(259), 11, + ACTIONS(287), 11, anon_sym_RBRACE, anon_sym_PLUS, anon_sym_DASH, @@ -8968,7 +9088,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8303] = 2, + [8315] = 2, ACTIONS(269), 4, sym_identifier, anon_sym_LT, @@ -8986,7 +9106,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8323] = 2, + [8335] = 2, ACTIONS(285), 4, sym_identifier, anon_sym_LT, @@ -9004,7 +9124,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8343] = 2, + [8355] = 2, ACTIONS(277), 4, sym_identifier, anon_sym_LT, @@ -9022,7 +9142,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8363] = 2, + [8375] = 2, ACTIONS(281), 4, sym_identifier, anon_sym_LT, @@ -9040,13 +9160,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8383] = 2, - ACTIONS(273), 4, + [8395] = 2, + ACTIONS(261), 4, sym_identifier, anon_sym_LT, anon_sym_GT, anon_sym_PIPE_PIPE, - ACTIONS(271), 11, + ACTIONS(259), 11, anon_sym_RBRACE, anon_sym_PLUS, anon_sym_DASH, @@ -9058,7 +9178,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8403] = 2, + [8415] = 2, ACTIONS(265), 4, sym_identifier, anon_sym_LT, @@ -9076,7 +9196,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8423] = 5, + [8435] = 5, STATE(110), 1, sym_logic_operator, STATE(111), 1, @@ -9097,25 +9217,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8449] = 2, - ACTIONS(241), 4, - sym_identifier, - anon_sym_LT, - anon_sym_GT, - anon_sym_PIPE_PIPE, - ACTIONS(239), 11, - anon_sym_RBRACE, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [8469] = 2, + [8461] = 2, ACTIONS(245), 4, sym_identifier, anon_sym_LT, @@ -9133,25 +9235,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8489] = 2, - ACTIONS(297), 4, - sym_identifier, - anon_sym_LT, - anon_sym_GT, - anon_sym_PIPE_PIPE, - ACTIONS(295), 11, - anon_sym_RBRACE, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [8509] = 2, + [8481] = 2, ACTIONS(253), 4, sym_identifier, anon_sym_LT, @@ -9169,13 +9253,49 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8529] = 3, + [8501] = 2, + ACTIONS(249), 4, + sym_identifier, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE_PIPE, + ACTIONS(247), 11, + anon_sym_RBRACE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [8521] = 2, + ACTIONS(273), 4, + sym_identifier, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE_PIPE, + ACTIONS(271), 11, + anon_sym_RBRACE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [8541] = 3, ACTIONS(519), 1, anon_sym_RPAREN, - ACTIONS(245), 2, + ACTIONS(253), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(243), 11, + ACTIONS(251), 11, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -9187,13 +9307,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8550] = 3, + [8562] = 3, ACTIONS(521), 1, anon_sym_RPAREN, - ACTIONS(245), 2, + ACTIONS(253), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(243), 11, + ACTIONS(251), 11, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -9205,13 +9325,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8571] = 3, + [8583] = 3, ACTIONS(523), 1, anon_sym_RPAREN, - ACTIONS(245), 2, + ACTIONS(253), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(243), 11, + ACTIONS(251), 11, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -9223,7 +9343,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [8592] = 2, + [8604] = 2, ACTIONS(525), 6, sym_identifier, sym_integer, @@ -9239,7 +9359,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_LBRACE, - [8610] = 2, + [8622] = 2, ACTIONS(529), 5, anon_sym_LPAREN, sym_float, @@ -9253,7 +9373,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_false, anon_sym_function, anon_sym_table, - [8626] = 2, + [8638] = 2, ACTIONS(533), 5, anon_sym_LPAREN, sym_float, @@ -9267,350 +9387,350 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_false, anon_sym_function, anon_sym_table, - [8642] = 2, + [8654] = 2, ACTIONS(537), 1, anon_sym_COMMA, ACTIONS(535), 2, sym_identifier, anon_sym_GT, - [8650] = 3, + [8662] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(541), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8660] = 3, + [8672] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(543), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8670] = 3, + [8682] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(545), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8680] = 3, + [8692] = 3, ACTIONS(547), 1, sym_identifier, ACTIONS(550), 1, anon_sym_RBRACE, STATE(184), 1, aux_sym_map_repeat1, - [8690] = 3, + [8702] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(552), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8700] = 3, + [8712] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(556), 1, anon_sym_RBRACE, STATE(193), 1, aux_sym_map_repeat1, - [8710] = 3, + [8722] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(558), 1, anon_sym_GT, STATE(183), 1, aux_sym_function_repeat1, - [8720] = 3, + [8732] = 3, ACTIONS(560), 1, sym_identifier, ACTIONS(563), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8730] = 3, + [8742] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(565), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8740] = 3, + [8752] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(567), 1, anon_sym_GT, STATE(189), 1, aux_sym_function_repeat1, - [8750] = 3, + [8762] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(569), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8760] = 3, + [8772] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(571), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8770] = 3, + [8782] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(573), 1, anon_sym_RBRACE, STATE(184), 1, aux_sym_map_repeat1, - [8780] = 3, + [8792] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(575), 1, anon_sym_GT, STATE(192), 1, aux_sym_function_repeat1, - [8790] = 3, + [8802] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(577), 1, anon_sym_RBRACE, STATE(196), 1, aux_sym_map_repeat1, - [8800] = 3, + [8812] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(579), 1, anon_sym_RBRACE, STATE(184), 1, aux_sym_map_repeat1, - [8810] = 3, + [8822] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(581), 1, anon_sym_RBRACE, STATE(198), 1, aux_sym_map_repeat1, - [8820] = 3, + [8832] = 3, ACTIONS(554), 1, sym_identifier, ACTIONS(583), 1, anon_sym_RBRACE, STATE(184), 1, aux_sym_map_repeat1, - [8830] = 3, + [8842] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(585), 1, anon_sym_GT, STATE(188), 1, aux_sym_function_repeat1, - [8840] = 3, + [8852] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(587), 1, anon_sym_GT, STATE(199), 1, aux_sym_function_repeat1, - [8850] = 3, + [8862] = 3, ACTIONS(539), 1, sym_identifier, ACTIONS(589), 1, anon_sym_GT, STATE(185), 1, aux_sym_function_repeat1, - [8860] = 2, + [8872] = 2, ACTIONS(539), 1, sym_identifier, STATE(191), 1, aux_sym_function_repeat1, - [8867] = 2, + [8879] = 2, ACTIONS(539), 1, sym_identifier, STATE(182), 1, aux_sym_function_repeat1, - [8874] = 2, + [8886] = 2, ACTIONS(539), 1, sym_identifier, STATE(181), 1, aux_sym_function_repeat1, - [8881] = 2, + [8893] = 2, ACTIONS(591), 1, anon_sym_LT, ACTIONS(593), 1, anon_sym_LBRACE, - [8888] = 2, + [8900] = 2, ACTIONS(595), 1, anon_sym_LT, ACTIONS(597), 1, anon_sym_LBRACE, - [8895] = 2, + [8907] = 2, ACTIONS(599), 1, anon_sym_LT, ACTIONS(601), 1, anon_sym_LBRACE, - [8902] = 1, + [8914] = 1, ACTIONS(563), 2, sym_identifier, anon_sym_GT, - [8907] = 1, + [8919] = 1, ACTIONS(603), 1, anon_sym_RBRACE, - [8911] = 1, + [8923] = 1, ACTIONS(605), 1, sym_identifier, - [8915] = 1, + [8927] = 1, ACTIONS(607), 1, anon_sym_RBRACE, - [8919] = 1, + [8931] = 1, ACTIONS(609), 1, anon_sym_LBRACE, - [8923] = 1, + [8935] = 1, ACTIONS(611), 1, anon_sym_RBRACE, - [8927] = 1, + [8939] = 1, ACTIONS(613), 1, sym_identifier, - [8931] = 1, + [8943] = 1, ACTIONS(615), 1, sym_identifier, - [8935] = 1, + [8947] = 1, ACTIONS(617), 1, anon_sym_in, - [8939] = 1, + [8951] = 1, ACTIONS(619), 1, anon_sym_in, - [8943] = 1, + [8955] = 1, ACTIONS(621), 1, anon_sym_RBRACE, - [8947] = 1, + [8959] = 1, ACTIONS(623), 1, anon_sym_from, - [8951] = 1, + [8963] = 1, ACTIONS(625), 1, anon_sym_from, - [8955] = 1, + [8967] = 1, ACTIONS(627), 1, anon_sym_RBRACE, - [8959] = 1, + [8971] = 1, ACTIONS(629), 1, anon_sym_RBRACE, - [8963] = 1, + [8975] = 1, ACTIONS(631), 1, anon_sym_in, - [8967] = 1, + [8979] = 1, ACTIONS(633), 1, anon_sym_from, - [8971] = 1, + [8983] = 1, ACTIONS(635), 1, anon_sym_in, - [8975] = 1, + [8987] = 1, ACTIONS(637), 1, ts_builtin_sym_end, - [8979] = 1, + [8991] = 1, ACTIONS(639), 1, anon_sym_in, - [8983] = 1, + [8995] = 1, ACTIONS(641), 1, anon_sym_RBRACE, - [8987] = 1, + [8999] = 1, ACTIONS(643), 1, anon_sym_RBRACE, - [8991] = 1, + [9003] = 1, ACTIONS(645), 1, anon_sym_RBRACE, - [8995] = 1, + [9007] = 1, ACTIONS(647), 1, anon_sym_LBRACE, - [8999] = 1, + [9011] = 1, ACTIONS(649), 1, anon_sym_RBRACE, - [9003] = 1, + [9015] = 1, ACTIONS(651), 1, anon_sym_RBRACE, - [9007] = 1, + [9019] = 1, ACTIONS(653), 1, anon_sym_RBRACE, - [9011] = 1, + [9023] = 1, ACTIONS(655), 1, anon_sym_RBRACE, - [9015] = 1, + [9027] = 1, ACTIONS(657), 1, anon_sym_RBRACE, - [9019] = 1, + [9031] = 1, ACTIONS(659), 1, anon_sym_into, - [9023] = 1, + [9035] = 1, ACTIONS(661), 1, sym_identifier, - [9027] = 1, + [9039] = 1, ACTIONS(663), 1, anon_sym_RBRACE, - [9031] = 1, + [9043] = 1, ACTIONS(665), 1, anon_sym_from, - [9035] = 1, + [9047] = 1, ACTIONS(667), 1, anon_sym_into, - [9039] = 1, + [9051] = 1, ACTIONS(669), 1, anon_sym_LT, - [9043] = 1, + [9055] = 1, ACTIONS(671), 1, anon_sym_EQ, - [9047] = 1, + [9059] = 1, ACTIONS(673), 1, anon_sym_LT, - [9051] = 1, + [9063] = 1, ACTIONS(675), 1, anon_sym_LBRACE, - [9055] = 1, + [9067] = 1, ACTIONS(677), 1, anon_sym_RBRACE, - [9059] = 1, + [9071] = 1, ACTIONS(679), 1, sym_identifier, - [9063] = 1, + [9075] = 1, ACTIONS(681), 1, anon_sym_RBRACE, - [9067] = 1, + [9079] = 1, ACTIONS(683), 1, sym_identifier, - [9071] = 1, + [9083] = 1, ACTIONS(685), 1, anon_sym_LT, - [9075] = 1, + [9087] = 1, ACTIONS(687), 1, anon_sym_LT, - [9079] = 1, + [9091] = 1, ACTIONS(689), 1, anon_sym_LBRACE, - [9083] = 1, + [9095] = 1, ACTIONS(691), 1, anon_sym_LBRACE, - [9087] = 1, + [9099] = 1, ACTIONS(693), 1, sym_identifier, - [9091] = 1, + [9103] = 1, ACTIONS(695), 1, anon_sym_LT, - [9095] = 1, + [9107] = 1, ACTIONS(697), 1, anon_sym_LBRACE, - [9099] = 1, + [9111] = 1, ACTIONS(699), 1, anon_sym_LBRACE, - [9103] = 1, + [9115] = 1, ACTIONS(701), 1, anon_sym_RBRACE, - [9107] = 1, + [9119] = 1, ACTIONS(703), 1, anon_sym_RBRACE, - [9111] = 1, + [9123] = 1, ACTIONS(705), 1, anon_sym_RBRACE, - [9115] = 1, + [9127] = 1, ACTIONS(707), 1, anon_sym_LBRACE, }; @@ -9625,257 +9745,257 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(8)] = 639, [SMALL_STATE(9)] = 744, [SMALL_STATE(10)] = 849, - [SMALL_STATE(11)] = 954, - [SMALL_STATE(12)] = 1059, - [SMALL_STATE(13)] = 1164, - [SMALL_STATE(14)] = 1269, - [SMALL_STATE(15)] = 1374, - [SMALL_STATE(16)] = 1479, - [SMALL_STATE(17)] = 1584, - [SMALL_STATE(18)] = 1689, - [SMALL_STATE(19)] = 1794, - [SMALL_STATE(20)] = 1899, - [SMALL_STATE(21)] = 2004, - [SMALL_STATE(22)] = 2109, - [SMALL_STATE(23)] = 2214, - [SMALL_STATE(24)] = 2319, + [SMALL_STATE(11)] = 916, + [SMALL_STATE(12)] = 1021, + [SMALL_STATE(13)] = 1126, + [SMALL_STATE(14)] = 1231, + [SMALL_STATE(15)] = 1336, + [SMALL_STATE(16)] = 1441, + [SMALL_STATE(17)] = 1546, + [SMALL_STATE(18)] = 1651, + [SMALL_STATE(19)] = 1756, + [SMALL_STATE(20)] = 1861, + [SMALL_STATE(21)] = 1966, + [SMALL_STATE(22)] = 2071, + [SMALL_STATE(23)] = 2176, + [SMALL_STATE(24)] = 2281, [SMALL_STATE(25)] = 2386, [SMALL_STATE(26)] = 2491, - [SMALL_STATE(27)] = 2592, - [SMALL_STATE(28)] = 2693, - [SMALL_STATE(29)] = 2794, - [SMALL_STATE(30)] = 2895, - [SMALL_STATE(31)] = 2996, - [SMALL_STATE(32)] = 3070, - [SMALL_STATE(33)] = 3144, - [SMALL_STATE(34)] = 3218, - [SMALL_STATE(35)] = 3277, - [SMALL_STATE(36)] = 3336, - [SMALL_STATE(37)] = 3387, - [SMALL_STATE(38)] = 3439, - [SMALL_STATE(39)] = 3484, - [SMALL_STATE(40)] = 3529, - [SMALL_STATE(41)] = 3574, - [SMALL_STATE(42)] = 3619, - [SMALL_STATE(43)] = 3664, - [SMALL_STATE(44)] = 3709, - [SMALL_STATE(45)] = 3754, - [SMALL_STATE(46)] = 3799, - [SMALL_STATE(47)] = 3844, - [SMALL_STATE(48)] = 3889, - [SMALL_STATE(49)] = 3934, - [SMALL_STATE(50)] = 3979, - [SMALL_STATE(51)] = 4024, - [SMALL_STATE(52)] = 4069, - [SMALL_STATE(53)] = 4114, - [SMALL_STATE(54)] = 4172, - [SMALL_STATE(55)] = 4230, - [SMALL_STATE(56)] = 4286, - [SMALL_STATE(57)] = 4342, - [SMALL_STATE(58)] = 4413, - [SMALL_STATE(59)] = 4484, - [SMALL_STATE(60)] = 4555, - [SMALL_STATE(61)] = 4597, - [SMALL_STATE(62)] = 4645, - [SMALL_STATE(63)] = 4687, - [SMALL_STATE(64)] = 4724, - [SMALL_STATE(65)] = 4755, - [SMALL_STATE(66)] = 4810, - [SMALL_STATE(67)] = 4841, - [SMALL_STATE(68)] = 4895, - [SMALL_STATE(69)] = 4949, - [SMALL_STATE(70)] = 5003, - [SMALL_STATE(71)] = 5057, - [SMALL_STATE(72)] = 5111, - [SMALL_STATE(73)] = 5165, - [SMALL_STATE(74)] = 5219, - [SMALL_STATE(75)] = 5273, - [SMALL_STATE(76)] = 5327, - [SMALL_STATE(77)] = 5381, - [SMALL_STATE(78)] = 5435, - [SMALL_STATE(79)] = 5489, - [SMALL_STATE(80)] = 5543, - [SMALL_STATE(81)] = 5597, - [SMALL_STATE(82)] = 5651, - [SMALL_STATE(83)] = 5680, - [SMALL_STATE(84)] = 5709, - [SMALL_STATE(85)] = 5738, - [SMALL_STATE(86)] = 5767, - [SMALL_STATE(87)] = 5796, - [SMALL_STATE(88)] = 5825, - [SMALL_STATE(89)] = 5854, - [SMALL_STATE(90)] = 5883, - [SMALL_STATE(91)] = 5912, - [SMALL_STATE(92)] = 5941, - [SMALL_STATE(93)] = 5970, - [SMALL_STATE(94)] = 5999, - [SMALL_STATE(95)] = 6028, - [SMALL_STATE(96)] = 6057, - [SMALL_STATE(97)] = 6086, - [SMALL_STATE(98)] = 6115, - [SMALL_STATE(99)] = 6163, - [SMALL_STATE(100)] = 6211, - [SMALL_STATE(101)] = 6259, - [SMALL_STATE(102)] = 6307, - [SMALL_STATE(103)] = 6355, - [SMALL_STATE(104)] = 6403, - [SMALL_STATE(105)] = 6451, - [SMALL_STATE(106)] = 6499, - [SMALL_STATE(107)] = 6547, - [SMALL_STATE(108)] = 6595, - [SMALL_STATE(109)] = 6643, - [SMALL_STATE(110)] = 6691, - [SMALL_STATE(111)] = 6739, - [SMALL_STATE(112)] = 6787, - [SMALL_STATE(113)] = 6835, - [SMALL_STATE(114)] = 6883, - [SMALL_STATE(115)] = 6931, - [SMALL_STATE(116)] = 6979, - [SMALL_STATE(117)] = 7027, - [SMALL_STATE(118)] = 7075, - [SMALL_STATE(119)] = 7123, - [SMALL_STATE(120)] = 7171, - [SMALL_STATE(121)] = 7219, - [SMALL_STATE(122)] = 7267, - [SMALL_STATE(123)] = 7294, - [SMALL_STATE(124)] = 7325, - [SMALL_STATE(125)] = 7354, - [SMALL_STATE(126)] = 7381, - [SMALL_STATE(127)] = 7412, - [SMALL_STATE(128)] = 7444, - [SMALL_STATE(129)] = 7470, - [SMALL_STATE(130)] = 7502, - [SMALL_STATE(131)] = 7534, - [SMALL_STATE(132)] = 7566, - [SMALL_STATE(133)] = 7598, - [SMALL_STATE(134)] = 7627, - [SMALL_STATE(135)] = 7648, - [SMALL_STATE(136)] = 7677, - [SMALL_STATE(137)] = 7706, - [SMALL_STATE(138)] = 7735, - [SMALL_STATE(139)] = 7764, - [SMALL_STATE(140)] = 7793, - [SMALL_STATE(141)] = 7814, - [SMALL_STATE(142)] = 7835, - [SMALL_STATE(143)] = 7856, - [SMALL_STATE(144)] = 7877, - [SMALL_STATE(145)] = 7898, - [SMALL_STATE(146)] = 7919, - [SMALL_STATE(147)] = 7940, - [SMALL_STATE(148)] = 7961, - [SMALL_STATE(149)] = 7990, - [SMALL_STATE(150)] = 8011, - [SMALL_STATE(151)] = 8040, - [SMALL_STATE(152)] = 8061, - [SMALL_STATE(153)] = 8082, - [SMALL_STATE(154)] = 8103, - [SMALL_STATE(155)] = 8132, - [SMALL_STATE(156)] = 8161, - [SMALL_STATE(157)] = 8182, - [SMALL_STATE(158)] = 8203, - [SMALL_STATE(159)] = 8223, - [SMALL_STATE(160)] = 8243, - [SMALL_STATE(161)] = 8263, - [SMALL_STATE(162)] = 8283, - [SMALL_STATE(163)] = 8303, - [SMALL_STATE(164)] = 8323, - [SMALL_STATE(165)] = 8343, - [SMALL_STATE(166)] = 8363, - [SMALL_STATE(167)] = 8383, - [SMALL_STATE(168)] = 8403, - [SMALL_STATE(169)] = 8423, - [SMALL_STATE(170)] = 8449, - [SMALL_STATE(171)] = 8469, - [SMALL_STATE(172)] = 8489, - [SMALL_STATE(173)] = 8509, - [SMALL_STATE(174)] = 8529, - [SMALL_STATE(175)] = 8550, - [SMALL_STATE(176)] = 8571, - [SMALL_STATE(177)] = 8592, - [SMALL_STATE(178)] = 8610, - [SMALL_STATE(179)] = 8626, - [SMALL_STATE(180)] = 8642, - [SMALL_STATE(181)] = 8650, - [SMALL_STATE(182)] = 8660, - [SMALL_STATE(183)] = 8670, - [SMALL_STATE(184)] = 8680, - [SMALL_STATE(185)] = 8690, - [SMALL_STATE(186)] = 8700, - [SMALL_STATE(187)] = 8710, - [SMALL_STATE(188)] = 8720, - [SMALL_STATE(189)] = 8730, - [SMALL_STATE(190)] = 8740, - [SMALL_STATE(191)] = 8750, - [SMALL_STATE(192)] = 8760, - [SMALL_STATE(193)] = 8770, - [SMALL_STATE(194)] = 8780, - [SMALL_STATE(195)] = 8790, - [SMALL_STATE(196)] = 8800, - [SMALL_STATE(197)] = 8810, - [SMALL_STATE(198)] = 8820, - [SMALL_STATE(199)] = 8830, - [SMALL_STATE(200)] = 8840, - [SMALL_STATE(201)] = 8850, - [SMALL_STATE(202)] = 8860, - [SMALL_STATE(203)] = 8867, - [SMALL_STATE(204)] = 8874, - [SMALL_STATE(205)] = 8881, - [SMALL_STATE(206)] = 8888, - [SMALL_STATE(207)] = 8895, - [SMALL_STATE(208)] = 8902, - [SMALL_STATE(209)] = 8907, - [SMALL_STATE(210)] = 8911, - [SMALL_STATE(211)] = 8915, - [SMALL_STATE(212)] = 8919, - [SMALL_STATE(213)] = 8923, - [SMALL_STATE(214)] = 8927, - [SMALL_STATE(215)] = 8931, - [SMALL_STATE(216)] = 8935, - [SMALL_STATE(217)] = 8939, - [SMALL_STATE(218)] = 8943, - [SMALL_STATE(219)] = 8947, - [SMALL_STATE(220)] = 8951, - [SMALL_STATE(221)] = 8955, - [SMALL_STATE(222)] = 8959, - [SMALL_STATE(223)] = 8963, - [SMALL_STATE(224)] = 8967, - [SMALL_STATE(225)] = 8971, - [SMALL_STATE(226)] = 8975, - [SMALL_STATE(227)] = 8979, - [SMALL_STATE(228)] = 8983, - [SMALL_STATE(229)] = 8987, - [SMALL_STATE(230)] = 8991, - [SMALL_STATE(231)] = 8995, - [SMALL_STATE(232)] = 8999, - [SMALL_STATE(233)] = 9003, - [SMALL_STATE(234)] = 9007, - [SMALL_STATE(235)] = 9011, - [SMALL_STATE(236)] = 9015, - [SMALL_STATE(237)] = 9019, - [SMALL_STATE(238)] = 9023, - [SMALL_STATE(239)] = 9027, - [SMALL_STATE(240)] = 9031, - [SMALL_STATE(241)] = 9035, - [SMALL_STATE(242)] = 9039, - [SMALL_STATE(243)] = 9043, - [SMALL_STATE(244)] = 9047, - [SMALL_STATE(245)] = 9051, - [SMALL_STATE(246)] = 9055, - [SMALL_STATE(247)] = 9059, - [SMALL_STATE(248)] = 9063, - [SMALL_STATE(249)] = 9067, - [SMALL_STATE(250)] = 9071, - [SMALL_STATE(251)] = 9075, - [SMALL_STATE(252)] = 9079, - [SMALL_STATE(253)] = 9083, - [SMALL_STATE(254)] = 9087, - [SMALL_STATE(255)] = 9091, - [SMALL_STATE(256)] = 9095, - [SMALL_STATE(257)] = 9099, - [SMALL_STATE(258)] = 9103, - [SMALL_STATE(259)] = 9107, - [SMALL_STATE(260)] = 9111, - [SMALL_STATE(261)] = 9115, + [SMALL_STATE(27)] = 2569, + [SMALL_STATE(28)] = 2647, + [SMALL_STATE(29)] = 2725, + [SMALL_STATE(30)] = 2826, + [SMALL_STATE(31)] = 2927, + [SMALL_STATE(32)] = 3028, + [SMALL_STATE(33)] = 3129, + [SMALL_STATE(34)] = 3230, + [SMALL_STATE(35)] = 3289, + [SMALL_STATE(36)] = 3348, + [SMALL_STATE(37)] = 3399, + [SMALL_STATE(38)] = 3451, + [SMALL_STATE(39)] = 3496, + [SMALL_STATE(40)] = 3541, + [SMALL_STATE(41)] = 3586, + [SMALL_STATE(42)] = 3631, + [SMALL_STATE(43)] = 3676, + [SMALL_STATE(44)] = 3721, + [SMALL_STATE(45)] = 3766, + [SMALL_STATE(46)] = 3811, + [SMALL_STATE(47)] = 3856, + [SMALL_STATE(48)] = 3901, + [SMALL_STATE(49)] = 3946, + [SMALL_STATE(50)] = 3991, + [SMALL_STATE(51)] = 4036, + [SMALL_STATE(52)] = 4081, + [SMALL_STATE(53)] = 4126, + [SMALL_STATE(54)] = 4184, + [SMALL_STATE(55)] = 4242, + [SMALL_STATE(56)] = 4298, + [SMALL_STATE(57)] = 4354, + [SMALL_STATE(58)] = 4425, + [SMALL_STATE(59)] = 4496, + [SMALL_STATE(60)] = 4567, + [SMALL_STATE(61)] = 4609, + [SMALL_STATE(62)] = 4657, + [SMALL_STATE(63)] = 4699, + [SMALL_STATE(64)] = 4736, + [SMALL_STATE(65)] = 4767, + [SMALL_STATE(66)] = 4822, + [SMALL_STATE(67)] = 4853, + [SMALL_STATE(68)] = 4907, + [SMALL_STATE(69)] = 4961, + [SMALL_STATE(70)] = 5015, + [SMALL_STATE(71)] = 5069, + [SMALL_STATE(72)] = 5123, + [SMALL_STATE(73)] = 5177, + [SMALL_STATE(74)] = 5231, + [SMALL_STATE(75)] = 5285, + [SMALL_STATE(76)] = 5339, + [SMALL_STATE(77)] = 5393, + [SMALL_STATE(78)] = 5447, + [SMALL_STATE(79)] = 5501, + [SMALL_STATE(80)] = 5555, + [SMALL_STATE(81)] = 5609, + [SMALL_STATE(82)] = 5663, + [SMALL_STATE(83)] = 5692, + [SMALL_STATE(84)] = 5721, + [SMALL_STATE(85)] = 5750, + [SMALL_STATE(86)] = 5779, + [SMALL_STATE(87)] = 5808, + [SMALL_STATE(88)] = 5837, + [SMALL_STATE(89)] = 5866, + [SMALL_STATE(90)] = 5895, + [SMALL_STATE(91)] = 5924, + [SMALL_STATE(92)] = 5953, + [SMALL_STATE(93)] = 5982, + [SMALL_STATE(94)] = 6011, + [SMALL_STATE(95)] = 6040, + [SMALL_STATE(96)] = 6069, + [SMALL_STATE(97)] = 6098, + [SMALL_STATE(98)] = 6127, + [SMALL_STATE(99)] = 6175, + [SMALL_STATE(100)] = 6223, + [SMALL_STATE(101)] = 6271, + [SMALL_STATE(102)] = 6319, + [SMALL_STATE(103)] = 6367, + [SMALL_STATE(104)] = 6415, + [SMALL_STATE(105)] = 6463, + [SMALL_STATE(106)] = 6511, + [SMALL_STATE(107)] = 6559, + [SMALL_STATE(108)] = 6607, + [SMALL_STATE(109)] = 6655, + [SMALL_STATE(110)] = 6703, + [SMALL_STATE(111)] = 6751, + [SMALL_STATE(112)] = 6799, + [SMALL_STATE(113)] = 6847, + [SMALL_STATE(114)] = 6895, + [SMALL_STATE(115)] = 6943, + [SMALL_STATE(116)] = 6991, + [SMALL_STATE(117)] = 7039, + [SMALL_STATE(118)] = 7087, + [SMALL_STATE(119)] = 7135, + [SMALL_STATE(120)] = 7183, + [SMALL_STATE(121)] = 7231, + [SMALL_STATE(122)] = 7279, + [SMALL_STATE(123)] = 7306, + [SMALL_STATE(124)] = 7337, + [SMALL_STATE(125)] = 7366, + [SMALL_STATE(126)] = 7393, + [SMALL_STATE(127)] = 7424, + [SMALL_STATE(128)] = 7456, + [SMALL_STATE(129)] = 7482, + [SMALL_STATE(130)] = 7514, + [SMALL_STATE(131)] = 7546, + [SMALL_STATE(132)] = 7578, + [SMALL_STATE(133)] = 7610, + [SMALL_STATE(134)] = 7639, + [SMALL_STATE(135)] = 7660, + [SMALL_STATE(136)] = 7689, + [SMALL_STATE(137)] = 7718, + [SMALL_STATE(138)] = 7747, + [SMALL_STATE(139)] = 7776, + [SMALL_STATE(140)] = 7805, + [SMALL_STATE(141)] = 7826, + [SMALL_STATE(142)] = 7847, + [SMALL_STATE(143)] = 7868, + [SMALL_STATE(144)] = 7889, + [SMALL_STATE(145)] = 7910, + [SMALL_STATE(146)] = 7931, + [SMALL_STATE(147)] = 7952, + [SMALL_STATE(148)] = 7973, + [SMALL_STATE(149)] = 8002, + [SMALL_STATE(150)] = 8023, + [SMALL_STATE(151)] = 8052, + [SMALL_STATE(152)] = 8073, + [SMALL_STATE(153)] = 8094, + [SMALL_STATE(154)] = 8115, + [SMALL_STATE(155)] = 8144, + [SMALL_STATE(156)] = 8173, + [SMALL_STATE(157)] = 8194, + [SMALL_STATE(158)] = 8215, + [SMALL_STATE(159)] = 8235, + [SMALL_STATE(160)] = 8255, + [SMALL_STATE(161)] = 8275, + [SMALL_STATE(162)] = 8295, + [SMALL_STATE(163)] = 8315, + [SMALL_STATE(164)] = 8335, + [SMALL_STATE(165)] = 8355, + [SMALL_STATE(166)] = 8375, + [SMALL_STATE(167)] = 8395, + [SMALL_STATE(168)] = 8415, + [SMALL_STATE(169)] = 8435, + [SMALL_STATE(170)] = 8461, + [SMALL_STATE(171)] = 8481, + [SMALL_STATE(172)] = 8501, + [SMALL_STATE(173)] = 8521, + [SMALL_STATE(174)] = 8541, + [SMALL_STATE(175)] = 8562, + [SMALL_STATE(176)] = 8583, + [SMALL_STATE(177)] = 8604, + [SMALL_STATE(178)] = 8622, + [SMALL_STATE(179)] = 8638, + [SMALL_STATE(180)] = 8654, + [SMALL_STATE(181)] = 8662, + [SMALL_STATE(182)] = 8672, + [SMALL_STATE(183)] = 8682, + [SMALL_STATE(184)] = 8692, + [SMALL_STATE(185)] = 8702, + [SMALL_STATE(186)] = 8712, + [SMALL_STATE(187)] = 8722, + [SMALL_STATE(188)] = 8732, + [SMALL_STATE(189)] = 8742, + [SMALL_STATE(190)] = 8752, + [SMALL_STATE(191)] = 8762, + [SMALL_STATE(192)] = 8772, + [SMALL_STATE(193)] = 8782, + [SMALL_STATE(194)] = 8792, + [SMALL_STATE(195)] = 8802, + [SMALL_STATE(196)] = 8812, + [SMALL_STATE(197)] = 8822, + [SMALL_STATE(198)] = 8832, + [SMALL_STATE(199)] = 8842, + [SMALL_STATE(200)] = 8852, + [SMALL_STATE(201)] = 8862, + [SMALL_STATE(202)] = 8872, + [SMALL_STATE(203)] = 8879, + [SMALL_STATE(204)] = 8886, + [SMALL_STATE(205)] = 8893, + [SMALL_STATE(206)] = 8900, + [SMALL_STATE(207)] = 8907, + [SMALL_STATE(208)] = 8914, + [SMALL_STATE(209)] = 8919, + [SMALL_STATE(210)] = 8923, + [SMALL_STATE(211)] = 8927, + [SMALL_STATE(212)] = 8931, + [SMALL_STATE(213)] = 8935, + [SMALL_STATE(214)] = 8939, + [SMALL_STATE(215)] = 8943, + [SMALL_STATE(216)] = 8947, + [SMALL_STATE(217)] = 8951, + [SMALL_STATE(218)] = 8955, + [SMALL_STATE(219)] = 8959, + [SMALL_STATE(220)] = 8963, + [SMALL_STATE(221)] = 8967, + [SMALL_STATE(222)] = 8971, + [SMALL_STATE(223)] = 8975, + [SMALL_STATE(224)] = 8979, + [SMALL_STATE(225)] = 8983, + [SMALL_STATE(226)] = 8987, + [SMALL_STATE(227)] = 8991, + [SMALL_STATE(228)] = 8995, + [SMALL_STATE(229)] = 8999, + [SMALL_STATE(230)] = 9003, + [SMALL_STATE(231)] = 9007, + [SMALL_STATE(232)] = 9011, + [SMALL_STATE(233)] = 9015, + [SMALL_STATE(234)] = 9019, + [SMALL_STATE(235)] = 9023, + [SMALL_STATE(236)] = 9027, + [SMALL_STATE(237)] = 9031, + [SMALL_STATE(238)] = 9035, + [SMALL_STATE(239)] = 9039, + [SMALL_STATE(240)] = 9043, + [SMALL_STATE(241)] = 9047, + [SMALL_STATE(242)] = 9051, + [SMALL_STATE(243)] = 9055, + [SMALL_STATE(244)] = 9059, + [SMALL_STATE(245)] = 9063, + [SMALL_STATE(246)] = 9067, + [SMALL_STATE(247)] = 9071, + [SMALL_STATE(248)] = 9075, + [SMALL_STATE(249)] = 9079, + [SMALL_STATE(250)] = 9083, + [SMALL_STATE(251)] = 9087, + [SMALL_STATE(252)] = 9091, + [SMALL_STATE(253)] = 9095, + [SMALL_STATE(254)] = 9099, + [SMALL_STATE(255)] = 9103, + [SMALL_STATE(256)] = 9107, + [SMALL_STATE(257)] = 9111, + [SMALL_STATE(258)] = 9115, + [SMALL_STATE(259)] = 9119, + [SMALL_STATE(260)] = 9123, + [SMALL_STATE(261)] = 9127, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -9883,10 +10003,10 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(205), [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), @@ -9904,10 +10024,10 @@ static const TSParseActionEntry ts_parse_actions[] = { [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), [45] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(37), [48] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(90), - [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(33), - [54] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(41), - [57] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(41), - [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(52), + [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(26), + [54] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(46), + [57] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(46), + [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(40), [63] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(76), [66] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(205), [69] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(197), @@ -9926,10 +10046,10 @@ static const TSParseActionEntry ts_parse_actions[] = { [107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), [109] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(37), [112] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(90), - [115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(33), - [118] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(41), - [121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(41), - [124] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(52), + [115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(26), + [118] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(46), + [121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(46), + [124] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(40), [127] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(76), [130] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(205), [133] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(197), @@ -9944,12 +10064,12 @@ static const TSParseActionEntry ts_parse_actions[] = { [160] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(242), [163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(241), [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_item_repeat1, 2), SHIFT_REPEAT(212), - [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [171] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_item, 1), - [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [175] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_item, 1), - [177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), - [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_item, 1), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [173] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_item, 1), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(156), [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), @@ -9957,58 +10077,58 @@ static const TSParseActionEntry ts_parse_actions[] = { [189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206), [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(250), - [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(251), - [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), - [199] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), - [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), - [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), - [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74), - [207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), - [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(69), - [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 5), - [213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 5), + [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(69), + [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), + [199] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74), + [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), + [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), + [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), + [207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(251), + [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), + [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3), + [213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3), [215] = {.entry = {.count = 1, .reusable = false}}, SHIFT(179), [217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), [219] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3), - [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3), + [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 5), + [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 5), [227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math, 3), [229] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math, 3), [231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_kind, 1), [233] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_kind, 1), [235] = {.entry = {.count = 1, .reusable = false}}, SHIFT(122), [237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4), - [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4), - [243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1), - [245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1), - [247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 2), - [249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 2), - [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1), - [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1), + [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 2), + [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 2), + [243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4), + [245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4), + [247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1), + [249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1), + [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1), + [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1), [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3), [257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3), - [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 7), - [261] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 7), + [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 6), + [261] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 6), [263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3), [265] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3), [267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tool, 3), [269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tool, 3), - [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 6), - [273] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 6), + [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1), + [273] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1), [275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 2), [277] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 2), [279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 3), [281] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 3), [283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 3), [285] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 3), - [287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tool, 4), - [289] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tool, 4), + [287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 7), + [289] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 7), [291] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4), [293] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4), - [295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1), - [297] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1), + [295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tool, 4), + [297] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tool, 4), [299] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select, 5), [301] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select, 5), [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), @@ -10019,7 +10139,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [313] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_insert, 4), [315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1), [317] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1), - [319] = {.entry = {.count = 1, .reusable = false}}, SHIFT(39), + [319] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), [325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), @@ -10037,12 +10157,12 @@ static const TSParseActionEntry ts_parse_actions[] = { [349] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(114), [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if, 5), [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if, 5), - [356] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(39), - [359] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(33), + [356] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(41), + [359] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(26), [362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), - [364] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(41), - [367] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(41), - [370] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(52), + [364] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(46), + [367] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(46), + [370] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(40), [373] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(76), [376] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(205), [379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(197), @@ -10050,7 +10170,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if, 5), [387] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if, 5), [389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), @@ -10063,7 +10183,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3), [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3), [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while, 5), @@ -10094,7 +10214,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select, 9), [475] = {.entry = {.count = 1, .reusable = false}}, SHIFT(153), [477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), - [479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), [481] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), [483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), [485] = {.entry = {.count = 1, .reusable = false}}, SHIFT(172), @@ -10107,9 +10227,9 @@ static const TSParseActionEntry ts_parse_actions[] = { [499] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 3), [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 3), [503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), [511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), [513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), [515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), @@ -10144,7 +10264,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), [577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), [579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), [583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), [585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), [587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), @@ -10157,7 +10277,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), [603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), [605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), [609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), [611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), [613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), @@ -10174,10 +10294,10 @@ static const TSParseActionEntry ts_parse_actions[] = { [635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), [637] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), [639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), [643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), [645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), [649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), [651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), [653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), @@ -10191,7 +10311,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), @@ -10203,11 +10323,11 @@ static const TSParseActionEntry ts_parse_actions[] = { [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), }; #ifdef __cplusplus