@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.3-rc0

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

@@ -1,17 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../core";
-import { compare, isNil } from "../../util";
-import { $push } from "./push";
-const $maxN = (collection, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  const m = collection.length;
-  const n = computeValue(copts?.local?.groupId, expr.n, null, copts);
-  const arr = $push(collection, expr.input, options).filter((o) => !isNil(o));
-  arr.sort((a, b) => -1 * compare(a, b));
-  return m <= n ? arr : arr.slice(0, n);
-};
-export {
-  $maxN
-};

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

@@ -1,5 +0,0 @@
-import { $percentile } from "./percentile";
-const $median = (collection, expr, options) => $percentile(collection, { ...expr, p: [0.5] }, options).pop();
-export {
-  $median
-};

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

@@ -1,9 +0,0 @@
-import { computeValue } from "../../core";
-import { $mergeObjects as __mergeObjects } from "../expression/object/mergeObjects";
-const $mergeObjects = (collection, expr, options) => {
-  const arr = computeValue(collection, expr, null, options);
-  return __mergeObjects(null, arr, options);
-};
-export {
-  $mergeObjects
-};

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

@@ -1,16 +0,0 @@
-import { assert, compare, isArray, isEmpty, isNil } from "../../util";
-import { $push } from "./push";
-const $min = (collection, expr, options) => {
-  const items = $push(collection, expr, options);
-  if (isEmpty(items)) return null;
-  assert(isArray(items), "$min: input must resolve to array");
-  let min = items[0];
-  for (const n of items) {
-    if (isNil(n) || isNaN(n)) continue;
-    if (compare(n, min) <= 0) min = n;
-  }
-  return min;
-};
-export {
-  $min
-};

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

@@ -1,17 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../core";
-import { compare, isNil } from "../../util";
-import { $push } from "./push";
-const $minN = (collection, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  const m = collection.length;
-  const n = computeValue(copts?.local?.groupId, expr.n, null, copts);
-  const arr = $push(collection, expr.input, options).filter((o) => !isNil(o));
-  arr.sort(compare);
-  return m <= n ? arr : arr.slice(0, n);
-};
-export {
-  $minN
-};

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

@@ -1,27 +0,0 @@
-import { assert, findInsertIndex, isNumber } from "../../util";
-import { $push } from "./push";
-const $percentile = (collection, expr, options) => {
-  const X = $push(collection, expr.input, options).filter(isNumber).sort();
-  const centiles = $push(expr.p, "$$CURRENT", options).filter(isNumber);
-  const method = expr.method || "approximate";
-  return centiles.map((p) => {
-    assert(
-      p > 0 && p <= 1,
-      `percentile value must be between 0 (exclusive) and 1 (inclusive): invalid '${p}'.`
-    );
-    const r = p * (X.length - 1) + 1;
-    const ri = Math.floor(r);
-    const result = r === ri ? X[r - 1] : X[ri - 1] + r % 1 * (X[ri] - X[ri - 1] || 0);
-    switch (method) {
-      case "exact":
-        return result;
-      case "approximate": {
-        const i = findInsertIndex(X, result);
-        return i / X.length >= p ? X[Math.max(i - 1, 0)] : X[i];
-      }
-    }
-  });
-};
-export {
-  $percentile
-};

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

@@ -1,15 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../core";
-import { isNil } from "../../util";
-const $push = (collection, expr, options) => {
-  if (isNil(expr)) return collection;
-  const copts = ComputeOptions.init(options);
-  return collection.map(
-    (obj) => computeValue(obj, expr, null, copts.update(obj))
-  );
-};
-export {
-  $push
-};

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

@@ -1,7 +0,0 @@
-import { isNumber } from "../../util";
-import { stddev } from "./_internal";
-import { $push } from "./push";
-const $stdDevPop = (collection, expr, options) => stddev($push(collection, expr, options).filter(isNumber), false);
-export {
-  $stdDevPop
-};

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

@@ -1,7 +0,0 @@
-import { isNumber } from "../../util";
-import { stddev } from "./_internal";
-import { $push } from "./push";
-const $stdDevSamp = (collection, expr, options) => stddev($push(collection, expr, options).filter(isNumber), true);
-export {
-  $stdDevSamp
-};

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

@@ -1,11 +0,0 @@
-import { isArray, isNumber } from "../../util";
-import { $push } from "./push";
-const $sum = (collection, expr, options) => {
-  if (!isArray(collection)) return 0;
-  if (isNumber(expr)) return collection.length * expr;
-  const nums = $push(collection, expr, options).filter(isNumber);
-  return nums.reduce((acc, n) => acc + n, 0);
-};
-export {
-  $sum
-};

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

@@ -1,5 +0,0 @@
-import { $topN } from "./topN";
-const $top = (collection, expr, options) => $topN(collection, { ...expr, n: 1 }, options);
-export {
-  $top
-};

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

@@ -1,21 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../core";
-import { Lazy } from "../../lazy";
-import { $sort } from "../pipeline/sort";
-import { $push } from "./push";
-const $topN = (collection, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  const { n, sortBy } = computeValue(
-    copts.local.groupId,
-    expr,
-    null,
-    copts
-  );
-  const result = $sort(Lazy(collection), sortBy, options).take(n).value();
-  return $push(result, expr.output, copts);
-};
-export {
-  $topN
-};

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

@@ -1,36 +0,0 @@
-function truncate(num, places = 0, roundOff = false) {
-  const sign = Math.abs(num) === num ? 1 : -1;
-  num = Math.abs(num);
-  let result = Math.trunc(num);
-  const decimals = parseFloat((num - result).toFixed(places + 1));
-  if (places === 0) {
-    const firstDigit = Math.trunc(10 * decimals);
-    if (roundOff && ((result & 1) === 1 && firstDigit >= 5 || firstDigit > 5)) {
-      result++;
-    }
-  } else if (places > 0) {
-    const offset = Math.pow(10, places);
-    let remainder = Math.trunc(decimals * offset);
-    const lastDigit = Math.trunc(decimals * offset * 10) % 10;
-    if (roundOff && lastDigit > 5) {
-      remainder += 1;
-    }
-    result = (result * offset + remainder) / offset;
-  } else if (places < 0) {
-    const offset = Math.pow(10, -1 * places);
-    let excess = result % offset;
-    result = Math.max(0, result - excess);
-    if (roundOff && sign === -1) {
-      while (excess > 10) {
-        excess -= excess % 10;
-      }
-      if (result > 0 && excess >= 5) {
-        result += offset;
-      }
-    }
-  }
-  return result * sign;
-}
-export {
-  truncate
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/abs.js

@@ -1,9 +0,0 @@
-import { computeValue } from "../../../core";
-import { isNil } from "../../../util";
-const $abs = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  return isNil(n) ? null : Math.abs(n);
-};
-export {
-  $abs
-};

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

@@ -1,18 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isDate } from "../../../util";
-const $add = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  let hasDate = false;
-  let sum = 0;
-  for (const n of args) {
-    if (isDate(n)) {
-      assert(!hasDate, "'$add' can only have one date value");
-      hasDate = true;
-    }
-    sum += +n;
-  }
-  return hasDate ? new Date(sum) : sum;
-};
-export {
-  $add
-};

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

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $ceil = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(isNumber(n) || isNaN(n), "$ceil expression must resolve to a number.");
-  return Math.ceil(n);
-};
-export {
-  $ceil
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/divide.js

@@ -1,8 +0,0 @@
-import { computeValue } from "../../../core";
-const $divide = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  return args[0] / args[1];
-};
-export {
-  $divide
-};

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

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $exp = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(isNumber(n) || isNaN(n), "$exp expression must resolve to a number.");
-  return Math.exp(n);
-};
-export {
-  $exp
-};

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

@@ -1,14 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $floor = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(
-    isNumber(n) || isNaN(n),
-    "$floor expression must resolve to a number."
-  );
-  return Math.floor(n);
-};
-export {
-  $floor
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/index.js

@@ -1,16 +0,0 @@
-export * from "./abs";
-export * from "./add";
-export * from "./ceil";
-export * from "./divide";
-export * from "./exp";
-export * from "./floor";
-export * from "./ln";
-export * from "./log";
-export * from "./log10";
-export * from "./mod";
-export * from "./multiply";
-export * from "./pow";
-export * from "./round";
-export * from "./sqrt";
-export * from "./subtract";
-export * from "./trunc";

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

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $ln = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(isNumber(n) || isNaN(n), "$ln expression must resolve to a number.");
-  return Math.log(n);
-};
-export {
-  $ln
-};

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

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

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

@@ -1,14 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $log10 = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(
-    isNumber(n) || isNaN(n),
-    "$log10 expression must resolve to a number."
-  );
-  return Math.log10(n);
-};
-export {
-  $log10
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/mod.js

@@ -1,8 +0,0 @@
-import { computeValue } from "../../../core";
-const $mod = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  return args[0] % args[1];
-};
-export {
-  $mod
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/multiply.js

@@ -1,8 +0,0 @@
-import { computeValue } from "../../../core";
-const $multiply = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  return args.reduce((acc, num) => acc * num, 1);
-};
-export {
-  $multiply
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/pow.js

@@ -1,17 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNumber } from "../../../util";
-const $pow = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  assert(
-    isArray(args) && args.length === 2 && args.every(isNumber),
-    "$pow expression must resolve to array(2) of numbers"
-  );
-  assert(
-    !(args[0] === 0 && args[1] < 0),
-    "$pow cannot raise 0 to a negative exponent"
-  );
-  return Math.pow(args[0], args[1]);
-};
-export {
-  $pow
-};

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

@@ -1,14 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-import { truncate } from "./_internal";
-const $round = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  const num = args[0];
-  const place = args[1];
-  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
-  assert(isNumber(num), "$round expression must resolve to a number.");
-  return truncate(num, place, true);
-};
-export {
-  $round
-};

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

@@ -1,14 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-const $sqrt = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  assert(
-    isNumber(n) && n > 0 || isNaN(n),
-    "$sqrt expression must resolve to non-negative number."
-  );
-  return Math.sqrt(n);
-};
-export {
-  $sqrt
-};

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

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isDate, isNumber } from "../../../util";
-const $subtract = (obj, expr, options) => {
-  const [a, b] = computeValue(obj, expr, null, options);
-  if (isNumber(a) && isNumber(b) || isDate(a) && isDate(b)) return +a - +b;
-  if (isDate(a) && isNumber(b)) return new Date(+a - b);
-  assert(false, "$subtract: must resolve to number/date.");
-};
-export {
-  $subtract
-};

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

@@ -1,18 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil, isNumber } from "../../../util";
-import { truncate } from "./_internal";
-const $trunc = (obj, expr, options) => {
-  const arr = computeValue(obj, expr, null, options);
-  const num = arr[0];
-  const places = arr[1];
-  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
-  assert(isNumber(num), "$trunc expression must resolve to a number.");
-  assert(
-    isNil(places) || isNumber(places) && places > -20 && places < 100,
-    "$trunc expression has invalid place"
-  );
-  return truncate(num, places, false);
-};
-export {
-  $trunc
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/arrayElemAt.js

@@ -1,21 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-const $arrayElemAt = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  assert(
-    isArray(args) && args.length === 2,
-    "$arrayElemAt expression must resolve to array(2)"
-  );
-  if (args.some(isNil)) return null;
-  const index = args[1];
-  const arr = args[0];
-  if (index < 0 && Math.abs(index) <= arr.length) {
-    return arr[(index + arr.length) % arr.length];
-  } else if (index >= 0 && index < arr.length) {
-    return arr[index];
-  }
-  return void 0;
-};
-export {
-  $arrayElemAt
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/arrayToObject.js

@@ -1,23 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, has, isArray, isObject } from "../../../util";
-const $arrayToObject = (obj, expr, options) => {
-  const arr = computeValue(obj, expr, null, options);
-  assert(isArray(arr), "$arrayToObject: expression must resolve to an array");
-  return arr.reduce((newObj, val) => {
-    while (isArray(val) && val.length === 1) val = val[0];
-    if (isArray(val) && val.length == 2) {
-      newObj[val[0]] = val[1];
-    } else {
-      const valObj = val;
-      assert(
-        isObject(valObj) && has(valObj, "k") && has(valObj, "v"),
-        "$arrayToObject expression is invalid."
-      );
-      newObj[valObj.k] = valObj.v;
-    }
-    return newObj;
-  }, {});
-};
-export {
-  $arrayToObject
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/concatArrays.js

@@ -1,18 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-const $concatArrays = (obj, expr, options) => {
-  const nArray = computeValue(obj, expr, null, options);
-  assert(isArray(nArray), "$concatArrays: input must resolve to an array");
-  let size = 0;
-  for (const arr of nArray) {
-    if (isNil(arr)) return null;
-    size += arr.length;
-  }
-  const result = new Array(size);
-  let i = 0;
-  for (const arr of nArray) for (const item of arr) result[i++] = item;
-  return result;
-};
-export {
-  $concatArrays
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/filter.js

@@ -1,28 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../../core";
-import { assert, isArray, isNil, truthy } from "../../../util";
-const $filter = (obj, expr, options) => {
-  const input = computeValue(obj, expr.input, null, options);
-  if (isNil(input)) return null;
-  assert(isArray(input), "$filter 'input' expression must resolve to an array");
-  const copts = ComputeOptions.init(options, obj);
-  const k = expr.as || "this";
-  const local = {
-    variables: { [k]: null }
-  };
-  return input.filter((o) => {
-    local.variables[k] = o;
-    const b = computeValue(
-      obj,
-      expr.cond,
-      null,
-      copts.update(copts.root, local)
-    );
-    return truthy(b, options.useStrictMode);
-  });
-};
-export {
-  $filter
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/first.js

@@ -1,16 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, flatten, isArray, isNil } from "../../../util";
-import { $first as __first } from "../../accumulator/first";
-const $first = (obj, expr, options) => {
-  if (isArray(obj)) return __first(obj, expr, options);
-  const arr = computeValue(obj, expr, null, options);
-  if (isNil(arr)) return null;
-  assert(
-    isArray(arr) && arr.length > 0,
-    "$first must resolve to a non-empty array."
-  );
-  return flatten(arr)[0];
-};
-export {
-  $first
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/firstN.js

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $firstN as __firstN } from "../../accumulator/firstN";
-const $firstN = (obj, expr, options) => {
-  if (isArray(obj)) return __firstN(obj, expr, options);
-  const { input, n } = computeValue(obj, expr, null, options);
-  if (isNil(input)) return null;
-  assert(isArray(input), "Must resolve to an array/null or missing");
-  return __firstN(input, { n, input: "$$this" }, options);
-};
-export {
-  $firstN
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/in.js

@@ -1,10 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isEqual } from "../../../util";
-const $in = (obj, expr, options) => {
-  const [item, arr] = computeValue(obj, expr, null, options);
-  assert(isArray(arr), "$in second argument must be an array");
-  return arr.some((v) => isEqual(v, item));
-};
-export {
-  $in
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/index.js

@@ -1,22 +0,0 @@
-export * from "./arrayElemAt";
-export * from "./arrayToObject";
-export * from "./concatArrays";
-export * from "./filter";
-export * from "./first";
-export * from "./firstN";
-export * from "./in";
-export * from "./indexOfArray";
-export * from "./isArray";
-export * from "./last";
-export * from "./lastN";
-export * from "./map";
-export * from "./maxN";
-export * from "./minN";
-export * from "./nin";
-export * from "./range";
-export * from "./reduce";
-export * from "./reverseArray";
-export * from "./size";
-export * from "./slice";
-export * from "./sortArray";
-export * from "./zip";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/indexOfArray.js

@@ -1,28 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isEqual, isNil } from "../../../util";
-const $indexOfArray = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  if (isNil(args)) return null;
-  let arr = args[0];
-  const searchValue = args[1];
-  if (isNil(arr)) return null;
-  assert(isArray(arr), "$indexOfArray expression must resolve to an array.");
-  const start = args[2] || 0;
-  let end = args[3];
-  if (isNil(end)) end = arr.length;
-  if (start > end) return -1;
-  assert(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
-  if (start > 0 || end < arr.length) {
-    arr = arr.slice(start, end);
-  }
-  let index = -1;
-  arr.some((v, i) => {
-    const b = isEqual(v, searchValue);
-    if (b) index = i;
-    return b;
-  });
-  return index + start;
-};
-export {
-  $indexOfArray
-};