@briza/illogical 1.6.1 → 1.7.1

package/lib/illogical.js

@@ -5,16 +5,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
+    enumerable: true,
+    configurable: true,
+    writable: true
   }) : e[r] = t, e;
 }
 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");
+    var i = e.call(t, r);
     if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
@@ -94,9 +94,15 @@ function areAllResults(values) {
  * @param {Result[]} results results or evaluables
  * @returns {boolean} type guard
  */
-function areAllNumbers(results) {
+function areAllNumbers$1(results) {
   return results.every(isNumber);
 }
+function isUndefined(value) {
+  return value === undefined;
+}
+function isNull(value) {
+  return value === null;
+}
 
 /**
  * Valid types for context members
@@ -154,7 +160,7 @@ class Arithmetic {
     if (presentValues.length !== results.length) {
       return false;
     }
-    if (!areAllNumbers(presentValues)) {
+    if (!areAllNumbers$1(presentValues)) {
       throw new Error(`operands must be numbers for ${this.constructor.name}`);
     }
     return presentValues;
@@ -470,29 +476,33 @@ const toDateNumber = value => {
 
 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]));
-        }
+function parseBacktickWrappedKey(key) {
+  return key[0] === '`' && key[key.length - 1] === '`' ? key.slice(1, -1) : key;
+}
+function parseKeyComponents(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;
-  });
-};
+  } else {
+    keys.push(unwrappedKey);
+  }
+  return keys;
+}
+const parseKeyRegex = /(`[^[\]]+`(\[\d+\])*|[^`.]+)/g;
+function parseKey(key) {
+  const keys = key.match(parseKeyRegex);
+  return !keys ? [] : keys.flatMap(parseKeyComponents);
+}
 const complexKeyExpression = /{([^{}]+)}/;
 function extractComplexKeys(ctx, key) {
   // Resolve complex keys
@@ -549,6 +559,7 @@ let DataType = /*#__PURE__*/function (DataType) {
 // Equivalent to /^.+\.\((Number|String)\)$/
 const dataTypeRegex = new RegExp(`^.+\\.\\((${Object.keys(DataType).join('|')})\\)$`);
 const isComplexKey = key => key.indexOf('{') > -1;
+const castingRegex = /\.\(.+\)$/;
 
 /**
  * Reference operand resolved within the context
@@ -571,9 +582,7 @@ class Reference extends Operand {
     const dataTypeMatch = dataTypeRegex.exec(this.key);
     if (dataTypeMatch) {
       this.dataType = DataType[dataTypeMatch[1]];
-    }
-    if (this.key.match(/.\(.+\)$/)) {
-      this.key = this.key.replace(/.\(.+\)$/, '');
+      this.key = this.key.replace(castingRegex, '');
     }
     if (isComplexKey(this.key)) {
       this.valueLookup = context => complexValueLookup(context, this.key);
@@ -1617,6 +1626,14 @@ class Xor extends Logical {
  * Collection operand resolved containing mixture of value and references.
  */
 class Collection extends Operand {
+  /**
+   * Get the items in the collection.
+   * @returns {Array<Value | Reference>}
+   */
+  getItems() {
+    return this.items;
+  }
+
   /**
    * @constructor
    * @param {Operand[]} items Collection of operands.
@@ -1680,7 +1697,7 @@ class Collection extends Operand {
  * @return {boolean}
  */
 function defaultReferencePredicate(key) {
-  return isString(key) && key.startsWith('$');
+  return key[0] === '$';
 }
 
 /**
@@ -1738,6 +1755,7 @@ class Parser {
     _defineProperty(this, "opts", void 0);
     _defineProperty(this, "expectedRootOperators", void 0);
     _defineProperty(this, "unexpectedRootSymbols", new Set([OPERATOR$i, OPERATOR$j, OPERATOR$k, OPERATOR$l]));
+    _defineProperty(this, "referenceCache", new Map());
     this.opts = {
       ...defaultOptions
     };
@@ -1759,6 +1777,18 @@ class Parser {
   get options() {
     return this.opts;
   }
+  getReference(key) {
+    const cached = this.referenceCache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const reference = new Reference(this.opts.referenceTransform(key));
+    this.referenceCache.set(key, reference);
+    return reference;
+  }
+  resolve(raw) {
+    return isString(raw) && this.opts.referencePredicate(raw) ? this.getReference(raw) : new Value(raw);
+  }
 
   /**
    * Parse raw expression into evaluable expression.
@@ -1917,14 +1947,527 @@ class Parser {
    * @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)));
+      const collectionItems = [];
+      for (const item of raw) {
+        collectionItems.push(this.resolve(item));
+      }
+      return new Collection(collectionItems);
     }
-    return resolve(raw);
+    return this.resolve(raw);
   }
 }
 
+const isTrueResult = value => value === true;
+const isFalseResult = value => value === false;
+const isNonFalseResult = operand => operand !== false && !isEvaluable(operand);
+const isNonTrueResult = operand => operand !== true && !isEvaluable(operand);
+const resultToInputInternal = value => {
+  if (isUndefined(value)) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    return undefined;
+  }
+  return value;
+};
+const resultToInput = value => {
+  if (isUndefined(value)) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const definedValues = value.map(resultToInputInternal).filter(val => !isUndefined(val));
+    if (definedValues.length === 0) {
+      return undefined;
+    }
+    return definedValues;
+  }
+  return value;
+};
+const areAllNumbers = results => {
+  return results.every(isNumber);
+};
+const areAllInputs = values => values.every(value => !isEvaluable(value));
+const getInputValues = results => {
+  const presentValues = results.filter(result => !isNull(result) && !isUndefined(result));
+  // If we have missing context values the result or we still have refences
+  // simplify to false.
+  if (presentValues.length !== results.length || !areAllNumbers(presentValues)) {
+    return false;
+  }
+  return presentValues;
+};
+const extractValues = input => {
+  const evaluable = isEvaluable(input);
+  if (!evaluable) {
+    return Array.isArray(input) ? input : [input];
+  }
+  if (input instanceof Collection) {
+    const results = input.getItems();
+    const values = results.map(item => item instanceof Value ? item.evaluate() : null).filter(value => !isNull(value));
+    return values;
+  }
+  return [];
+};
+
+const simplifyAnd = simplifyInput => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isUndefined(simplification) || isBoolean(simplification) && !isTrueResult(simplification)) {
+      // Short-circuit for AND
+      return false;
+    }
+    simplifiedOperands.push(simplification);
+  }
+
+  // Remove false operands leaving only the Inputs
+  const simplified = simplifiedOperands.filter(isNonTrueResult);
+  if (simplified.length === 0) {
+    return true;
+  }
+  if (simplified.length === 1) {
+    return simplified[0];
+  }
+  return [operator, ...simplified];
+};
+
+const simplify$3 = (simplifyInput, predicate) => input => {
+  const [, ...operands] = input;
+  const results = operands.map(simplifyInput);
+  if (areAllInputs(results)) {
+    const presentValues = getInputValues(results);
+    if (isFalseResult(presentValues)) {
+      return false;
+    }
+    return presentValues.reduce(predicate);
+  }
+  return input;
+};
+const simplifySum = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('sum'))(input);
+const simplifySubtract = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('subtract'))(input);
+const simplifyMultiply = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('multiply'))(input);
+const simplifyDivide = simplifyInput => input => simplify$3(simplifyInput, (acc, result) => acc / result)(input);
+
+const simplifyComparison = predicate => (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+  if (isNumber(leftSimplified) && isNumber(rightSimplified)) {
+    return predicate(leftSimplified, rightSimplified);
+  }
+  const leftDate = toDateNumber(leftSimplified);
+  const rightDate = toDateNumber(rightSimplified);
+  if (leftDate && rightDate) {
+    return predicate(leftDate, rightDate);
+  }
+  if (Array.isArray(leftSimplified) || Array.isArray(rightSimplified)) {
+    return [operator, leftSimplified, rightSimplified];
+  }
+  return false;
+};
+const simplifyGt = (opts, simplifyInput) => input => simplifyComparison((left, right) => left > right)(opts, simplifyInput)(input);
+const simplifyGe = (opts, simplifyInput) => input => simplifyComparison((left, right) => left >= right)(opts, simplifyInput)(input);
+const simplifyLt = (opts, simplifyInput) => input => simplifyComparison((left, right) => left < right)(opts, simplifyInput)(input);
+const simplifyLe = (opts, simplifyInput) => input => simplifyComparison((left, right) => left <= right)(opts, simplifyInput)(input);
+
+const simplifyEquality = predicate => (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+
+  // See Equal.comparison
+  return predicate(leftSimplified, rightSimplified);
+};
+const simplifyEq = (opts, simplifyInput) => input => simplifyEquality((left, right) => left === right)(opts, simplifyInput)(input);
+const simplifyNe = (opts, simplifyInput) => input => simplifyEquality((left, right) => left !== right)(opts, simplifyInput)(input);
+
+const simplify$2 = (originalInput, nonArrayInput, arrayInput) => {
+  // If we don't have the non-array operand, there is nothing to do.
+  if (isEvaluable(nonArrayInput)) {
+    return originalInput;
+  }
+
+  // If we don't have all the values, try with what we have for the
+  // positive case, but otherwise return the original input.
+  if (isEvaluable(arrayInput)) {
+    const leftValues = extractValues(arrayInput);
+    const isFound = leftValues.indexOf(nonArrayInput) > -1;
+    return isFound ? true : originalInput;
+  }
+
+  // If we have all the values, we can check if the non-array operand is
+  // included in the array operand.
+  return arrayInput.indexOf(nonArrayInput) > -1;
+};
+const simplifyIn = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  if (isNull(left) || isUndefined(left) || isNull(right) || isUndefined(right)) {
+    return false;
+  }
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftArray = Array.isArray(leftSimplified) || isEvaluable(leftSimplified);
+  const isRightArray = Array.isArray(rightSimplified) || isEvaluable(rightSimplified);
+  if (isLeftArray) {
+    return simplify$2(input, rightSimplified, leftSimplified);
+  }
+  if (isRightArray) {
+    return simplify$2(input, leftSimplified, rightSimplified);
+  }
+  return false;
+};
+
+const simplifyNor = (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isUndefined(simplification) || isBoolean(simplification) && isTrueResult(simplification)) {
+      // Short-circuit for AND
+      return false;
+    }
+    simplifiedOperands.push(simplification);
+  }
+
+  // Remove true operands leaving only the Inputs
+  const simplified = simplifiedOperands.filter(isNonFalseResult);
+  if (simplified.length === 0) {
+    return true;
+  }
+  if (simplified.length === 1) {
+    var _opts$operatorMapping;
+    return [(_opts$operatorMapping = opts.operatorMapping.get(OPERATOR$3)) !== null && _opts$operatorMapping !== void 0 ? _opts$operatorMapping : 'NOT', simplified[0]];
+  }
+  return [operator, ...simplified];
+};
+
+const simplifyNot = simplifyInput => input => {
+  const [, ...operands] = input;
+  const simplification = simplifyInput(operands[0]);
+  if (isBoolean(simplification)) {
+    return !simplification;
+  }
+  return input;
+};
+
+const simplifyNotIn = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  const leftArray = Array.isArray(left);
+  const rightArray = Array.isArray(right);
+  if (isNull(left) || isUndefined(left) || isNull(right) || isUndefined(right) || leftArray && rightArray || !leftArray && !rightArray) {
+    return true;
+  }
+  if (leftArray) {
+    // If any operand is still an Evaluable, we cannot simplify further
+    const rightSimplified = simplifyInput(right);
+    if (isEvaluable(rightSimplified)) {
+      return input;
+    }
+    const leftSimplified = left.map(simplifyInput);
+    if (leftSimplified.some(isEvaluable)) {
+      return input;
+    }
+    return leftSimplified.indexOf(rightSimplified) === -1;
+  }
+  if (rightArray) {
+    const leftSimplified = simplifyInput(left);
+    if (isEvaluable(leftSimplified)) {
+      return input;
+    }
+    const rightSimplified = right.map(simplifyInput);
+    if (rightSimplified.some(isEvaluable)) {
+      return input;
+    }
+    return rightSimplified.indexOf(leftSimplified) === -1;
+  }
+  return input;
+};
+
+const simplifyOr = simplifyInput => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isBoolean(simplification) && isTrueResult(simplification)) {
+      // Short-circuit for OR
+      return true;
+    } else if (simplification) {
+      simplifiedOperands.push(simplification);
+    }
+  }
+  const simplified = simplifiedOperands.filter(isNonFalseResult);
+  if (simplified.length === 0) {
+    return false;
+  }
+  if (simplified.length === 1) {
+    return simplified[0];
+  }
+  return [operator, ...simplified];
+};
+
+const simplifyOverlap = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+
+  // If we don't have all operands simplified, we can try the positive case
+  // of the values we have satisfying the OVERLAP. But if not, we need to
+  // return the original input.
+  if (isLeftEvaluable || isRightEvaluable) {
+    const leftValues = extractValues(leftSimplified);
+    const rightValues = extractValues(rightSimplified);
+    const rightSet = new Set(rightValues);
+    const res = leftValues.some(element => rightSet.has(element));
+    if (res) {
+      return true;
+    }
+    return input;
+  }
+
+  // If simplified results are not arrays, it means we had a strictKey
+  // without values provided. Simplify to false.
+  if (!Array.isArray(leftSimplified) || !Array.isArray(rightSimplified)) {
+    return false;
+  }
+  const rightSet = new Set(rightSimplified);
+  const res = leftSimplified.some(element => rightSet.has(element));
+  if (res) {
+    return true;
+  }
+  return false;
+};
+
+const simplify$1 = (opts, simplifyInput, startsWith = true) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+  if (isString(leftSimplified) && isString(rightSimplified)) {
+    return startsWith ? rightSimplified.startsWith(leftSimplified) : leftSimplified.endsWith(rightSimplified);
+  }
+  return false;
+};
+const simplifyPrefix = (opts, simplifyInput) => input => simplify$1(opts, simplifyInput)(input);
+const simplifySuffix = (opts, simplifyInput) => input => simplify$1(opts, simplifyInput, false)(input);
+
+const simplify = (simplifyInput, predicate, present = true) => input => {
+  const [, ...operands] = input;
+  const [operand] = operands;
+  const simplified = simplifyInput(operand);
+  const isOperandEvaluable = isEvaluable(simplified);
+  if (isOperandEvaluable) {
+    return input;
+  }
+
+  // Operand simplifies to itself when it is included in strictKeys or
+  // optionalKeys, thus it was undefined.
+  if (operand === simplified) {
+    return !present;
+  }
+  return predicate(simplified);
+};
+const simplifyPresent = simplifyInput => input => simplify(simplifyInput, input => !isUndefined(input) && !isNull(input))(input);
+const simplifyUndefined = simplifyInput => input => simplify(simplifyInput, isUndefined, false)(input);
+
+const simplifyXor = (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  let trueCount = 0;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isBoolean(simplification) && isTrueResult(simplification)) {
+      trueCount++;
+      continue;
+    }
+    if (isBoolean(simplification) && isFalseResult(simplification)) {
+      continue;
+    }
+    if (!isEvaluable(simplification)) {
+      simplifiedOperands.push(simplification);
+    }
+  }
+  if (trueCount > 1) {
+    return false;
+  }
+  if (simplifiedOperands.length === 0) {
+    return trueCount === 1;
+  }
+  if (simplifiedOperands.length === 1) {
+    if (trueCount === 1) {
+      var _opts$operatorMapping;
+      return [(_opts$operatorMapping = opts.operatorMapping.get(OPERATOR$3)) !== null && _opts$operatorMapping !== void 0 ? _opts$operatorMapping : 'NOT', simplifiedOperands[0]];
+    }
+    return simplifiedOperands[0];
+  }
+  if (trueCount === 1) {
+    var _opts$operatorMapping2;
+    return [(_opts$operatorMapping2 = opts.operatorMapping.get(OPERATOR$2)) !== null && _opts$operatorMapping2 !== void 0 ? _opts$operatorMapping2 : 'NOR', ...simplifiedOperands];
+  }
+  return [operator, ...simplifiedOperands];
+};
+
+const unsafeSimplify = (context, opts, strictKeys, optionalKeys) => {
+  const simplifyInput = input => {
+    // Value or Reference
+    if (!Array.isArray(input)) {
+      // Reference
+      if (isString(input) && opts.referencePredicate(input)) {
+        const result = new Reference(opts.referenceTransform(input)).simplify(context, strictKeys, optionalKeys);
+        if (isEvaluable(result)) {
+          return result;
+        }
+        const inputResult = resultToInput(result);
+        if (!isUndefined(inputResult)) {
+          return inputResult;
+        }
+        // It should have been a boolean or an Evaluable, but just in case
+        // fallback to returning the input.
+      }
+      // Value
+      return input;
+    }
+    const [operator] = input;
+    switch (operator) {
+      // Logical operators
+      case opts.operatorMapping.get(OPERATOR$4):
+        {
+          return simplifyAnd(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$1):
+        {
+          return simplifyOr(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$2):
+        {
+          return simplifyNor(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR):
+        {
+          return simplifyXor(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$3):
+        {
+          return simplifyNot(simplifyInput)(input);
+        }
+      // Comparison operators
+      case opts.operatorMapping.get(OPERATOR$h):
+        {
+          return simplifyEq(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$b):
+        {
+          return simplifyNe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$f):
+        {
+          return simplifyGt(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$g):
+        {
+          return simplifyGe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$c):
+        {
+          return simplifyLt(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$d):
+        {
+          return simplifyLe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$e):
+        {
+          return simplifyIn(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$a):
+        {
+          return simplifyNotIn(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$8):
+        {
+          return simplifyPrefix(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$6):
+        {
+          return simplifySuffix(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$9):
+        {
+          return simplifyOverlap(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$5):
+        {
+          return simplifyUndefined(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$7):
+        {
+          return simplifyPresent(simplifyInput)(input);
+        }
+      // Arithmetic operators
+      case opts.operatorMapping.get(OPERATOR$i):
+        {
+          return simplifySum(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$j):
+        {
+          return simplifySubtract(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$k):
+        {
+          return simplifyMultiply(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$l):
+        {
+          return simplifyDivide(simplifyInput)(input);
+        }
+      default:
+        {
+          // Handle as an array of References / Values if no operator matches
+          const result = input.map(simplifyInput);
+          if (!areAllInputs(result)) {
+            return new Collection(result.map(item => {
+              if (item instanceof Reference) {
+                return item;
+              }
+              if (!isEvaluable(item)) {
+                return new Value(item);
+              }
+              throw new Error('Unexpected expression found within a collection of values/references');
+            }));
+          }
+          return result;
+        }
+    }
+  };
+  return simplifyInput;
+};
+
 const unexpectedResultError = 'non expression or boolean result should be returned';
 
 /**
@@ -1997,6 +2540,18 @@ class Engine {
     }
     throw new Error(unexpectedResultError);
   }
+  unsafeSimplify(exp, context, strictKeys, optionalKeys) {
+    const result = unsafeSimplify(context, this.parser.options, strictKeys, optionalKeys)(exp);
+    if (isBoolean(result)) {
+      return result;
+    }
+
+    // The unsafe implementation should not expose the Evaluable interface
+    if (isEvaluable(result)) {
+      throw new Error('Unexpected Evaluable not serialized result');
+    }
+    return result;
+  }
 }
 
 exports.OPERATOR_AND = OPERATOR$4;