@react-querybuilder/core 8.9.2 → 8.11.0

package/dist/parseCEL.mjs

@@ -1,567 +1,282 @@
-import { defaultOperatorNegationMap, joinWith } from "./arrayUtils-BF1P8iHS.mjs";
-import { isRuleGroup } from "./isRuleGroup-CnhYpLOM.mjs";
-import "./optGroupUtils-Duv-M8rf.mjs";
-import { fieldIsValidUtil, getFieldsArray, prepareRuleGroup } from "./prepareQueryObjects-CS6Wmhmf.mjs";
+import { l as defaultOperatorNegationMap } from "./optGroupUtils-VeZ3k7-1.mjs";
+import { t as joinWith } from "./arrayUtils-A_OXU9W1.mjs";
+import { t as isRuleGroup } from "./isRuleGroup-CYcfPgbg.mjs";
+import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-DPCC-iHp.mjs";
+import { JisonParser } from "@ts-jison/parser";
+import { JisonLexer } from "@ts-jison/lexer";
 
-//#region src/utils/parseCEL/celParser.js
-var celParser = (function() {
-	var o = function(k, v, o$1, l) {
-		for (o$1 = o$1 || {}, l = k.length; l--; o$1[k[l]] = v);
-		return o$1;
-	}, $V0 = [1, 27], $V1 = [1, 31], $V2 = [1, 32], $V3 = [1, 28], $V4 = [1, 29], $V5 = [1, 30], $V6 = [1, 33], $V7 = [1, 34], $V8 = [1, 18], $V9 = [1, 26], $Va = [1, 12], $Vb = [1, 13], $Vc = [1, 19], $Vd = [1, 20], $Ve = [1, 40], $Vf = [1, 39], $Vg = [1, 41], $Vh = [1, 42], $Vi = [1, 43], $Vj = [1, 36], $Vk = [1, 37], $Vl = [1, 38], $Vm = [
-		5,
-		37,
-		43,
-		45,
-		49,
-		50,
-		53,
-		54,
-		55,
-		56,
-		60,
-		61,
-		62,
-		63
-	], $Vn = [1, 44], $Vo = [1, 45], $Vp = [1, 46], $Vq = [
-		5,
-		23,
-		24,
-		25,
-		26,
-		27,
-		28,
-		31,
-		37,
-		40,
-		43,
-		44,
-		45,
-		46,
-		49,
-		50,
-		53,
-		54,
-		55,
-		56,
-		60,
-		61,
-		62,
-		63
-	], $Vr = [
-		7,
-		9,
-		10,
-		12,
-		13,
-		14,
-		16,
-		18,
-		21,
-		35,
-		40,
-		41,
-		44,
-		46
-	], $Vs = [2, 36], $Vt = [1, 85], $Vu = [
-		43,
-		45,
-		50
-	], $Vv = [
-		5,
-		37,
-		43,
-		45,
-		49,
-		50,
-		53,
-		61,
-		62,
-		63
-	], $Vw = [
-		5,
-		37,
-		43,
-		45,
-		49,
-		50,
-		53,
-		54,
-		55,
-		56,
-		61,
-		62,
-		63
-	], $Vx = [2, 37], $Vy = [49, 50];
-	var parser = {
-		trace: function trace() {},
-		yy: {},
-		symbols_: {
-			"error": 2,
-			"main": 3,
-			"expr": 4,
-			"EOF": 5,
-			"string_literal": 6,
-			"STRING_LIT": 7,
-			"bytes_literal": 8,
-			"b": 9,
-			"B": 10,
-			"number_literal": 11,
-			"INT_LIT": 12,
-			"UINT_LIT": 13,
-			"FLOAT_LIT": 14,
-			"boolean_literal": 15,
-			"BOOL_LIT": 16,
-			"null_literal": 17,
-			"NULL_LIT": 18,
-			"literal": 19,
-			"ident": 20,
-			"IDENT": 21,
-			"relop": 22,
-			"==": 23,
-			">=": 24,
-			">": 25,
-			"<=": 26,
-			"<": 27,
-			"!=": 28,
-			"relation": 29,
-			"member": 30,
-			"in": 31,
-			"list": 32,
-			"map": 33,
-			"negation": 34,
-			"!": 35,
-			"negative": 36,
-			"-": 37,
-			"unary": 38,
-			"primary": 39,
-			"DOT": 40,
-			"(": 41,
-			"expr_list": 42,
-			")": 43,
-			"[": 44,
-			"]": 45,
-			"{": 46,
-			"field_inits": 47,
-			"trailing_comma": 48,
-			"}": 49,
-			",": 50,
-			"map_inits": 51,
-			"math_operation": 52,
-			"+": 53,
-			"*": 54,
-			"/": 55,
-			"%": 56,
-			"conditional_expr": 57,
-			"conditional_and": 58,
-			"conditional_or": 59,
-			"?": 60,
-			":": 61,
-			"&&": 62,
-			"||": 63,
-			"$accept": 0,
-			"$end": 1
-		},
-		terminals_: {
-			2: "error",
-			5: "EOF",
-			7: "STRING_LIT",
-			9: "b",
-			10: "B",
-			12: "INT_LIT",
-			13: "UINT_LIT",
-			14: "FLOAT_LIT",
-			16: "BOOL_LIT",
-			18: "NULL_LIT",
-			21: "IDENT",
-			23: "==",
-			24: ">=",
-			25: ">",
-			26: "<=",
-			27: "<",
-			28: "!=",
-			31: "in",
-			35: "!",
-			37: "-",
-			40: "DOT",
-			41: "(",
-			43: ")",
-			44: "[",
-			45: "]",
-			46: "{",
-			49: "}",
-			50: ",",
-			53: "+",
-			54: "*",
-			55: "/",
-			56: "%",
-			60: "?",
-			61: ":",
-			62: "&&",
-			63: "||"
-		},
-		productions_: [
-			0,
-			[3, 2],
-			[6, 1],
-			[8, 2],
-			[8, 2],
-			[11, 1],
-			[11, 1],
-			[11, 1],
-			[15, 1],
-			[17, 1],
-			[19, 1],
-			[19, 1],
-			[19, 1],
-			[19, 1],
-			[19, 1],
-			[20, 1],
-			[22, 1],
-			[22, 1],
-			[22, 1],
-			[22, 1],
-			[22, 1],
-			[22, 1],
-			[29, 3],
-			[29, 3],
-			[29, 3],
-			[34, 1],
-			[34, 2],
-			[36, 1],
-			[36, 2],
-			[38, 2],
-			[30, 1],
-			[30, 1],
-			[30, 3],
-			[30, 6],
-			[30, 4],
-			[30, 5],
-			[48, 0],
-			[48, 1],
-			[39, 1],
-			[39, 2],
-			[39, 5],
-			[39, 6],
-			[39, 3],
-			[39, 1],
-			[39, 1],
-			[39, 1],
-			[32, 4],
-			[33, 4],
-			[52, 3],
-			[52, 3],
-			[52, 3],
-			[52, 3],
-			[52, 3],
-			[4, 1],
-			[4, 1],
-			[4, 1],
-			[4, 1],
-			[4, 1],
-			[4, 1],
-			[57, 5],
-			[58, 3],
-			[59, 3],
-			[42, 1],
-			[42, 3],
-			[47, 3],
-			[47, 5],
-			[51, 3],
-			[51, 5]
-		],
-		performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
-			var $0 = $$.length - 1;
-			switch (yystate) {
-				case 1: return {
-					nodeType: "Main",
-					value: $$[$0 - 1]
-				};
-				case 2:
-					this.$ = {
-						type: "StringLiteral",
-						value: $$[$0]
-					};
-					break;
-				case 3:
-				case 4:
-					this.$ = {
-						type: "BytesLiteral",
-						value: $$[$0]
-					};
-					break;
-				case 5:
-					this.$ = {
-						type: "IntegerLiteral",
-						value: parseInt($$[$0], /x/.test($$[$0]) ? 16 : 10)
-					};
-					break;
-				case 6:
-					this.$ = {
-						type: "UnsignedIntegerLiteral",
-						value: parseInt($$[$0].replace(/u$/i, ""), /^0x/.test($$[$0]) ? 16 : 10)
-					};
-					break;
-				case 7:
-					this.$ = {
-						type: "FloatLiteral",
-						value: parseFloat($$[$0])
-					};
-					break;
-				case 8:
-					this.$ = {
-						type: "BooleanLiteral",
-						value: $$[$0] === "true"
-					};
-					break;
-				case 9:
-					this.$ = {
-						type: "NullLiteral",
-						value: null
-					};
-					break;
-				case 10:
-				case 11:
-				case 12:
-				case 13:
-				case 14:
-				case 16:
-				case 17:
-				case 18:
-				case 19:
-				case 20:
-				case 21:
-				case 38:
-				case 43:
-				case 44:
-				case 45:
-				case 53:
-				case 54:
-				case 55:
-				case 56:
-				case 57:
-				case 58:
-					this.$ = $$[$0];
-					break;
-				case 15:
-					this.$ = {
-						type: "Identifier",
-						value: $$[$0]
-					};
-					break;
-				case 22:
-				case 23:
-				case 24:
-					this.$ = {
-						type: "Relation",
-						left: $$[$0 - 2],
-						operator: $$[$0 - 1],
-						right: $$[$0]
-					};
-					break;
-				case 25:
-				case 27:
-					this.$ = 1;
-					break;
-				case 26:
-				case 28:
-					this.$ = this.$ += 1;
-					break;
-				case 29:
-					this.$ = {
-						type: "Negation",
-						negations: $$[$0 - 1],
-						value: $$[$0]
-					};
-					break;
-				case 30:
-				case 31:
-					this.$ = $$[$0];
-					break;
-				case 32:
-					this.$ = {
-						type: "Member",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 33:
-					this.$ = {
-						type: "Member",
-						left: $$[$0 - 5],
-						right: $$[$0 - 3],
-						list: $$[$0 - 1]
-					};
-					break;
-				case 34:
-					this.$ = {
-						type: "DynamicPropertyAccessor",
-						left: $$[$0 - 3],
-						right: $$[$0 - 1]
-					};
-					break;
-				case 35:
-					this.$ = {
-						type: "FieldsObject",
-						left: $$[$0 - 4],
-						list: $$[$0 - 2],
-						trailingComma: $$[$0 - 1]
-					};
-					break;
-				case 36:
-					this.$ = false;
-					break;
-				case 37:
-					this.$ = true;
-					break;
-				case 39:
-					this.$ = {
-						type: "Property",
-						value: $$[$0]
-					};
-					break;
-				case 40:
-					this.$ = {
-						type: "FunctionCall",
-						name: $$[$0 - 4],
-						args: $$[$0 - 2],
-						trailingComma: $$[$0 - 1]
-					};
-					break;
-				case 41:
-					this.$ = {
-						type: "Property",
-						value: $$[$0 - 4],
-						args: $$[$0 - 2],
-						trailingComma: $$[$0 - 1]
-					};
-					break;
-				case 42:
-					this.$ = {
-						type: "ExpressionGroup",
-						value: $$[$0 - 1]
-					};
-					break;
-				case 46:
-					this.$ = {
-						type: "List",
-						value: $$[$0 - 2],
-						trailingComma: $$[$0 - 1]
-					};
-					break;
-				case 47:
-					this.$ = {
-						type: "Map",
-						value: $$[$0 - 2],
-						trailingComma: $$[$0 - 1]
-					};
-					break;
-				case 48:
-					this.$ = {
-						type: "Addition",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 49:
-					this.$ = {
-						type: "Subtraction",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 50:
-					this.$ = {
-						type: "Multiplication",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 51:
-					this.$ = {
-						type: "Division",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 52:
-					this.$ = {
-						type: "Modulo",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 59:
-					this.$ = {
-						type: "ConditionalExpr",
-						condition: $$[$0 - 4],
-						valueIfTrue: $$[$0 - 2],
-						valueIfFalse: $$[$0]
-					};
-					break;
-				case 60:
-					this.$ = {
-						type: "ConditionalAnd",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 61:
-					this.$ = {
-						type: "ConditionalOr",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					};
-					break;
-				case 62:
-					this.$ = {
-						type: "ExpressionList",
-						value: [$$[$0]]
-					};
-					break;
-				case 63:
-					this.$ = $$[$0 - 2];
-					this.$.value.push($$[$0]);
-					break;
-				case 64:
-					this.$ = {
-						type: "FieldInits",
-						value: [{
-							type: "FieldInit",
-							left: $$[$0 - 2],
-							right: $$[$0]
-						}]
-					};
-					break;
-				case 65:
-					this.$ = $$[$0 - 4];
-					this.$.value.push({
-						type: "FieldInit",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					});
-					break;
-				case 66:
-					this.$ = {
-						type: "MapInits",
-						value: [{
-							type: "MapInit",
-							left: $$[$0 - 2],
-							right: $$[$0]
-						}]
-					};
-					break;
-				case 67:
-					this.$ = $$[$0 - 4];
-					this.$.value.push({
-						type: "MapInit",
-						left: $$[$0 - 2],
-						right: $$[$0]
-					});
-					break;
-			}
-		},
-		table: [
+//#region src/utils/parseCEL/celParser.ts
+/**
+* parser generated by  @ts-jison/parser-generator 0.4.1-alpha.2
+* @returns Parser implementing JisonParserApi and a Lexer implementing JisonLexerApi.
+*/
+var CELParser = class extends JisonParser {
+	$;
+	symbols_ = {
+		"error": 2,
+		"main": 3,
+		"expr": 4,
+		"EOF": 5,
+		"string_literal": 6,
+		"STRING_LIT": 7,
+		"bytes_literal": 8,
+		"b": 9,
+		"B": 10,
+		"number_literal": 11,
+		"INT_LIT": 12,
+		"UINT_LIT": 13,
+		"FLOAT_LIT": 14,
+		"boolean_literal": 15,
+		"BOOL_LIT": 16,
+		"null_literal": 17,
+		"NULL_LIT": 18,
+		"literal": 19,
+		"ident": 20,
+		"IDENT": 21,
+		"relop": 22,
+		"==": 23,
+		">=": 24,
+		">": 25,
+		"<=": 26,
+		"<": 27,
+		"!=": 28,
+		"relation": 29,
+		"member": 30,
+		"in": 31,
+		"list": 32,
+		"map": 33,
+		"negation": 34,
+		"!": 35,
+		"negative": 36,
+		"-": 37,
+		"unary": 38,
+		"primary": 39,
+		"DOT": 40,
+		"(": 41,
+		"expr_list": 42,
+		")": 43,
+		"[": 44,
+		"]": 45,
+		"{": 46,
+		"field_inits": 47,
+		"trailing_comma": 48,
+		"}": 49,
+		",": 50,
+		"map_inits": 51,
+		"math_operation": 52,
+		"+": 53,
+		"*": 54,
+		"/": 55,
+		"%": 56,
+		"conditional_expr": 57,
+		"conditional_and": 58,
+		"conditional_or": 59,
+		"?": 60,
+		":": 61,
+		"&&": 62,
+		"||": 63,
+		"$accept": 0,
+		"$end": 1
+	};
+	terminals_ = {
+		2: "error",
+		5: "EOF",
+		7: "STRING_LIT",
+		9: "b",
+		10: "B",
+		12: "INT_LIT",
+		13: "UINT_LIT",
+		14: "FLOAT_LIT",
+		16: "BOOL_LIT",
+		18: "NULL_LIT",
+		21: "IDENT",
+		23: "==",
+		24: ">=",
+		25: ">",
+		26: "<=",
+		27: "<",
+		28: "!=",
+		31: "in",
+		35: "!",
+		37: "-",
+		40: "DOT",
+		41: "(",
+		43: ")",
+		44: "[",
+		45: "]",
+		46: "{",
+		49: "}",
+		50: ",",
+		53: "+",
+		54: "*",
+		55: "/",
+		56: "%",
+		60: "?",
+		61: ":",
+		62: "&&",
+		63: "||"
+	};
+	productions_ = [
+		0,
+		[3, 2],
+		[6, 1],
+		[8, 2],
+		[8, 2],
+		[11, 1],
+		[11, 1],
+		[11, 1],
+		[15, 1],
+		[17, 1],
+		[19, 1],
+		[19, 1],
+		[19, 1],
+		[19, 1],
+		[19, 1],
+		[20, 1],
+		[22, 1],
+		[22, 1],
+		[22, 1],
+		[22, 1],
+		[22, 1],
+		[22, 1],
+		[29, 3],
+		[29, 3],
+		[29, 3],
+		[34, 1],
+		[34, 2],
+		[36, 1],
+		[36, 2],
+		[38, 2],
+		[30, 1],
+		[30, 1],
+		[30, 3],
+		[30, 6],
+		[30, 4],
+		[30, 5],
+		[48, 0],
+		[48, 1],
+		[39, 1],
+		[39, 2],
+		[39, 5],
+		[39, 6],
+		[39, 3],
+		[39, 1],
+		[39, 1],
+		[39, 1],
+		[32, 4],
+		[33, 4],
+		[52, 3],
+		[52, 3],
+		[52, 3],
+		[52, 3],
+		[52, 3],
+		[4, 1],
+		[4, 1],
+		[4, 1],
+		[4, 1],
+		[4, 1],
+		[4, 1],
+		[57, 5],
+		[58, 3],
+		[59, 3],
+		[42, 1],
+		[42, 3],
+		[47, 3],
+		[47, 5],
+		[51, 3],
+		[51, 5]
+	];
+	table;
+	defaultActions = { 35: [2, 1] };
+	constructor(yy = {}, lexer = new CELLexer(yy)) {
+		super(yy, lexer);
+		const $V0 = [1, 27], $V1 = [1, 31], $V2 = [1, 32], $V3 = [1, 28], $V4 = [1, 29], $V5 = [1, 30], $V6 = [1, 33], $V7 = [1, 34], $V8 = [1, 18], $V9 = [1, 26], $Va = [1, 12], $Vb = [1, 13], $Vc = [1, 19], $Vd = [1, 20], $Ve = [1, 40], $Vf = [1, 39], $Vg = [1, 41], $Vh = [1, 42], $Vi = [1, 43], $Vj = [1, 36], $Vk = [1, 37], $Vl = [1, 38], $Vm = [
+			5,
+			37,
+			43,
+			45,
+			49,
+			50,
+			53,
+			54,
+			55,
+			56,
+			60,
+			61,
+			62,
+			63
+		], $Vn = [1, 44], $Vo = [1, 45], $Vp = [1, 46], $Vq = [
+			5,
+			23,
+			24,
+			25,
+			26,
+			27,
+			28,
+			31,
+			37,
+			40,
+			43,
+			44,
+			45,
+			46,
+			49,
+			50,
+			53,
+			54,
+			55,
+			56,
+			60,
+			61,
+			62,
+			63
+		], $Vr = [
+			7,
+			9,
+			10,
+			12,
+			13,
+			14,
+			16,
+			18,
+			21,
+			35,
+			40,
+			41,
+			44,
+			46
+		], $Vs = [2, 36], $Vt = [1, 85], $Vu = [
+			43,
+			45,
+			50
+		], $Vv = [
+			5,
+			37,
+			43,
+			45,
+			49,
+			50,
+			53,
+			61,
+			62,
+			63
+		], $Vw = [
+			5,
+			37,
+			43,
+			45,
+			49,
+			50,
+			53,
+			54,
+			55,
+			56,
+			61,
+			62,
+			63
+		], $Vx = [2, 37], $Vy = [49, 50];
+		const o = JisonParser.expandParseTable;
+		this.table = [
 			{
 				3: 1,
 				4: 2,
@@ -1800,548 +1515,496 @@ var celParser = (function() {
 				62: $Vk,
 				63: $Vl
 			})
-		],
-		defaultActions: { 35: [2, 1] },
-		parseError: function parseError(str, hash) {
-			if (hash.recoverable) this.trace(str);
-			else {
-				var error = Error(str);
-				error.hash = hash;
-				throw error;
-			}
-		},
-		parse: function parse(input) {
-			var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1, args = lstack.slice.call(arguments, 1), lexer = Object.create(this.lexer), sharedState = { yy: {} };
-			for (var k in this.yy) if (Object.prototype.hasOwnProperty.call(this.yy, k)) sharedState.yy[k] = this.yy[k];
-			lexer.setInput(input, sharedState.yy);
-			sharedState.yy.lexer = lexer;
-			sharedState.yy.parser = this;
-			if (typeof lexer.yylloc > "u") lexer.yylloc = {};
-			var yyloc = lexer.yylloc;
-			lstack.push(yyloc);
-			var ranges = lexer.options && lexer.options.ranges;
-			if (typeof sharedState.yy.parseError === "function") this.parseError = sharedState.yy.parseError;
-			else this.parseError = Object.getPrototypeOf(this).parseError;
-			function popStack(n) {
-				stack.length = stack.length - 2 * n;
-				vstack.length = vstack.length - n;
-				lstack.length = lstack.length - n;
-			}
-			var lex = function() {
-				var token = lexer.lex() || EOF;
-				if (typeof token !== "number") token = self.symbols_[token] || token;
-				return token;
-			}, symbol, preErrorSymbol, state, action, r, yyval = {}, p, len, newState, expected;
-			while (!0) {
-				state = stack[stack.length - 1];
-				if (this.defaultActions[state]) action = this.defaultActions[state];
-				else {
-					if (symbol === null || typeof symbol > "u") symbol = lex();
-					action = table[state] && table[state][symbol];
-				}
-				if (typeof action > "u" || !action.length || !action[0]) {
-					let locateNearestErrorRecoveryRule = function(state$1) {
-						var stack_probe = stack.length - 1, depth = 0;
-						for (;;) {
-							if (TERROR.toString() in table[state$1]) return depth;
-							if (state$1 === 0 || stack_probe < 2) return !1;
-							stack_probe -= 2;
-							state$1 = stack[stack_probe];
-							++depth;
-						}
-					};
-					var error_rule_depth, errStr = "";
-					if (!recovering) {
-						error_rule_depth = locateNearestErrorRecoveryRule(state);
-						expected = [];
-						for (p in table[state]) if (this.terminals_[p] && p > TERROR) expected.push("'" + this.terminals_[p] + "'");
-						if (lexer.showPosition) errStr = "Parse error on line " + (yylineno + 1) + `:
-` + lexer.showPosition() + `
-Expecting ` + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
-						else errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
-						this.parseError(errStr, {
-							text: lexer.match,
-							token: this.terminals_[symbol] || symbol,
-							line: lexer.yylineno,
-							loc: yyloc,
-							expected,
-							recoverable: error_rule_depth !== !1
-						});
-					} else if (preErrorSymbol !== EOF) error_rule_depth = locateNearestErrorRecoveryRule(state);
-					if (recovering == 3) {
-						if (symbol === EOF || preErrorSymbol === EOF) throw Error(errStr || "Parsing halted while starting to recover from another error.");
-						yyleng = lexer.yyleng;
-						yytext = lexer.yytext;
-						yylineno = lexer.yylineno;
-						yyloc = lexer.yylloc;
-						symbol = lex();
-					}
-					if (error_rule_depth === !1) throw Error(errStr || "Parsing halted. No suitable error recovery rule available.");
-					popStack(error_rule_depth);
-					preErrorSymbol = symbol == TERROR ? null : symbol;
-					symbol = TERROR;
-					state = stack[stack.length - 1];
-					action = table[state] && table[state][TERROR];
-					recovering = 3;
-				}
-				if (action[0] instanceof Array && action.length > 1) throw Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
-				switch (action[0]) {
-					case 1:
-						stack.push(symbol);
-						vstack.push(lexer.yytext);
-						lstack.push(lexer.yylloc);
-						stack.push(action[1]);
-						symbol = null;
-						if (!preErrorSymbol) {
-							yyleng = lexer.yyleng;
-							yytext = lexer.yytext;
-							yylineno = lexer.yylineno;
-							yyloc = lexer.yylloc;
-							if (recovering > 0) recovering--;
-						} else {
-							symbol = preErrorSymbol;
-							preErrorSymbol = null;
-						}
-						break;
-					case 2:
-						len = this.productions_[action[1]][1];
-						yyval.$ = vstack[vstack.length - len];
-						yyval._$ = {
-							first_line: lstack[lstack.length - (len || 1)].first_line,
-							last_line: lstack[lstack.length - 1].last_line,
-							first_column: lstack[lstack.length - (len || 1)].first_column,
-							last_column: lstack[lstack.length - 1].last_column
-						};
-						if (ranges) yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
-						r = this.performAction.apply(yyval, [
-							yytext,
-							yyleng,
-							yylineno,
-							sharedState.yy,
-							action[1],
-							vstack,
-							lstack
-						].concat(args));
-						if (typeof r < "u") return r;
-						if (len) {
-							stack = stack.slice(0, -1 * len * 2);
-							vstack = vstack.slice(0, -1 * len);
-							lstack = lstack.slice(0, -1 * len);
-						}
-						stack.push(this.productions_[action[1]][0]);
-						vstack.push(yyval.$);
-						lstack.push(yyval._$);
-						newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
-						stack.push(newState);
-						break;
-					case 3: return !0;
-				}
-			}
-			return !0;
-		}
-	};
-	parser.lexer = (function() {
-		return {
-			EOF: 1,
-			parseError: function parseError(str, hash) {
-				if (this.yy.parser) this.yy.parser.parseError(str, hash);
-				else throw Error(str);
-			},
-			setInput: function(input, yy) {
-				this.yy = yy || this.yy || {};
-				this._input = input;
-				this._more = this._backtrack = this.done = !1;
-				this.yylineno = this.yyleng = 0;
-				this.yytext = this.matched = this.match = "";
-				this.conditionStack = ["INITIAL"];
-				this.yylloc = {
-					first_line: 1,
-					first_column: 0,
-					last_line: 1,
-					last_column: 0
+		];
+	}
+	performAction(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+		var $0 = $$.length - 1;
+		switch (yystate) {
+			case 1: return {
+				nodeType: "Main",
+				value: $$[$0 - 1]
+			};
+			case 2:
+				this.$ = {
+					type: "StringLiteral",
+					value: $$[$0]
 				};
-				if (this.options.ranges) this.yylloc.range = [0, 0];
-				this.offset = 0;
-				return this;
-			},
-			input: function() {
-				var ch = this._input[0];
-				this.yytext += ch;
-				this.yyleng++;
-				this.offset++;
-				this.match += ch;
-				this.matched += ch;
-				if (ch.match(/(?:\r\n?|\n).*/g)) {
-					this.yylineno++;
-					this.yylloc.last_line++;
-				} else this.yylloc.last_column++;
-				if (this.options.ranges) this.yylloc.range[1]++;
-				this._input = this._input.slice(1);
-				return ch;
-			},
-			unput: function(ch) {
-				var len = ch.length, lines = ch.split(/(?:\r\n?|\n)/g);
-				this._input = ch + this._input;
-				this.yytext = this.yytext.substr(0, this.yytext.length - len);
-				this.offset -= len;
-				var oldLines = this.match.split(/(?:\r\n?|\n)/g);
-				this.match = this.match.substr(0, this.match.length - 1);
-				this.matched = this.matched.substr(0, this.matched.length - 1);
-				if (lines.length - 1) this.yylineno -= lines.length - 1;
-				var r = this.yylloc.range;
-				this.yylloc = {
-					first_line: this.yylloc.first_line,
-					last_line: this.yylineno + 1,
-					first_column: this.yylloc.first_column,
-					last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
+				break;
+			case 3:
+			case 4:
+				this.$ = {
+					type: "BytesLiteral",
+					value: $$[$0]
 				};
-				if (this.options.ranges) this.yylloc.range = [r[0], r[0] + this.yyleng - len];
-				this.yyleng = this.yytext.length;
-				return this;
-			},
-			more: function() {
-				this._more = !0;
-				return this;
-			},
-			reject: function() {
-				if (this.options.backtrack_lexer) this._backtrack = !0;
-				else return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
-` + this.showPosition(), {
-					text: "",
-					token: null,
-					line: this.yylineno
+				break;
+			case 5:
+				this.$ = {
+					type: "IntegerLiteral",
+					value: parseInt($$[$0], /x/.test($$[$0]) ? 16 : 10)
+				};
+				break;
+			case 6:
+				this.$ = {
+					type: "UnsignedIntegerLiteral",
+					value: parseInt($$[$0].replace(/u$/i, ""), /^0x/.test($$[$0]) ? 16 : 10)
+				};
+				break;
+			case 7:
+				this.$ = {
+					type: "FloatLiteral",
+					value: parseFloat($$[$0])
+				};
+				break;
+			case 8:
+				this.$ = {
+					type: "BooleanLiteral",
+					value: $$[$0] === "true"
+				};
+				break;
+			case 9:
+				this.$ = {
+					type: "NullLiteral",
+					value: null
+				};
+				break;
+			case 10:
+			case 11:
+			case 12:
+			case 13:
+			case 14:
+			case 16:
+			case 17:
+			case 18:
+			case 19:
+			case 20:
+			case 21:
+			case 38:
+			case 43:
+			case 44:
+			case 45:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57:
+			case 58:
+				this.$ = $$[$0];
+				break;
+			case 15:
+				this.$ = {
+					type: "Identifier",
+					value: $$[$0]
+				};
+				break;
+			case 22:
+			case 23:
+			case 24:
+				this.$ = {
+					type: "Relation",
+					left: $$[$0 - 2],
+					operator: $$[$0 - 1],
+					right: $$[$0]
+				};
+				break;
+			case 25:
+			case 27:
+				this.$ = 1;
+				break;
+			case 26:
+			case 28:
+				this.$ = this.$ += 1;
+				break;
+			case 29:
+				this.$ = {
+					type: "Negation",
+					negations: $$[$0 - 1],
+					value: $$[$0]
+				};
+				break;
+			case 30:
+			case 31:
+				this.$ = $$[$0];
+				break;
+			case 32:
+				this.$ = {
+					type: "Member",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 33:
+				this.$ = {
+					type: "Member",
+					left: $$[$0 - 5],
+					right: $$[$0 - 3],
+					list: $$[$0 - 1]
+				};
+				break;
+			case 34:
+				this.$ = {
+					type: "DynamicPropertyAccessor",
+					left: $$[$0 - 3],
+					right: $$[$0 - 1]
+				};
+				break;
+			case 35:
+				this.$ = {
+					type: "FieldsObject",
+					left: $$[$0 - 4],
+					list: $$[$0 - 2],
+					trailingComma: $$[$0 - 1]
+				};
+				break;
+			case 36:
+				this.$ = false;
+				break;
+			case 37:
+				this.$ = true;
+				break;
+			case 39:
+				this.$ = {
+					type: "Property",
+					value: $$[$0]
+				};
+				break;
+			case 40:
+				this.$ = {
+					type: "FunctionCall",
+					name: $$[$0 - 4],
+					args: $$[$0 - 2],
+					trailingComma: $$[$0 - 1]
+				};
+				break;
+			case 41:
+				this.$ = {
+					type: "Property",
+					value: $$[$0 - 4],
+					args: $$[$0 - 2],
+					trailingComma: $$[$0 - 1]
+				};
+				break;
+			case 42:
+				this.$ = {
+					type: "ExpressionGroup",
+					value: $$[$0 - 1]
+				};
+				break;
+			case 46:
+				this.$ = {
+					type: "List",
+					value: $$[$0 - 2],
+					trailingComma: $$[$0 - 1]
+				};
+				break;
+			case 47:
+				this.$ = {
+					type: "Map",
+					value: $$[$0 - 2],
+					trailingComma: $$[$0 - 1]
+				};
+				break;
+			case 48:
+				this.$ = {
+					type: "Addition",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 49:
+				this.$ = {
+					type: "Subtraction",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 50:
+				this.$ = {
+					type: "Multiplication",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 51:
+				this.$ = {
+					type: "Division",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 52:
+				this.$ = {
+					type: "Modulo",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 59:
+				this.$ = {
+					type: "ConditionalExpr",
+					condition: $$[$0 - 4],
+					valueIfTrue: $$[$0 - 2],
+					valueIfFalse: $$[$0]
+				};
+				break;
+			case 60:
+				this.$ = {
+					type: "ConditionalAnd",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 61:
+				this.$ = {
+					type: "ConditionalOr",
+					left: $$[$0 - 2],
+					right: $$[$0]
+				};
+				break;
+			case 62:
+				this.$ = {
+					type: "ExpressionList",
+					value: [$$[$0]]
+				};
+				break;
+			case 63:
+				this.$ = $$[$0 - 2];
+				this.$.value.push($$[$0]);
+				break;
+			case 64:
+				this.$ = {
+					type: "FieldInits",
+					value: [{
+						type: "FieldInit",
+						left: $$[$0 - 2],
+						right: $$[$0]
+					}]
+				};
+				break;
+			case 65:
+				this.$ = $$[$0 - 4];
+				this.$.value.push({
+					type: "FieldInit",
+					left: $$[$0 - 2],
+					right: $$[$0]
 				});
-				return this;
-			},
-			less: function(n) {
-				this.unput(this.match.slice(n));
-			},
-			pastInput: function() {
-				var past = this.matched.substr(0, this.matched.length - this.match.length);
-				return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
-			},
-			upcomingInput: function() {
-				var next = this.match;
-				if (next.length < 20) next += this._input.substr(0, 20 - next.length);
-				return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
-			},
-			showPosition: function() {
-				var pre = this.pastInput(), c = Array(pre.length + 1).join("-");
-				return pre + this.upcomingInput() + `
-` + c + "^";
-			},
-			test_match: function(match, indexed_rule) {
-				var token, lines, backup;
-				if (this.options.backtrack_lexer) {
-					backup = {
-						yylineno: this.yylineno,
-						yylloc: {
-							first_line: this.yylloc.first_line,
-							last_line: this.last_line,
-							first_column: this.yylloc.first_column,
-							last_column: this.yylloc.last_column
-						},
-						yytext: this.yytext,
-						match: this.match,
-						matches: this.matches,
-						matched: this.matched,
-						yyleng: this.yyleng,
-						offset: this.offset,
-						_more: this._more,
-						_input: this._input,
-						yy: this.yy,
-						conditionStack: this.conditionStack.slice(0),
-						done: this.done
-					};
-					if (this.options.ranges) backup.yylloc.range = this.yylloc.range.slice(0);
-				}
-				lines = match[0].match(/(?:\r\n?|\n).*/g);
-				if (lines) this.yylineno += lines.length;
-				this.yylloc = {
-					first_line: this.yylloc.last_line,
-					last_line: this.yylineno + 1,
-					first_column: this.yylloc.last_column,
-					last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
+				break;
+			case 66:
+				this.$ = {
+					type: "MapInits",
+					value: [{
+						type: "MapInit",
+						left: $$[$0 - 2],
+						right: $$[$0]
+					}]
 				};
-				this.yytext += match[0];
-				this.match += match[0];
-				this.matches = match;
-				this.yyleng = this.yytext.length;
-				if (this.options.ranges) this.yylloc.range = [this.offset, this.offset += this.yyleng];
-				this._more = !1;
-				this._backtrack = !1;
-				this._input = this._input.slice(match[0].length);
-				this.matched += match[0];
-				token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
-				if (this.done && this._input) this.done = !1;
-				if (token) return token;
-				else if (this._backtrack) {
-					for (var k in backup) this[k] = backup[k];
-					return !1;
-				}
-				return !1;
-			},
-			next: function() {
-				if (this.done) return this.EOF;
-				if (!this._input) this.done = !0;
-				var token, match, tempMatch, index;
-				if (!this._more) {
-					this.yytext = "";
-					this.match = "";
-				}
-				var rules = this._currentRules();
-				for (var i = 0; i < rules.length; i++) {
-					tempMatch = this._input.match(this.rules[rules[i]]);
-					if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
-						match = tempMatch;
-						index = i;
-						if (this.options.backtrack_lexer) {
-							token = this.test_match(tempMatch, rules[i]);
-							if (token !== !1) return token;
-							else if (this._backtrack) {
-								match = !1;
-								continue;
-							} else return !1;
-						} else if (!this.options.flex) break;
-					}
-				}
-				if (match) {
-					token = this.test_match(match, rules[index]);
-					if (token !== !1) return token;
-					return !1;
-				}
-				if (this._input === "") return this.EOF;
-				else return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
-` + this.showPosition(), {
-					text: "",
-					token: null,
-					line: this.yylineno
+				break;
+			case 67:
+				this.$ = $$[$0 - 4];
+				this.$.value.push({
+					type: "MapInit",
+					left: $$[$0 - 2],
+					right: $$[$0]
 				});
-			},
-			lex: function lex() {
-				var r = this.next();
-				if (r) return r;
-				else return this.lex();
-			},
-			begin: function begin(condition) {
-				this.conditionStack.push(condition);
-			},
-			popState: function popState() {
-				if (this.conditionStack.length - 1 > 0) return this.conditionStack.pop();
-				else return this.conditionStack[0];
-			},
-			_currentRules: function _currentRules() {
-				if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
-				else return this.conditions.INITIAL.rules;
-			},
-			topState: function topState(n) {
-				n = this.conditionStack.length - 1 - Math.abs(n || 0);
-				if (n >= 0) return this.conditionStack[n];
-				else return "INITIAL";
-			},
-			pushState: function pushState(condition) {
-				this.begin(condition);
-			},
-			stateStackSize: function stateStackSize() {
-				return this.conditionStack.length;
-			},
-			options: { "flex": true },
-			performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
-				switch ($avoiding_name_collisions) {
-					case 0: break;
-					case 1: break;
-					case 2: return 31;
-					case 3: return "as";
-					case 4: return "break";
-					case 5: return "const";
-					case 6: return "continue";
-					case 7: return "else";
-					case 8: return "for";
-					case 9: return "function";
-					case 10: return "if";
-					case 11: return "import";
-					case 12: return "let";
-					case 13: return "loop";
-					case 14: return "package";
-					case 15: return "namespace";
-					case 16: return "return";
-					case 17: return "var";
-					case 18: return "void";
-					case 19: return "while";
-					case 20: return 18;
-					case 21: return 16;
-					case 22: return 16;
-					case 23: return 40;
-					case 24: return 60;
-					case 25: return 61;
-					case 26: return 50;
-					case 27: return 44;
-					case 28: return 45;
-					case 29: return 41;
-					case 30: return 43;
-					case 31: return 28;
-					case 32: return 35;
-					case 33: return 53;
-					case 34: return 37;
-					case 35: return 54;
-					case 36: return 55;
-					case 37: return 56;
-					case 38: return 23;
-					case 39: return 24;
-					case 40: return 25;
-					case 41: return 26;
-					case 42: return 27;
-					case 43: return 46;
-					case 44: return 49;
-					case 45: return 62;
-					case 46: return 63;
-					case 47: return 21;
-					case 48: return 7;
-					case 49: return 7;
-					case 50: return 7;
-					case 51: return 7;
-					case 52: return 12;
-					case 53: return 13;
-					case 54: return 14;
-					case 55: return 5;
-					case 56: return "INVALID";
-					case 57:
-						console.log(yy_.yytext);
-						break;
-				}
-			},
-			rules: [
-				/^(?:[/][/]\s.*\n)/,
-				/^(?:\s+)/,
-				/^(?:in)/,
-				/^(?:as)/,
-				/^(?:break)/,
-				/^(?:const)/,
-				/^(?:continue)/,
-				/^(?:else)/,
-				/^(?:for)/,
-				/^(?:function)/,
-				/^(?:if)/,
-				/^(?:import)/,
-				/^(?:let)/,
-				/^(?:loop)/,
-				/^(?:package)/,
-				/^(?:namespace)/,
-				/^(?:return)/,
-				/^(?:var)/,
-				/^(?:void)/,
-				/^(?:while)/,
-				/^(?:null)/,
-				/^(?:true)/,
-				/^(?:false)/,
-				/^(?:\.)/,
-				/^(?:\?)/,
-				/^(?::)/,
-				/^(?:,)/,
-				/^(?:\[)/,
-				/^(?:\])/,
-				/^(?:\()/,
-				/^(?:\))/,
-				/^(?:!=)/,
-				/^(?:!)/,
-				/^(?:\+)/,
-				/^(?:-)/,
-				/^(?:\*)/,
-				/^(?:\/)/,
-				/^(?:%)/,
-				/^(?:==)/,
-				/^(?:>=)/,
-				/^(?:>)/,
-				/^(?:<=)/,
-				/^(?:<)/,
-				/^(?:\{)/,
-				/^(?:\})/,
-				/^(?:&&)/,
-				/^(?:\|\|)/,
-				/^(?:[_a-zA-Z][_a-zA-Z0-9]*)/,
-				/^(?:[rR]?['][']['](\.|[^'])*['][']['])/,
-				/^(?:[rR]?["]["]["](\.|[^"])*["]["]["])/,
-				/^(?:[rR]?['](\.|[^'\n\r])*['])/,
-				/^(?:[rR]?["](\.|[^"\n\r])*["])/,
-				/^(?:[-]?([0-9]+|0x[0-9a-fA-F]+))/,
-				/^(?:([0-9]+|0x[0-9a-fA-F]+)[uU])/,
-				/^(?:[-]?[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+(\.[0-9]+)?)?)/,
-				/^(?:$)/,
-				/^(?:.)/,
-				/^(?:.)/
-			],
-			conditions: { "INITIAL": {
-				"rules": [
-					0,
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					8,
-					9,
-					10,
-					11,
-					12,
-					13,
-					14,
-					15,
-					16,
-					17,
-					18,
-					19,
-					20,
-					21,
-					22,
-					23,
-					24,
-					25,
-					26,
-					27,
-					28,
-					29,
-					30,
-					31,
-					32,
-					33,
-					34,
-					35,
-					36,
-					37,
-					38,
-					39,
-					40,
-					41,
-					42,
-					43,
-					44,
-					45,
-					46,
-					47,
-					48,
-					49,
-					50,
-					51,
-					52,
-					53,
-					54,
-					55,
-					56,
-					57
-				],
-				"inclusive": true
-			} }
-		};
-	})();
-	function Parser() {
-		this.yy = {};
+				break;
+		}
+	}
+};
+var CELLexer = class extends JisonLexer {
+	options = {
+		"flex": true,
+		"moduleName": "CEL"
+	};
+	constructor(yy = {}) {
+		super(yy);
 	}
-	Parser.prototype = parser;
-	parser.Parser = Parser;
-	return new Parser();
-})();
+	rules = [
+		/^(?:[/][/]\s.*\n)/,
+		/^(?:\s+)/,
+		/^(?:in)/,
+		/^(?:as)/,
+		/^(?:break)/,
+		/^(?:const)/,
+		/^(?:continue)/,
+		/^(?:else)/,
+		/^(?:for)/,
+		/^(?:function)/,
+		/^(?:if)/,
+		/^(?:import)/,
+		/^(?:let)/,
+		/^(?:loop)/,
+		/^(?:package)/,
+		/^(?:namespace)/,
+		/^(?:return)/,
+		/^(?:var)/,
+		/^(?:void)/,
+		/^(?:while)/,
+		/^(?:null)/,
+		/^(?:true)/,
+		/^(?:false)/,
+		/^(?:\.)/,
+		/^(?:\?)/,
+		/^(?::)/,
+		/^(?:,)/,
+		/^(?:\[)/,
+		/^(?:\])/,
+		/^(?:\()/,
+		/^(?:\))/,
+		/^(?:!=)/,
+		/^(?:!)/,
+		/^(?:\+)/,
+		/^(?:-)/,
+		/^(?:\*)/,
+		/^(?:\/)/,
+		/^(?:%)/,
+		/^(?:==)/,
+		/^(?:>=)/,
+		/^(?:>)/,
+		/^(?:<=)/,
+		/^(?:<)/,
+		/^(?:\{)/,
+		/^(?:\})/,
+		/^(?:&&)/,
+		/^(?:\|\|)/,
+		/^(?:[_a-zA-Z][_a-zA-Z0-9]*)/,
+		/^(?:[rR]?['][']['](?:\.|[^'])*['][']['])/,
+		/^(?:[rR]?["]["]["](?:\.|[^"])*["]["]["])/,
+		/^(?:[rR]?['](?:\.|[^'\n\r])*['])/,
+		/^(?:[rR]?["](?:\.|[^"\n\r])*["])/,
+		/^(?:[-]?(?:[0-9]+|0x[0-9a-fA-F]+))/,
+		/^(?:(?:[0-9]+|0x[0-9a-fA-F]+)[uU])/,
+		/^(?:[-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+(?:\.[0-9]+)?)?)/,
+		/^(?:$)/,
+		/^(?:.)/,
+		/^(?:.)/
+	];
+	conditions = { "INITIAL": {
+		"rules": [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11,
+			12,
+			13,
+			14,
+			15,
+			16,
+			17,
+			18,
+			19,
+			20,
+			21,
+			22,
+			23,
+			24,
+			25,
+			26,
+			27,
+			28,
+			29,
+			30,
+			31,
+			32,
+			33,
+			34,
+			35,
+			36,
+			37,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			46,
+			47,
+			48,
+			49,
+			50,
+			51,
+			52,
+			53,
+			54,
+			55,
+			56,
+			57
+		],
+		"inclusive": true
+	} };
+	performAction(yy, yy_, $avoiding_name_collisions, YY_START) {
+		switch ($avoiding_name_collisions) {
+			case 0: break;
+			case 1: break;
+			case 2: return 31;
+			case 3: return "as";
+			case 4: return "break";
+			case 5: return "const";
+			case 6: return "continue";
+			case 7: return "else";
+			case 8: return "for";
+			case 9: return "function";
+			case 10: return "if";
+			case 11: return "import";
+			case 12: return "let";
+			case 13: return "loop";
+			case 14: return "package";
+			case 15: return "namespace";
+			case 16: return "return";
+			case 17: return "var";
+			case 18: return "void";
+			case 19: return "while";
+			case 20: return 18;
+			case 21: return 16;
+			case 22: return 16;
+			case 23: return 40;
+			case 24: return 60;
+			case 25: return 61;
+			case 26: return 50;
+			case 27: return 44;
+			case 28: return 45;
+			case 29: return 41;
+			case 30: return 43;
+			case 31: return 28;
+			case 32: return 35;
+			case 33: return 53;
+			case 34: return 37;
+			case 35: return 54;
+			case 36: return 55;
+			case 37: return 56;
+			case 38: return 23;
+			case 39: return 24;
+			case 40: return 25;
+			case 41: return 26;
+			case 42: return 27;
+			case 43: return 46;
+			case 44: return 49;
+			case 45: return 62;
+			case 46: return 63;
+			case 47: return 21;
+			case 48: return 7;
+			case 49: return 7;
+			case 50: return 7;
+			case 51: return 7;
+			case 52: return 12;
+			case 53: return 13;
+			case 54: return 14;
+			case 55: return 5;
+			case 56: return "INVALID";
+			case 57:
+				console.log(yy_.yytext);
+				break;
+		}
+	}
+};
 
 //#endregion
 //#region src/utils/parseCEL/utils.ts
@@ -2349,26 +2012,64 @@ const isCELExpressionGroup = (expr) => expr.type === "ExpressionGroup";
 const isCELConditionalAnd = (expr) => expr.type === "ConditionalAnd";
 const isCELConditionalOr = (expr) => expr.type === "ConditionalOr";
 const isCELStringLiteral = (expr) => expr.type === "StringLiteral";
-const isCELLiteral = (expr) => isCELNumericLiteral(expr) || isCELStringLiteral(expr) || expr.type === "BooleanLiteral" || expr.type === "NullLiteral" || expr.type === "BytesLiteral";
-const isCELNumericLiteral = (expr) => expr.type === "FloatLiteral" || expr.type === "IntegerLiteral" || expr.type === "UnsignedIntegerLiteral";
+const isCELLiteral = (expr) => isCELNumericLiteral(expr) || isCELStringLiteral(expr) || isCELBooleanLiteral(expr) || isCELNullLiteral(expr) || isCELBytesLiteral(expr);
+const isCELNumericLiteral = (expr) => isCELFloatLiteral(expr) || isCELIntegerLiteral(expr) || isCELUnsignedIntegerLiteral(expr);
 const isCELRelation = (expr) => expr.type === "Relation";
 const isCELList = (expr) => expr.type === "List";
 const isCELMap = (expr) => expr.type === "Map";
 const isCELIdentifier = (expr) => expr.type === "Identifier";
 const isCELNegation = (expr) => expr.type === "Negation";
 const isCELMember = (expr) => expr.type === "Member";
+// istanbul ignore next
+const isCELAddition = (expr) => expr.type === "Addition";
+const isCELBooleanLiteral = (expr) => expr.type === "BooleanLiteral";
+const isCELBytesLiteral = (expr) => expr.type === "BytesLiteral";
+// istanbul ignore next
+const isCELConditionalExpr = (expr) => expr.type === "ConditionalExpr";
+// istanbul ignore next
+const isCELDivision = (expr) => expr.type === "Division";
+// istanbul ignore next
+const isCELDynamicPropertyAccessor = (expr) => expr.type === "DynamicPropertyAccessor";
+// istanbul ignore next
+const isCELExpressionList = (expr) => expr.type === "ExpressionList";
+// istanbul ignore next
+const isCELFieldInit = (expr) => expr.type === "FieldInit";
+// istanbul ignore next
+const isCELFieldInits = (expr) => expr.type === "FieldInits";
+// istanbul ignore next
+const isCELFieldsObject = (expr) => expr.type === "FieldsObject";
+const isCELFloatLiteral = (expr) => expr.type === "FloatLiteral";
+// istanbul ignore next
+const isCELFunctionCall = (expr) => expr.type === "FunctionCall";
+const isCELIntegerLiteral = (expr) => expr.type === "IntegerLiteral";
+// istanbul ignore next
+const isCELMapInit = (expr) => expr.type === "MapInit";
+// istanbul ignore next
+const isCELMapInits = (expr) => expr.type === "MapInits";
+// istanbul ignore next
+const isCELModulo = (expr) => expr.type === "Modulo";
+// istanbul ignore next
+const isCELMultiplication = (expr) => expr.type === "Multiplication";
+// istanbul ignore next
+const isCELNegative = (expr) => expr.type === "Negative";
+const isCELNullLiteral = (expr) => expr.type === "NullLiteral";
+// istanbul ignore next
+const isCELProperty = (expr) => expr.type === "Property";
+// istanbul ignore next
+const isCELSubtraction = (expr) => expr.type === "Subtraction";
+const isCELUnsignedIntegerLiteral = (expr) => expr.type === "UnsignedIntegerLiteral";
 const isCELIdentifierOrChain = (expr) => isCELIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right);
 const isCELNegatedIdentifier = (expr) => isCELNegation(expr) && isCELIdentifier(expr.value);
 const isCELNegatedIdentifierOrChain = (expr) => isCELNegatedIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.right) && isCELNegatedIdentifier(expr.left);
 const isCELLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
 const isCELNegatedLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELNegatedIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
-const getIdentifierFromChain = (expr) => {
+const getCELIdentifierFromChain = (expr) => {
 	if (isCELIdentifier(expr)) return expr.value;
-	return `${getIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
 };
-const getIdentifierFromNegatedChain = (expr) => {
+const getCELIdentifierFromNegatedChain = (expr) => {
 	if (isCELNegatedIdentifier(expr)) return `${``.padStart(expr.negations, `!`)}${expr.value.value}`;
-	return `${getIdentifierFromNegatedChain(expr.left)}.${expr.right.value}`;
+	return `${getCELIdentifierFromNegatedChain(expr.left)}.${expr.right.value}`;
 };
 function evalCELLiteralValue(literal) {
 	switch (literal.type) {
@@ -2379,8 +2080,8 @@ function evalCELLiteralValue(literal) {
 		default: return literal.value;
 	}
 }
-const normalizeCombinator = (c) => c === "||" ? "or" : "and";
-const normalizeOperator = (op, flip) => {
+const celNormalizeCombinator = (c) => c === "||" ? "or" : "and";
+const celNormalizeOperator = (op, flip) => {
 	if (flip) {
 		if (op === "<") return ">";
 		if (op === "<=") return ">=";
@@ -2390,11 +2091,11 @@ const normalizeOperator = (op, flip) => {
 	if (op === "==") return "=";
 	return op;
 };
-const generateFlatAndOrList = (expr) => {
-	const combinator = normalizeCombinator(expr.type === "ConditionalAnd" ? "&&" : "||");
+const celGenerateFlatAndOrList = (expr) => {
+	const combinator = celNormalizeCombinator(expr.type === "ConditionalAnd" ? "&&" : "||");
 	const { left, right } = expr;
 	if (isCELConditionalAnd(left) || isCELConditionalOr(left)) return [
-		...generateFlatAndOrList(left),
+		...celGenerateFlatAndOrList(left),
 		combinator,
 		right
 	];
@@ -2404,8 +2105,8 @@ const generateFlatAndOrList = (expr) => {
 		right
 	];
 };
-const generateMixedAndOrList = (expr) => {
-	const arr = generateFlatAndOrList(expr);
+const celGenerateMixedAndOrList = (expr) => {
+	const arr = celGenerateFlatAndOrList(expr);
 	const returnArray = [];
 	let startIndex = 0;
 	for (let i = 0; i < arr.length; i += 2) if (arr[i + 1] === "and") {
@@ -2431,7 +2132,7 @@ const generateMixedAndOrList = (expr) => {
 //#endregion
 //#region src/utils/parseCEL/parseCEL.ts
 function parseCEL(cel, options = {}) {
-	const { fields, independentCombinators, listsAsArrays } = options;
+	const { fields, independentCombinators, listsAsArrays, customExpressionHandler } = options;
 	const ic = !!independentCombinators;
 	const fieldsFlat = getFieldsArray(fields);
 	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
@@ -2449,12 +2150,12 @@ function parseCEL(cel, options = {}) {
 		const { forwardNegation: forwardedNegation, groupOnlyIfNecessary } = processOpts;
 		/* istanbul ignore if */
 		if (isCELNegation(expr) || isCELNegatedLikeExpression(expr)) {
-			const negate = isCELNegation(expr) ? expr.negations % 2 === 1 : (getIdentifierFromNegatedChain(expr.left).match(/^!+/)?.[0].length ?? 0) % 2 === 1;
+			const negate = isCELNegation(expr) ? expr.negations % 2 === 1 : (getCELIdentifierFromNegatedChain(expr.left).match(/^!+/)?.[0].length ?? 0) % 2 === 1;
 			const negatedExpr = isCELNegation(expr) && isCELExpressionGroup(expr.value) && isCELLikeExpression(expr.value.value) ? processCELExpression(expr.value.value, { forwardNegation: negate }) : isCELNegatedLikeExpression(expr) ? processCELExpression({
 				...expr,
 				left: {
 					type: "Identifier",
-					value: getIdentifierFromNegatedChain(expr.left).replace(/^!+/, "")
+					value: getCELIdentifierFromNegatedChain(expr.left).replace(/^!+/, "")
 				}
 			}, { forwardNegation: negate }) : isCELNegation(expr) && isCELExpressionGroup(expr.value) && isCELRelation(expr.value.value) ? processCELExpression(expr.value.value, { forwardNegation: negate }) : processCELExpression(expr.value, {
 				groupOnlyIfNecessary: true,
@@ -2486,14 +2187,14 @@ function parseCEL(cel, options = {}) {
 			}
 		} else if (isCELConditionalAnd(expr) || isCELConditionalOr(expr)) {
 			if (ic) {
-				const rules$1 = generateFlatAndOrList(expr).map((v) => {
+				const rules$1 = celGenerateFlatAndOrList(expr).map((v) => {
 					if (typeof v === "string") return v;
 					return processCELExpression(v);
 				});
 				if (!rules$1.every(Boolean)) return null;
 				return { rules: rules$1 };
 			}
-			const andOrList = generateMixedAndOrList(expr);
+			const andOrList = celGenerateMixedAndOrList(expr);
 			const combinator = andOrList[1];
 			const rules = andOrList.filter((v) => Array.isArray(v) || !!v && typeof v !== "string" && "type" in v).map((v) => Array.isArray(v) ? v.filter((vf) => !!v && typeof vf !== "string" && "type" in vf) : v).map((exp) => {
 				if (Array.isArray(exp)) return {
@@ -2508,7 +2209,7 @@ function parseCEL(cel, options = {}) {
 				rules
 			};
 		} else if (isCELLikeExpression(expr)) {
-			const field = getIdentifierFromChain(expr.left);
+			const field = getCELIdentifierFromChain(expr.left);
 			const func = expr.right.value;
 			const operatorPre = func === "startsWith" ? "beginsWith" : func;
 			const operator = forwardedNegation ? `doesNot${operatorPre[0].toUpperCase()}${operatorPre.slice(1).replace("s", "")}` : operatorPre;
@@ -2532,29 +2233,29 @@ function parseCEL(cel, options = {}) {
 			let flip = false;
 			const { left, right } = expr;
 			if (isCELIdentifierOrChain(left)) {
-				field = getIdentifierFromChain(left);
+				field = getCELIdentifierFromChain(left);
 				if (isCELIdentifierOrChain(right)) {
-					value = getIdentifierFromChain(right);
+					value = getCELIdentifierFromChain(right);
 					valueSource = "field";
 				} else if (isCELLiteral(right)) value = evalCELLiteralValue(right);
 			} else if (isCELIdentifierOrChain(right) && isCELLiteral(left) && expr.operator !== "in") {
 				flip = true;
-				field = getIdentifierFromChain(right);
+				field = getCELIdentifierFromChain(right);
 				value = evalCELLiteralValue(left);
 			}
-			let operator = normalizeOperator(expr.operator, flip);
+			let operator = celNormalizeOperator(expr.operator, flip);
 			if (forwardedNegation) operator = defaultOperatorNegationMap[operator];
 			if (value === null && (operator === "=" || operator === "!=")) operator = operator === "=" ? "null" : "notNull";
 			else if ((operator === "in" || operator === "notIn") && isCELList(right)) {
 				if (right.value.value.every((v) => isCELLiteral(v))) value = right.value.value.map((v) => evalCELLiteralValue(v));
 				else if (right.value.value.every((v) => isCELIdentifierOrChain(v))) {
 					valueSource = "field";
-					value = right.value.value.map((id) => getIdentifierFromChain(id));
+					value = right.value.value.map((id) => getCELIdentifierFromChain(id));
 				}
 				if (value && !listsAsArrays) value = joinWith(value.map((v) => `${v}`), ",");
 			} else if ((operator === "in" || operator === "notIn") && isCELMap(right)) {
 				const keys = right.value.value.map((v) => v.left);
-				if (keys.every((k) => isCELLiteral(k) || isCELIdentifierOrChain(k))) value = keys.map((k) => isCELLiteral(k) ? evalCELLiteralValue(k) : getIdentifierFromChain(k));
+				if (keys.every((k) => isCELLiteral(k) || isCELIdentifierOrChain(k))) value = keys.map((k) => isCELLiteral(k) ? evalCELLiteralValue(k) : getCELIdentifierFromChain(k));
 				if (value && !listsAsArrays) value = joinWith(value.map((v) => `${v}`), ",");
 			}
 			if (field && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
@@ -2567,10 +2268,11 @@ function parseCEL(cel, options = {}) {
 				operator,
 				value
 			};
-		}
+		} else if (customExpressionHandler) return customExpressionHandler(expr);
 		return null;
 	};
 	const prepare = options.generateIDs ? prepareRuleGroup : (g) => g;
+	const celParser = new CELParser();
 	let processedCEL;
 	try {
 		processedCEL = celParser.parse(cel).value;
@@ -2589,5 +2291,5 @@ function parseCEL(cel, options = {}) {
 }
 
 //#endregion
-export { parseCEL };
+export { celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL };
 //# sourceMappingURL=parseCEL.mjs.map