@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.4-rc01

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

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

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

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

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

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $lastN as __lastN } from "../../accumulator/lastN";
-const $lastN = (obj, expr, options) => {
-  if (isArray(obj)) return __lastN(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 __lastN(input, { n, input: "$$this" }, options);
-};
-export {
-  $lastN
-};

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

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

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

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $maxN as __maxN } from "../../accumulator/maxN";
-const $maxN = (obj, expr, options) => {
-  if (isArray(obj)) return __maxN(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 __maxN(input, { n, input: "$$this" }, options);
-};
-export {
-  $maxN
-};

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

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $minN as __minN } from "../../accumulator/minN";
-const $minN = (obj, expr, options) => {
-  if (isArray(obj)) return __minN(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 __minN(input, { n, input: "$$this" }, options);
-};
-export {
-  $minN
-};

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

@@ -1,5 +0,0 @@
-import { $nin as __nin, createExpressionOperator } from "../../_predicates";
-const $nin = createExpressionOperator(__nin);
-export {
-  $nin
-};

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

@@ -1,17 +0,0 @@
-import { computeValue } from "../../../core";
-const $range = (obj, expr, options) => {
-  const arr = computeValue(obj, expr, null, options);
-  const start = arr[0];
-  const end = arr[1];
-  const step = arr[2] || 1;
-  const result = new Array();
-  let counter = start;
-  while (counter < end && step > 0 || counter > end && step < 0) {
-    result.push(counter);
-    counter += step;
-  }
-  return result;
-};
-export {
-  $range
-};

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

@@ -1,26 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-const $reduce = (obj, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  const input = computeValue(obj, expr.input, null, copts);
-  const initialValue = computeValue(obj, expr.initialValue, null, copts);
-  const inExpr = expr["in"];
-  if (isNil(input)) return null;
-  assert(isArray(input), "$reduce 'input' expression must resolve to an array");
-  return input.reduce((acc, n) => {
-    return computeValue(
-      n,
-      inExpr,
-      null,
-      copts.update(copts.root, {
-        variables: { value: acc }
-      })
-    );
-  }, initialValue);
-};
-export {
-  $reduce
-};

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

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-const $reverseArray = (obj, expr, options) => {
-  const arr = computeValue(obj, expr, null, options);
-  if (isNil(arr)) return null;
-  assert(isArray(arr), "$reverseArray expression must resolve to an array");
-  const result = arr.slice(0);
-  result.reverse();
-  return result;
-};
-export {
-  $reverseArray
-};

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

@@ -1,9 +0,0 @@
-import { computeValue } from "../../../core";
-import { isArray } from "../../../util";
-const $size = (obj, expr, options) => {
-  const value = computeValue(obj, expr, null, options);
-  return isArray(value) ? value.length : void 0;
-};
-export {
-  $size
-};

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

@@ -1,29 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isNil } from "../../../util";
-const $slice = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  const arr = args[0];
-  let skip = args[1];
-  let limit = args[2];
-  if (isNil(limit)) {
-    if (skip < 0) {
-      skip = Math.max(0, arr.length + skip);
-    } else {
-      limit = skip;
-      skip = 0;
-    }
-  } else {
-    if (skip < 0) {
-      skip = Math.max(0, arr.length + skip);
-    }
-    assert(
-      limit > 0,
-      `Invalid argument for $slice operator. Limit must be a positive number`
-    );
-    limit += skip;
-  }
-  return arr.slice(skip, limit);
-};
-export {
-  $slice
-};

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

@@ -1,19 +0,0 @@
-import { computeValue } from "../../../core";
-import { Lazy } from "../../../lazy";
-import { assert, compare, isArray, isNil, isObject } from "../../../util";
-import { $sort } from "../../pipeline/sort";
-const $sortArray = (obj, expr, options) => {
-  const { input, sortBy } = computeValue(obj, expr, null, options);
-  if (isNil(input)) return null;
-  assert(isArray(input), "$sortArray expression must resolve to an array");
-  if (isObject(sortBy)) {
-    return $sort(Lazy(input), sortBy, options).value();
-  }
-  const result = [...input];
-  result.sort(compare);
-  if (sortBy === -1) result.reverse();
-  return result;
-};
-export {
-  $sortArray
-};

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

@@ -1,36 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isBoolean, isNil } from "../../../util";
-const $zip = (obj, expr, options) => {
-  const inputs = computeValue(obj, expr.inputs, null, options);
-  const useLongestLength = expr.useLongestLength || false;
-  if (isNil(inputs)) return null;
-  assert(isArray(inputs), "'inputs' expression must resolve to an array");
-  assert(isBoolean(useLongestLength), "'useLongestLength' must be a boolean");
-  if (isArray(expr.defaults)) {
-    assert(
-      useLongestLength,
-      "'useLongestLength' must be set to true to use 'defaults'"
-    );
-  }
-  let zipCount = 0;
-  for (const arr of inputs) {
-    if (isNil(arr)) return null;
-    assert(
-      isArray(arr),
-      "'inputs' expression values must resolve to an array or null"
-    );
-    zipCount = useLongestLength ? Math.max(zipCount, arr.length) : Math.min(zipCount || arr.length, arr.length);
-  }
-  const result = [];
-  const defaults = expr.defaults || [];
-  for (let i = 0; i < zipCount; i++) {
-    const temp = inputs.map((val, index) => {
-      return isNil(val[i]) ? defaults[index] || null : val[i];
-    });
-    result.push(temp);
-  }
-  return result;
-};
-export {
-  $zip
-};

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

@@ -1,15 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isNil, isNumber } from "../../../util";
-const bitwise = (op, compute) => (obj, expr, options) => {
-  assert(isArray(expr), `${op}: expression must be an array.`);
-  const nums = computeValue(obj, expr, null, options);
-  if (nums.some(isNil)) return null;
-  assert(
-    nums.every(isNumber),
-    `${op}: expression must evalue to array of numbers.`
-  );
-  return compute(nums);
-};
-export {
-  bitwise
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/bitAnd.js

@@ -1,8 +0,0 @@
-import { bitwise } from "./_internal";
-const $bitAnd = bitwise(
-  "$bitAnd",
-  (nums) => nums.reduce((a, b) => a & b, -1)
-);
-export {
-  $bitAnd
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/bitNot.js

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { isNil, isNumber, MingoError } from "../../../util";
-const $bitNot = (obj, expr, options) => {
-  const n = computeValue(obj, expr, null, options);
-  if (isNil(n)) return null;
-  if (isNumber(n)) return ~n;
-  throw new MingoError("$bitNot: expression must evaluate to a number.");
-};
-export {
-  $bitNot
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/bitOr.js

@@ -1,8 +0,0 @@
-import { bitwise } from "./_internal";
-const $bitOr = bitwise(
-  "$bitOr",
-  (nums) => nums.reduce((a, b) => a | b, 0)
-);
-export {
-  $bitOr
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/bitXor.js

@@ -1,8 +0,0 @@
-import { bitwise } from "./_internal";
-const $bitXor = bitwise(
-  "$bitXor",
-  (nums) => nums.reduce((a, b) => a ^ b, 0)
-);
-export {
-  $bitXor
-};

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

@@ -1,4 +0,0 @@
-export * from "./bitAnd";
-export * from "./bitNot";
-export * from "./bitOr";
-export * from "./bitXor";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/boolean/and.js

@@ -1,9 +0,0 @@
-import { computeValue } from "../../../core";
-import { truthy } from "../../../util";
-const $and = (obj, expr, options) => {
-  const value = computeValue(obj, expr, null, options);
-  return truthy(value, options.useStrictMode) && value.every((v) => truthy(v, options.useStrictMode));
-};
-export {
-  $and
-};

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

@@ -1,3 +0,0 @@
-export * from "./and";
-export * from "./not";
-export * from "./or";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/boolean/not.js

@@ -1,11 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, ensureArray } from "../../../util";
-const $not = (obj, expr, options) => {
-  const booleanExpr = ensureArray(expr);
-  if (booleanExpr.length == 0) return false;
-  assert(booleanExpr.length == 1, "Expression $not takes exactly 1 argument");
-  return !computeValue(obj, booleanExpr[0], null, options);
-};
-export {
-  $not
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/boolean/or.js

@@ -1,10 +0,0 @@
-import { computeValue } from "../../../core";
-import { truthy } from "../../../util";
-const $or = (obj, expr, options) => {
-  const value = computeValue(obj, expr, null, options);
-  const strict = options.useStrictMode;
-  return truthy(value, strict) && value.some((v) => truthy(v, strict));
-};
-export {
-  $or
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/cmp.js

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, compare, isArray } from "../../../util";
-const $cmp = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  assert(
-    isArray(args) && args.length == 2,
-    "$cmp: expression must resolve to array of size 2."
-  );
-  return compare(args[0], args[1]);
-};
-export {
-  $cmp
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/eq.js

@@ -1,5 +0,0 @@
-import { $eq as __eq, createExpressionOperator } from "../../_predicates";
-const $eq = createExpressionOperator(__eq);
-export {
-  $eq
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/gt.js

@@ -1,5 +0,0 @@
-import { $gt as __gt, createExpressionOperator } from "../../_predicates";
-const $gt = createExpressionOperator(__gt);
-export {
-  $gt
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/gte.js

@@ -1,5 +0,0 @@
-import { $gte as __gte, createExpressionOperator } from "../../_predicates";
-const $gte = createExpressionOperator(__gte);
-export {
-  $gte
-};

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

@@ -1,7 +0,0 @@
-export * from "./cmp";
-export * from "./eq";
-export * from "./gt";
-export * from "./gte";
-export * from "./lt";
-export * from "./lte";
-export * from "./ne";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/lt.js

@@ -1,5 +0,0 @@
-import { $lt as __lt, createExpressionOperator } from "../../_predicates";
-const $lt = createExpressionOperator(__lt);
-export {
-  $lt
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/lte.js

@@ -1,5 +0,0 @@
-import { $lte as __lte, createExpressionOperator } from "../../_predicates";
-const $lte = createExpressionOperator(__lte);
-export {
-  $lte
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/ne.js

@@ -1,5 +0,0 @@
-import { $ne as __ne, createExpressionOperator } from "../../_predicates";
-const $ne = createExpressionOperator(__ne);
-export {
-  $ne
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/cond.js

@@ -1,27 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert, isArray, isObject, truthy } from "../../../util";
-const $cond = (obj, expr, options) => {
-  let ifExpr;
-  let thenExpr;
-  let elseExpr;
-  const errorMsg = "$cond: invalid arguments";
-  if (isArray(expr)) {
-    assert(expr.length === 3, errorMsg);
-    ifExpr = expr[0];
-    thenExpr = expr[1];
-    elseExpr = expr[2];
-  } else {
-    assert(isObject(expr), errorMsg);
-    ifExpr = expr.if;
-    thenExpr = expr.then;
-    elseExpr = expr.else;
-  }
-  const condition = truthy(
-    computeValue(obj, ifExpr, null, options),
-    options.useStrictMode
-  );
-  return computeValue(obj, condition ? thenExpr : elseExpr, null, options);
-};
-export {
-  $cond
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/ifNull.js

@@ -1,9 +0,0 @@
-import { computeValue } from "../../../core";
-import { isNil } from "../../../util";
-const $ifNull = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  return args.find((arg) => !isNil(arg)) ?? args[args.length - 1];
-};
-export {
-  $ifNull
-};

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

@@ -1,3 +0,0 @@
-export * from "./cond";
-export * from "./ifNull";
-export * from "./switch";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/switch.js

@@ -1,22 +0,0 @@
-import { computeValue } from "../../../core";
-import { truthy } from "../../../util";
-const $switch = (obj, expr, options) => {
-  let thenExpr = null;
-  expr.branches.some((b) => {
-    const condition = truthy(
-      computeValue(obj, b.case, null, options),
-      options.useStrictMode
-    );
-    if (condition) thenExpr = b.then;
-    return condition;
-  });
-  return computeValue(
-    obj,
-    thenExpr !== null ? thenExpr : expr.default,
-    null,
-    options
-  );
-};
-export {
-  $switch
-};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/custom/function.js

@@ -1,13 +0,0 @@
-import { computeValue } from "../../../core";
-import { assert } from "../../../util";
-const $function = (obj, expr, options) => {
-  assert(
-    options.scriptEnabled,
-    "$function operator requires 'scriptEnabled' option to be true"
-  );
-  const fn = computeValue(obj, expr, null, options);
-  return fn.body.apply(null, fn.args);
-};
-export {
-  $function
-};

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

@@ -1 +0,0 @@
-export * from "./function";