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

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/setWindowFields.js

@@ -1,9 +1,8 @@
 import {
   getOperator,
-  initOptions,
-  OperatorType
+  initOptions
 } from "../../core";
-import { compose, Lazy } from "../../lazy";
+import { concat, Lazy } from "../../lazy";
 import { assert, isNumber, isOperator, isString } from "../../util";
 import { $function } from "../expression/custom/function";
 import { $dateAdd } from "../expression/date/dateAdd";
@@ -35,7 +34,7 @@ const $setWindowFields = (collection, expr, options) => {
     const keys = Object.keys(outputExpr);
     const op = keys.find(isOperator);
     assert(
-      !!getOperator(OperatorType.WINDOW, op, options) || !!getOperator(OperatorType.ACCUMULATOR, op, options),
+      !!getOperator("window", op, options) || !!getOperator("accumulator", op, options),
       `'${op}' is not a valid window operator`
     );
     assert(
@@ -69,12 +68,8 @@ const $setWindowFields = (collection, expr, options) => {
       const config = {
         operatorName: op,
         func: {
-          left: getOperator(
-            OperatorType.ACCUMULATOR,
-            op,
-            options
-          ),
-          right: getOperator(OperatorType.WINDOW, op, options)
+          left: getOperator("accumulator", op, options),
+          right: getOperator("window", op, options)
         },
         args: outputExpr[op],
         field,
@@ -124,17 +119,13 @@ const $setWindowFields = (collection, expr, options) => {
           if (!isUnbounded(window)) {
             const [begin, end] = boundary;
             const toBeginIndex = (currentIndex) => {
-              if (begin == "current")
-                return currentIndex;
-              if (begin == "unbounded")
-                return 0;
+              if (begin == "current") return currentIndex;
+              if (begin == "unbounded") return 0;
               return Math.max(begin + currentIndex, 0);
             };
             const toEndIndex = (currentIndex) => {
-              if (end == "current")
-                return currentIndex + 1;
-              if (end == "unbounded")
-                return items.length;
+              if (end == "current") return currentIndex + 1;
+              if (end == "unbounded") return items.length;
               return end + currentIndex + 1;
             };
             const getItems = (current, index) => {
@@ -164,10 +155,8 @@ const $setWindowFields = (collection, expr, options) => {
                 upper = isNumber(end) ? currentValue + end : Infinity;
               }
               let array = items;
-              if (begin == "current")
-                array = items.slice(index);
-              if (end == "current")
-                array = items.slice(0, index + 1);
+              if (begin == "current") array = items.slice(index);
+              if (end == "current") array = items.slice(0, index + 1);
               return array.filter((o) => {
                 const n = +o[sortKey];
                 return n >= lower && n <= upper;
@@ -194,7 +183,7 @@ const $setWindowFields = (collection, expr, options) => {
       }
       iterators.push(iterator);
     });
-    return compose(...iterators);
+    return concat(...iterators);
   });
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/skip.js

@@ -1,4 +1,4 @@
-const $skip = (collection, expr, options) => {
+const $skip = (collection, expr, _options) => {
   return collection.drop(expr);
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/sort.js

@@ -1,15 +1,14 @@
 import {
+  assert,
   compare,
   groupBy,
-  into,
   isEmpty,
   isObject,
   isString,
   resolve
 } from "../../util";
 const $sort = (collection, sortKeys, options) => {
-  if (isEmpty(sortKeys) || !isObject(sortKeys))
-    return collection;
+  if (isEmpty(sortKeys) || !isObject(sortKeys)) return collection;
   let cmp = compare;
   const collationSpec = options.collation;
   if (isObject(collationSpec) && isString(collationSpec.locale)) {
@@ -24,13 +23,10 @@ const $sort = (collection, sortKeys, options) => {
         options.hashFunction
       );
       const sortedKeys = Array.from(groups.keys()).sort(cmp);
-      if (sortKeys[key] === -1)
-        sortedKeys.reverse();
-      coll = [];
-      sortedKeys.reduce(
-        (acc, key2) => into(acc, groups.get(key2)),
-        coll
-      );
+      if (sortKeys[key] === -1) sortedKeys.reverse();
+      let i = 0;
+      for (const k of sortedKeys) for (const v of groups.get(k)) coll[i++] = v;
+      assert(i == coll.length, "bug: counter must match collection size.");
     }
     return coll;
   });
@@ -54,20 +50,15 @@ function collationComparator(spec) {
     ignorePunctuation: spec.alternate === "shifted"
   };
   if ((spec.caseLevel || false) === true) {
-    if (localeOpt.sensitivity === "base")
-      localeOpt.sensitivity = "case";
-    if (localeOpt.sensitivity === "accent")
-      localeOpt.sensitivity = "variant";
+    if (localeOpt.sensitivity === "base") localeOpt.sensitivity = "case";
+    if (localeOpt.sensitivity === "accent") localeOpt.sensitivity = "variant";
   }
   const collator = new Intl.Collator(spec.locale, localeOpt);
   return (a, b) => {
-    if (!isString(a) || !isString(b))
-      return compare(a, b);
+    if (!isString(a) || !isString(b)) return compare(a, b);
     const i = collator.compare(a, b);
-    if (i < 0)
-      return -1;
-    if (i > 0)
-      return 1;
+    if (i < 0) return -1;
+    if (i > 0) return 1;
     return 0;
   };
 }

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/sortByCount.js

@@ -1,9 +1,11 @@
 import { $group } from "./group";
 import { $sort } from "./sort";
 const $sortByCount = (collection, expr, options) => {
-  const newExpr = { count: { $sum: 1 } };
-  newExpr["_id"] = expr;
-  return $sort($group(collection, newExpr, options), { count: -1 }, options);
+  return $sort(
+    $group(collection, { _id: expr, count: { $sum: 1 } }, options),
+    { count: -1 },
+    options
+  );
 };
 export {
   $sortByCount

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/unionWith.js

@@ -1,5 +1,5 @@
 import { Aggregator } from "../../aggregator";
-import { compose, Lazy } from "../../lazy";
+import { concat, Lazy } from "../../lazy";
 import { isString } from "../../util";
 const $unionWith = (collection, expr, options) => {
   const array = isString(expr.coll) ? options.collectionResolver(expr.coll) : expr.coll;
@@ -7,7 +7,7 @@ const $unionWith = (collection, expr, options) => {
   iterators.push(
     expr.pipeline ? new Aggregator(expr.pipeline, options).stream(array) : Lazy(array)
   );
-  return compose(...iterators);
+  return concat(...iterators);
 };
 export {
   $unionWith

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/unset.js

@@ -3,8 +3,7 @@ import { $project } from "./project";
 const $unset = (collection, expr, options) => {
   expr = ensureArray(expr);
   const doc = {};
-  for (const k of expr)
-    doc[k] = 0;
+  for (const k of expr) doc[k] = 0;
   return $project(collection, doc, options);
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/unwind.js

@@ -1,5 +1,6 @@
 import { Iterator, Lazy } from "../../lazy";
 import {
+  isArray,
   isEmpty,
   isString,
   removeValue,
@@ -8,15 +9,13 @@ import {
   setValue
 } from "../../util";
 const $unwind = (collection, expr, _options) => {
-  if (isString(expr))
-    expr = { path: expr };
+  if (isString(expr)) expr = { path: expr };
   const path = expr.path;
   const field = path.substring(1);
   const includeArrayIndex = expr?.includeArrayIndex || false;
   const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;
   const format = (o, i) => {
-    if (includeArrayIndex !== false)
-      o[includeArrayIndex] = i;
+    if (includeArrayIndex !== false) o[includeArrayIndex] = i;
     return o;
   };
   let value;
@@ -24,15 +23,13 @@ const $unwind = (collection, expr, _options) => {
     for (; ; ) {
       if (value instanceof Iterator) {
         const tmp = value.next();
-        if (!tmp.done)
-          return tmp;
+        if (!tmp.done) return tmp;
       }
       const wrapper = collection.next();
-      if (wrapper.done)
-        return wrapper;
+      if (wrapper.done) return wrapper;
       const obj = wrapper.value;
       value = resolve(obj, field);
-      if (value instanceof Array) {
+      if (isArray(value)) {
         if (value.length === 0 && preserveNullAndEmptyArrays === true) {
           value = null;
           removeValue(obj, field);

package/rust-client/node_modules/mingo/dist/esm/operators/projection/elemMatch.js

@@ -1,14 +1,13 @@
 import { Query } from "../../query";
-import { assert, resolve } from "../../util";
+import { assert, isArray, resolve } from "../../util";
 const $elemMatch = (obj, expr, field, options) => {
   const arr = resolve(obj, field);
   const query = new Query(expr, options);
-  assert(arr instanceof Array, "$elemMatch: argument must resolve to array");
+  assert(isArray(arr), "$elemMatch: argument must resolve to array");
   const result = [];
   for (let i = 0; i < arr.length; i++) {
     if (query.test(arr[i])) {
-      if (options.useStrictMode)
-        return [arr[i]];
+      if (options.useStrictMode) return [arr[i]];
       result.push(arr[i]);
     }
   }

package/rust-client/node_modules/mingo/dist/esm/operators/projection/slice.js

@@ -3,11 +3,10 @@ import { $slice as __slice } from "../expression/array/slice";
 const $slice = (obj, expr, field, options) => {
   const xs = resolve(obj, field);
   const exprAsArray = expr;
-  if (!isArray(xs))
-    return xs;
+  if (!isArray(xs)) return xs;
   return __slice(
     obj,
-    expr instanceof Array ? [xs, ...exprAsArray] : [xs, expr],
+    isArray(expr) ? [xs, ...exprAsArray] : [xs, expr],
     options
   );
 };

package/rust-client/node_modules/mingo/dist/esm/operators/query/bitwise/_internal.js

@@ -1,11 +1,11 @@
+import { isArray } from "../../../util";
 import { createQueryOperator } from "../../_predicates";
 const createBitwiseOperator = (predicate) => {
   return createQueryOperator(
-    (value, mask, options) => {
+    (value, mask, _options) => {
       let b = 0;
-      if (mask instanceof Array) {
-        for (const n of mask)
-          b = b | 1 << n;
+      if (isArray(mask)) {
+        for (const n of mask) b = b | 1 << n;
       } else {
         b = mask;
       }

package/rust-client/node_modules/mingo/dist/esm/operators/update/_internal.js

@@ -5,6 +5,7 @@ import {
   isArray,
   isDate,
   isObject,
+  isRegExp,
   resolve,
   walk
 } from "../../util";
@@ -13,12 +14,10 @@ const clone = (mode, val) => {
     case "deep":
       return cloneDeep(val);
     case "copy": {
-      if (isDate(val))
-        return new Date(val);
-      if (isArray(val))
-        return [...val];
-      if (isObject(val))
-        return { ...val };
+      if (isDate(val)) return new Date(val);
+      if (isArray(val)) return [...val];
+      if (isObject(val)) return { ...val };
+      if (isRegExp(val)) return new RegExp(val);
       return val;
     }
     default:
@@ -54,11 +53,9 @@ const applyUpdate = (o, n, q, f, opts) => {
     return b;
   }
   const t = resolve(o, parent);
-  if (!isArray(t))
-    return false;
+  if (!isArray(t)) return false;
   return t.map((e, i) => {
-    if (q[c] && !q[c].test({ [c]: e }))
-      return false;
+    if (q[c] && !q[c].test({ [c]: e })) return false;
     return next ? applyUpdate(e, next, q, f, opts) : f(t, i);
   }).some(Boolean);
 };
@@ -67,8 +64,7 @@ function walkExpression(expr, arrayFilter, options, callback) {
   for (const [selector, val] of Object.entries(expr)) {
     const [node, vars] = tokenizePath(selector);
     if (!vars.length) {
-      if (callback(val, node, {}))
-        res.push(node.parent);
+      if (callback(val, node, {})) res.push(node.parent);
     } else {
       const conditions = {};
       arrayFilter.forEach((o) => {
@@ -85,8 +81,7 @@ function walkExpression(expr, arrayFilter, options, callback) {
       for (const [k, condition] of Object.entries(conditions)) {
         queries[k] = new Query(condition, options.queryOptions);
       }
-      if (callback(val, node, queries))
-        res.push(node.parent);
+      if (callback(val, node, queries)) res.push(node.parent);
     }
   }
   return res;

package/rust-client/node_modules/mingo/dist/esm/operators/update/addToSet.js

@@ -13,8 +13,7 @@ const $addToSet = (obj, expr, arrayFilters = [], options = {}) => {
       (o, k) => {
         const prev = o[k] ||= [];
         const common = intersection([prev, args.$each]);
-        if (common.length === args.$each.length)
-          return false;
+        if (common.length === args.$each.length) return false;
         o[k] = clone(options.cloneMode, unique(prev.concat(args.$each)));
         return true;
       },

package/rust-client/node_modules/mingo/dist/esm/operators/update/bit.js

@@ -15,8 +15,7 @@ const $bit = (obj, expr, arrayFilters = [], options = {}) => {
       (o, k) => {
         let n = o[k];
         const v = val[op[0]];
-        if (n !== void 0 && !(isNumber(n) && isNumber(v)))
-          return false;
+        if (n !== void 0 && !(isNumber(n) && isNumber(v))) return false;
         n = n || 0;
         switch (op[0]) {
           case "and":

package/rust-client/node_modules/mingo/dist/esm/operators/update/max.js

@@ -7,8 +7,7 @@ const $max = (obj, expr, arrayFilters = [], options = {}) => {
       node,
       queries,
       (o, k) => {
-        if (o[k] !== void 0 && compare(o[k], val) > -1)
-          return false;
+        if (o[k] !== void 0 && compare(o[k], val) > -1) return false;
         o[k] = val;
         return true;
       },

package/rust-client/node_modules/mingo/dist/esm/operators/update/min.js

@@ -7,8 +7,7 @@ const $min = (obj, expr, arrayFilters = [], options = {}) => {
       node,
       queries,
       (o, k) => {
-        if (o[k] !== void 0 && compare(o[k], val) < 1)
-          return false;
+        if (o[k] !== void 0 && compare(o[k], val) < 1) return false;
         o[k] = val;
         return true;
       },

package/rust-client/node_modules/mingo/dist/esm/operators/update/pop.js

@@ -8,8 +8,7 @@ const $pop = (obj, expr, arrayFilters = [], options = {}) => {
         isArray(arr),
         `path '${node.selector}' contains an element of non-array type.`
       );
-      if (!arr.length)
-        return false;
+      if (!arr.length) return false;
       if (val === -1) {
         arr.splice(0, 1);
       } else {

package/rust-client/node_modules/mingo/dist/esm/operators/update/pull.js

@@ -14,12 +14,10 @@ const $pull = (obj, expr, arrayFilters = [], options = {}) => {
       const curr = new Array();
       const found = prev.map((v) => {
         const b = pred(v);
-        if (!b)
-          curr.push(v);
+        if (!b) curr.push(v);
         return b;
       }).some(Boolean);
-      if (!found)
-        return false;
+      if (!found) return false;
       o[k] = curr;
       return true;
     });

package/rust-client/node_modules/mingo/dist/esm/operators/update/push.js

@@ -23,11 +23,7 @@ const $push = (obj, expr, arrayFilters = [], options = {}) => {
         const prev = arr.slice(0, args.$slice || arr.length);
         const oldsize = arr.length;
         const pos = isNumber(args.$position) ? args.$position : arr.length;
-        arr.splice(
-          pos,
-          0,
-          ...clone(options.cloneMode, args.$each)
-        );
+        arr.splice(pos, 0, ...clone(options.cloneMode, args.$each));
         if (args.$sort) {
           const sortKey = isObject(args.$sort) ? Object.keys(args.$sort || {}).pop() : "";
           const order = !sortKey ? args.$sort : args.$sort[sortKey];
@@ -35,10 +31,8 @@ const $push = (obj, expr, arrayFilters = [], options = {}) => {
           arr.sort((a, b) => order * compare(f(a), f(b)));
         }
         if (isNumber(args.$slice)) {
-          if (args.$slice < 0)
-            arr.splice(0, arr.length + args.$slice);
-          else
-            arr.splice(args.$slice);
+          if (args.$slice < 0) arr.splice(0, arr.length + args.$slice);
+          else arr.splice(args.$slice);
         }
         return oldsize != arr.length || !isEqual(prev, arr);
       },

package/rust-client/node_modules/mingo/dist/esm/operators/update/rename.js

@@ -5,8 +5,7 @@ const $rename = (obj, expr, arrayFilters = [], options = {}) => {
   const res = [];
   const changed = walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(obj, node, queries, (o, k) => {
-      if (!has(o, k))
-        return false;
+      if (!has(o, k)) return false;
       res.push(...$set(obj, { [val]: o[k] }, arrayFilters, options));
       delete o[k];
       return true;

package/rust-client/node_modules/mingo/dist/esm/operators/update/set.js

@@ -7,8 +7,7 @@ const $set = (obj, expr, arrayFilters = [], options = {}) => {
       node,
       queries,
       (o, k) => {
-        if (isEqual(o[k], val))
-          return false;
+        if (isEqual(o[k], val)) return false;
         o[k] = clone(options.cloneMode, val);
         return true;
       },

package/rust-client/node_modules/mingo/dist/esm/operators/update/unset.js

@@ -3,8 +3,7 @@ import { applyUpdate, walkExpression } from "./_internal";
 const $unset = (obj, expr, arrayFilters = [], options = {}) => {
   return walkExpression(expr, arrayFilters, options, (_, node, queries) => {
     return applyUpdate(obj, node, queries, (o, k) => {
-      if (!has(o, k))
-        return false;
+      if (!has(o, k)) return false;
       if (isArray(o)) {
         o[k] = null;
       } else {

package/rust-client/node_modules/mingo/dist/esm/operators/window/_internal.js

@@ -25,13 +25,12 @@ function withMemo(collection, expr, cacheFn, fn) {
   let failed = false;
   try {
     return fn(data[expr.field]);
-  } catch (e) {
+  } catch {
     failed = true;
   } finally {
     if (failed || expr.documentNumber === collection.length) {
       delete data[expr.field];
-      if (Object.keys(data).length === 0)
-        memo.delete(collection);
+      if (Object.keys(data).length === 0) memo.delete(collection);
     }
   }
 }

package/rust-client/node_modules/mingo/dist/esm/operators/window/denseRank.js

@@ -1,14 +1,12 @@
 import { rank } from "./_internal";
-function $denseRank(obj, collection, expr, options) {
-  return rank(
-    obj,
-    collection,
-    expr,
-    options,
-    true
-    /*dense*/
-  );
-}
+const $denseRank = (obj, collection, expr, options) => rank(
+  obj,
+  collection,
+  expr,
+  options,
+  true
+  /*dense*/
+);
 export {
   $denseRank
 };

package/rust-client/node_modules/mingo/dist/esm/operators/window/derivative.js

@@ -1,21 +1,19 @@
 import { isNumber } from "../../util";
 import { $push } from "../accumulator";
 import { MILLIS_PER_UNIT } from "./_internal";
-function $derivative(_, collection, expr, options) {
-  if (collection.length < 2)
-    return null;
+const $derivative = (_, collection, expr, options) => {
+  if (collection.length < 2) return null;
   const { input, unit } = expr.inputExpr;
   const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
   const values = [collection[0], collection[collection.length - 1]];
   const points = $push(values, [sortKey, input], options).filter(
     ([x, y]) => isNumber(+x) && isNumber(+y)
   );
-  if (points.length !== 2)
-    return null;
+  if (points.length !== 2) return null;
   const [[x1, y1], [x2, y2]] = points;
   const deltaX = (x2 - x1) / (MILLIS_PER_UNIT[unit] || 1);
   return (y2 - y1) / deltaX;
-}
+};
 export {
   $derivative
 };

package/rust-client/node_modules/mingo/dist/esm/operators/window/documentNumber.js

@@ -1,6 +1,4 @@
-function $documentNumber(_obj, _collection, expr, _options) {
-  return expr.documentNumber;
-}
+const $documentNumber = (_obj, _collection, expr, _options) => expr.documentNumber;
 export {
   $documentNumber
 };

package/rust-client/node_modules/mingo/dist/esm/operators/window/expMovingAvg.js

@@ -1,7 +1,7 @@
 import { assert, isNumber } from "../../util";
 import { $push } from "../accumulator";
 import { withMemo } from "./_internal";
-function $expMovingAvg(_, collection, expr, options) {
+const $expMovingAvg = (_, collection, expr, options) => {
   const { input, N, alpha } = expr.inputExpr;
   assert(
     !(N && alpha),
@@ -15,17 +15,15 @@ function $expMovingAvg(_, collection, expr, options) {
       return series.length === collection.length ? series : null;
     },
     (series) => {
-      if (series === null)
-        return null;
-      if (expr.documentNumber == 1)
-        return series[0];
+      if (series === null) return null;
+      if (expr.documentNumber == 1) return series[0];
       const weight = N != void 0 ? 2 / (N + 1) : alpha;
       const i = expr.documentNumber - 1;
       series[i] = series[i] * weight + series[i - 1] * (1 - weight);
       return series[i];
     }
   );
-}
+};
 export {
   $expMovingAvg
 };

package/rust-client/node_modules/mingo/dist/esm/operators/window/integral.js

@@ -1,14 +1,13 @@
 import { isNumber } from "../../util";
 import { $push } from "../accumulator";
 import { MILLIS_PER_UNIT } from "./_internal";
-function $integral(_, collection, expr, options) {
+const $integral = (_, collection, expr, options) => {
   const { input, unit } = expr.inputExpr;
   const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
   const points = $push(collection, [sortKey, input], options).filter(
     ([x, y]) => isNumber(+x) && isNumber(+y)
   );
-  if (points.length !== collection.length)
-    return null;
+  if (points.length !== collection.length) return null;
   let result = 0;
   const size = collection.length;
   for (let k = 1; k < size; k++) {
@@ -18,7 +17,7 @@ function $integral(_, collection, expr, options) {
     result += 0.5 * (y1 + y2) * deltaX;
   }
   return result;
-}
+};
 export {
   $integral
 };

package/rust-client/node_modules/mingo/dist/esm/operators/window/linearFill.js

@@ -2,7 +2,7 @@ import { isNumber } from "../../util";
 import { $push } from "../accumulator";
 import { withMemo } from "./_internal";
 const interpolate = (x1, y1, x2, y2, x) => y1 + (x - x1) * ((y2 - y1) / (x2 - x1));
-function $linearFill(_, collection, expr, options) {
+const $linearFill = (_, collection, expr, options) => {
   return withMemo(
     collection,
     expr,
@@ -13,8 +13,7 @@ function $linearFill(_, collection, expr, options) {
         [sortKey, expr.inputExpr],
         options
       ).filter(([x, _2]) => isNumber(+x));
-      if (points.length !== collection.length)
-        return null;
+      if (points.length !== collection.length) return null;
       let lindex = -1;
       let rindex = 0;
       while (rindex < points.length) {
@@ -25,8 +24,7 @@ function $linearFill(_, collection, expr, options) {
         while (rindex + 1 < points.length && !isNumber(points[rindex + 1][1])) {
           rindex++;
         }
-        if (rindex + 1 >= points.length)
-          break;
+        if (rindex + 1 >= points.length) break;
         rindex++;
         while (lindex + 1 < rindex) {
           points[lindex + 1][1] = interpolate(
@@ -44,7 +42,7 @@ function $linearFill(_, collection, expr, options) {
     },
     (values) => values[expr.documentNumber - 1]
   );
-}
+};
 export {
   $linearFill
 };