@briza/illogical 1.7.0 → 1.7.2

package/lib/illogical.js

@@ -94,15 +94,9 @@ function areAllResults(values) {
  * @param {Result[]} results results or evaluables
  * @returns {boolean} type guard
  */
-function areAllNumbers$1(results) {
+function areAllNumbers(results) {
   return results.every(isNumber);
 }
-function isUndefined(value) {
-  return value === undefined;
-}
-function isNull(value) {
-  return value === null;
-}
 
 /**
  * Valid types for context members
@@ -160,7 +154,7 @@ class Arithmetic {
     if (presentValues.length !== results.length) {
       return false;
     }
-    if (!areAllNumbers$1(presentValues)) {
+    if (!areAllNumbers(presentValues)) {
       throw new Error(`operands must be numbers for ${this.constructor.name}`);
     }
     return presentValues;
@@ -476,29 +470,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
@@ -555,6 +553,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
@@ -577,9 +576,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);
@@ -599,6 +596,9 @@ class Reference extends Operand {
   evaluate(ctx) {
     return this.toDataType(this.valueLookup(ctx));
   }
+  checkStrictAndOptional(key, strictKeys, optionalKeys) {
+    return strictKeys !== undefined && (Array.isArray(strictKeys) ? strictKeys.includes(key) : strictKeys.has(key)) || optionalKeys !== undefined && (Array.isArray(optionalKeys) ? !optionalKeys.includes(key) : !optionalKeys.has(key)) ? undefined : this;
+  }
 
   /**
    * {@link Evaluable.simplify}
@@ -612,7 +612,7 @@ class Reference extends Operand {
     if (!key || typeof key === 'number') {
       return this;
     }
-    return strictKeys && strictKeys.includes(key) || optionalKeys && !optionalKeys.includes(key) ? undefined : this;
+    return this.checkStrictAndOptional(key, strictKeys, optionalKeys);
   }
 
   /**
@@ -1694,7 +1694,7 @@ class Collection extends Operand {
  * @return {boolean}
  */
 function defaultReferencePredicate(key) {
-  return isString(key) && key.startsWith('$');
+  return key[0] === '$';
 }
 
 /**
@@ -1752,6 +1752,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
     };
@@ -1773,6 +1774,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.
@@ -1931,524 +1944,17 @@ 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';
 
 /**
@@ -2505,10 +2011,12 @@ class Engine {
    *
    * @param {ExpressionInput} exp  Raw expression.
    * @param {Context} context Evaluation data context.
-   * @param {string[]} strictKeys keys to be considered present even if they are not present in the context
-   * @param {string[]} optionalKeys keys to be considered not present unless they are in the context or in
+   * @param {string[] | Set<string>} strictKeys keys to be considered present even if they are not present in the
+   *  context. Passing as a Set is recommended for performance reasons.
+   * @param {string[] | Set<string>} optionalKeys keys to be considered not present unless they are in the context or in
    *  `strictKeys`; when `strictKeys` is `undefined` and `optionalKeys` is an array, every key that is not in
-   *  `optionalKeys` is considered to be present and thus will be evaluated
+   *  `optionalKeys` is considered to be present and thus will be evaluated. Passing as a Set is recommended for
+   *  performance reasons.
    * @returns {Inpunt | boolean}
    */
   simplify(exp, context, strictKeys, optionalKeys) {
@@ -2521,18 +2029,6 @@ 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;