@react-querybuilder/core 8.9.2 → 8.11.0

package/dist/{import-Cksobmln.d.ts → import-Cz8canKo.d.mts}

@@ -1,4 +1,4 @@
-import { FullField, OptionList, ValueSources } from "./basic-C8xXKHIA.js";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-DEc65Kng.mjs";
 
 //#region src/types/import.d.ts
 
@@ -24,5 +24,5 @@ interface ParserCommonOptions {
   bigIntOnOverflow?: boolean;
 }
 //#endregion
-export { ParserCommonOptions };
-//# sourceMappingURL=import-Cksobmln.d.ts.map
+export { ParserCommonOptions as t };
+//# sourceMappingURL=import-Cz8canKo.d.mts.map

package/dist/{import-BwbbP4oU.d.mts → import-DtS9Ocx5.d.ts}

@@ -1,4 +1,4 @@
-import { FullField, OptionList, ValueSources } from "./basic-BfD-7CN3.mjs";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-Dd_M2f3M.js";
 
 //#region src/types/import.d.ts
 
@@ -24,5 +24,5 @@ interface ParserCommonOptions {
   bigIntOnOverflow?: boolean;
 }
 //#endregion
-export { ParserCommonOptions };
-//# sourceMappingURL=import-BwbbP4oU.d.mts.map
+export { ParserCommonOptions as t };
+//# sourceMappingURL=import-DtS9Ocx5.d.ts.map

package/dist/{isRuleGroup-CnhYpLOM.mjs → isRuleGroup-CYcfPgbg.mjs}

@@ -36,5 +36,5 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 
 //#endregion
-export { isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc, nullOrUndefinedOrEmpty, numericRegex$1 as numericRegex };
-//# sourceMappingURL=isRuleGroup-CnhYpLOM.mjs.map
+export { lc as a, isPojo as i, isRuleGroupType as n, nullOrUndefinedOrEmpty as o, isRuleGroupTypeIC as r, numericRegex$1 as s, isRuleGroup as t };
+//# sourceMappingURL=isRuleGroup-CYcfPgbg.mjs.map

package/dist/{isRuleGroup-CnhYpLOM.mjs.map → isRuleGroup-CYcfPgbg.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isRuleGroup-CnhYpLOM.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}
+{"version":3,"file":"isRuleGroup-CYcfPgbg.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/lexer-C53tqS2p.js

@@ -0,0 +1,406 @@
+const require_isRuleGroup = require('./isRuleGroup-DqAs2x4E.js');
+
+//#region ../../node_modules/@ts-jison/parser/lib/parser.js
+var require_parser = /* @__PURE__ */ require_isRuleGroup.__commonJS({ "../../node_modules/@ts-jison/parser/lib/parser.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var JisonParser = function() {
+		function JisonParser$1(yy, lexer) {
+			if (yy === void 0) yy = {};
+			this.yy = yy;
+			this.lexer = lexer;
+		}
+		JisonParser$1.prototype.trace = function(str) {};
+		JisonParser$1.prototype.parseError = function(str, hash) {
+			if (hash.recoverable) this.trace(str);
+			else {
+				var error = new Error(str);
+				error.hash = hash;
+				throw error;
+			}
+		};
+		JisonParser$1.prototype.parse = function(input, yy) {
+			if (yy === void 0) yy = typeof this.yy === "function" && typeof this.yy.constructor === "function" ? new this.yy(this, this.lexer) : Object.create(this.yy);
+			var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+			var args = lstack.slice.call(arguments, 1);
+			var lexer = Object.create(this.lexer);
+			var sharedState = { yy };
+			lexer.setInput(input, sharedState.yy);
+			sharedState.yy.lexer = lexer;
+			sharedState.yy.parser = this;
+			if (typeof lexer.yylloc == "undefined") 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;
+			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 (true) {
+				state = stack[stack.length - 1];
+				if (this.defaultActions[state]) action = this.defaultActions[state];
+				else {
+					if (symbol === null || typeof symbol == "undefined") symbol = lex();
+					action = table[state] && table[state][symbol];
+				}
+				_handle_error: if (typeof action === "undefined" || !action.length || !action[0]) {
+					var error_rule_depth = null;
+					var errStr = "";
+					if (!recovering) {
+						error_rule_depth = locateNearestErrorRecoveryRule(state);
+						expected = [];
+						for (var _p in table[state]) {
+							p = Number(_p);
+							if (this.terminals_[p] && p > TERROR) expected.push("'" + this.terminals_[p] + "'");
+						}
+						if (lexer.showPosition) errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer.showPosition() + "\nExpecting " + 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: lexer.yylloc,
+							expected,
+							recoverable: error_rule_depth !== null
+						});
+					} else if (preErrorSymbol !== EOF) error_rule_depth = locateNearestErrorRecoveryRule(state);
+					if (recovering == 3) {
+						if (symbol === EOF || preErrorSymbol === EOF) throw new 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 === null) throw new Error(errStr || "Parsing halted. No suitable error recovery rule available.");
+					popStack(error_rule_depth || 0);
+					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 new 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 !== "undefined") 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 true;
+				}
+			}
+			return true;
+			function locateNearestErrorRecoveryRule(state$1) {
+				var stack_probe = stack.length - 1;
+				var depth = 0;
+				for (;;) {
+					if (TERROR.toString() in table[state$1]) return depth;
+					if (state$1 === 0 || stack_probe < 2) return null;
+					stack_probe -= 2;
+					state$1 = stack[stack_probe];
+					++depth;
+				}
+			}
+		};
+		JisonParser$1.expandParseTable = function(k, v, o) {
+			var l = k.length;
+			for (o = o || {}; l--; o[k[l]] = v);
+			return o;
+		};
+		return JisonParser$1;
+	}();
+	exports.JisonParser = JisonParser;
+}) });
+
+//#endregion
+//#region ../../node_modules/@ts-jison/lexer/lib/lexer.js
+var require_lexer = /* @__PURE__ */ require_isRuleGroup.__commonJS({ "../../node_modules/@ts-jison/lexer/lib/lexer.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var JisonLexer = function() {
+		function JisonLexer$1(yy) {
+			if (yy === void 0) yy = {};
+			this.yy = yy;
+			this.EOF = 1;
+			this.options = {};
+			this.yyleng = 0;
+			this.yylloc = {
+				first_line: 1,
+				first_column: 0,
+				last_line: 1,
+				last_column: 0
+			};
+		}
+		JisonLexer$1.prototype.parseError = function(str, hash) {
+			if (this.yy.parser) this.yy.parser.parseError(str, hash);
+			else throw new Error(str);
+		};
+		JisonLexer$1.prototype.setInput = function(input, yy) {
+			this.yy = yy || this.yy || {};
+			this._input = input;
+			this._more = this._backtrack = this.done = false;
+			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
+			};
+			if (this.options.ranges) this.yylloc.range = [0, 0];
+			this.offset = 0;
+			return this;
+		};
+		JisonLexer$1.prototype.input = function() {
+			if (this._input.length === 0) {
+				this.done = true;
+				return "" + this.EOF;
+			}
+			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;
+		};
+		JisonLexer$1.prototype.unput = function(ch) {
+			var len = ch.length;
+			var 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
+			};
+			if (this.options.ranges) this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+			this.yyleng = this.yytext.length;
+			return this;
+		};
+		JisonLexer$1.prototype.more = function() {
+			this._more = true;
+			return this;
+		};
+		JisonLexer$1.prototype.reject = function() {
+			if (this.options.backtrack_lexer) this._backtrack = true;
+			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).\n" + this.showPosition(), {
+				text: "",
+				token: null,
+				line: this.yylineno
+			});
+			return this;
+		};
+		JisonLexer$1.prototype.less = function(n) {
+			this.unput(this.match.slice(n));
+		};
+		JisonLexer$1.prototype.pastInput = function() {
+			var past = this.matched.substr(0, this.matched.length - this.match.length);
+			return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
+		};
+		JisonLexer$1.prototype.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, "");
+		};
+		JisonLexer$1.prototype.showPosition = function() {
+			var pre = this.pastInput();
+			var c = new Array(pre.length + 1).join("-");
+			return pre + this.upcomingInput() + "\n" + c + "^";
+		};
+		JisonLexer$1.prototype.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.yylloc.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
+			};
+			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 = false;
+			this._backtrack = false;
+			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 = false;
+			if (token) return token;
+			else if (this._backtrack) {
+				for (var k in backup) this[k] = backup[k];
+				return false;
+			}
+			return false;
+		};
+		JisonLexer$1.prototype.next = function() {
+			if (this.done) return this.EOF;
+			if (!this._input) this.done = true;
+			var token, match = null, 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 !== false) return token;
+						else if (this._backtrack) {
+							match = null;
+							continue;
+						} else return false;
+					} else if (!this.options.flex) break;
+				}
+			}
+			if (match) {
+				token = this.test_match(match, rules[index]);
+				if (token !== false) return token;
+				return false;
+			}
+			if (this._input === "") return this.EOF;
+			else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+				text: "",
+				token: null,
+				line: this.yylineno
+			});
+		};
+		JisonLexer$1.prototype.lex = function() {
+			var r = this.next();
+			if (r) return r;
+			else return this.lex();
+		};
+		JisonLexer$1.prototype.begin = function(condition) {
+			this.conditionStack.push(condition);
+		};
+		JisonLexer$1.prototype.popState = function() {
+			if (this.conditionStack.length - 1 > 0) return this.conditionStack.pop();
+			else return this.conditionStack[0];
+		};
+		JisonLexer$1.prototype._currentRules = function() {
+			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;
+		};
+		JisonLexer$1.prototype.topState = function(n) {
+			n = this.conditionStack.length - 1 - Math.abs(n || 0);
+			if (n >= 0) return this.conditionStack[n];
+			else return "INITIAL";
+		};
+		JisonLexer$1.prototype.pushState = function(condition) {
+			this.begin(condition);
+		};
+		JisonLexer$1.prototype.stateStackSize = function() {
+			return this.conditionStack.length;
+		};
+		return JisonLexer$1;
+	}();
+	exports.JisonLexer = JisonLexer;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'require_lexer', {
+  enumerable: true,
+  get: function () {
+    return require_lexer;
+  }
+});
+Object.defineProperty(exports, 'require_parser', {
+  enumerable: true,
+  get: function () {
+    return require_parser;
+  }
+});
+//# sourceMappingURL=lexer-C53tqS2p.js.map

package/dist/lexer-C53tqS2p.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer-C53tqS2p.js","names":["JisonParser","state","JisonLexer"],"sources":["../../../node_modules/@ts-jison/parser/lib/parser.js","../../../node_modules/@ts-jison/lexer/lib/lexer.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.JisonParser = void 0;\nvar JisonParser = /** @class */ (function () {\n    function JisonParser(yy, lexer) {\n        if (yy === void 0) { yy = {}; }\n        this.yy = yy;\n        this.lexer = lexer;\n    }\n    JisonParser.prototype.trace = function (str) { };\n    JisonParser.prototype.parseError = function (str, hash) {\n        if (hash.recoverable) {\n            this.trace(str);\n        }\n        else {\n            var error = new Error(str);\n            error.hash = hash;\n            throw error;\n        }\n    };\n    JisonParser.prototype.parse = function (input, yy) {\n        if (yy === void 0) { yy = typeof this.yy === 'function' && typeof this.yy.constructor === 'function' ? new this.yy(this, this.lexer) : Object.create(this.yy); }\n        var self = this, stack = [0], tstack = [], // token stack\n        vstack = [null], // semantic value stack\n        lstack = [], // location stack\n        table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;\n        var args = lstack.slice.call(arguments, 1);\n        //this.reductionCount = this.shiftCount = 0;\n        var lexer = Object.create(this.lexer);\n        var sharedState = { yy: yy };\n        lexer.setInput(input, sharedState.yy);\n        sharedState.yy.lexer = lexer;\n        sharedState.yy.parser = this;\n        if (typeof lexer.yylloc == 'undefined') {\n            lexer.yylloc = {};\n        }\n        var yyloc = lexer.yylloc;\n        lstack.push(yyloc);\n        var ranges = lexer.options && lexer.options.ranges;\n        if (typeof sharedState.yy.parseError === 'function') {\n            this.parseError = sharedState.yy.parseError;\n        }\n        function popStack(n) {\n            stack.length = stack.length - 2 * n;\n            vstack.length = vstack.length - n;\n            lstack.length = lstack.length - n;\n        }\n        var lex = function () {\n            var token;\n            // @ts-ignore\n            token = (lexer.lex() || EOF);\n            // if token isn't its numeric value, convert\n            if (typeof token !== 'number') {\n                token = self.symbols_[token] || token;\n            }\n            return token;\n        };\n        var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;\n        while (true) {\n            // retreive state number from top of stack\n            state = stack[stack.length - 1];\n            // use default actions if available\n            if (this.defaultActions[state]) {\n                action = this.defaultActions[state];\n            }\n            else {\n                if (symbol === null || typeof symbol == 'undefined') {\n                    symbol = lex();\n                }\n                // read action for current state and first input\n                action = table[state] && table[state][symbol];\n            }\n            _handle_error: \n            // handle parse error\n            if (typeof action === 'undefined' || !action.length || !action[0]) {\n                var error_rule_depth = null;\n                var errStr = '';\n                if (!recovering) {\n                    // first see if there's any chance at hitting an error recovery rule:\n                    error_rule_depth = locateNearestErrorRecoveryRule(state);\n                    // Report error\n                    expected = [];\n                    for (var _p in table[state]) {\n                        p = Number(_p);\n                        if (this.terminals_[p] && p > TERROR) {\n                            expected.push(\"'\" + this.terminals_[p] + \"'\");\n                        }\n                    }\n                    if (lexer.showPosition) {\n                        errStr = 'Parse error on line ' + (yylineno + 1) + \":\\n\" + lexer.showPosition() + \"\\nExpecting \" + expected.join(', ') + \", got '\" + (this.terminals_[symbol] || symbol) + \"'\";\n                    }\n                    else {\n                        errStr = 'Parse error on line ' + (yylineno + 1) + \": Unexpected \" +\n                            (symbol == EOF ? \"end of input\" :\n                                (\"'\" + (this.terminals_[symbol] || symbol) + \"'\"));\n                    }\n                    this.parseError(errStr, {\n                        text: lexer.match,\n                        token: this.terminals_[symbol] || symbol,\n                        line: lexer.yylineno,\n                        loc: lexer.yylloc,\n                        expected: expected,\n                        recoverable: (error_rule_depth !== null)\n                    });\n                }\n                else if (preErrorSymbol !== EOF) {\n                    error_rule_depth = locateNearestErrorRecoveryRule(state);\n                }\n                // just recovered from another error\n                if (recovering == 3) {\n                    if (symbol === EOF || preErrorSymbol === EOF) {\n                        throw new Error(errStr || 'Parsing halted while starting to recover from another error.');\n                    }\n                    // discard current lookahead and grab another\n                    yyleng = lexer.yyleng;\n                    yytext = lexer.yytext;\n                    yylineno = lexer.yylineno;\n                    yyloc = lexer.yylloc;\n                    symbol = lex();\n                }\n                // try to recover from error\n                if (error_rule_depth === null) {\n                    throw new Error(errStr || 'Parsing halted. No suitable error recovery rule available.');\n                }\n                popStack(error_rule_depth || 0);\n                preErrorSymbol = (symbol == TERROR ? null : symbol); // save the lookahead token\n                symbol = TERROR; // insert generic error symbol as new lookahead\n                state = stack[stack.length - 1];\n                action = table[state] && table[state][TERROR];\n                recovering = 3; // allow 3 real symbols to be shifted before reporting a new error\n            }\n            // this shouldn't happen, unless resolve defaults are off\n            if (action[0] instanceof Array && action.length > 1) {\n                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);\n            }\n            switch (action[0]) {\n                case 1: // shift\n                    //this.shiftCount++;\n                    stack.push(symbol);\n                    vstack.push(lexer.yytext);\n                    lstack.push(lexer.yylloc);\n                    stack.push(action[1]); // push state\n                    symbol = null;\n                    if (!preErrorSymbol) { // normal execution/no error\n                        yyleng = lexer.yyleng;\n                        yytext = lexer.yytext;\n                        yylineno = lexer.yylineno;\n                        yyloc = lexer.yylloc;\n                        if (recovering > 0) {\n                            recovering--;\n                        }\n                    }\n                    else {\n                        // error just occurred, resume old lookahead f/ before error\n                        symbol = preErrorSymbol;\n                        preErrorSymbol = null;\n                    }\n                    break;\n                case 2:\n                    // reduce\n                    //this.reductionCount++;\n                    len = this.productions_[action[1]][1];\n                    // perform semantic action\n                    yyval.$ = vstack[vstack.length - len]; // default to $$ = $1\n                    // default location, uses first token for firsts, last for lasts\n                    yyval._$ = {\n                        first_line: lstack[lstack.length - (len || 1)].first_line,\n                        last_line: lstack[lstack.length - 1].last_line,\n                        first_column: lstack[lstack.length - (len || 1)].first_column,\n                        last_column: lstack[lstack.length - 1].last_column\n                    };\n                    if (ranges) {\n                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];\n                    }\n                    // @ts-ignore\n                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));\n                    if (typeof r !== 'undefined') {\n                        return r;\n                    }\n                    // pop off stack\n                    if (len) {\n                        stack = stack.slice(0, -1 * len * 2);\n                        vstack = vstack.slice(0, -1 * len);\n                        lstack = lstack.slice(0, -1 * len);\n                    }\n                    stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)\n                    vstack.push(yyval.$);\n                    lstack.push(yyval._$);\n                    // goto new state = table[STATE][NONTERMINAL]\n                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];\n                    stack.push(newState);\n                    break;\n                case 3:\n                    // accept\n                    return true;\n            }\n        }\n        return true;\n        // Return the rule stack depth where the nearest error rule can be found.\n        // Return FALSE when no error recovery rule was found.\n        function locateNearestErrorRecoveryRule(state) {\n            var stack_probe = stack.length - 1;\n            var depth = 0;\n            // try to recover from error\n            for (;;) {\n                // check for error recovery rule in this state\n                if ((TERROR.toString()) in table[state]) {\n                    return depth;\n                }\n                if (state === 0 || stack_probe < 2) {\n                    return null; // No suitable error recovery rule available.\n                }\n                stack_probe -= 2; // popStack(1): [symbol, action]\n                state = stack[stack_probe];\n                ++depth;\n            }\n        }\n    };\n    /* Function that extends an object with the given value for all given keys\n     * e.g., o([1, 3, 4], [6, 7], { x: 1, y: 2 }) = { 1: [6, 7]; 3: [6, 7], 4: [6, 7], x: 1, y: 2 }\n     * This is used to docompress parser tables at module load time.\n     */\n    JisonParser.expandParseTable = function (k, v, o) {\n        var l = k.length;\n        for (o = o || {}; l--; o[k[l]] = v)\n            ;\n        return o;\n    };\n    return JisonParser;\n}());\nexports.JisonParser = JisonParser;\n//# sourceMappingURL=parser.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.JisonLexer = void 0;\nvar JisonLexer = /** @class */ (function () {\n    function JisonLexer(yy) {\n        if (yy === void 0) { yy = {}; }\n        this.yy = yy;\n        this.EOF = 1;\n        this.options = {};\n        this.yyleng = 0;\n        this.yylloc = {\n            first_line: 1,\n            first_column: 0,\n            last_line: 1,\n            last_column: 0\n        };\n    }\n    JisonLexer.prototype.parseError = function (str, hash) {\n        if (this.yy.parser) {\n            this.yy.parser.parseError(str, hash);\n        }\n        else {\n            throw new Error(str);\n        }\n    };\n    // resets the lexer, sets new input\n    JisonLexer.prototype.setInput = function (input, yy) {\n        this.yy = yy || this.yy || {};\n        this._input = input;\n        this._more = this._backtrack = this.done = false;\n        this.yylineno = this.yyleng = 0;\n        this.yytext = this.matched = this.match = '';\n        this.conditionStack = ['INITIAL'];\n        this.yylloc = {\n            first_line: 1,\n            first_column: 0,\n            last_line: 1,\n            last_column: 0\n        };\n        if (this.options.ranges) {\n            this.yylloc.range = [0, 0];\n        }\n        this.offset = 0;\n        return this;\n    };\n    // consumes and returns one char from the input\n    JisonLexer.prototype.input = function () {\n        if (this._input.length === 0) {\n            this.done = true;\n            return '' + this.EOF;\n        }\n        var ch = this._input[0];\n        this.yytext += ch;\n        this.yyleng++;\n        this.offset++;\n        this.match += ch;\n        this.matched += ch;\n        var lines = ch.match(/(?:\\r\\n?|\\n).*/g);\n        if (lines) {\n            this.yylineno++;\n            this.yylloc.last_line++;\n        }\n        else {\n            this.yylloc.last_column++;\n        }\n        if (this.options.ranges) {\n            this.yylloc.range[1]++;\n        }\n        this._input = this._input.slice(1);\n        return ch;\n    };\n    // unshifts one char (or a string) into the input\n    JisonLexer.prototype.unput = function (ch) {\n        var len = ch.length;\n        var lines = ch.split(/(?:\\r\\n?|\\n)/g);\n        this._input = ch + this._input;\n        this.yytext = this.yytext.substr(0, this.yytext.length - len);\n        //this.yyleng -= len;\n        this.offset -= len;\n        var oldLines = this.match.split(/(?:\\r\\n?|\\n)/g);\n        this.match = this.match.substr(0, this.match.length - 1);\n        this.matched = this.matched.substr(0, this.matched.length - 1);\n        if (lines.length - 1) {\n            this.yylineno -= lines.length - 1;\n        }\n        var r = this.yylloc.range;\n        var yylloc = {\n            first_line: this.yylloc.first_line,\n            last_line: this.yylineno + 1,\n            first_column: this.yylloc.first_column,\n            last_column: lines ?\n                (lines.length === oldLines.length ? this.yylloc.first_column : 0)\n                    + oldLines[oldLines.length - lines.length].length - lines[0].length :\n                this.yylloc.first_column - len\n        };\n        this.yylloc = yylloc;\n        if (this.options.ranges) {\n            this.yylloc.range = [r[0], r[0] + this.yyleng - len];\n        }\n        this.yyleng = this.yytext.length;\n        return this;\n    };\n    // When called from action, caches matched text and appends it on next action\n    JisonLexer.prototype.more = function () {\n        this._more = true;\n        return this;\n    };\n    // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.\n    JisonLexer.prototype.reject = function () {\n        if (this.options.backtrack_lexer) {\n            this._backtrack = true;\n        }\n        else {\n            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).\\n' + this.showPosition(), {\n                text: \"\",\n                token: null,\n                line: this.yylineno\n            });\n        }\n        return this;\n    };\n    // retain first n characters of the match\n    JisonLexer.prototype.less = function (n) {\n        this.unput(this.match.slice(n));\n    };\n    // displays already matched input, i.e. for error messages\n    JisonLexer.prototype.pastInput = function () {\n        var past = this.matched.substr(0, this.matched.length - this.match.length);\n        return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\\n/g, \"\");\n    };\n    // displays upcoming input, i.e. for error messages\n    JisonLexer.prototype.upcomingInput = function () {\n        var next = this.match;\n        if (next.length < 20) {\n            next += this._input.substr(0, 20 - next.length);\n        }\n        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\\n/g, \"\");\n    };\n    // displays the character position where the lexing error occurred, i.e. for error messages\n    JisonLexer.prototype.showPosition = function () {\n        var pre = this.pastInput();\n        var c = new Array(pre.length + 1).join(\"-\");\n        return pre + this.upcomingInput() + \"\\n\" + c + \"^\";\n    };\n    // test the lexed token: return FALSE when not a match, otherwise return token\n    JisonLexer.prototype.test_match = function (match, indexed_rule) {\n        var token, lines, backup;\n        if (this.options.backtrack_lexer) {\n            // save context\n            backup = {\n                yylineno: this.yylineno,\n                yylloc: {\n                    first_line: this.yylloc.first_line,\n                    last_line: this.yylloc.last_line,\n                    first_column: this.yylloc.first_column,\n                    last_column: this.yylloc.last_column\n                },\n                yytext: this.yytext,\n                match: this.match,\n                matches: this.matches,\n                matched: this.matched,\n                yyleng: this.yyleng,\n                offset: this.offset,\n                _more: this._more,\n                _input: this._input,\n                yy: this.yy,\n                conditionStack: this.conditionStack.slice(0),\n                done: this.done\n            };\n            if (this.options.ranges) {\n                backup.yylloc.range = (this.yylloc.range.slice(0));\n            }\n        }\n        lines = match[0].match(/(?:\\r\\n?|\\n).*/g);\n        if (lines) {\n            this.yylineno += lines.length;\n        }\n        this.yylloc = {\n            first_line: this.yylloc.last_line,\n            last_line: this.yylineno + 1,\n            first_column: this.yylloc.last_column,\n            last_column: lines ?\n                lines[lines.length - 1].length - lines[lines.length - 1].match(/\\r?\\n?/)[0].length :\n                this.yylloc.last_column + match[0].length\n        };\n        this.yytext += match[0];\n        this.match += match[0];\n        this.matches = match;\n        this.yyleng = this.yytext.length;\n        if (this.options.ranges) {\n            this.yylloc.range = [this.offset, this.offset += this.yyleng];\n        }\n        this._more = false;\n        this._backtrack = false;\n        this._input = this._input.slice(match[0].length);\n        this.matched += match[0];\n        token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);\n        if (this.done && this._input) {\n            this.done = false;\n        }\n        if (token) {\n            return token;\n        }\n        else if (this._backtrack) {\n            // recover context\n            for (var k in backup) { // what's the typescript-y way to copy fields across?\n                this[k] = backup[k];\n            }\n            return false; // rule action called reject() implying the next rule should be tested instead.\n        }\n        return false;\n    };\n    // return next match in input\n    JisonLexer.prototype.next = function () {\n        if (this.done) {\n            return this.EOF;\n        }\n        if (!this._input) {\n            this.done = true;\n        }\n        var token, match = null, tempMatch, index;\n        if (!this._more) {\n            this.yytext = '';\n            this.match = '';\n        }\n        var rules = this._currentRules();\n        for (var i = 0; i < rules.length; i++) {\n            tempMatch = this._input.match(this.rules[rules[i]]);\n            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {\n                match = tempMatch;\n                index = i;\n                if (this.options.backtrack_lexer) {\n                    token = this.test_match(tempMatch, rules[i]);\n                    if (token !== false) {\n                        return token;\n                    }\n                    else if (this._backtrack) {\n                        match = null;\n                        continue; // rule action called reject() implying a rule MISmatch.\n                    }\n                    else {\n                        // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n                        return false;\n                    }\n                }\n                else if (!this.options.flex) {\n                    break;\n                }\n            }\n        }\n        if (match) {\n            token = this.test_match(match, rules[index]);\n            if (token !== false) {\n                return token;\n            }\n            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n            return false;\n        }\n        if (this._input === \"\") {\n            return this.EOF;\n        }\n        else {\n            return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\\n' + this.showPosition(), {\n                text: \"\",\n                token: null,\n                line: this.yylineno\n            });\n        }\n    };\n    // return next match that has a token\n    JisonLexer.prototype.lex = function () {\n        var r = this.next();\n        if (r) {\n            return r;\n        }\n        else {\n            return this.lex();\n        }\n    };\n    // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)\n    JisonLexer.prototype.begin = function (condition) {\n        this.conditionStack.push(condition);\n    };\n    // pop the previously active lexer condition state off the condition stack\n    JisonLexer.prototype.popState = function () {\n        var n = this.conditionStack.length - 1;\n        if (n > 0) {\n            return this.conditionStack.pop();\n        }\n        else {\n            return this.conditionStack[0];\n        }\n    };\n    // produce the lexer rule set which is active for the currently active lexer condition state\n    JisonLexer.prototype._currentRules = function () {\n        if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {\n            return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;\n        }\n        else {\n            return this.conditions[\"INITIAL\"].rules;\n        }\n    };\n    // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available\n    JisonLexer.prototype.topState = function (n) {\n        n = this.conditionStack.length - 1 - Math.abs(n || 0);\n        if (n >= 0) {\n            return this.conditionStack[n];\n        }\n        else {\n            return \"INITIAL\";\n        }\n    };\n    // alias for begin(condition)\n    JisonLexer.prototype.pushState = function (condition) {\n        this.begin(condition);\n    };\n    // return the number of states currently on the stack\n    JisonLexer.prototype.stateStackSize = function () {\n        return this.conditionStack.length;\n    };\n    return JisonLexer;\n}());\nexports.JisonLexer = JisonLexer;\n//# sourceMappingURL=lexer.js.map"],"x_google_ignoreList":[0,1],"mappings":";;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;CAE7D,IAAI,cAA6B,WAAY;EACzC,SAASA,cAAY,IAAI,OAAO;AAC5B,OAAI,OAAO,KAAK,EAAK,MAAK,EAAE;AAC5B,QAAK,KAAK;AACV,QAAK,QAAQ;;AAEjB,gBAAY,UAAU,QAAQ,SAAU,KAAK;AAC7C,gBAAY,UAAU,aAAa,SAAU,KAAK,MAAM;AACpD,OAAI,KAAK,YACL,MAAK,MAAM,IAAI;QAEd;IACD,IAAI,QAAQ,IAAI,MAAM,IAAI;AAC1B,UAAM,OAAO;AACb,UAAM;;;AAGd,gBAAY,UAAU,QAAQ,SAAU,OAAO,IAAI;AAC/C,OAAI,OAAO,KAAK,EAAK,MAAK,OAAO,KAAK,OAAO,cAAc,OAAO,KAAK,GAAG,gBAAgB,aAAa,IAAI,KAAK,GAAG,MAAM,KAAK,MAAM,GAAG,OAAO,OAAO,KAAK,GAAG;GAC7J,IAAI,OAAO,MAAM,QAAQ,CAAC,EAAE,EAC5B,SAAS,CAAC,KAAK,EACf,SAAS,EAAE,EACX,QAAQ,KAAK,OAAO,SAAS,IAAI,WAAW,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,MAAM;GAC7F,IAAI,OAAO,OAAO,MAAM,KAAK,WAAW,EAAE;GAE1C,IAAI,QAAQ,OAAO,OAAO,KAAK,MAAM;GACrC,IAAI,cAAc,EAAM,IAAI;AAC5B,SAAM,SAAS,OAAO,YAAY,GAAG;AACrC,eAAY,GAAG,QAAQ;AACvB,eAAY,GAAG,SAAS;AACxB,OAAI,OAAO,MAAM,UAAU,YACvB,OAAM,SAAS,EAAE;GAErB,IAAI,QAAQ,MAAM;AAClB,UAAO,KAAK,MAAM;GAClB,IAAI,SAAS,MAAM,WAAW,MAAM,QAAQ;AAC5C,OAAI,OAAO,YAAY,GAAG,eAAe,WACrC,MAAK,aAAa,YAAY,GAAG;GAErC,SAAS,SAAS,GAAG;AACjB,UAAM,SAAS,MAAM,SAAS,IAAI;AAClC,WAAO,SAAS,OAAO,SAAS;AAChC,WAAO,SAAS,OAAO,SAAS;;GAEpC,IAAI,MAAM,WAAY;IAClB,IAAI,QAEK,MAAM,KAAK,IAAI;AAExB,QAAI,OAAO,UAAU,SACjB,SAAQ,KAAK,SAAS,UAAU;AAEpC,WAAO;MAEP,QAAQ,gBAAgB,OAAO,QAAW,GAAG,QAAQ,EAAE,EAAE,GAAG,KAAK,UAAU;AAC/E,UAAO,MAAM;AAET,YAAQ,MAAM,MAAM,SAAS;AAE7B,QAAI,KAAK,eAAe,OACpB,UAAS,KAAK,eAAe;SAE5B;AACD,SAAI,WAAW,QAAQ,OAAO,UAAU,YACpC,UAAS,KAAK;AAGlB,cAAS,MAAM,UAAU,MAAM,OAAO;;AAE1C,kBAEA,KAAI,OAAO,WAAW,eAAe,CAAC,OAAO,UAAU,CAAC,OAAO,IAAI;KAC/D,IAAI,mBAAmB;KACvB,IAAI,SAAS;AACb,SAAI,CAAC,YAAY;AAEb,yBAAmB,+BAA+B,MAAM;AAExD,iBAAW,EAAE;AACb,WAAK,IAAI,MAAM,MAAM,QAAQ;AACzB,WAAI,OAAO,GAAG;AACd,WAAI,KAAK,WAAW,MAAM,IAAI,OAC1B,UAAS,KAAK,MAAM,KAAK,WAAW,KAAK,IAAI;;AAGrD,UAAI,MAAM,aACN,UAAS,0BAA0B,WAAW,KAAK,QAAQ,MAAM,cAAc,GAAG,iBAAiB,SAAS,KAAK,KAAK,GAAG,aAAa,KAAK,WAAW,WAAW,UAAU;UAG3K,UAAS,0BAA0B,WAAW,KAAK,mBAC9C,UAAU,MAAM,iBACZ,OAAO,KAAK,WAAW,WAAW,UAAU;AAEzD,WAAK,WAAW,QAAQ;OACpB,MAAM,MAAM;OACZ,OAAO,KAAK,WAAW,WAAW;OAClC,MAAM,MAAM;OACZ,KAAK,MAAM;OACD;OACV,aAAc,qBAAqB;OACtC,CAAC;gBAEG,mBAAmB,IACxB,oBAAmB,+BAA+B,MAAM;AAG5D,SAAI,cAAc,GAAG;AACjB,UAAI,WAAW,OAAO,mBAAmB,IACrC,OAAM,IAAI,MAAM,UAAU,+DAA+D;AAG7F,eAAS,MAAM;AACf,eAAS,MAAM;AACf,iBAAW,MAAM;AACjB,cAAQ,MAAM;AACd,eAAS,KAAK;;AAGlB,SAAI,qBAAqB,KACrB,OAAM,IAAI,MAAM,UAAU,6DAA6D;AAE3F,cAAS,oBAAoB,EAAE;AAC/B,sBAAkB,UAAU,SAAS,OAAO;AAC5C,cAAS;AACT,aAAQ,MAAM,MAAM,SAAS;AAC7B,cAAS,MAAM,UAAU,MAAM,OAAO;AACtC,kBAAa;;AAGjB,QAAI,OAAO,cAAc,SAAS,OAAO,SAAS,EAC9C,OAAM,IAAI,MAAM,sDAAsD,QAAQ,cAAc,OAAO;AAEvG,YAAQ,OAAO,IAAf;KACI,KAAK;AAED,YAAM,KAAK,OAAO;AAClB,aAAO,KAAK,MAAM,OAAO;AACzB,aAAO,KAAK,MAAM,OAAO;AACzB,YAAM,KAAK,OAAO,GAAG;AACrB,eAAS;AACT,UAAI,CAAC,gBAAgB;AACjB,gBAAS,MAAM;AACf,gBAAS,MAAM;AACf,kBAAW,MAAM;AACjB,eAAQ,MAAM;AACd,WAAI,aAAa,EACb;aAGH;AAED,gBAAS;AACT,wBAAiB;;AAErB;KACJ,KAAK;AAGD,YAAM,KAAK,aAAa,OAAO,IAAI;AAEnC,YAAM,IAAI,OAAO,OAAO,SAAS;AAEjC,YAAM,KAAK;OACP,YAAY,OAAO,OAAO,UAAU,OAAO,IAAI;OAC/C,WAAW,OAAO,OAAO,SAAS,GAAG;OACrC,cAAc,OAAO,OAAO,UAAU,OAAO,IAAI;OACjD,aAAa,OAAO,OAAO,SAAS,GAAG;OAC1C;AACD,UAAI,OACA,OAAM,GAAG,QAAQ,CAAC,OAAO,OAAO,UAAU,OAAO,IAAI,MAAM,IAAI,OAAO,OAAO,SAAS,GAAG,MAAM,GAAG;AAGtG,UAAI,KAAK,cAAc,MAAM,OAAO;OAAC;OAAQ;OAAQ;OAAU,YAAY;OAAI,OAAO;OAAI;OAAQ;OAAO,CAAC,OAAO,KAAK,CAAC;AACvH,UAAI,OAAO,MAAM,YACb,QAAO;AAGX,UAAI,KAAK;AACL,eAAQ,MAAM,MAAM,GAAG,KAAK,MAAM,EAAE;AACpC,gBAAS,OAAO,MAAM,GAAG,KAAK,IAAI;AAClC,gBAAS,OAAO,MAAM,GAAG,KAAK,IAAI;;AAEtC,YAAM,KAAK,KAAK,aAAa,OAAO,IAAI,GAAG;AAC3C,aAAO,KAAK,MAAM,EAAE;AACpB,aAAO,KAAK,MAAM,GAAG;AAErB,iBAAW,MAAM,MAAM,MAAM,SAAS,IAAI,MAAM,MAAM,SAAS;AAC/D,YAAM,KAAK,SAAS;AACpB;KACJ,KAAK,EAED,QAAO;;;AAGnB,UAAO;GAGP,SAAS,+BAA+B,SAAO;IAC3C,IAAI,cAAc,MAAM,SAAS;IACjC,IAAI,QAAQ;AAEZ,aAAS;AAEL,SAAK,OAAO,UAAU,IAAK,MAAMC,SAC7B,QAAO;AAEX,SAAIA,YAAU,KAAK,cAAc,EAC7B,QAAO;AAEX,oBAAe;AACf,eAAQ,MAAM;AACd,OAAE;;;;AAQd,gBAAY,mBAAmB,SAAU,GAAG,GAAG,GAAG;GAC9C,IAAI,IAAI,EAAE;AACV,QAAK,IAAI,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM;AAEjC,UAAO;;AAEX,SAAOD;IACR;AACH,SAAQ,cAAc;;;;;;ACrOtB,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;CAE7D,IAAI,aAA4B,WAAY;EACxC,SAASE,aAAW,IAAI;AACpB,OAAI,OAAO,KAAK,EAAK,MAAK,EAAE;AAC5B,QAAK,KAAK;AACV,QAAK,MAAM;AACX,QAAK,UAAU,EAAE;AACjB,QAAK,SAAS;AACd,QAAK,SAAS;IACV,YAAY;IACZ,cAAc;IACd,WAAW;IACX,aAAa;IAChB;;AAEL,eAAW,UAAU,aAAa,SAAU,KAAK,MAAM;AACnD,OAAI,KAAK,GAAG,OACR,MAAK,GAAG,OAAO,WAAW,KAAK,KAAK;OAGpC,OAAM,IAAI,MAAM,IAAI;;AAI5B,eAAW,UAAU,WAAW,SAAU,OAAO,IAAI;AACjD,QAAK,KAAK,MAAM,KAAK,MAAM,EAAE;AAC7B,QAAK,SAAS;AACd,QAAK,QAAQ,KAAK,aAAa,KAAK,OAAO;AAC3C,QAAK,WAAW,KAAK,SAAS;AAC9B,QAAK,SAAS,KAAK,UAAU,KAAK,QAAQ;AAC1C,QAAK,iBAAiB,CAAC,UAAU;AACjC,QAAK,SAAS;IACV,YAAY;IACZ,cAAc;IACd,WAAW;IACX,aAAa;IAChB;AACD,OAAI,KAAK,QAAQ,OACb,MAAK,OAAO,QAAQ,CAAC,GAAG,EAAE;AAE9B,QAAK,SAAS;AACd,UAAO;;AAGX,eAAW,UAAU,QAAQ,WAAY;AACrC,OAAI,KAAK,OAAO,WAAW,GAAG;AAC1B,SAAK,OAAO;AACZ,WAAO,KAAK,KAAK;;GAErB,IAAI,KAAK,KAAK,OAAO;AACrB,QAAK,UAAU;AACf,QAAK;AACL,QAAK;AACL,QAAK,SAAS;AACd,QAAK,WAAW;AAEhB,OADY,GAAG,MAAM,kBAAkB,EAC5B;AACP,SAAK;AACL,SAAK,OAAO;SAGZ,MAAK,OAAO;AAEhB,OAAI,KAAK,QAAQ,OACb,MAAK,OAAO,MAAM;AAEtB,QAAK,SAAS,KAAK,OAAO,MAAM,EAAE;AAClC,UAAO;;AAGX,eAAW,UAAU,QAAQ,SAAU,IAAI;GACvC,IAAI,MAAM,GAAG;GACb,IAAI,QAAQ,GAAG,MAAM,gBAAgB;AACrC,QAAK,SAAS,KAAK,KAAK;AACxB,QAAK,SAAS,KAAK,OAAO,OAAO,GAAG,KAAK,OAAO,SAAS,IAAI;AAE7D,QAAK,UAAU;GACf,IAAI,WAAW,KAAK,MAAM,MAAM,gBAAgB;AAChD,QAAK,QAAQ,KAAK,MAAM,OAAO,GAAG,KAAK,MAAM,SAAS,EAAE;AACxD,QAAK,UAAU,KAAK,QAAQ,OAAO,GAAG,KAAK,QAAQ,SAAS,EAAE;AAC9D,OAAI,MAAM,SAAS,EACf,MAAK,YAAY,MAAM,SAAS;GAEpC,IAAI,IAAI,KAAK,OAAO;AAUpB,QAAK,SATQ;IACT,YAAY,KAAK,OAAO;IACxB,WAAW,KAAK,WAAW;IAC3B,cAAc,KAAK,OAAO;IAC1B,aAAa,SACR,MAAM,WAAW,SAAS,SAAS,KAAK,OAAO,eAAe,KACzD,SAAS,SAAS,SAAS,MAAM,QAAQ,SAAS,MAAM,GAAG,SACjE,KAAK,OAAO,eAAe;IAClC;AAED,OAAI,KAAK,QAAQ,OACb,MAAK,OAAO,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,KAAK,SAAS,IAAI;AAExD,QAAK,SAAS,KAAK,OAAO;AAC1B,UAAO;;AAGX,eAAW,UAAU,OAAO,WAAY;AACpC,QAAK,QAAQ;AACb,UAAO;;AAGX,eAAW,UAAU,SAAS,WAAY;AACtC,OAAI,KAAK,QAAQ,gBACb,MAAK,aAAa;OAGlB,QAAO,KAAK,WAAW,4BAA4B,KAAK,WAAW,KAAK,qIAAqI,KAAK,cAAc,EAAE;IAC9N,MAAM;IACN,OAAO;IACP,MAAM,KAAK;IACd,CAAC;AAEN,UAAO;;AAGX,eAAW,UAAU,OAAO,SAAU,GAAG;AACrC,QAAK,MAAM,KAAK,MAAM,MAAM,EAAE,CAAC;;AAGnC,eAAW,UAAU,YAAY,WAAY;GACzC,IAAI,OAAO,KAAK,QAAQ,OAAO,GAAG,KAAK,QAAQ,SAAS,KAAK,MAAM,OAAO;AAC1E,WAAQ,KAAK,SAAS,KAAK,QAAQ,MAAM,KAAK,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG;;AAGhF,eAAW,UAAU,gBAAgB,WAAY;GAC7C,IAAI,OAAO,KAAK;AAChB,OAAI,KAAK,SAAS,GACd,SAAQ,KAAK,OAAO,OAAO,GAAG,KAAK,KAAK,OAAO;AAEnD,WAAQ,KAAK,OAAO,GAAG,GAAG,IAAI,KAAK,SAAS,KAAK,QAAQ,KAAK,QAAQ,OAAO,GAAG;;AAGpF,eAAW,UAAU,eAAe,WAAY;GAC5C,IAAI,MAAM,KAAK,WAAW;GAC1B,IAAI,IAAI,IAAI,MAAM,IAAI,SAAS,EAAE,CAAC,KAAK,IAAI;AAC3C,UAAO,MAAM,KAAK,eAAe,GAAG,OAAO,IAAI;;AAGnD,eAAW,UAAU,aAAa,SAAU,OAAO,cAAc;GAC7D,IAAI,OAAO,OAAO;AAClB,OAAI,KAAK,QAAQ,iBAAiB;AAE9B,aAAS;KACL,UAAU,KAAK;KACf,QAAQ;MACJ,YAAY,KAAK,OAAO;MACxB,WAAW,KAAK,OAAO;MACvB,cAAc,KAAK,OAAO;MAC1B,aAAa,KAAK,OAAO;MAC5B;KACD,QAAQ,KAAK;KACb,OAAO,KAAK;KACZ,SAAS,KAAK;KACd,SAAS,KAAK;KACd,QAAQ,KAAK;KACb,QAAQ,KAAK;KACb,OAAO,KAAK;KACZ,QAAQ,KAAK;KACb,IAAI,KAAK;KACT,gBAAgB,KAAK,eAAe,MAAM,EAAE;KAC5C,MAAM,KAAK;KACd;AACD,QAAI,KAAK,QAAQ,OACb,QAAO,OAAO,QAAS,KAAK,OAAO,MAAM,MAAM,EAAE;;AAGzD,WAAQ,MAAM,GAAG,MAAM,kBAAkB;AACzC,OAAI,MACA,MAAK,YAAY,MAAM;AAE3B,QAAK,SAAS;IACV,YAAY,KAAK,OAAO;IACxB,WAAW,KAAK,WAAW;IAC3B,cAAc,KAAK,OAAO;IAC1B,aAAa,QACT,MAAM,MAAM,SAAS,GAAG,SAAS,MAAM,MAAM,SAAS,GAAG,MAAM,SAAS,CAAC,GAAG,SAC5E,KAAK,OAAO,cAAc,MAAM,GAAG;IAC1C;AACD,QAAK,UAAU,MAAM;AACrB,QAAK,SAAS,MAAM;AACpB,QAAK,UAAU;AACf,QAAK,SAAS,KAAK,OAAO;AAC1B,OAAI,KAAK,QAAQ,OACb,MAAK,OAAO,QAAQ,CAAC,KAAK,QAAQ,KAAK,UAAU,KAAK,OAAO;AAEjE,QAAK,QAAQ;AACb,QAAK,aAAa;AAClB,QAAK,SAAS,KAAK,OAAO,MAAM,MAAM,GAAG,OAAO;AAChD,QAAK,WAAW,MAAM;AACtB,WAAQ,KAAK,cAAc,KAAK,MAAM,KAAK,IAAI,MAAM,cAAc,KAAK,eAAe,KAAK,eAAe,SAAS,GAAG;AACvH,OAAI,KAAK,QAAQ,KAAK,OAClB,MAAK,OAAO;AAEhB,OAAI,MACA,QAAO;YAEF,KAAK,YAAY;AAEtB,SAAK,IAAI,KAAK,OACV,MAAK,KAAK,OAAO;AAErB,WAAO;;AAEX,UAAO;;AAGX,eAAW,UAAU,OAAO,WAAY;AACpC,OAAI,KAAK,KACL,QAAO,KAAK;AAEhB,OAAI,CAAC,KAAK,OACN,MAAK,OAAO;GAEhB,IAAI,OAAO,QAAQ,MAAM,WAAW;AACpC,OAAI,CAAC,KAAK,OAAO;AACb,SAAK,SAAS;AACd,SAAK,QAAQ;;GAEjB,IAAI,QAAQ,KAAK,eAAe;AAChC,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,gBAAY,KAAK,OAAO,MAAM,KAAK,MAAM,MAAM,IAAI;AACnD,QAAI,cAAc,CAAC,SAAS,UAAU,GAAG,SAAS,MAAM,GAAG,SAAS;AAChE,aAAQ;AACR,aAAQ;AACR,SAAI,KAAK,QAAQ,iBAAiB;AAC9B,cAAQ,KAAK,WAAW,WAAW,MAAM,GAAG;AAC5C,UAAI,UAAU,MACV,QAAO;eAEF,KAAK,YAAY;AACtB,eAAQ;AACR;YAIA,QAAO;gBAGN,CAAC,KAAK,QAAQ,KACnB;;;AAIZ,OAAI,OAAO;AACP,YAAQ,KAAK,WAAW,OAAO,MAAM,OAAO;AAC5C,QAAI,UAAU,MACV,QAAO;AAGX,WAAO;;AAEX,OAAI,KAAK,WAAW,GAChB,QAAO,KAAK;OAGZ,QAAO,KAAK,WAAW,4BAA4B,KAAK,WAAW,KAAK,2BAA2B,KAAK,cAAc,EAAE;IACpH,MAAM;IACN,OAAO;IACP,MAAM,KAAK;IACd,CAAC;;AAIV,eAAW,UAAU,MAAM,WAAY;GACnC,IAAI,IAAI,KAAK,MAAM;AACnB,OAAI,EACA,QAAO;OAGP,QAAO,KAAK,KAAK;;AAIzB,eAAW,UAAU,QAAQ,SAAU,WAAW;AAC9C,QAAK,eAAe,KAAK,UAAU;;AAGvC,eAAW,UAAU,WAAW,WAAY;AAExC,OADQ,KAAK,eAAe,SAAS,IAC7B,EACJ,QAAO,KAAK,eAAe,KAAK;OAGhC,QAAO,KAAK,eAAe;;AAInC,eAAW,UAAU,gBAAgB,WAAY;AAC7C,OAAI,KAAK,eAAe,UAAU,KAAK,eAAe,KAAK,eAAe,SAAS,GAC/E,QAAO,KAAK,WAAW,KAAK,eAAe,KAAK,eAAe,SAAS,IAAI;OAG5E,QAAO,KAAK,WAAW,WAAW;;AAI1C,eAAW,UAAU,WAAW,SAAU,GAAG;AACzC,OAAI,KAAK,eAAe,SAAS,IAAI,KAAK,IAAI,KAAK,EAAE;AACrD,OAAI,KAAK,EACL,QAAO,KAAK,eAAe;OAG3B,QAAO;;AAIf,eAAW,UAAU,YAAY,SAAU,WAAW;AAClD,QAAK,MAAM,UAAU;;AAGzB,eAAW,UAAU,iBAAiB,WAAY;AAC9C,UAAO,KAAK,eAAe;;AAE/B,SAAOA;IACR;AACH,SAAQ,aAAa"}

package/dist/{optGroupUtils-CXLgyg2i.js → optGroupUtils-B0hTpodo.js}

@@ -2,6 +2,89 @@ const require_isRuleGroup = require('./isRuleGroup-DqAs2x4E.js');
 let immer = require("immer");
 immer = require_isRuleGroup.__toESM(immer);
 
+//#region src/defaults.ts
+/**
+* @group Defaults
+*/
+const defaultPlaceholderName = "~";
+/**
+* Default `name` for placeholder option in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldName = defaultPlaceholderName;
+/**
+* Default `name` for placeholder option in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorName = defaultPlaceholderName;
+/**
+* Default character used to `.join` and `.split` arrays.
+*
+* @group Defaults
+*/
+const defaultJoinChar = ",";
+/**
+* Map of default operators to their respective opposite/negating operators.
+*
+* @group Defaults
+*/
+const defaultOperatorNegationMap = {
+	"=": "!=",
+	"!=": "=",
+	"<": ">=",
+	"<=": ">",
+	">": "<=",
+	">=": "<",
+	beginsWith: "doesNotBeginWith",
+	doesNotBeginWith: "beginsWith",
+	endsWith: "doesNotEndWith",
+	doesNotEndWith: "endsWith",
+	contains: "doesNotContain",
+	doesNotContain: "contains",
+	between: "notBetween",
+	notBetween: "between",
+	in: "notIn",
+	notIn: "in",
+	notNull: "null",
+	null: "notNull"
+};
+/**
+* Default combinator list.
+*
+* @group Defaults
+*/
+const defaultCombinators = [{
+	name: "and",
+	value: "and",
+	label: "AND"
+}, {
+	name: "or",
+	value: "or",
+	label: "OR"
+}];
+/**
+* Default combinator list, with `XOR` added.
+*
+* @group Defaults
+*/
+const defaultCombinatorsExtended = [...defaultCombinators, {
+	name: "xor",
+	value: "xor",
+	label: "XOR"
+}];
+
+//#endregion
+//#region src/utils/objectUtils.ts
+/**
+* A strongly-typed version of `Object.keys()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+*/
+const objectKeys = Object.keys;
+
+//#endregion
 //#region src/utils/optGroupUtils.ts
 const isOptionWithName = (opt) => require_isRuleGroup.isPojo(opt) && "name" in opt && typeof opt.name === "string";
 const isOptionWithValue = (opt) => require_isRuleGroup.isPojo(opt) && "value" in opt && typeof opt.value === "string";
@@ -99,6 +182,30 @@ function getOption(arr, name) {
 const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
 
 //#endregion
+Object.defineProperty(exports, 'defaultJoinChar', {
+  enumerable: true,
+  get: function () {
+    return defaultJoinChar;
+  }
+});
+Object.defineProperty(exports, 'defaultOperatorNegationMap', {
+  enumerable: true,
+  get: function () {
+    return defaultOperatorNegationMap;
+  }
+});
+Object.defineProperty(exports, 'defaultPlaceholderFieldName', {
+  enumerable: true,
+  get: function () {
+    return defaultPlaceholderFieldName;
+  }
+});
+Object.defineProperty(exports, 'defaultPlaceholderOperatorName', {
+  enumerable: true,
+  get: function () {
+    return defaultPlaceholderOperatorName;
+  }
+});
 Object.defineProperty(exports, 'getOption', {
   enumerable: true,
   get: function () {
@@ -117,6 +224,12 @@ Object.defineProperty(exports, 'isFlexibleOptionGroupArray', {
     return isFlexibleOptionGroupArray;
   }
 });
+Object.defineProperty(exports, 'objectKeys', {
+  enumerable: true,
+  get: function () {
+    return objectKeys;
+  }
+});
 Object.defineProperty(exports, 'toFlatOptionArray', {
   enumerable: true,
   get: function () {
@@ -135,4 +248,4 @@ Object.defineProperty(exports, 'toFullOptionList', {
     return toFullOptionList;
   }
 });
-//# sourceMappingURL=optGroupUtils-CXLgyg2i.js.map
+//# sourceMappingURL=optGroupUtils-B0hTpodo.js.map