@briza/illogical 1.7.1 → 1.7.3

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;
@@ -602,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}
@@ -615,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);
   }
 
   /**
@@ -1958,516 +1955,6 @@ class Parser {
   }
 }
 
-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';
 
 /**
@@ -2524,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) {
@@ -2540,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;

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@briza/illogical",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "A micro conditional javascript engine used to parse the raw logical and comparison expressions, evaluate the expression in the given data context, and provide access to a text form of the given expressions.",
-  "main": "lib/illogical.js",
-  "module": "lib/illogical.esm.js",
-  "typings": "types/index.d.ts",
+  "main": "./lib/illogical.js",
+  "module": "./lib/illogical.esm.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "require": "./lib/illogical.js",
+      "import": "./lib/illogical.esm.js"
+    }
+  },
   "files": [
     "/lib",
     "/types",
@@ -42,31 +49,31 @@
     "rules"
   ],
   "devDependencies": {
-    "@babel/core": "^7.27.3",
+    "@babel/core": "^7.28.5",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/preset-env": "^7.25.3",
-    "@babel/preset-typescript": "^7.24.7",
-    "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-eslint": "^9.0.5",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@types/jest": "^29.5.12",
-    "@typescript-eslint/eslint-plugin": "^8.0.1",
-    "@typescript-eslint/parser": "^8.0.1",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
+    "@babel/preset-env": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@rollup/plugin-babel": "^6.1.0",
+    "@rollup/plugin-commonjs": "^26.0.3",
+    "@rollup/plugin-eslint": "^9.1.0",
+    "@rollup/plugin-node-resolve": "^15.3.1",
+    "@types/jest": "^29.5.14",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.2",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "eslint-plugin-promise": "^7.1.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "jest": "^29.7.0",
     "license-checker": "^25.0.1",
-    "prettier": "^3.3.3",
-    "rollup": "^4.41.1",
-    "ts-jest": "^29.2.4",
-    "typedoc": "^0.26.5",
-    "typescript": "^5.5.4"
+    "prettier": "^3.6.2",
+    "rollup": "^4.52.5",
+    "ts-jest": "^29.4.5",
+    "typedoc": "^0.26.11",
+    "typescript": "^5.6.3"
   }
 }

package/readme.md

@@ -222,19 +222,6 @@ engine.simplify(
 ) // ['==', '$b', 20]
 ```
 
-### Unsafe Simplify
-
-Simplifies an expression with a given context, but without parsing and ensuring the condition is
-syntatically correct. This can be used in situations where you can decouple the parsing from
-the simplification and extra performance is needed in runtime.
-
-```js
-engine.unsafeSimplify(
-  ['OR', ['==', '$a', 10], ['==', '$b', 20], ['==', '$c', 20]],
-  { a: 10 }
-) // true due to $a. Expressions for $b and $c won't even be parsed.
-```
-
 ## Working with Expressions
 
 ### Evaluation Data Context