@valkey/valkey-glide-darwin-arm64 1.2.0-rc10 → 1.2.0-rc2

package/rust-client/node_modules/mingo/dist/esm/operators/expression/misc/sampleRate.js

@@ -0,0 +1,5 @@
+import { computeValue } from "../../../core";
+const $sampleRate = (obj, expr, options) => Math.random() <= computeValue(obj, expr, null, options);
+export {
+  $sampleRate
+};

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

@@ -0,0 +1,4 @@
+export * from "./mergeObjects";
+export * from "./objectToArray";
+export * from "./setField";
+export * from "./unsetField";

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { into } from "../../../util";
+const $mergeObjects = (obj, expr, options) => {
+  const docs = computeValue(obj, expr, null, options);
+  return docs instanceof Array ? docs.reduce((memo, o) => into(memo, o), {}) : {};
+};
+export {
+  $mergeObjects
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/object/objectToArray.js

@@ -0,0 +1,16 @@
+import { computeValue } from "../../../core";
+import { assert, isObject } from "../../../util";
+const $objectToArray = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  assert(isObject(val), "$objectToArray expression must resolve to an object");
+  const entries = Object.entries(val);
+  const result = new Array(entries.length);
+  let i = 0;
+  for (const [k, v] of entries) {
+    result[i++] = { k, v };
+  }
+  return result;
+};
+export {
+  $objectToArray
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/object/setField.js

@@ -0,0 +1,24 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isObject, isString } from "../../../util";
+const $setField = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  if (isNil(args.input))
+    return null;
+  assert(
+    isObject(args.input),
+    "$setField expression 'input' must evaluate to an object"
+  );
+  assert(
+    isString(args.field),
+    "$setField expression 'field' must evaluate to a string"
+  );
+  if (expr.value == "$$REMOVE") {
+    delete obj[args.field];
+  } else {
+    obj[args.field] = args.value;
+  }
+  return obj;
+};
+export {
+  $setField
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/object/unsetField.js

@@ -0,0 +1,14 @@
+import { $setField } from "./setField";
+const $unsetField = (obj, expr, options) => {
+  return $setField(
+    obj,
+    {
+      ...expr,
+      value: "$$REMOVE"
+    },
+    options
+  );
+};
+export {
+  $unsetField
+};

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../core";
+import { $percentile as __percentile } from "../accumulator/percentile";
+const $percentile = (obj, expr, options) => {
+  const input = computeValue(obj, expr.input, null, options);
+  return __percentile(input, { ...expr, input: "$$CURRENT" }, options);
+};
+export {
+  $percentile
+};

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

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

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { truthy } from "../../../util";
+const $anyElementTrue = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options)[0];
+  return args.some((v) => truthy(v, options.useStrictMode));
+};
+export {
+  $anyElementTrue
+};

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

@@ -0,0 +1,7 @@
+export * from "./allElementsTrue";
+export * from "./anyElementTrue";
+export * from "./setDifference";
+export * from "./setEquals";
+export * from "./setIntersection";
+export * from "./setIsSubset";
+export * from "./setUnion";

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { notInArray } from "../../../util";
+const $setDifference = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  return args[0].filter(notInArray.bind(null, args[1]));
+};
+export {
+  $setDifference
+};

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

@@ -0,0 +1,11 @@
+import { computeValue } from "../../../core";
+import { intersection, unique } from "../../../util";
+const $setEquals = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const xs = unique(args[0], options?.hashFunction);
+  const ys = unique(args[1], options?.hashFunction);
+  return xs.length === ys.length && xs.length === intersection([xs, ys], options?.hashFunction).length;
+};
+export {
+  $setEquals
+};

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

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { assert, intersection, isArray } from "../../../util";
+const $setIntersection = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  assert(
+    isArray(args) && args.every(isArray),
+    "$setIntersection: expresssion must resolve to array of arrays"
+  );
+  return intersection(args, options?.hashFunction);
+};
+export {
+  $setIntersection
+};

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

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

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

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, unique } from "../../../util";
+const $setUnion = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  assert(
+    isArray(args) && args.length == 2 && args.every(isArray),
+    "$setUnion: arguments must be arrays"
+  );
+  return unique(args[0].concat(args[1]), options?.hashFunction);
+};
+export {
+  $setUnion
+};

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

@@ -0,0 +1,95 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isString } from "../../../util";
+const WHITESPACE_CHARS = [
+  0,
+  // '\0' Null character
+  32,
+  // ' ', Space
+  9,
+  // '\t' Horizontal tab
+  10,
+  // '\n' Line feed/new line
+  11,
+  // '\v' Vertical tab
+  12,
+  // '\f' Form feed
+  13,
+  // '\r' Carriage return
+  160,
+  // Non-breaking space
+  5760,
+  // Ogham space mark
+  8192,
+  // En quad
+  8193,
+  // Em quad
+  8194,
+  // En space
+  8195,
+  // Em space
+  8196,
+  // Three-per-em space
+  8197,
+  // Four-per-em space
+  8198,
+  // Six-per-em space
+  8199,
+  // Figure space
+  8200,
+  // Punctuation space
+  8201,
+  // Thin space
+  8202
+  // Hair space
+];
+function trimString(obj, expr, options, trimOpts) {
+  const val = computeValue(obj, expr, null, options);
+  const s = val.input;
+  if (isNil(s))
+    return null;
+  const codepoints = isNil(val.chars) ? WHITESPACE_CHARS : val.chars.split("").map((c) => c.codePointAt(0));
+  let i = 0;
+  let j = s.length - 1;
+  while (trimOpts.left && i <= j && codepoints.indexOf(s[i].codePointAt(0)) !== -1)
+    i++;
+  while (trimOpts.right && i <= j && codepoints.indexOf(s[j].codePointAt(0)) !== -1)
+    j--;
+  return s.substring(i, j + 1);
+}
+function regexSearch(obj, expr, options, reOpts) {
+  const val = computeValue(obj, expr, null, options);
+  if (!isString(val.input))
+    return [];
+  const regexOptions = val.options;
+  if (regexOptions) {
+    assert(
+      regexOptions.indexOf("x") === -1,
+      "extended capability option 'x' not supported"
+    );
+    assert(regexOptions.indexOf("g") === -1, "global option 'g' not supported");
+  }
+  let input = val.input;
+  const re = new RegExp(val.regex, regexOptions);
+  let m;
+  const matches = new Array();
+  let offset = 0;
+  while (m = re.exec(input)) {
+    const result = {
+      match: m[0],
+      idx: m.index + offset,
+      captures: []
+    };
+    for (let i = 1; i < m.length; i++)
+      result.captures.push(m[i] || null);
+    matches.push(result);
+    if (!reOpts.global)
+      break;
+    offset = m.index + m[0].length;
+    input = input.substring(offset);
+  }
+  return matches;
+}
+export {
+  regexSearch,
+  trimString
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/concat.js

@@ -0,0 +1,11 @@
+import { computeValue } from "../../../core";
+import { inArray } from "../../../util";
+const $concat = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  if ([null, void 0].some(inArray.bind(null, args)))
+    return null;
+  return args.join("");
+};
+export {
+  $concat
+};

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

@@ -0,0 +1,19 @@
+export * from "./concat";
+export * from "./indexOfBytes";
+export * from "./ltrim";
+export * from "./regexFind";
+export * from "./regexFindAll";
+export * from "./regexMatch";
+export * from "./replaceAll";
+export * from "./replaceOne";
+export * from "./rtrim";
+export * from "./split";
+export * from "./strcasecmp";
+export * from "./strLenBytes";
+export * from "./strLenCP";
+export * from "./substr";
+export * from "./substrBytes";
+export * from "./substrCP";
+export * from "./toLower";
+export * from "./toUpper";
+export * from "./trim";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/indexOfBytes.js

@@ -0,0 +1,25 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isNumber, isString } from "../../../util";
+const $indexOfBytes = (obj, expr, options) => {
+  const arr = computeValue(obj, expr, null, options);
+  const errorMsg = "$indexOfBytes expression resolves to invalid an argument";
+  if (isNil(arr[0]))
+    return null;
+  assert(isString(arr[0]) && isString(arr[1]), errorMsg);
+  const str = arr[0];
+  const searchStr = arr[1];
+  let start = arr[2];
+  let end = arr[3];
+  let valid = isNil(start) || isNumber(start) && start >= 0 && Math.round(start) === start;
+  valid = valid && (isNil(end) || isNumber(end) && end >= 0 && Math.round(end) === end);
+  assert(valid, errorMsg);
+  start = start || 0;
+  end = end || str.length;
+  if (start > end)
+    return -1;
+  const index = str.substring(start, end).indexOf(searchStr);
+  return index > -1 ? index + start : index;
+};
+export {
+  $indexOfBytes
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/ltrim.js

@@ -0,0 +1,7 @@
+import { trimString } from "./_internal";
+const $ltrim = (obj, expr, options) => {
+  return trimString(obj, expr, options, { left: true, right: false });
+};
+export {
+  $ltrim
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/regexFind.js

@@ -0,0 +1,8 @@
+import { regexSearch } from "./_internal";
+const $regexFind = (obj, expr, options) => {
+  const result = regexSearch(obj, expr, options, { global: false });
+  return result && result.length > 0 ? result[0] : null;
+};
+export {
+  $regexFind
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/regexFindAll.js

@@ -0,0 +1,7 @@
+import { regexSearch } from "./_internal";
+const $regexFindAll = (obj, expr, options) => {
+  return regexSearch(obj, expr, options, { global: true });
+};
+export {
+  $regexFindAll
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/regexMatch.js

@@ -0,0 +1,7 @@
+import { regexSearch } from "./_internal";
+const $regexMatch = (obj, expr, options) => {
+  return regexSearch(obj, expr, options, { global: false }).length != 0;
+};
+export {
+  $regexMatch
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/replaceAll.js

@@ -0,0 +1,16 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isString } from "../../../util";
+const $replaceAll = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const arr = [args.input, args.find, args.replacement];
+  if (arr.some(isNil))
+    return null;
+  assert(
+    arr.every(isString),
+    "$replaceAll expression fields must evaluate to string"
+  );
+  return args.input.replace(new RegExp(args.find, "g"), args.replacement);
+};
+export {
+  $replaceAll
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/replaceOne.js

@@ -0,0 +1,16 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isString } from "../../../util";
+const $replaceOne = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const arr = [args.input, args.find, args.replacement];
+  if (arr.some(isNil))
+    return null;
+  assert(
+    arr.every(isString),
+    "$replaceOne expression fields must evaluate to string"
+  );
+  return args.input.replace(args.find, args.replacement);
+};
+export {
+  $replaceOne
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/rtrim.js

@@ -0,0 +1,7 @@
+import { trimString } from "./_internal";
+const $rtrim = (obj, expr, options) => {
+  return trimString(obj, expr, options, { left: false, right: true });
+};
+export {
+  $rtrim
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/split.js

@@ -0,0 +1,15 @@
+import { computeValue } from "../../../core";
+import { assert, isNil, isString } from "../../../util";
+const $split = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  if (isNil(args[0]))
+    return null;
+  assert(
+    args.every(isString),
+    "$split expression must result to array(2) of strings"
+  );
+  return args[0].split(args[1]);
+};
+export {
+  $split
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/strLenBytes.js

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+const $strLenBytes = (obj, expr, options) => {
+  return ~-encodeURI(computeValue(obj, expr, null, options)).split(
+    /%..|./
+  ).length;
+};
+export {
+  $strLenBytes
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/strLenCP.js

@@ -0,0 +1,7 @@
+import { computeValue } from "../../../core";
+const $strLenCP = (obj, expr, options) => {
+  return computeValue(obj, expr, null, options).length;
+};
+export {
+  $strLenCP
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/strcasecmp.js

@@ -0,0 +1,19 @@
+import { computeValue } from "../../../core";
+import { assert, isEqual, isNil, isString } from "../../../util";
+const $strcasecmp = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  let a = args[0];
+  let b = args[1];
+  if (isEqual(a, b) || args.every(isNil))
+    return 0;
+  assert(
+    args.every(isString),
+    "$strcasecmp must resolve to array(2) of strings"
+  );
+  a = a.toUpperCase();
+  b = b.toUpperCase();
+  return a > b && 1 || a < b && -1 || 0;
+};
+export {
+  $strcasecmp
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/substr.js

@@ -0,0 +1,21 @@
+import { computeValue } from "../../../core";
+import { isString } from "../../../util";
+const $substr = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const s = args[0];
+  const index = args[1];
+  const count = args[2];
+  if (isString(s)) {
+    if (index < 0) {
+      return "";
+    } else if (count < 0) {
+      return s.substr(index);
+    } else {
+      return s.substr(index, count);
+    }
+  }
+  return "";
+};
+export {
+  $substr
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/substrBytes.js

@@ -0,0 +1,47 @@
+import { computeValue } from "../../../core";
+import { assert, isNumber, isString } from "../../../util";
+const UTF8_MASK = [192, 224, 240];
+function toUtf8(n) {
+  if (n < 128)
+    return [n];
+  let count = n < 2048 && 1 || n < 65536 && 2 || 3;
+  const offset = UTF8_MASK[count - 1];
+  const utf8 = [(n >> 6 * count) + offset];
+  while (count > 0)
+    utf8.push(128 | n >> 6 * --count & 63);
+  return utf8;
+}
+function utf8Encode(s) {
+  const buf = [];
+  for (let i = 0, len = s.length; i < len; i++) {
+    buf.push(toUtf8(s.codePointAt(i)));
+  }
+  return buf;
+}
+const $substrBytes = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const s = args[0];
+  const index = args[1];
+  const count = args[2];
+  assert(
+    isString(s) && isNumber(index) && index >= 0 && isNumber(count) && count >= 0,
+    "$substrBytes: invalid arguments"
+  );
+  const buf = utf8Encode(s);
+  const validIndex = [];
+  let acc = 0;
+  for (let i = 0; i < buf.length; i++) {
+    validIndex.push(acc);
+    acc += buf[i].length;
+  }
+  const begin = validIndex.indexOf(index);
+  const end = validIndex.indexOf(index + count);
+  assert(
+    begin > -1 && end > -1,
+    "$substrBytes: invalid range, start or end index is a UTF-8 continuation byte."
+  );
+  return s.substring(begin, end);
+};
+export {
+  $substrBytes
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/substrCP.js

@@ -0,0 +1,7 @@
+import { $substr } from "./substr";
+const $substrCP = (obj, expr, options) => {
+  return $substr(obj, expr, options);
+};
+export {
+  $substrCP
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/toLower.js

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

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/toUpper.js

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

package/rust-client/node_modules/mingo/dist/esm/operators/expression/string/trim.js

@@ -0,0 +1,7 @@
+import { trimString } from "./_internal";
+const $trim = (obj, expr, options) => {
+  return trimString(obj, expr, options, { left: true, right: true });
+};
+export {
+  $trim
+};

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

@@ -0,0 +1,29 @@
+import { computeValue } from "../../../core";
+import { MingoError } from "../../../util";
+const FIXED_POINTS = {
+  undefined: null,
+  null: null,
+  NaN: NaN,
+  Infinity: new Error(),
+  "-Infinity": new Error()
+};
+function createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {
+  const fp = Object.assign({}, FIXED_POINTS, fixedPoints);
+  const keySet = new Set(Object.keys(fp));
+  return (obj, expr, options) => {
+    const n = computeValue(obj, expr, null, options);
+    if (keySet.has(`${n}`)) {
+      const res = fp[`${n}`];
+      if (res instanceof Error) {
+        throw new MingoError(
+          `cannot apply $${f.name} to -inf, value must in (-inf,inf)`
+        );
+      }
+      return res;
+    }
+    return f(n);
+  };
+}
+export {
+  createTrignometryOperator
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/acos.js

@@ -0,0 +1,8 @@
+import { createTrignometryOperator } from "./_internal";
+const $acos = createTrignometryOperator(Math.acos, {
+  Infinity: Infinity,
+  0: new Error()
+});
+export {
+  $acos
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/acosh.js

@@ -0,0 +1,8 @@
+import { createTrignometryOperator } from "./_internal";
+const $acosh = createTrignometryOperator(Math.acosh, {
+  Infinity: Infinity,
+  0: new Error()
+});
+export {
+  $acosh
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/asin.js

@@ -0,0 +1,5 @@
+import { createTrignometryOperator } from "./_internal";
+const $asin = createTrignometryOperator(Math.asin);
+export {
+  $asin
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/asinh.js

@@ -0,0 +1,8 @@
+import { createTrignometryOperator } from "./_internal";
+const $asinh = createTrignometryOperator(Math.asinh, {
+  Infinity: Infinity,
+  "-Infinity": -Infinity
+});
+export {
+  $asinh
+};