@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc0

package/rust-client/node_modules/mingo/dist/cjs/init/basic.js

@@ -4,10 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,35 +20,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var basic_exports = {};
-__export(basic_exports, {
-  BASIC_CONTEXT: () => BASIC_CONTEXT
-});
-module.exports = __toCommonJS(basic_exports);
 var import_core = require("../core");
 var booleanOperators = __toESM(require("../operators/expression/boolean"));
 var comparisonOperators = __toESM(require("../operators/expression/comparison"));
 var import_pipeline = require("../operators/pipeline");
 var projectionOperators = __toESM(require("../operators/projection"));
 var queryOperators = __toESM(require("../operators/query"));
-(0, import_core.useOperators)(import_core.OperatorType.EXPRESSION, {
+(0, import_core.useOperators)("expression", {
   ...booleanOperators,
   ...comparisonOperators
 });
-(0, import_core.useOperators)(import_core.OperatorType.PIPELINE, {
+(0, import_core.useOperators)("pipeline", {
   $project: import_pipeline.$project,
   $skip: import_pipeline.$skip,
   $limit: import_pipeline.$limit,
   $sort: import_pipeline.$sort
 });
-(0, import_core.useOperators)(import_core.OperatorType.PROJECTION, projectionOperators);
-(0, import_core.useOperators)(import_core.OperatorType.QUERY, queryOperators);
-const BASIC_CONTEXT = import_core.Context.init().addExpressionOps({
-  ...booleanOperators,
-  ...comparisonOperators
-}).addPipelineOps({ $project: import_pipeline.$project, $skip: import_pipeline.$skip, $limit: import_pipeline.$limit, $sort: import_pipeline.$sort }).addProjectionOps(projectionOperators).addQueryOps(queryOperators);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BASIC_CONTEXT
-});
+(0, import_core.useOperators)("projection", projectionOperators);
+(0, import_core.useOperators)("query", queryOperators);

package/rust-client/node_modules/mingo/dist/cjs/init/system.js

@@ -27,9 +27,9 @@ var pipelineOperators = __toESM(require("../operators/pipeline"));
 var projectionOperators = __toESM(require("../operators/projection"));
 var queryOperators = __toESM(require("../operators/query"));
 var windowOperators = __toESM(require("../operators/window"));
-(0, import_core.useOperators)(import_core.OperatorType.ACCUMULATOR, accumulatorOperators);
-(0, import_core.useOperators)(import_core.OperatorType.EXPRESSION, expressionOperators);
-(0, import_core.useOperators)(import_core.OperatorType.PIPELINE, pipelineOperators);
-(0, import_core.useOperators)(import_core.OperatorType.PROJECTION, projectionOperators);
-(0, import_core.useOperators)(import_core.OperatorType.QUERY, queryOperators);
-(0, import_core.useOperators)(import_core.OperatorType.WINDOW, windowOperators);
+(0, import_core.useOperators)("accumulator", accumulatorOperators);
+(0, import_core.useOperators)("expression", expressionOperators);
+(0, import_core.useOperators)("pipeline", pipelineOperators);
+(0, import_core.useOperators)("projection", projectionOperators);
+(0, import_core.useOperators)("query", queryOperators);
+(0, import_core.useOperators)("window", windowOperators);

package/rust-client/node_modules/mingo/dist/cjs/lazy.js

@@ -19,20 +19,19 @@ var lazy_exports = {};
 __export(lazy_exports, {
   Iterator: () => Iterator,
   Lazy: () => Lazy,
-  compose: () => compose
+  concat: () => concat
 });
 module.exports = __toCommonJS(lazy_exports);
 var import_util = require("./util");
 function Lazy(source) {
   return source instanceof Iterator ? source : new Iterator(source);
 }
-function compose(...iterators) {
+function concat(...iterators) {
   let index = 0;
   return Lazy(() => {
     while (index < iterators.length) {
       const o = iterators[index].next();
-      if (!o.done)
-        return o;
+      if (!o.done) return o;
       index++;
     }
     return { done: true };
@@ -60,47 +59,42 @@ function createCallback(nextFn, iteratees, buffer) {
   let bufferIndex = 0;
   return function(storeResult) {
     try {
-      outer:
-        while (!done) {
-          let o = nextFn();
-          index++;
-          let i = -1;
-          const size = iteratees.length;
-          let innerDone = false;
-          while (++i < size) {
-            const r = iteratees[i];
-            switch (r.action) {
-              case 0 /* MAP */:
-                o = r.func(o, index);
-                break;
-              case 1 /* FILTER */:
-                if (!r.func(o, index))
-                  continue outer;
-                break;
-              case 2 /* TAKE */:
-                --r.count;
-                if (!r.count)
-                  innerDone = true;
-                break;
-              case 3 /* DROP */:
-                --r.count;
-                if (!r.count)
-                  dropItem(iteratees, i);
-                continue outer;
-              default:
-                break outer;
-            }
-          }
-          done = innerDone;
-          if (storeResult) {
-            buffer[bufferIndex++] = o;
-          } else {
-            return { value: o, done: false };
+      outer: while (!done) {
+        let o = nextFn();
+        index++;
+        let i = -1;
+        const size = iteratees.length;
+        let innerDone = false;
+        while (++i < size) {
+          const r = iteratees[i];
+          switch (r.action) {
+            case 0 /* MAP */:
+              o = r.func(o, index);
+              break;
+            case 1 /* FILTER */:
+              if (!r.func(o, index)) continue outer;
+              break;
+            case 2 /* TAKE */:
+              --r.count;
+              if (!r.count) innerDone = true;
+              break;
+            case 3 /* DROP */:
+              --r.count;
+              if (!r.count) dropItem(iteratees, i);
+              continue outer;
+            default:
+              break outer;
           }
         }
+        done = innerDone;
+        if (storeResult) {
+          buffer[bufferIndex++] = o;
+        } else {
+          return { value: o, done: false };
+        }
+      }
     } catch (e) {
-      if (e !== DONE)
-        throw e;
+      if (e !== DONE) throw e;
     }
     done = true;
     return { done };
@@ -115,8 +109,8 @@ class Iterator {
    * @param {Function} fn An optional transformation function
    */
   constructor(source) {
-    this.iteratees = [];
-    this.yieldedValues = [];
+    this.#iteratees = [];
+    this.#yieldedValues = [];
     this.isDone = false;
     let nextVal;
     if (source instanceof Function) {
@@ -126,17 +120,15 @@ class Iterator {
       const src = source;
       nextVal = () => {
         const o = src.next();
-        if (o.done)
-          throw DONE;
+        if (o.done) throw DONE;
         return o.value;
       };
-    } else if (source instanceof Array) {
+    } else if ((0, import_util.isArray)(source)) {
       const data = source;
       const size = data.length;
       let index = 0;
       nextVal = () => {
-        if (index < size)
-          return data[index++];
+        if (index < size) return data[index++];
         throw DONE;
       };
     } else if (!(source instanceof Function)) {
@@ -144,21 +136,28 @@ class Iterator {
         `Lazy must be initialized with an array, generator, or function.`
       );
     }
-    this.getNext = createCallback(nextVal, this.iteratees, this.yieldedValues);
+    this.#getNext = createCallback(
+      nextVal,
+      this.#iteratees,
+      this.#yieldedValues
+    );
   }
+  #iteratees;
+  #yieldedValues;
+  #getNext;
   /**
    * Add an iteratee to this lazy sequence
    */
   push(action, value) {
     if (typeof value === "function") {
-      this.iteratees.push({ action, func: value });
+      this.#iteratees.push({ action, func: value });
     } else if (typeof value === "number") {
-      this.iteratees.push({ action, count: value });
+      this.#iteratees.push({ action, count: value });
     }
     return this;
   }
   next() {
-    return this.getNext();
+    return this.#getNext();
   }
   // Iteratees methods
   /**
@@ -194,7 +193,7 @@ class Iterator {
    * Returns a new lazy object with results of the transformation
    * The entire sequence is realized.
    *
-   * @param {Callback<Source, RawArray>} fn Tranform function of type (Array) => (Any)
+   * @param {Callback<Source, Any[]>} fn Tranform function of type (Array) => (Any)
    */
   transform(fn) {
     const self = this;
@@ -214,9 +213,9 @@ class Iterator {
    */
   value() {
     if (!this.isDone) {
-      this.isDone = this.getNext(true).done;
+      this.isDone = this.#getNext(true).done;
     }
-    return this.yieldedValues;
+    return this.#yieldedValues;
   }
   /**
    * Execute the funcion for each value. Will stop when an execution returns false.
@@ -226,10 +225,8 @@ class Iterator {
   each(f) {
     for (; ; ) {
       const o = this.next();
-      if (o.done)
-        break;
-      if (f(o.value) === false)
-        return false;
+      if (o.done) break;
+      if (f(o.value) === false) return false;
     }
     return true;
   }
@@ -268,5 +265,5 @@ class Iterator {
 0 && (module.exports = {
   Iterator,
   Lazy,
-  compose
+  concat
 });

package/rust-client/node_modules/mingo/dist/cjs/operators/_predicates.js

@@ -58,13 +58,10 @@ function createExpressionOperator(predicate) {
   };
 }
 function $eq(a, b, options) {
-  if ((0, import_util.isEqual)(a, b))
-    return true;
-  if ((0, import_util.isNil)(a) && (0, import_util.isNil)(b))
-    return true;
-  if (a instanceof Array) {
-    const eq = import_util.isEqual.bind(null, b);
-    return a.some(eq) || (0, import_util.flatten)(a, options?.depth).some(eq);
+  if ((0, import_util.isEqual)(a, b)) return true;
+  if ((0, import_util.isNil)(a) && (0, import_util.isNil)(b)) return true;
+  if ((0, import_util.isArray)(a)) {
+    return a.some((v) => (0, import_util.isEqual)(v, b)) || (0, import_util.flatten)(a, options?.depth).some((v) => (0, import_util.isEqual)(v, b));
   }
   return false;
 }
@@ -72,8 +69,7 @@ function $ne(a, b, options) {
   return !$eq(a, b, options);
 }
 function $in(a, b, options) {
-  if ((0, import_util.isNil)(a))
-    return b.some((v) => v === null);
+  if ((0, import_util.isNil)(a)) return b.some((v) => v === null);
   return (0, import_util.intersection)([(0, import_util.ensureArray)(a), b], options?.hashFunction).length > 0;
 }
 function $nin(a, b, options) {
@@ -110,11 +106,10 @@ function $all(values, queries, options) {
   }
   let matched = true;
   for (const query of queries) {
-    if (!matched)
-      break;
-    if ((0, import_util.isObject)(query) && (0, import_util.inArray)(Object.keys(query), "$elemMatch")) {
+    if (!matched) break;
+    if ((0, import_util.isObject)(query) && Object.keys(query).includes("$elemMatch")) {
       matched = $elemMatch(values, query["$elemMatch"], options);
-    } else if (query instanceof RegExp) {
+    } else if ((0, import_util.isRegExp)(query)) {
       matched = values.some((s) => typeof s === "string" && query.test(s));
     } else {
       matched = values.some((v) => (0, import_util.isEqual)(query, v));
@@ -146,22 +141,14 @@ function $elemMatch(a, b, options) {
   return false;
 }
 const isNull = (a) => a === null;
-const isInt = (a) => (0, import_util.isNumber)(a) && a >= import_util.MIN_INT && a <= import_util.MAX_INT && a.toString().indexOf(".") === -1;
-const isLong = (a) => (0, import_util.isNumber)(a) && a >= import_util.MIN_LONG && a <= import_util.MAX_LONG && a.toString().indexOf(".") === -1;
 const compareFuncs = {
   array: import_util.isArray,
-  bool: import_util.isBoolean,
   boolean: import_util.isBoolean,
   date: import_util.isDate,
-  decimal: import_util.isNumber,
-  double: import_util.isNumber,
-  int: isInt,
-  long: isLong,
   number: import_util.isNumber,
   null: isNull,
   object: import_util.isObject,
   regex: import_util.isRegExp,
-  regexp: import_util.isRegExp,
   string: import_util.isString,
   // added for completeness
   undefined: import_util.isNil,
@@ -181,8 +168,8 @@ const compareFuncs = {
   9: import_util.isDate,
   10: isNull,
   11: import_util.isRegExp,
-  16: isInt,
-  18: isLong,
+  16: import_util.isNumber,
+  18: import_util.isNumber,
   19: import_util.isNumber
   //decimal
 };
@@ -191,10 +178,10 @@ function compareType(a, b, _) {
   return f ? f(a) : false;
 }
 function $type(a, b, options) {
-  return Array.isArray(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);
+  return (0, import_util.isArray)(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);
 }
 function compare(a, b, f) {
-  return (0, import_util.ensureArray)(a).some((x) => (0, import_util.getType)(x) === (0, import_util.getType)(b) && f(x, b));
+  return (0, import_util.ensureArray)(a).some((x) => (0, import_util.typeOf)(x) === (0, import_util.typeOf)(b) && f(x, b));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/_internal.js

@@ -30,10 +30,8 @@ function stddev(data, sampled = true) {
   );
 }
 function covariance(dataset, sampled = true) {
-  if (!dataset)
-    return null;
-  if (dataset.length < 2)
-    return sampled ? null : 0;
+  if (!dataset) return null;
+  if (dataset.length < 2) return sampled ? null : 0;
   let meanX = 0;
   let meanY = 0;
   for (const [x, y] of dataset) {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/accumulator.js

@@ -27,8 +27,7 @@ const $accumulator = (collection, expr, options) => {
     !!options && options.scriptEnabled,
     "$accumulator operator requires 'scriptEnabled' option to be true"
   );
-  if (collection.length == 0)
-    return expr.initArgs;
+  if (collection.length == 0) return expr.initArgs;
   const copts = import_core.ComputeOptions.init(options);
   const initArgs = (0, import_core.computeValue)(
     {},

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/first.js

@@ -22,7 +22,9 @@ __export(first_exports, {
 module.exports = __toCommonJS(first_exports);
 var import_core = require("../../core");
 const $first = (collection, expr, options) => {
-  return collection.length > 0 ? (0, import_core.computeValue)(collection[0], expr, null, options) : void 0;
+  if (collection.length === 0) return void 0;
+  const copts = import_core.ComputeOptions.init(options).update(collection[0]);
+  return (0, import_core.computeValue)(collection[0], expr, null, copts);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/last.js

@@ -22,7 +22,10 @@ __export(last_exports, {
 module.exports = __toCommonJS(last_exports);
 var import_core = require("../../core");
 const $last = (collection, expr, options) => {
-  return collection.length > 0 ? (0, import_core.computeValue)(collection[collection.length - 1], expr, null, options) : void 0;
+  if (collection.length === 0) return void 0;
+  const obj = collection[collection.length - 1];
+  const copts = import_core.ComputeOptions.init(options).update(obj);
+  return (0, import_core.computeValue)(obj, expr, null, copts);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/max.js

@@ -23,12 +23,15 @@ module.exports = __toCommonJS(max_exports);
 var import_util = require("../../util");
 var import_push = require("./push");
 const $max = (collection, expr, options) => {
-  const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNotNaN);
-  const n = nums.reduce(
-    (acc, n2) => (0, import_util.compare)(n2, acc) >= 0 ? n2 : acc,
-    -Infinity
-  );
-  return n === -Infinity ? void 0 : n;
+  const items = (0, import_push.$push)(collection, expr, options);
+  if ((0, import_util.isEmpty)(items)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(items), "$max: input must resolve to array");
+  let max = items[0];
+  for (const n of items) {
+    if ((0, import_util.isNil)(n) || isNaN(n)) continue;
+    if ((0, import_util.compare)(n, max) >= 0) max = n;
+  }
+  return max;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/mergeObjects.js

@@ -20,8 +20,12 @@ __export(mergeObjects_exports, {
   $mergeObjects: () => $mergeObjects
 });
 module.exports = __toCommonJS(mergeObjects_exports);
+var import_core = require("../../core");
 var import_mergeObjects = require("../expression/object/mergeObjects");
-const $mergeObjects = (collection, _, options) => (0, import_mergeObjects.$mergeObjects)({ docs: collection }, "$docs", options);
+const $mergeObjects = (collection, expr, options) => {
+  const arr = (0, import_core.computeValue)(collection, expr, null, options);
+  return (0, import_mergeObjects.$mergeObjects)(null, arr, options);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $mergeObjects

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/min.js

@@ -23,9 +23,15 @@ module.exports = __toCommonJS(min_exports);
 var import_util = require("../../util");
 var import_push = require("./push");
 const $min = (collection, expr, options) => {
-  const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNotNaN);
-  const n = nums.reduce((acc, n2) => (0, import_util.compare)(n2, acc) <= 0 ? n2 : acc, Infinity);
-  return n === Infinity ? void 0 : n;
+  const items = (0, import_push.$push)(collection, expr, options);
+  if ((0, import_util.isEmpty)(items)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(items), "$min: input must resolve to array");
+  let min = items[0];
+  for (const n of items) {
+    if ((0, import_util.isNil)(n) || isNaN(n)) continue;
+    if ((0, import_util.compare)(n, min) <= 0) min = n;
+  }
+  return min;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/push.js

@@ -23,8 +23,7 @@ module.exports = __toCommonJS(push_exports);
 var import_core = require("../../core");
 var import_util = require("../../util");
 const $push = (collection, expr, options) => {
-  if ((0, import_util.isNil)(expr))
-    return collection;
+  if ((0, import_util.isNil)(expr)) return collection;
   const copts = import_core.ComputeOptions.init(options);
   return collection.map(
     (obj) => (0, import_core.computeValue)(obj, expr, null, copts.update(obj))

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/sum.js

@@ -23,10 +23,8 @@ module.exports = __toCommonJS(sum_exports);
 var import_util = require("../../util");
 var import_push = require("./push");
 const $sum = (collection, expr, options) => {
-  if (!(0, import_util.isArray)(collection))
-    return 0;
-  if ((0, import_util.isNumber)(expr))
-    return collection.length * expr;
+  if (!(0, import_util.isArray)(collection)) return 0;
+  if ((0, import_util.isNumber)(expr)) return collection.length * expr;
   const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);
   return nums.reduce((acc, n) => acc + n, 0);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/add.js

@@ -24,17 +24,16 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $add = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  let foundDate = false;
-  const result = args.reduce((acc, val) => {
-    if ((0, import_util.isDate)(val)) {
-      (0, import_util.assert)(!foundDate, "'$add' can only have one date value");
-      foundDate = true;
-      val = val.getTime();
+  let hasDate = false;
+  let sum = 0;
+  for (const n of args) {
+    if ((0, import_util.isDate)(n)) {
+      (0, import_util.assert)(!hasDate, "'$add' can only have one date value");
+      hasDate = true;
     }
-    acc += val;
-    return acc;
-  }, 0);
-  return foundDate ? new Date(result) : result;
+    sum += +n;
+  }
+  return hasDate ? new Date(sum) : sum;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/ceil.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $ceil = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$ceil expression must resolve to a number.");
   return Math.ceil(n);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/exp.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $exp = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$exp expression must resolve to a number.");
   return Math.exp(n);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/floor.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $floor = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)(
     (0, import_util.isNumber)(n) || isNaN(n),
     "$floor expression must resolve to a number."

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/ln.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $ln = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$ln expression must resolve to a number.");
   return Math.log(n);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/log.js

@@ -26,8 +26,7 @@ const $log = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   const msg = "$log expression must resolve to array(2) of numbers";
   (0, import_util.assert)((0, import_util.isArray)(args) && args.length === 2, msg);
-  if (args.some(import_util.isNil))
-    return null;
+  if (args.some(import_util.isNil)) return null;
   (0, import_util.assert)(args.some(isNaN) || args.every(import_util.isNumber), msg);
   return Math.log10(args[0]) / Math.log10(args[1]);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/log10.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $log10 = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)(
     (0, import_util.isNumber)(n) || isNaN(n),
     "$log10 expression must resolve to a number."

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/round.js

@@ -27,8 +27,7 @@ const $round = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   const num = args[0];
   const place = args[1];
-  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
-    return num;
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
   (0, import_util.assert)((0, import_util.isNumber)(num), "$round expression must resolve to a number.");
   return (0, import_internal.truncate)(num, place, true);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/sqrt.js

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $sqrt = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
+  if ((0, import_util.isNil)(n)) return null;
   (0, import_util.assert)(
     (0, import_util.isNumber)(n) && n > 0 || isNaN(n),
     "$sqrt expression must resolve to non-negative number."

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/subtract.js

@@ -21,9 +21,12 @@ __export(subtract_exports, {
 });
 module.exports = __toCommonJS(subtract_exports);
 var import_core = require("../../../core");
+var import_util = require("../../../util");
 const $subtract = (obj, expr, options) => {
-  const args = (0, import_core.computeValue)(obj, expr, null, options);
-  return args[0] - args[1];
+  const [a, b] = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNumber)(a) && (0, import_util.isNumber)(b) || (0, import_util.isDate)(a) && (0, import_util.isDate)(b)) return +a - +b;
+  if ((0, import_util.isDate)(a) && (0, import_util.isNumber)(b)) return new Date(+a - b);
+  (0, import_util.assert)(false, "$subtract: must resolve to number/date.");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/trunc.js

@@ -27,8 +27,7 @@ const $trunc = (obj, expr, options) => {
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
   const num = arr[0];
   const places = arr[1];
-  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
-    return num;
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
   (0, import_util.assert)((0, import_util.isNumber)(num), "$trunc expression must resolve to a number.");
   (0, import_util.assert)(
     (0, import_util.isNil)(places) || (0, import_util.isNumber)(places) && places > -20 && places < 100,