@briza/illogical 1.5.9 → 1.6.1

package/lib/illogical.esm.js

@@ -1,3 +1,11 @@
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
@@ -10,21 +18,7 @@ function _toPrimitive(t, r) {
 }
 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;
+  return "symbol" == typeof i ? i : i + "";
 }
 
 /**
@@ -32,7 +26,14 @@ function _defineProperty(obj, key, value) {
  * @param value Tested value.
  */
 function isNumber(value) {
-  return typeof value === 'number' && isFinite(value);
+  return typeof value === 'number';
+}
+/**
+ * Is number predicate.
+ * @param value Tested value.
+ */
+function isInfinite(value) {
+  return typeof value === 'number' && !isFinite(value);
 }
 
 /**
@@ -54,50 +55,597 @@ function isObject(value) {
   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';
-}
+  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';
+}
+
+/**
+ * Ensures all values are results.
+ * @param {(Result | Evaluable)[]} values results or evaluables
+ * @returns {boolean} type guard
+ */
+function areAllResults(values) {
+  return values.every(value => !isEvaluable(value));
+}
+
+/**
+ * Ensures all values are numbers.
+ * @param {Result[]} results results or evaluables
+ * @returns {boolean} type guard
+ */
+function areAllNumbers(results) {
+  return results.every(isNumber);
+}
+
+/**
+ * Valid types for context members
+ */
+
+/**
+ * Evaluation Context
+ * Holds references used during the evaluation process.
+ * Format: key: value.
+ */
+
+/**
+ * Evaluation result
+ */
+
+let EvaluableType = /*#__PURE__*/function (EvaluableType) {
+  EvaluableType["Operand"] = "Operand";
+  EvaluableType["Expression"] = "Expression";
+  return EvaluableType;
+}({});
+
+/**
+ * Evaluable
+ */
+
+/**
+ * Abstract arithmetic expression
+ */
+class Arithmetic {
+  /**
+   * @constructor
+   * @param {string} operator String representation of the operator.
+   * @param {symbol} operatorSymbol Operator symbol.
+   * @param {Operand[]} operands Operands.
+   */
+  constructor(operator, operatorSymbol, operands) {
+    this.operator = operator;
+    this.operatorSymbol = operatorSymbol;
+    this.operands = operands;
+    _defineProperty(this, "type", EvaluableType.Expression);
+  }
+
+  /**
+   * Helper function to assist with arithmetic evaluation. Ensures that all
+   * operands are present and are numbers. Throws error if any operand is not a
+   * number.
+   *
+   * @param {Result[]} results
+   * @returns {number[] | false} false if any operand is missing, otherwise the
+   *   array of numbers
+   */
+  getResultValues(results) {
+    const presentValues = results.filter(result => result !== null && result !== undefined);
+    // If we have missing context values the result must be false
+    if (presentValues.length !== results.length) {
+      return false;
+    }
+    if (!areAllNumbers(presentValues)) {
+      throw new Error(`operands must be numbers for ${this.constructor.name}`);
+    }
+    return presentValues;
+  }
+
+  /**
+   * Performs the arithmetic operation on the operands evaluated values.
+   * @param {Result[]} results Operand result values.
+   * @returns {Result}
+   */
+
+  /**
+   * {@link Evaluable.evaluate}
+   */
+  evaluate(ctx) {
+    return this.operate(this.operands.map(operand => operand.evaluate(ctx)));
+  }
+
+  /**
+   * {@link Evaluable.toString}
+   */
+  toString() {
+    return `(${this.operands.map(operand => operand.toString()).join(` ${this.operator} `)})`;
+  }
+
+  /**
+   * {@link Evaluable.simplify}
+   */
+  simplify(...args) {
+    const results = this.operands.map(operand => operand.simplify(...args));
+    if (areAllResults(results)) {
+      return this.operate(results);
+    }
+    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.operands.map(operand => operand.serialize(options))];
+  }
+}
+
+// Operator key
+const OPERATOR$l = Symbol('DIVIDE');
+
+/**
+ * Divide operation expression
+ */
+class Divide extends Arithmetic {
+  /**
+   * @constructor Generic constructor
+   * @param {Evaluable[]} args
+   */
+
+  /**
+   * @constructor
+   * @param {Operand[]} operands Operands.
+   */
+  constructor(...operands) {
+    if (operands.length < 2) {
+      throw new Error('divide expression requires at least 2 operands');
+    }
+    super('/', OPERATOR$l, operands);
+  }
+  operate(results) {
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
+    }
+    return presentResults.reduce((acc, result) => acc / result);
+  }
+}
+
+const getNumDecimals = num => {
+  const numberSplit = num.toString().split('.');
+  return numberSplit.length == 2 ? numberSplit[1].length : 0;
+};
+const operateWithExpectedDecimals = operation => (first, second) => {
+  const numDecimals1 = getNumDecimals(first);
+  const numDecimals2 = getNumDecimals(second);
+  const maxDecimals = operation === 'multiply' ? numDecimals1 + numDecimals2 : numDecimals1 > numDecimals2 ? numDecimals1 : numDecimals2;
+  return operation === 'sum' ? Number((first + second).toFixed(maxDecimals)) : operation === 'subtract' ? Number((first - second).toFixed(maxDecimals)) : Number((first * second).toFixed(maxDecimals));
+};
+
+// Operator key
+const OPERATOR$k = Symbol('MULTIPLY');
+const multiplyWithExpectedDecimals = operateWithExpectedDecimals('multiply');
+
+/**
+ * Multiply operation expression
+ */
+class Multiply extends Arithmetic {
+  /**
+   * @constructor Generic constructor
+   * @param {Evaluable[]} args
+   */
+
+  /**
+   * @constructor
+   * @param {Operand[]} operands Operands.
+   */
+  constructor(...operands) {
+    if (operands.length < 2) {
+      throw new Error('multiply expression requires at least 2 operands');
+    }
+    super('*', OPERATOR$k, operands);
+  }
+  operate(results) {
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
+    }
+    return presentResults.reduce((acc, result) => multiplyWithExpectedDecimals(acc, result));
+  }
+}
+
+// Operator key
+const OPERATOR$j = Symbol('SUBTRACT');
+const subtractWithExpectedDecimals = operateWithExpectedDecimals('subtract');
+
+/**
+ * Subtract operation expression
+ */
+class Subtract extends Arithmetic {
+  /**
+   * @constructor Generic constructor
+   * @param {Evaluable[]} args
+   */
+
+  /**
+   * @constructor
+   * @param {Operand[]} operands Operands.
+   */
+  constructor(...operands) {
+    if (operands.length < 2) {
+      throw new Error('subtract expression requires at least 2 operands');
+    }
+    super('-', OPERATOR$j, operands);
+  }
+  operate(results) {
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
+    }
+    return presentResults.reduce((acc, result) => subtractWithExpectedDecimals(acc, result));
+  }
+}
+
+// Operator key
+const OPERATOR$i = Symbol('SUM');
+const addWithExpectedDecimals = operateWithExpectedDecimals('sum');
+
+/**
+ * Sum operation expression
+ */
+class Sum extends Arithmetic {
+  /**
+   * @constructor Generic constructor
+   * @param {Evaluable[]} args
+   */
+
+  /**
+   * @constructor
+   * @param {Operand[]} operands Operands.
+   */
+  constructor(...operands) {
+    if (operands.length < 2) {
+      throw new Error('sum expression requires at least 2 operands');
+    }
+    super('+', OPERATOR$i, operands);
+  }
+  operate(results) {
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
+    }
+    return presentResults.reduce((acc, result) => addWithExpectedDecimals(acc, result));
+  }
+}
+
+/**
+ * Abstract operand
+ */
+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');
+  }
+}
+
+/**
+ * Print value as string
+ * @param {Result} value
+ * @return {string}
+ */
+function printValue(value) {
+  if (isString(value)) {
+    return `"${value}"`;
+  }
+  return `${value}`;
+}
+
+/**
+ * Static value operand
+ */
+class Value extends Operand {
+  /**
+   * @constructor
+   * @param {Result} value Constant value.
+   */
+  constructor(value) {
+    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);
+  }
+}
+
+/**
+ * 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;
+};
+
+const keyWithArrayIndexRegex = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
+const arrayIndexRegex = /\[(\d+)]/g;
+const parseBacktickWrappedKey = key => key.startsWith('`') && key.endsWith('`') ? key.slice(1, -1) : key;
+const parseKey = key => {
+  const keys = key.match(/(`[^[\]]+`(\[\d+\])*|[^`.]+)/g);
+  return !keys ? [] : keys.flatMap(key => {
+    const unwrappedKey = parseBacktickWrappedKey(key);
+    const keys = [];
+    const parseResult = keyWithArrayIndexRegex.exec(unwrappedKey);
+    if (parseResult) {
+      var _parseResult$groups$c, _parseResult$groups, _parseResult$groups2;
+      const extractedKey = parseBacktickWrappedKey((_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 : unwrappedKey);
+      keys.push(extractedKey);
+      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(unwrappedKey);
+    }
+    return keys;
+  });
+};
+const complexKeyExpression = /{([^{}]+)}/;
+function extractComplexKeys(ctx, key) {
+  // Resolve complex keys
+  let complexKeyMatches = complexKeyExpression.exec(key);
+  while (complexKeyMatches) {
+    const resolvedValue = complexValueLookup(ctx, complexKeyMatches[1]);
+    if (resolvedValue === undefined) {
+      return undefined;
+    }
+    key = key.replace(complexKeyExpression, `${resolvedValue}`);
+    complexKeyMatches = complexKeyExpression.exec(key);
+  }
+  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;
+};
+
+/**
+ * Lookup for the reference in the context.
+ * The nested context value is annotated with "." delimiter.
+ * @example address.city
+ * @param {Context} ctx
+ * @param {string} key Context lookup key.
+ * @return {Result}
+ */
+function complexValueLookup(ctx, key) {
+  const keys = extractComplexKeys(ctx, key);
+  if (!keys) {
+    return undefined;
+  }
+  return simpleValueLookup(keys !== null && keys !== void 0 ? keys : [])(ctx);
+}
+let DataType = /*#__PURE__*/function (DataType) {
+  DataType["Number"] = "Number";
+  DataType["String"] = "String";
+  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
+   * @param {string} key Context key.
+   */
+  constructor(key) {
+    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;
+    }
+  }
 
-/**
- * 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';
-}
+  /**
+   * Evaluate in the given context.
+   * @param {Context} ctx
+   * @return {boolean}
+   */
+  evaluate(ctx) {
+    return this.toDataType(this.valueLookup(ctx));
+  }
 
-/**
- * Valid types for context members
- */
+  /**
+   * {@link Evaluable.simplify}
+   */
+  simplify(ctx, strictKeys, optionalKeys) {
+    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;
+  }
 
-/**
- * Evaluation Context
- * Holds references used during the evaluation process.
- * Format: key: value.
- */
+  /**
+   * {@link Evaluable.serialize}
+   */
+  serialize({
+    referenceSerialization
+  }) {
+    const key = this.dataType ? `${this.key}.(${this.dataType})` : this.key;
+    return referenceSerialization(key);
+  }
 
-/**
- * Evaluation result
- */
+  /**
+   * Get the strict representation of the operand.
+   * @return {string}
+   */
+  toString() {
+    return `{${this.key}}`;
+  }
 
-let EvaluableType = /*#__PURE__*/function (EvaluableType) {
-  EvaluableType["Operand"] = "Operand";
-  EvaluableType["Expression"] = "Expression";
-  return EvaluableType;
-}({});
+  /**
+   * 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;
+  }
+}
 
-/**
- * Evaluable
- */
+const isSimplifiedArithmeticExpression = (operand, result) => operand instanceof Arithmetic && !isEvaluable(result) && !isInfinite(result) && !(operand instanceof Reference);
 
 /**
  * Abstract comparison expression
@@ -148,6 +696,12 @@ class Comparison {
     if (!isEvaluable(left) && !isEvaluable(right)) {
       return this.comparison(left, right);
     }
+    if (isEvaluable(left) && isSimplifiedArithmeticExpression(this.right, right)) {
+      return Reflect.construct(this.constructor, [left, new Value(right)]);
+    }
+    if (isEvaluable(right) && isSimplifiedArithmeticExpression(this.left, left)) {
+      return Reflect.construct(this.constructor, [new Value(left), right]);
+    }
     return this;
   }
 
@@ -194,47 +748,6 @@ class Equal extends Comparison {
   }
 }
 
-/**
- * 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');
 
@@ -551,142 +1064,59 @@ class Overlap extends Comparison {
     const rightArray = right;
     if (leftArray.length === 0 && rightArray.length === 0) {
       return true;
-    }
-    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})`;
-  }
-}
-
-/**
- * Abstract operand
- */
-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');
-  }
-}
-
-/**
- * Print value as string
- * @param {Result} value
- * @return {string}
- */
-function printValue(value) {
-  if (isString(value)) {
-    return `"${value}"`;
-  }
-  return `${value}`;
-}
-
-/**
- * Static value operand
- */
-class Value extends Operand {
-  /**
-   * @constructor
-   * @param {Result} value Constant value.
-   */
-  constructor(value) {
-    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;
+    }
+    return leftArray.some(element => rightArray.includes(element));
   }
 
   /**
-   * {@link Evaluable.evaluate}
+   * Get the strict representation of the expression.
+   * @return {string}
    */
-  evaluate() {
-    return this.value;
+  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 {
   /**
-   * {@link Evaluable.simplify}
+   * @constructor
+   * @param {Evaluable} left Left operand.
+   * @param {Evaluable} right Right operand.
    */
-  simplify() {
-    return this.value;
+
+  constructor(left, right) {
+    if (arguments.length !== 2) {
+      throw new Error('comparison expression expects left and right operands');
+    }
+    super('prefix', OPERATOR$8, left, right);
   }
 
   /**
-   * {@link Evaluable.serialize}
+   * {@link Comparison.comparison}
    */
-  serialize() {
-    return this.value;
+  comparison(left, right) {
+    if (isString(left) === false || isString(right) === false) {
+      return false;
+    }
+    return right.startsWith(left);
   }
 
   /**
-   * Get the strict representation of the operand.
+   * Get the strict representation of the expression.
    * @return {string}
    */
   toString() {
-    return printValue(this.value);
+    const left = this.left.toString();
+    const right = this.right.toString();
+    return `(<${left}>${right})`;
   }
 }
 
@@ -1233,187 +1663,6 @@ class Collection extends Operand {
   }
 }
 
-const keyWithArrayIndexRegex = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
-const arrayIndexRegex = /\[(\d+)]/g;
-const parseBacktickWrappedKey = key => key.startsWith('`') && key.endsWith('`') ? key.slice(1, -1) : key;
-const parseKey = key => {
-  const keys = key.match(/(`[^[\]]+`(\[\d+\])*|[^`.]+)/g);
-  return !keys ? [] : keys.flatMap(key => {
-    const unwrappedKey = parseBacktickWrappedKey(key);
-    const keys = [];
-    const parseResult = keyWithArrayIndexRegex.exec(unwrappedKey);
-    if (parseResult) {
-      var _parseResult$groups$c, _parseResult$groups, _parseResult$groups2;
-      const extractedKey = parseBacktickWrappedKey((_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 : unwrappedKey);
-      keys.push(extractedKey);
-      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(unwrappedKey);
-    }
-    return keys;
-  });
-};
-const complexKeyExpression = /{([^{}]+)}/;
-function extractComplexKeys(ctx, key) {
-  // Resolve complex keys
-  let complexKeyMatches = complexKeyExpression.exec(key);
-  while (complexKeyMatches) {
-    const resolvedValue = complexValueLookup(ctx, complexKeyMatches[1]);
-    if (resolvedValue === undefined) {
-      return undefined;
-    }
-    key = key.replace(complexKeyExpression, `${resolvedValue}`);
-    complexKeyMatches = complexKeyExpression.exec(key);
-  }
-  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;
-};
-
-/**
- * Lookup for the reference in the context.
- * The nested context value is annotated with "." delimiter.
- * @example address.city
- * @param {Context} ctx
- * @param {string} key Context lookup key.
- * @return {Result}
- */
-function complexValueLookup(ctx, key) {
-  const keys = extractComplexKeys(ctx, key);
-  if (!keys) {
-    return undefined;
-  }
-  return simpleValueLookup(keys !== null && keys !== void 0 ? keys : [])(ctx);
-}
-let DataType = /*#__PURE__*/function (DataType) {
-  DataType["Number"] = "Number";
-  DataType["String"] = "String";
-  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
-   * @param {string} key Context key.
-   */
-  constructor(key) {
-    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(this.valueLookup(ctx));
-  }
-
-  /**
-   * {@link Evaluable.simplify}
-   */
-  simplify(ctx, strictKeys, optionalKeys) {
-    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({
-    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
@@ -1449,7 +1698,9 @@ 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']]);
+[OPERATOR$4, 'AND'], [OPERATOR$1, 'OR'], [OPERATOR$2, 'NOR'], [OPERATOR, 'XOR'], [OPERATOR$3, 'NOT'],
+// Arithmetic
+[OPERATOR$i, '+'], [OPERATOR$j, '-'], [OPERATOR$k, '*'], [OPERATOR$l, '/']]);
 
 /**
  * Default parser options
@@ -1463,6 +1714,14 @@ const defaultOptions = {
 
 // Input types
 
+const invalidExpression = 'invalid expression';
+const logicalIfValidOperands = (operands, logical) => {
+  if (operands.every(operand => operand instanceof Logical || operand instanceof Comparison)) {
+    return logical;
+  }
+  throw new Error(invalidExpression);
+};
+
 /**
  * Parser of raw expressions into Evaluable expression
  */
@@ -1473,7 +1732,8 @@ class Parser {
    */
   constructor(options) {
     _defineProperty(this, "opts", void 0);
-    _defineProperty(this, "expectedOperators", void 0);
+    _defineProperty(this, "expectedRootOperators", void 0);
+    _defineProperty(this, "unexpectedRootSymbols", new Set([OPERATOR$i, OPERATOR$j, OPERATOR$k, OPERATOR$l]));
     this.opts = {
       ...defaultOptions
     };
@@ -1485,7 +1745,7 @@ class Parser {
         }
       }
     }
-    this.expectedOperators = new Set(this.opts.operatorMapping.values());
+    this.expectedRootOperators = new Set(Array.from(this.opts.operatorMapping.entries()).filter(([symbol]) => !this.unexpectedRootSymbols.has(symbol)).map(([, operator]) => operator));
   }
 
   /**
@@ -1503,10 +1763,10 @@ class Parser {
    */
   parse(raw) {
     if (raw === undefined || raw === null || Array.isArray(raw) === false) {
-      throw new Error('invalid expression');
+      throw new Error(invalidExpression);
     }
-    if (raw.length === 0 || !this.expectedOperators.has(`${raw[0]}`)) {
-      throw new Error('invalid expression');
+    if (raw.length === 0 || !this.expectedRootOperators.has(`${raw[0]}`)) {
+      throw new Error(invalidExpression);
     }
     return this.parseRawExp(raw);
   }
@@ -1544,71 +1804,103 @@ class Parser {
       return collapsible && operands.length === 1 ? operands[0] : undefined;
     };
     switch (operator) {
-      /**
-       * Logical
-       */
+      // Logical
       case this.opts.operatorMapping.get(OPERATOR$4):
-        expression = operands => logicalExpressionReducer(operands, true) || new And(operands);
+        expression = operands => logicalExpressionReducer(operands, true) || logicalIfValidOperands(operands, new And(operands));
         operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$1):
-        expression = operands => logicalExpressionReducer(operands, true) || new Or(operands);
+        expression = operands => logicalExpressionReducer(operands, true) || logicalIfValidOperands(operands, new Or(operands));
         operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$2):
-        expression = operands => logicalExpressionReducer(operands) || new Nor(operands);
+        expression = operands => logicalExpressionReducer(operands) || logicalIfValidOperands(operands, new Nor(operands));
         operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR):
-        expression = operands => logicalExpressionReducer(operands) || new Xor(operands);
+        expression = operands => logicalExpressionReducer(operands) || logicalIfValidOperands(operands, new Xor(operands));
         operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$3):
-        expression = operands => logicalExpressionReducer(operands) || new Not(...operands);
+        expression = operands => logicalExpressionReducer(operands) || logicalIfValidOperands(operands, new Not(...operands));
         operandParser = this.parseRawExp;
         break;
-      /**
-       * Comparison
-       */
+
+      // Comparison
       case this.opts.operatorMapping.get(OPERATOR$h):
         expression = operands => new Equal(...operands);
+        operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$b):
         expression = operands => new NotEqual(...operands);
+        operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$f):
         expression = operands => new GreaterThan(...operands);
+        operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$g):
         expression = operands => new GreaterThanOrEqual(...operands);
+        operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$c):
         expression = operands => new LessThan(...operands);
+        operandParser = this.parseRawExp;
         break;
       case this.opts.operatorMapping.get(OPERATOR$d):
         expression = operands => new LessThanOrEqual(...operands);
+        operandParser = this.parseRawExp;
         break;
+
+      // Containment
       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;
+
+      // Prefix
       case this.opts.operatorMapping.get(OPERATOR$8):
         expression = operands => new Prefix(...operands);
         break;
+
+      // Suffix
       case this.opts.operatorMapping.get(OPERATOR$6):
         expression = operands => new Suffix(...operands);
         break;
+
+      // Overlap
       case this.opts.operatorMapping.get(OPERATOR$9):
         expression = operands => new Overlap(...operands);
         break;
+
+      // Presence
       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;
+
+      // Arithmetic
+      case this.opts.operatorMapping.get(OPERATOR$i):
+        expression = operands => new Sum(...operands);
+        operandParser = this.parseRawExp;
+        break;
+      case this.opts.operatorMapping.get(OPERATOR$j):
+        expression = operands => new Subtract(...operands);
+        operandParser = this.parseRawExp;
+        break;
+      case this.opts.operatorMapping.get(OPERATOR$k):
+        expression = operands => new Multiply(...operands);
+        operandParser = this.parseRawExp;
+        break;
+      case this.opts.operatorMapping.get(OPERATOR$l):
+        expression = operands => new Divide(...operands);
+        operandParser = this.parseRawExp;
+        break;
+
       // Collection
       default:
         return this.getOperand(raw);
@@ -1629,6 +1921,8 @@ class Parser {
   }
 }
 
+const unexpectedResultError = 'non expression or boolean result should be returned';
+
 /**
  * Condition engine
  */
@@ -1649,7 +1943,11 @@ class Engine {
    * @return {boolean}
    */
   evaluate(exp, ctx) {
-    return this.parse(exp).evaluate(ctx);
+    const result = this.parse(exp).evaluate(ctx);
+    if (isBoolean(result)) {
+      return result;
+    }
+    throw new Error(unexpectedResultError);
   }
 
   /**
@@ -1693,8 +1991,8 @@ class Engine {
     if (isBoolean(result)) {
       return result;
     }
-    throw new Error('non expression or boolean result should be returned');
+    throw new Error(unexpectedResultError);
   }
 }
 
-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 };
+export { OPERATOR$4 as OPERATOR_AND, OPERATOR$l as OPERATOR_DIVIDE, 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$k as OPERATOR_MULTIPLY, 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$j as OPERATOR_SUBTRACT, OPERATOR$6 as OPERATOR_SUFFIX, OPERATOR$i as OPERATOR_SUM, OPERATOR$5 as OPERATOR_UNDEFINED, OPERATOR as OPERATOR_XOR, Engine as default, defaultOptions, isEvaluable };