@briza/illogical 1.5.4 → 1.5.6

package/lib/illogical.esm.js

@@ -1,3 +1,32 @@
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
 /**
  * Is number predicate.
  * @param value Tested value.
@@ -5,64 +34,47 @@
 function isNumber(value) {
   return typeof value === 'number' && isFinite(value);
 }
+
 /**
  * Is string type predicate.
  * @param value Tested value.
  */
-
 function isString(value) {
   return typeof value === 'string' || value instanceof String;
 }
+
 /**
  * Is Object
  * @param value tested value result of the test
  */
-
 function isObject(value) {
   if (value === null || value === undefined) {
     return false;
   }
-
   if (typeof value !== 'object' || (value === null || value === void 0 ? void 0 : value.constructor) !== Object) {
     return false;
   }
-
   return true;
 }
+
 /**
  * Is Boolean predicate.
  * @param value tested value.
  * @return result of the test
  */
-
 function isBoolean(value) {
   return typeof value === 'boolean';
 }
+
 /**
  * Check if a value is a an Evaluable
  * @param {Result | Evaluable} value value to check if is Evaluable
  * @returns {Evaluable}
  */
-
 function isEvaluable(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.evaluate === 'function' && typeof value.simplify === 'function' && typeof value.serialize === 'function' && typeof value.toString === 'function';
 }
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
 /**
  * Valid types for context members
  */
@@ -76,15 +88,16 @@ function _defineProperty(obj, key, value) {
 /**
  * Evaluation result
  */
-let EvaluableType;
-/**
- * Evaluable
- */
 
-(function (EvaluableType) {
+let EvaluableType = /*#__PURE__*/function (EvaluableType) {
   EvaluableType["Operand"] = "Operand";
   EvaluableType["Expression"] = "Expression";
-})(EvaluableType || (EvaluableType = {}));
+  return EvaluableType;
+}({});
+
+/**
+ * Evaluable
+ */
 
 /**
  * Abstract comparison expression
@@ -97,30 +110,28 @@ class Comparison {
    * @param {Operand} right Right operand.
    */
   constructor(operator, operatorSymbol, left, right) {
-    _defineProperty(this, "type", EvaluableType.Expression);
-
     this.operator = operator;
     this.operatorSymbol = operatorSymbol;
     this.left = left;
     this.right = right;
+    _defineProperty(this, "type", EvaluableType.Expression);
   }
+
   /**
    * {@link Evaluable.evaluate}
    */
-
-
   evaluate(ctx) {
     return this.comparison(this.left.evaluate(ctx), this.right.evaluate(ctx));
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     return `(${this.left.toString()} ${this.operator} ${this.right.toString()})`;
   }
+
   /**
    * Compares left and right operands evaluated values.
    * @param {Result} left left operand result value
@@ -128,450 +139,469 @@ class Comparison {
    * @returns {boolean}
    */
 
-
   /**
    * {@link Evaluable.simplify}
    */
-  simplify() {
-    const left = this.left.simplify(...arguments);
-    const right = this.right.simplify(...arguments);
-
+  simplify(...args) {
+    const left = this.left.simplify(...args);
+    const right = this.right.simplify(...args);
     if (!isEvaluable(left) && !isEvaluable(right)) {
       return this.comparison(left, right);
     }
-
     return this;
   }
+
   /**
    * {@link Evaluable.serialize}
    */
-
-
   serialize(options) {
     const {
       operatorMapping
     } = options;
     const operator = operatorMapping.get(this.operatorSymbol);
-
     if (operator === undefined) {
       throw new Error(`missing operator ${this.operatorSymbol.toString()}`);
     }
-
     return [operator, this.left.serialize(options), this.right.serialize(options)];
   }
-
 }
 
+// Operator key
 const OPERATOR$h = Symbol('EQ');
+
 /**
  * Equal comparison expression
  */
-
 class Equal extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('==', OPERATOR$h, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     return left === right;
   }
-
 }
 
+/**
+ * Convert a value to number if possible, otherwise return undefined
+ * @param value value to be converted to number
+ */
+const toNumber = value => {
+  const isValueNumber = isNumber(value);
+  if (isValueNumber) {
+    return value;
+  } else if (isString(value)) {
+    if (value.match(/^\d+\.\d+$/)) {
+      return parseFloat(value);
+    } else if (value.match(/^0$|^[1-9]\d*$/)) {
+      return parseInt(value);
+    }
+  }
+  return undefined;
+};
+
+/**
+ * Convert a value to string if possible, otherwise return undefined
+ * @param value value to be converted to string
+ */
+const toString = value => {
+  if (isNumber(value)) {
+    return `${value}`;
+  } else if (isString(value)) {
+    return value;
+  }
+  return undefined;
+};
+/**
+ * Convert a value to number if it's type is string, otherwise return NaN
+ * @param value value to be converted to number
+ */
+const toDateNumber = value => {
+  if (isString(value)) {
+    return Date.parse(value);
+  }
+  return NaN;
+};
+
+// Operator key
 const OPERATOR$g = Symbol('GE');
+
 /**
  * Greater than or equal comparison expression
  */
-
 class GreaterThanOrEqual extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('>=', OPERATOR$g, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isNumber(left) && isNumber(right)) {
       return left >= right;
     }
-
+    const leftDate = toDateNumber(left),
+      rightDate = toDateNumber(right);
+    if (leftDate && rightDate) {
+      return leftDate >= rightDate;
+    }
     return false;
   }
-
 }
 
+// Operator key
 const OPERATOR$f = Symbol('GT');
+
 /**
  * Greater than comparison expression
  */
-
 class GreaterThan extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('>', OPERATOR$f, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isNumber(left) && isNumber(right)) {
       return left > right;
     }
-
+    const leftDate = toDateNumber(left),
+      rightDate = toDateNumber(right);
+    if (leftDate && rightDate) {
+      return leftDate > rightDate;
+    }
     return false;
   }
-
 }
 
+// Operator key
 const OPERATOR$e = Symbol('IN');
+
 /**
  * In comparison expression
  */
-
 class In extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('in', OPERATOR$e, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (left === undefined || left === null || right === undefined || right === null) {
       return false;
     }
-
     const leftArray = Array.isArray(left);
     const rightArray = Array.isArray(right);
-
     if (leftArray && rightArray) {
       throw new Error('invalid IN expression, both operands are array');
     }
-
     if (!leftArray && !rightArray) {
       throw new Error('invalid IN expression, non of the operands is array');
     }
-
     if (leftArray) {
       return left.indexOf(right) > -1;
     }
-
     return right.indexOf(left) > -1;
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     const left = this.left.toString();
     const right = this.right.toString();
-
     if (left.startsWith('[')) {
       return `(${right} ${this.operator} ${left})`;
     }
-
     return `(${left} ${this.operator} ${right})`;
   }
-
 }
 
+// Operator key
 const OPERATOR$d = Symbol('LE');
+
 /**
  * Less than or equal comparison expression
  */
-
 class LessThanOrEqual extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('<=', OPERATOR$d, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isNumber(left) && isNumber(right)) {
       return left <= right;
     }
-
+    const leftDate = toDateNumber(left),
+      rightDate = toDateNumber(right);
+    if (leftDate && rightDate) {
+      return leftDate <= rightDate;
+    }
     return false;
   }
-
 }
 
+// Operator key
 const OPERATOR$c = Symbol('LT');
+
 /**
  * Less than comparison expression
  */
-
 class LessThan extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('<', OPERATOR$c, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isNumber(left) && isNumber(right)) {
       return left < right;
     }
-
+    const leftDate = toDateNumber(left),
+      rightDate = toDateNumber(right);
+    if (leftDate && rightDate) {
+      return leftDate < rightDate;
+    }
     return false;
   }
-
 }
 
+// Operator key
 const OPERATOR$b = Symbol('NE');
+
 /**
  * Not equal comparison expression
  */
-
 class NotEqual extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('!=', OPERATOR$b, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     return left !== right;
   }
-
 }
 
+// Operator key
 const OPERATOR$a = Symbol('NOT IN');
+
 /**
  * Not in comparison expression
  */
-
 class NotIn extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('not in', OPERATOR$a, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (left === undefined || left === null || right === undefined || right === null) {
       return true;
     }
-
     const leftArray = Array.isArray(left);
     const rightArray = Array.isArray(right);
-
     if (leftArray && rightArray) {
       throw new Error('invalid NOT IN expression, both operands are array');
     }
-
     if (!leftArray && !rightArray) {
       throw new Error('invalid NOT IN expression, one operand must be array');
     }
-
     if (leftArray) {
       return left.indexOf(right) === -1;
     }
-
     return right.indexOf(left) === -1;
   }
+
   /**
    * Get the strict representation of the expression
    * @return {string}
    */
-
-
   toString() {
     const left = this.left.toString();
     const right = this.right.toString();
-
     if (left.startsWith('[')) {
       return `(${right} ${this.operator} ${left})`;
     }
-
     return `(${left} ${this.operator} ${right})`;
   }
-
 }
 
+// Operator key
 const OPERATOR$9 = Symbol('OVERLAP');
+
 /**
  * Overlap comparison expression
  */
-
 class Overlap extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('overlap', OPERATOR$9, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (left === undefined || left === null || right === undefined || right === null) {
       return false;
     }
-
     if (!Array.isArray(left) || !Array.isArray(right)) {
       throw new Error('invalid OVERLAP expression, both operands must be array');
     }
-
     const leftArray = left;
     const rightArray = right;
     return leftArray.some(element => rightArray.includes(element));
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     const left = this.left.toString();
     const right = this.right.toString();
     return `(${left} ${this.operator} ${right})`;
   }
-
 }
 
+// Operator key
 const OPERATOR$8 = Symbol('PREFIX');
+
 /**
  * Prefix comparison expression
  */
-
 class Prefix extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('prefix', OPERATOR$8, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isString(left) === false || isString(right) === false) {
       return false;
     }
-
     return right.startsWith(left);
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     const left = this.left.toString();
     const right = this.right.toString();
     return `(<${left}>${right})`;
   }
-
 }
 
 /**
@@ -581,14 +611,21 @@ class Operand {
   constructor() {
     _defineProperty(this, "type", EvaluableType.Operand);
   }
-
+  /**
+   * {@link Evaluable.evaluate}
+   */
+  /**
+   * {@link Evaluable.simplify}
+   */
+  /**
+   * {@link Evaluable.serialize}
+   */
   /**
    * Get the strict representation.
    */
   toString() {
     throw new Error('not implemented exception');
   }
-
 }
 
 /**
@@ -596,19 +633,16 @@ class Operand {
  * @param {Result} value
  * @return {string}
  */
-
 function printValue(value) {
   if (isString(value)) {
     return `"${value}"`;
   }
-
   return `${value}`;
 }
+
 /**
  * Static value operand
  */
-
-
 class Value extends Operand {
   /**
    * @constructor
@@ -618,192 +652,174 @@ class Value extends Operand {
     if (Array.isArray(value)) {
       throw new Error('deprecated direct usage of array, please use Collection operand');
     }
-
     super();
+    _defineProperty(this, "value", void 0);
     this.value = value;
   }
+
   /**
    * {@link Evaluable.evaluate}
    */
-
-
   evaluate() {
     return this.value;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
   simplify() {
     return this.value;
   }
+
   /**
    * {@link Evaluable.serialize}
    */
-
-
   serialize() {
     return this.value;
   }
+
   /**
    * Get the strict representation of the operand.
    * @return {string}
    */
-
-
   toString() {
     return printValue(this.value);
   }
-
 }
 
+// Operator key
 const OPERATOR$7 = Symbol('PRESENT');
+
 /**
  * Present comparison expression
  */
-
 class Present extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} operand
    */
+
   constructor(operand) {
     if (arguments.length !== 1) {
       throw new Error('comparison expression PRESENT expects exactly one operand');
     }
-
     super('PRESENT', OPERATOR$7, operand, new Value(true));
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left) {
     return left !== undefined && left !== null;
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     return `(${this.left.toString()} is ${this.operator})`;
   }
-
   serialize(options) {
     const {
       operatorMapping
     } = options;
     const operator = operatorMapping.get(this.operatorSymbol);
-
     if (operator === undefined) {
       throw new Error(`missing operator ${this.operatorSymbol.toString()}`);
     }
-
     return [operator, this.left.serialize(options)];
   }
-
 }
 
+// Operator key
 const OPERATOR$6 = Symbol('PREFIX');
+
 /**
  * Suffix comparison expression
  */
-
 class Suffix extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} left Left operand.
    * @param {Evaluable} right Right operand.
    */
+
   constructor(left, right) {
     if (arguments.length !== 2) {
       throw new Error('comparison expression expects left and right operands');
     }
-
     super('suffix', OPERATOR$6, left, right);
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left, right) {
     if (isString(left) === false || isString(right) === false) {
       return false;
     }
-
     return left.endsWith(right);
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     const left = this.left.toString();
     const right = this.right.toString();
     return `(${left}<${right}>)`;
   }
-
 }
 
+// Operator key
 const OPERATOR$5 = Symbol('UNDEFINED');
+
 /**
  * Undefined comparison expression
  */
-
 class Undefined extends Comparison {
   /**
    * @constructor
    * @param {Evaluable} operand
    */
+
   constructor(operand) {
     if (arguments.length !== 1) {
       throw new Error('comparison expression UNDEFINED expects exactly one operand');
     }
-
     super('UNDEFINED', OPERATOR$5, operand, new Value(true));
   }
+
   /**
    * {@link Comparison.comparison}
    */
-
-
   comparison(left) {
     return left === undefined;
   }
+
   /**
    * Get the strict representation of the expression.
    * @return {string}
    */
-
-
   toString() {
     return `(${this.left.toString()} is ${this.operator})`;
   }
+
   /**
    * {@link Evaluable.serialize}
    */
-
-
   serialize(options) {
     const {
       operatorMapping
     } = options;
     const operator = operatorMapping.get(this.operatorSymbol);
-
     if (operator === undefined) {
       throw new Error(`missing operator ${this.operatorSymbol.toString()}`);
     }
-
     return [operator, this.left.serialize(options)];
   }
-
 }
 
 /**
@@ -816,16 +832,19 @@ class Logical {
    * @param {Evaluable[]} operands Collection of operands.
    */
   constructor(operator, operatorSymbol, operands) {
-    _defineProperty(this, "type", EvaluableType.Expression);
-
     this.operator = operator;
     this.operatorSymbol = operatorSymbol;
     this.operands = operands;
+    _defineProperty(this, "type", EvaluableType.Expression);
   }
+
   /**
    * {@link Evaluable.evaluate}
    */
 
+  /**
+   * {@link Evaluable.simplify}
+   */
 
   /**
    * Get the strict representation of the expression.
@@ -834,27 +853,24 @@ class Logical {
   toString() {
     return '(' + this.operands.map(operand => operand.toString()).join(` ${this.operator} `) + ')';
   }
-
   serialize(options) {
     const {
       operatorMapping
     } = options;
     const operator = operatorMapping.get(this.operatorSymbol);
-
     if (operator === undefined) {
       throw new Error(`missing operator ${this.operatorSymbol.toString()}`);
     }
-
     return [operator, ...this.operands.map(operand => operand.serialize(options))];
   }
-
 }
 
+// Operator key
 const OPERATOR$4 = Symbol('AND');
+
 /**
  * And logical expression
  */
-
 class And extends Logical {
   /**
    * @constructor
@@ -864,127 +880,105 @@ class And extends Logical {
     if (operands.length < 2) {
       throw new Error('logical expression must have at least two operands');
     }
-
     super('AND', OPERATOR$4, operands);
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {Result}
    */
-
-
   evaluate(ctx) {
     for (const operand of this.operands) {
       if (operand.evaluate(ctx) === false) {
         return false;
       }
     }
-
     return true;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
+  simplify(...args) {
     const simplified = this.operands.reduce((result, child) => {
       if (result !== false) {
         const childResult = child.simplify(...args);
-
         if (isEvaluable(childResult)) {
           if (isBoolean(result)) {
             return [childResult];
           }
-
           return [...result, childResult];
         }
-
         if (!childResult) {
           return false;
         }
       }
-
       return result;
     }, true);
-
     if (Array.isArray(simplified)) {
       if (simplified.length === 1) {
         return simplified[0];
       }
-
       return new And(simplified);
     }
-
     return simplified;
   }
-
 }
 
+// Operator key
 const OPERATOR$3 = Symbol('NOT');
+
 /**
  * Not logical expression
  */
-
 class Not extends Logical {
   /**
    * @constructor
    * @param {Evaluable} operand
    */
+
   constructor(operand) {
     if (arguments.length !== 1) {
       throw new Error('logical NOT expression must have exactly one operand');
     }
-
     super('NOT', OPERATOR$3, [operand]);
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {Result}
    */
-
-
   evaluate(ctx) {
     const result = this.operands[0].evaluate(ctx);
-
     if (result !== true && result !== false) {
       throw new Error("logical NOT expression's operand must be evaluated to boolean value");
     }
-
     return !result;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
-    const simplified = this.operands[0].simplify(...arguments);
-
+  simplify(...args) {
+    const simplified = this.operands[0].simplify(...args);
     if (isBoolean(simplified)) {
       return !simplified;
     }
-
     if (isEvaluable(simplified)) {
       return new Not(simplified);
     }
-
     throw new Error("logical NOT expression's operand must be evaluated to boolean value");
   }
-
 }
 
+// Operator key
 const OPERATOR$2 = Symbol('NOR');
+
 /**
  * Nor logical expression
  */
-
 class Nor extends Logical {
   /**
    * @constructor
@@ -994,73 +988,58 @@ class Nor extends Logical {
     if (operands.length < 2) {
       throw new Error('logical expression must have at least two operands');
     }
-
     super('NOR', OPERATOR$2, operands);
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {Result}
    */
-
-
   evaluate(ctx) {
     for (const operand of this.operands) {
       if (operand.evaluate(ctx) === true) {
         return false;
       }
     }
-
     return true;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
+  simplify(...args) {
     const simplified = this.operands.reduce((result, child) => {
       if (result !== false) {
         const childResult = child.simplify(...args);
-
         if (isEvaluable(childResult)) {
           if (isBoolean(result)) {
             return [childResult];
           }
-
           return [...result, childResult];
         }
-
         if (childResult) {
           return false;
         }
       }
-
       return result;
     }, true);
-
     if (Array.isArray(simplified)) {
       if (simplified.length === 1) {
         return new Not(...simplified);
       }
-
       return new Nor(simplified);
     }
-
     return simplified;
   }
-
 }
 
+// Operator key
 const OPERATOR$1 = Symbol('OR');
+
 /**
  * Or logical expression
  */
-
 class Or extends Logical {
   /**
    * @constructor
@@ -1070,84 +1049,68 @@ class Or extends Logical {
     if (operands.length < 2) {
       throw new Error('logical expression must have at least two operands');
     }
-
     super('OR', OPERATOR$1, operands);
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {Result}
    */
-
-
   evaluate(ctx) {
     for (const operand of this.operands) {
       if (operand.evaluate(ctx) === true) {
         return true;
       }
     }
-
     return false;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
+  simplify(...args) {
     const simplified = this.operands.reduce((result, child) => {
       if (result !== true) {
         const childResult = child.simplify(...args);
-
         if (isEvaluable(childResult)) {
           if (isBoolean(result)) {
             return [childResult];
           }
-
           return [...result, childResult];
         }
-
         if (childResult) {
           return true;
         }
       }
-
       return result;
     }, false);
-
     if (Array.isArray(simplified)) {
       if (simplified.length === 1) {
         return simplified[0];
       }
-
       return new Or(simplified);
     }
-
     return simplified;
   }
-
 }
 
+// Operator key
 const OPERATOR = Symbol('XOR');
+
 /**
  * Logical xor
  * @param {boolean} a
  * @param {boolean} b
  * @return {boolean}
  */
-
 function xor(a, b) {
   return (a || b) && !(a && b);
 }
+
 /**
  * Xor logical expression
  */
-
-
 class Xor extends Logical {
   /**
    * @constructor
@@ -1157,19 +1120,16 @@ class Xor extends Logical {
     if (operands.length < 2) {
       throw new Error('logical expression must have at least two operands');
     }
-
     super('XOR', OPERATOR, operands);
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {Result}
    */
-
-
   evaluate(ctx) {
     let res = null;
-
     for (const operand of this.operands) {
       if (res === null) {
         res = operand.evaluate(ctx);
@@ -1177,62 +1137,43 @@ class Xor extends Logical {
         res = xor(res, operand.evaluate(ctx));
       }
     }
-
     return res;
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    const [evaluablesLeft, trueCount] = this.operands.reduce((_ref, child) => {
-      let [notSimplifiedConditions, trueCount] = _ref;
-
+  simplify(...args) {
+    const [evaluablesLeft, trueCount] = this.operands.reduce(([notSimplifiedConditions, trueCount], child) => {
       if (trueCount > 1) {
         return [notSimplifiedConditions, trueCount];
       }
-
       const childResult = child.simplify(...args);
-
       if (isEvaluable(childResult)) {
         return [[...notSimplifiedConditions, childResult], trueCount];
       }
-
       if (childResult) {
         return [notSimplifiedConditions, trueCount + 1];
       }
-
       return [notSimplifiedConditions, trueCount];
     }, [[], 0]);
-
     if (trueCount > 1) {
       return false;
     }
-
     if (evaluablesLeft.length === 0) {
       return trueCount === 1;
     }
-
     if (evaluablesLeft.length === 1) {
       if (trueCount === 1) {
         return new Not(...evaluablesLeft);
       }
-
       return evaluablesLeft[0];
     }
-
     if (trueCount === 1) {
       return new Nor(evaluablesLeft);
     }
-
     return new Xor(evaluablesLeft);
   }
-
 }
 
 /**
@@ -1245,117 +1186,101 @@ class Collection extends Operand {
    */
   constructor(items) {
     super();
+    _defineProperty(this, "items", void 0);
     this.items = items;
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {boolean}
    */
-
-
   evaluate(ctx) {
     return this.items.map(item => item.evaluate(ctx));
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
-  simplify() {
+  simplify(...args) {
     const values = [];
-
     for (const item of this.items) {
-      const simplifiedItem = item.simplify(...arguments);
-
+      const simplifiedItem = item.simplify(...args);
       if (isEvaluable(simplifiedItem)) {
         return this;
       }
-
       values.push(simplifiedItem);
     }
-
     return values;
   }
+
   /**
    * {@link Evaluable.serialize}
    */
-
-
   serialize(options) {
     return this.items.map(item => isEvaluable(item) ? item.serialize(options) : item);
   }
+
   /**
    * Get the strict representation of the operand.
    * @return {string}
    */
-
-
   toString() {
     return '[' + this.items.map(item => item.toString()).join(', ') + ']';
   }
-
 }
 
-/**
- * Convert a value to number if possible, otherwise return undefined
- * @param value value to be converted to number
- */
-
-const toNumber = value => {
-  const isValueNumber = isNumber(value);
-
-  if (isValueNumber) {
-    return value;
-  } else if (isString(value)) {
-    if (value.match(/^\d+\.\d+$/)) {
-      return parseFloat(value);
-    } else if (value.match(/^0$|^[1-9]\d*$/)) {
-      return parseInt(value);
+const keyWithArrayIndexRegex = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
+const arrayIndexRegex = /\[(\d+)]/g;
+const parseKey = key => key.split('.').flatMap(key => {
+  const parseResult = keyWithArrayIndexRegex.exec(key);
+  const keys = [];
+  if (parseResult) {
+    var _parseResult$groups$c, _parseResult$groups, _parseResult$groups2;
+    keys.push((_parseResult$groups$c = parseResult === null || parseResult === void 0 || (_parseResult$groups = parseResult.groups) === null || _parseResult$groups === void 0 ? void 0 : _parseResult$groups.currentKey) !== null && _parseResult$groups$c !== void 0 ? _parseResult$groups$c : key);
+    const rawIndexes = parseResult === null || parseResult === void 0 || (_parseResult$groups2 = parseResult.groups) === null || _parseResult$groups2 === void 0 ? void 0 : _parseResult$groups2.indexes;
+    if (rawIndexes) {
+      for (const indexResult of rawIndexes.matchAll(arrayIndexRegex)) {
+        keys.push(parseInt(indexResult[1]));
+      }
     }
+  } else {
+    keys.push(key);
   }
-
-  return undefined;
-};
-/**
- * Convert a value to string if possible, otherwise return undefined
- * @param value value to be converted to string
- */
-
-const toString = value => {
-  if (isNumber(value)) {
-    return `${value}`;
-  } else if (isString(value)) {
-    return value;
-  }
-
-  return undefined;
-};
-
-function extractKeys(ctx, key) {
+  return keys;
+});
+const complexKeyExpression = /{([^{}]+)}/;
+function extractComplexKeys(ctx, key) {
   // Resolve complex keys
-  const complexKeyExpression = /{([^{}]+)}/;
   let complexKeyMatches = complexKeyExpression.exec(key);
-
   while (complexKeyMatches) {
-    const resolvedValue = contextValueLookup(ctx, complexKeyMatches[1]);
-
+    const resolvedValue = complexValueLookup(ctx, complexKeyMatches[1]);
     if (resolvedValue === undefined) {
       return undefined;
     }
-
     key = key.replace(complexKeyExpression, `${resolvedValue}`);
     complexKeyMatches = complexKeyExpression.exec(key);
   }
-
-  let keys = [key]; // Nested reference
-
-  if (key.includes('.')) {
-    keys = key.split('.');
+  return parseKey(key);
+}
+const isContext = value => isObject(value);
+const simpleValueLookup = keys => ctx => {
+  let pointer = ctx;
+  for (const key of keys) {
+    if (typeof key === 'number') {
+      if (!Array.isArray(pointer)) {
+        return undefined;
+      }
+      pointer = pointer[key];
+    } else if (!isContext(pointer)) {
+      return undefined;
+    } else {
+      pointer = pointer[key];
+    }
   }
+  return pointer;
+};
 
-  return keys;
-}
 /**
  * Lookup for the reference in the context.
  * The nested context value is annotated with "." delimiter.
@@ -1364,58 +1289,26 @@ function extractKeys(ctx, key) {
  * @param {string} key Context lookup key.
  * @return {Result}
  */
-
-
-function contextValueLookup(ctx, key) {
-  const keys = extractKeys(ctx, key);
-
+function complexValueLookup(ctx, key) {
+  const keys = extractComplexKeys(ctx, key);
   if (!keys) {
     return undefined;
-  } // Context pointer
-
-
-  let pointer = ctx;
-
-  for (let i = 0; i < keys.length; i++) {
-    var _keys$i$match;
-
-    const currentKey = keys[i].replace(/\[.+$/, '');
-    let currentValue = pointer[currentKey]; // Resolve array notation
-
-    (_keys$i$match = keys[i].match(/\[\d+\]/g)) === null || _keys$i$match === void 0 ? void 0 : _keys$i$match.forEach(match => {
-      const arrayIndex = parseInt(match.replace(/[[\]]/g, ''));
-
-      if (!Array.isArray(currentValue) || currentValue[arrayIndex] === undefined) {
-        currentValue = undefined;
-      } else {
-        currentValue = currentValue[arrayIndex];
-      }
-    }); // Last node
-
-    if (i === keys.length - 1) {
-      return currentValue; // Nested path
-    } else if (currentValue !== undefined && isObject(currentValue)) {
-      pointer = currentValue; // Invalid nested reference path
-    } else {
-      break;
-    }
   }
-
-  return undefined;
+  return simpleValueLookup(keys !== null && keys !== void 0 ? keys : [])(ctx);
 }
-
-let DataType; // Equivalent to /^.+\.\((Number|String)\)$/
-
-(function (DataType) {
+let DataType = /*#__PURE__*/function (DataType) {
   DataType["Number"] = "Number";
   DataType["String"] = "String";
-})(DataType || (DataType = {}));
+  return DataType;
+}({});
 
+// Equivalent to /^.+\.\((Number|String)\)$/
 const dataTypeRegex = new RegExp(`^.+\\.\\((${Object.keys(DataType).join('|')})\\)$`);
+const isComplexKey = key => key.indexOf('{') > -1;
+
 /**
  * Reference operand resolved within the context
  */
-
 class Reference extends Operand {
   /**
    * @constructor
@@ -1425,99 +1318,97 @@ class Reference extends Operand {
     if (key.trim() === '') {
       throw new Error('invalid reference key');
     }
-
     super();
+    _defineProperty(this, "key", void 0);
+    _defineProperty(this, "dataType", void 0);
+    _defineProperty(this, "valueLookup", void 0);
+    _defineProperty(this, "getKeys", void 0);
     this.key = key;
     const dataTypeMatch = dataTypeRegex.exec(this.key);
-
     if (dataTypeMatch) {
       this.dataType = DataType[dataTypeMatch[1]];
     }
-
     if (this.key.match(/.\(.+\)$/)) {
       this.key = this.key.replace(/.\(.+\)$/, '');
     }
+    if (isComplexKey(this.key)) {
+      this.valueLookup = context => complexValueLookup(context, this.key);
+      this.getKeys = context => extractComplexKeys(context, this.key);
+    } else {
+      const keys = parseKey(this.key);
+      this.valueLookup = simpleValueLookup(keys);
+      this.getKeys = () => keys;
+    }
   }
+
   /**
    * Evaluate in the given context.
    * @param {Context} ctx
    * @return {boolean}
    */
-
-
   evaluate(ctx) {
-    return this.toDataType(contextValueLookup(ctx, this.key));
+    return this.toDataType(this.valueLookup(ctx));
   }
+
   /**
    * {@link Evaluable.simplify}
    */
-
-
   simplify(ctx, strictKeys, optionalKeys) {
-    const keys = extractKeys(ctx, this.key);
-
-    if (!keys) {
-      return this;
-    }
-
-    const key = keys[0].replace(/\[.+$/, '');
-
+    var _this$getKeys;
+    const [key] = (_this$getKeys = this.getKeys(ctx)) !== null && _this$getKeys !== void 0 ? _this$getKeys : [];
     if (ctx[key] !== undefined) {
       return this.evaluate(ctx);
     }
-
+    if (!key || typeof key === 'number') {
+      return this;
+    }
     return strictKeys && strictKeys.includes(key) || optionalKeys && !optionalKeys.includes(key) ? undefined : this;
   }
+
   /**
    * {@link Evaluable.serialize}
    */
-
-
-  serialize(_ref) {
-    let {
-      referenceSerialization
-    } = _ref;
+  serialize({
+    referenceSerialization
+  }) {
     const key = this.dataType ? `${this.key}.(${this.dataType})` : this.key;
     return referenceSerialization(key);
   }
+
   /**
    * Get the strict representation of the operand.
    * @return {string}
    */
-
-
   toString() {
     return `{${this.key}}`;
   }
+
   /**
    * Converts a value to a specified data type
    * Silently returns original value if data type conversion has not been implemented.
    * @param value value to cast as data type
    */
-
-
   toDataType(value) {
     let result = value;
-
     switch (this.dataType) {
       case DataType.Number:
         result = toNumber(value);
         break;
-
       case DataType.String:
         result = toString(value);
         break;
     }
-
     if (value && result === undefined) {
       console.warn(`Casting ${value} to ${this.dataType} resulted in ${result}`);
     }
-
     return result;
   }
-
 }
 
+// Option value whitelist
+
+// Parser options
+
 /**
  * Default reference predicate.
  * The "$" symbol at the begging of the operand is used
@@ -1529,28 +1420,31 @@ class Reference extends Operand {
 function defaultReferencePredicate(key) {
   return isString(key) && key.startsWith('$');
 }
+
 /**
  * Default reference transform.
  * It removes the "$" symbol at the begging of the operand name.
  * @param {string} key
  * @return {string}
  */
-
 function defaultReferenceTransform(key) {
   return key.slice(1);
 }
 function defaultReferenceSerialization(key) {
   return `$${key}`;
-} // Default operator mapping
-// Unique operator key <-> raw expression key
+}
 
-const defaultOperatorMapping = new Map([// Comparison
-[OPERATOR$h, '=='], [OPERATOR$b, '!='], [OPERATOR$f, '>'], [OPERATOR$g, '>='], [OPERATOR$c, '<'], [OPERATOR$d, '<='], [OPERATOR$e, 'IN'], [OPERATOR$a, 'NOT IN'], [OPERATOR$8, 'PREFIX'], [OPERATOR$6, 'SUFFIX'], [OPERATOR$9, 'OVERLAP'], [OPERATOR$5, 'UNDEFINED'], [OPERATOR$7, 'PRESENT'], // Logical
+// Default operator mapping
+// Unique operator key <-> raw expression key
+const defaultOperatorMapping = new Map([
+// Comparison
+[OPERATOR$h, '=='], [OPERATOR$b, '!='], [OPERATOR$f, '>'], [OPERATOR$g, '>='], [OPERATOR$c, '<'], [OPERATOR$d, '<='], [OPERATOR$e, 'IN'], [OPERATOR$a, 'NOT IN'], [OPERATOR$8, 'PREFIX'], [OPERATOR$6, 'SUFFIX'], [OPERATOR$9, 'OVERLAP'], [OPERATOR$5, 'UNDEFINED'], [OPERATOR$7, 'PRESENT'],
+// Logical
 [OPERATOR$4, 'AND'], [OPERATOR$1, 'OR'], [OPERATOR$2, 'NOR'], [OPERATOR, 'XOR'], [OPERATOR$3, 'NOT']]);
+
 /**
  * Default parser options
  */
-
 const defaultOptions = {
   referencePredicate: defaultReferencePredicate,
   referenceTransform: defaultReferenceTransform,
@@ -1558,6 +1452,8 @@ const defaultOptions = {
   operatorMapping: defaultOperatorMapping
 };
 
+// Input types
+
 /**
  * Parser of raw expressions into Evaluable expression
  */
@@ -1567,9 +1463,12 @@ class Parser {
    * @param {Options?} options Parser options.
    */
   constructor(options) {
-    this.opts = { ...defaultOptions
-    }; // Apply exclusive options overrides
-
+    _defineProperty(this, "opts", void 0);
+    _defineProperty(this, "expectedOperators", void 0);
+    this.opts = {
+      ...defaultOptions
+    };
+    // Apply exclusive options overrides
     if (options) {
       for (const key of Object.keys(options)) {
         if (key in this.opts) {
@@ -1577,55 +1476,47 @@ class Parser {
         }
       }
     }
-
     this.expectedOperators = new Set(this.opts.operatorMapping.values());
   }
+
   /**
    * Parser options
    * @type {Options}
    */
-
-
   get options() {
     return this.opts;
   }
+
   /**
    * Parse raw expression into evaluable expression.
    * @param {ExpressionInput} raw Raw expression.
    * @return {Evaluable}
    */
-
-
   parse(raw) {
     if (raw === undefined || raw === null || Array.isArray(raw) === false) {
       throw new Error('invalid expression');
     }
-
     if (raw.length === 0 || !this.expectedOperators.has(`${raw[0]}`)) {
       throw new Error('invalid expression');
     }
-
     return this.parseRawExp(raw);
   }
+
   /**
    * Parse raw expression based on the expression type.
    * @param {Input} raw Raw expression.
    * @return {Evaluable}
    */
-
-
   parseRawExp(raw) {
-    var _this = this;
-
     // Value / Reference
     if (!Array.isArray(raw)) {
       return this.getOperand(raw);
     }
-
     let expression;
     let operandParser = this.getOperand;
     const operator = raw[0];
     const operands = raw.slice(1);
+
     /**
      * Simplify the logical expression if possible.
      * - AND, OR with one operand is collapsed, i.e. reduced to inner expression
@@ -1637,192 +1528,139 @@ class Parser {
      * @param operands
      * @param collapsible
      */
-
-    const logicalExpressionReducer = function (operands) {
-      let collapsible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
+    const logicalExpressionReducer = (operands, collapsible = false) => {
       if (operands.length === 0 || operands.filter(operand => operand.type === EvaluableType.Expression).length === 0) {
-        return _this.getOperand(raw);
+        return this.getOperand(raw);
       }
-
       return collapsible && operands.length === 1 ? operands[0] : undefined;
     };
-
     switch (operator) {
       /**
        * Logical
        */
       case this.opts.operatorMapping.get(OPERATOR$4):
         expression = operands => logicalExpressionReducer(operands, true) || new And(operands);
-
         operandParser = this.parseRawExp;
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$1):
         expression = operands => logicalExpressionReducer(operands, true) || new Or(operands);
-
         operandParser = this.parseRawExp;
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$2):
         expression = operands => logicalExpressionReducer(operands) || new Nor(operands);
-
         operandParser = this.parseRawExp;
         break;
-
       case this.opts.operatorMapping.get(OPERATOR):
         expression = operands => logicalExpressionReducer(operands) || new Xor(operands);
-
         operandParser = this.parseRawExp;
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$3):
         expression = operands => logicalExpressionReducer(operands) || new Not(...operands);
-
         operandParser = this.parseRawExp;
         break;
-
       /**
        * Comparison
        */
-
       case this.opts.operatorMapping.get(OPERATOR$h):
         expression = operands => new Equal(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$b):
         expression = operands => new NotEqual(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$f):
         expression = operands => new GreaterThan(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$g):
         expression = operands => new GreaterThanOrEqual(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$c):
         expression = operands => new LessThan(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$d):
         expression = operands => new LessThanOrEqual(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$e):
         expression = operands => new In(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$a):
         expression = operands => new NotIn(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$8):
         expression = operands => new Prefix(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$6):
         expression = operands => new Suffix(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$9):
         expression = operands => new Overlap(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$5):
         expression = operands => new Undefined(...operands);
-
         break;
-
       case this.opts.operatorMapping.get(OPERATOR$7):
         expression = operands => new Present(...operands);
-
         break;
       // Collection
-
       default:
         return this.getOperand(raw);
     }
-
     return expression(operands.map(operandParser.bind(this)));
   }
+
   /**
    * Get resolved operand
    * @param raw Raw data
    */
-
-
   getOperand(raw) {
     const resolve = raw => this.opts.referencePredicate(raw) ? new Reference(this.opts.referenceTransform(raw)) : new Value(raw);
-
     if (Array.isArray(raw)) {
       return new Collection(raw.map(item => resolve(item)));
     }
-
     return resolve(raw);
   }
-
 }
 
-/**
- * Main module.
- * @module illogical
- */
 /**
  * Condition engine
  */
-
 class Engine {
   /**
    * @constructor
    * @param {Options?} options Parser options.
    */
   constructor(options) {
+    _defineProperty(this, "parser", void 0);
     this.parser = new Parser(options);
   }
+
   /**
    * Evaluate the expression.
    * @param {ExpressionInput} exp Raw expression.
    * @param {Context} ctx Evaluation data context.
    * @return {boolean}
    */
-
-
   evaluate(exp, ctx) {
     return this.parse(exp).evaluate(ctx);
   }
+
   /**
    * Get expression statement
    * @param {ExpressionInput} exp Raw expression.
    * @return {string}
    */
-
-
   statement(exp) {
     return this.parse(exp).toString();
   }
+
   /**
    * Parse expression.
    * @param {ExpressionInput} exp Raw expression.
    * @return {Evaluable}
    */
-
-
   parse(exp) {
     return this.parser.parse(exp);
   }
+
   /**
    * Simplifies an expression with values in context.
    *
@@ -1838,22 +1676,16 @@ class Engine {
    *  `optionalKeys` is considered to be present and thus will be evaluated
    * @returns {Inpunt | boolean}
    */
-
-
   simplify(exp, context, strictKeys, optionalKeys) {
     const result = this.parse(exp).simplify(context, strictKeys, optionalKeys);
-
     if (isEvaluable(result)) {
       return result.serialize(this.parser.options);
     }
-
     if (isBoolean(result)) {
       return result;
     }
-
     throw new Error('non expression or boolean result should be returned');
   }
-
 }
 
-export { OPERATOR$4 as OPERATOR_AND, OPERATOR$h as OPERATOR_EQ, OPERATOR$g as OPERATOR_GE, OPERATOR$f as OPERATOR_GT, OPERATOR$e as OPERATOR_IN, OPERATOR$d as OPERATOR_LE, OPERATOR$c as OPERATOR_LT, OPERATOR$b as OPERATOR_NE, OPERATOR$2 as OPERATOR_NOR, OPERATOR$3 as OPERATOR_NOT, OPERATOR$a as OPERATOR_NOT_IN, OPERATOR$1 as OPERATOR_OR, OPERATOR$9 as OPERATOR_OVERLAP, OPERATOR$8 as OPERATOR_PREFIX, OPERATOR$7 as OPERATOR_PRESENT, OPERATOR$6 as OPERATOR_SUFFIX, OPERATOR$5 as OPERATOR_UNDEFINED, OPERATOR as OPERATOR_XOR, Engine as default };
+export { OPERATOR$4 as OPERATOR_AND, OPERATOR$h as OPERATOR_EQ, OPERATOR$g as OPERATOR_GE, OPERATOR$f as OPERATOR_GT, OPERATOR$e as OPERATOR_IN, OPERATOR$d as OPERATOR_LE, OPERATOR$c as OPERATOR_LT, OPERATOR$b as OPERATOR_NE, OPERATOR$2 as OPERATOR_NOR, OPERATOR$3 as OPERATOR_NOT, OPERATOR$a as OPERATOR_NOT_IN, OPERATOR$1 as OPERATOR_OR, OPERATOR$9 as OPERATOR_OVERLAP, OPERATOR$8 as OPERATOR_PREFIX, OPERATOR$7 as OPERATOR_PRESENT, OPERATOR$6 as OPERATOR_SUFFIX, OPERATOR$5 as OPERATOR_UNDEFINED, OPERATOR as OPERATOR_XOR, Engine as default, defaultOptions, isEvaluable };