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

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

@@ -1,21 +1,25 @@
 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;
+  const { input, field, value } = computeValue(
+    obj,
+    expr,
+    null,
+    options
+  );
+  if (isNil(input)) return null;
   assert(
-    isObject(args.input),
+    isObject(input),
     "$setField expression 'input' must evaluate to an object"
   );
   assert(
-    isString(args.field),
+    isString(field),
     "$setField expression 'field' must evaluate to a string"
   );
   if (expr.value == "$$REMOVE") {
-    delete obj[args.field];
+    delete obj[field];
   } else {
-    obj[args.field] = args.value;
+    obj[field] = value;
   }
   return obj;
 };

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

@@ -1,8 +1,16 @@
 import { computeValue } from "../../../core";
-import { notInArray } from "../../../util";
+import { assert, isArray, isNil, ValueMap } from "../../../util";
 const $setDifference = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  return args[0].filter(notInArray.bind(null, args[1]));
+  if (isNil(args)) return null;
+  assert(isArray(args), "$setDifference must be an arrays.");
+  if (args.some(isNil)) return null;
+  assert(args.length == 2, `$setDifference takes exactly 2 arguments.`);
+  assert(args.every(isArray), "$setDifference operands must be arrays.");
+  const m = ValueMap.init(options.hashFunction);
+  args[0].forEach((v) => m.set(v, true));
+  args[1].forEach((v) => m.delete(v));
+  return Array.from(m.keys());
 };
 export {
   $setDifference

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

@@ -1,10 +1,24 @@
 import { computeValue } from "../../../core";
-import { intersection, unique } from "../../../util";
+import { assert, isArray, ValueMap } 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;
+  assert(
+    isArray(args) && args.every(isArray),
+    "$setEquals operands must be arrays."
+  );
+  const map = ValueMap.init();
+  args[0].every((v, i) => map.set(v, i));
+  for (let i = 1; i < args.length; i++) {
+    const arr = args[i];
+    const set = /* @__PURE__ */ new Set();
+    for (let j = 0; j < arr.length; j++) {
+      const n = map.get(arr[j]) ?? -1;
+      if (n === -1) return false;
+      set.add(n);
+    }
+    if (set.size !== map.size) return false;
+  }
+  return true;
 };
 export {
   $setEquals

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

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

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

@@ -1,8 +1,22 @@
 import { computeValue } from "../../../core";
-import { intersection } from "../../../util";
+import { assert, isArray, ValueMap } from "../../../util";
 const $setIsSubset = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  return intersection(args, options?.hashFunction).length === args[0].length;
+  assert(
+    isArray(args) && args.every(isArray),
+    "$setIsSubset operands must be arrays."
+  );
+  const first = args[0];
+  const second = args[1];
+  const map = ValueMap.init();
+  const set = /* @__PURE__ */ new Set();
+  first.every((v, i) => map.set(v, i));
+  for (const v of second) {
+    set.add(map.get(v) ?? -1);
+    if (set.size > map.size) return true;
+  }
+  set.delete(-1);
+  return set.size == map.size;
 };
 export {
   $setIsSubset

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

@@ -1,12 +1,11 @@
 import { computeValue } from "../../../core";
-import { assert, isArray, unique } from "../../../util";
+import { assert, flatten, isArray, isNil, 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);
+  if (isNil(args)) return null;
+  assert(isArray(args), "$setUnion operands must be arrays.");
+  if (args.some(isNil)) return null;
+  return unique(flatten(args), options?.hashFunction);
 };
 export {
   $setUnion

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

@@ -45,8 +45,7 @@ const WHITESPACE_CHARS = [
 function trimString(obj, expr, options, trimOpts) {
   const val = computeValue(obj, expr, null, options);
   const s = val.input;
-  if (isNil(s))
-    return null;
+  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;
@@ -58,8 +57,7 @@ function trimString(obj, expr, options, trimOpts) {
 }
 function regexSearch(obj, expr, options, reOpts) {
   const val = computeValue(obj, expr, null, options);
-  if (!isString(val.input))
-    return [];
+  if (!isString(val.input)) return [];
   const regexOptions = val.options;
   if (regexOptions) {
     assert(
@@ -79,11 +77,9 @@ function regexSearch(obj, expr, options, reOpts) {
       idx: m.index + offset,
       captures: []
     };
-    for (let i = 1; i < m.length; i++)
-      result.captures.push(m[i] || null);
+    for (let i = 1; i < m.length; i++) result.captures.push(m[i] || null);
     matches.push(result);
-    if (!reOpts.global)
-      break;
+    if (!reOpts.global) break;
     offset = m.index + m[0].length;
     input = input.substring(offset);
   }

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

@@ -1,9 +1,12 @@
 import { computeValue } from "../../../core";
-import { inArray } from "../../../util";
+import { assert, isNil, isString } 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;
+  assert(
+    args.every((v) => isString(v) || isNil(v)),
+    "$concat only supports strings."
+  );
+  if (args.some(isNil)) return null;
   return args.join("");
 };
 export {

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

@@ -3,8 +3,7 @@ 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;
+  if (isNil(arr[0])) return null;
   assert(isString(arr[0]) && isString(arr[1]), errorMsg);
   const str = arr[0];
   const searchStr = arr[1];
@@ -15,8 +14,7 @@ const $indexOfBytes = (obj, expr, options) => {
   assert(valid, errorMsg);
   start = start || 0;
   end = end || str.length;
-  if (start > end)
-    return -1;
+  if (start > end) return -1;
   const index = str.substring(start, end).indexOf(searchStr);
   return index > -1 ? index + start : index;
 };

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

@@ -3,8 +3,7 @@ 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;
+  if (arr.some(isNil)) return null;
   assert(
     arr.every(isString),
     "$replaceAll expression fields must evaluate to string"

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

@@ -3,8 +3,7 @@ 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;
+  if (arr.some(isNil)) return null;
   assert(
     arr.every(isString),
     "$replaceOne expression fields must evaluate to string"

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

@@ -2,8 +2,7 @@ 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;
+  if (isNil(args[0])) return null;
   assert(
     args.every(isString),
     "$split expression must result to array(2) of strings"

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

@@ -4,8 +4,7 @@ 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;
+  if (isEqual(a, b) || args.every(isNil)) return 0;
   assert(
     args.every(isString),
     "$strcasecmp must resolve to array(2) of strings"

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

@@ -1,20 +1,10 @@
 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 "";
+  const [s, start, count] = computeValue(obj, expr, null, options);
+  if (start < 0 || !isString(s)) return "";
+  if (count < 0) return s.substring(start);
+  return s.substring(start, start + count);
 };
 export {
   $substr

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

@@ -2,13 +2,11 @@ import { computeValue } from "../../../core";
 import { assert, isNumber, isString } from "../../../util";
 const UTF8_MASK = [192, 224, 240];
 function toUtf8(n) {
-  if (n < 128)
-    return [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);
+  while (count > 0) utf8.push(128 | n >> 6 * --count & 63);
   return utf8;
 }
 function utf8Encode(s) {

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

@@ -2,10 +2,8 @@ import { computeValue } from "../../../core";
 import { isNil } from "../../../util";
 const $atan2 = (obj, expr, options) => {
   const [y, x] = computeValue(obj, expr, null, options);
-  if (isNaN(y) || isNil(y))
-    return y;
-  if (isNaN(x) || isNil(x))
-    return x;
+  if (isNaN(y) || isNil(y)) return y;
+  if (isNaN(x) || isNil(x)) return x;
   return Math.atan2(y, x);
 };
 export {

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

@@ -2,7 +2,6 @@ import { createTrignometryOperator } from "./_internal";
 const $cosh = createTrignometryOperator(Math.cosh, {
   "-Infinity": Infinity,
   Infinity: Infinity
-  // [Math.PI]: -1,
 });
 export {
   $cosh

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

@@ -1,29 +1,35 @@
 import { computeValue } from "../../../core";
-import { isNil, isNumber, isString } from "../../../util";
+import { isDate, isNil, isNumber, isString } from "../../../util";
+const MAX_INT = 2147483647;
+const MIN_INT = -2147483648;
+const MAX_LONG = Number.MAX_SAFE_INTEGER;
+const MIN_LONG = Number.MIN_SAFE_INTEGER;
 class TypeConvertError extends Error {
   constructor(message) {
     super(message);
   }
 }
-function toInteger(obj, expr, options, max, min, typename) {
+function toInteger(obj, expr, options, min, max) {
   const val = computeValue(obj, expr, null, options);
-  if (isNil(val))
-    return null;
-  if (val instanceof Date)
-    return val.getTime();
-  if (val === true)
-    return 1;
-  if (val === false)
-    return 0;
+  if (val === true) return 1;
+  if (val === false) return 0;
+  if (isNil(val)) return null;
+  if (isDate(val)) return val.getTime();
   const n = Number(val);
   if (isNumber(n) && n >= min && n <= max) {
     if (!isString(val) || n.toString().indexOf(".") === -1) {
       return Math.trunc(n);
     }
   }
-  throw new TypeConvertError(`cannot convert '${val}' to ${typename}`);
+  throw new TypeConvertError(
+    `cannot convert '${val}' to ${max == MAX_INT ? "int" : "long"}`
+  );
 }
 export {
+  MAX_INT,
+  MAX_LONG,
+  MIN_INT,
+  MIN_LONG,
   TypeConvertError,
   toInteger
 };

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

@@ -10,8 +10,7 @@ import { $toString } from "./toString";
 const $convert = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   args.onNull = args.onNull === void 0 ? null : args.onNull;
-  if (isNil(args.input))
-    return args.onNull;
+  if (isNil(args.input)) return args.onNull;
   try {
     switch (args.to) {
       case 2:
@@ -37,10 +36,9 @@ const $convert = (obj, expr, options) => {
       case "long":
         return $toLong(obj, args.input, options);
     }
-  } catch (e) {
+  } catch {
   }
-  if (args.onError !== void 0)
-    return args.onError;
+  if (args.onError !== void 0) return args.onError;
   throw new TypeConvertError(`could not convert to type ${args.to}.`);
 };
 export {

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

@@ -2,10 +2,8 @@ import { computeValue } from "../../../core";
 import { isNil, isString } from "../../../util";
 const $toBool = (obj, expr, options) => {
   const val = computeValue(obj, expr, null, options);
-  if (isNil(val))
-    return null;
-  if (isString(val))
-    return true;
+  if (isNil(val)) return null;
+  if (isString(val)) return true;
   return Boolean(val);
 };
 export {

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

@@ -1,16 +1,13 @@
 import { computeValue } from "../../../core";
-import { isNil } from "../../../util";
+import { isDate, isNil } from "../../../util";
 import { TypeConvertError } from "./_internal";
 const $toDate = (obj, expr, options) => {
   const val = computeValue(obj, expr, null, options);
-  if (val instanceof Date)
-    return val;
-  if (isNil(val))
-    return null;
+  if (isDate(val)) return val;
+  if (isNil(val)) return null;
   const d = new Date(val);
   const n = d.getTime();
-  if (!isNaN(n))
-    return d;
+  if (!isNaN(n)) return d;
   throw new TypeConvertError(`cannot convert '${val}' to date`);
 };
 export {

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

@@ -1,19 +1,14 @@
 import { computeValue } from "../../../core";
-import { isNil, isNumber } from "../../../util";
+import { isDate, isNil, isNumber } from "../../../util";
 import { TypeConvertError } from "./_internal";
 const $toDouble = (obj, expr, options) => {
   const val = computeValue(obj, expr, null, options);
-  if (isNil(val))
-    return null;
-  if (val instanceof Date)
-    return val.getTime();
-  if (val === true)
-    return 1;
-  if (val === false)
-    return 0;
+  if (isNil(val)) return null;
+  if (isDate(val)) return val.getTime();
+  if (val === true) return 1;
+  if (val === false) return 0;
   const n = Number(val);
-  if (isNumber(n))
-    return n;
+  if (isNumber(n)) return n;
   throw new TypeConvertError(`cannot convert '${val}' to double/decimal`);
 };
 export {

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

@@ -1,8 +1,5 @@
-import { MAX_INT, MIN_INT } from "../../../util";
-import { toInteger } from "./_internal";
-const $toInt = (obj, expr, options) => {
-  return toInteger(obj, expr, options, MAX_INT, MIN_INT, "int");
-};
+import { MAX_INT, MIN_INT, toInteger } from "./_internal";
+const $toInt = (obj, expr, options) => toInteger(obj, expr, options, MIN_INT, MAX_INT);
 export {
   $toInt
 };

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

@@ -1,8 +1,5 @@
-import { MAX_LONG, MIN_LONG } from "../../../util";
-import { toInteger } from "./_internal";
-const $toLong = (obj, expr, options) => {
-  return toInteger(obj, expr, options, MAX_LONG, MIN_LONG, "long");
-};
+import { MAX_LONG, MIN_LONG, toInteger } from "./_internal";
+const $toLong = (obj, expr, options) => toInteger(obj, expr, options, MIN_LONG, MAX_LONG);
 export {
   $toLong
 };

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

@@ -1,19 +1,20 @@
 import { computeValue } from "../../../core";
-import { isNil } from "../../../util";
+import { isDate, isNil } from "../../../util";
 import { $dateToString } from "../date/dateToString";
 const $toString = (obj, expr, options) => {
   const val = computeValue(obj, expr, null, options);
-  if (isNil(val))
-    return null;
-  if (val instanceof Date) {
-    const dateExpr = {
-      date: expr,
-      format: "%Y-%m-%dT%H:%M:%S.%LZ"
-    };
-    return $dateToString(obj, dateExpr, options);
-  } else {
-    return val.toString();
+  if (isNil(val)) return null;
+  if (isDate(val)) {
+    return $dateToString(
+      obj,
+      {
+        date: expr,
+        format: "%Y-%m-%dT%H:%M:%S.%LZ"
+      },
+      options
+    );
   }
+  return val.toString();
 };
 export {
   $toString

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

@@ -1,21 +1,18 @@
 import { computeValue } from "../../../core";
-import { getType, MAX_INT, MIN_INT } from "../../../util";
+import { isNumber, isRegExp, typeOf } from "../../../util";
+import { MAX_INT, MIN_INT } from "./_internal";
 const $type = (obj, expr, options) => {
-  const val = computeValue(obj, expr, null, options);
-  const typename = getType(val);
-  const nativeType = typename.toLowerCase();
-  switch (nativeType) {
-    case "boolean":
-      return "bool";
-    case "number":
-      if (val.toString().indexOf(".") >= 0)
-        return "double";
-      return val >= MIN_INT && val <= MAX_INT ? "int" : "long";
-    case "regexp":
-      return "regex";
-    default:
-      return nativeType;
+  const v = computeValue(obj, expr, null, options);
+  if (options.useStrictMode) {
+    if (v === void 0) return "missing";
+    if (v === true || v === false) return "bool";
+    if (isNumber(v)) {
+      if (v % 1 != 0) return "double";
+      return v >= MIN_INT && v <= MAX_INT ? "int" : "long";
+    }
+    if (isRegExp(v)) return "regex";
   }
+  return typeOf(v);
 };
 export {
   $type

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

@@ -2,8 +2,7 @@ import { computeValue } from "../../core";
 import { removeValue, setValue } from "../../util";
 const $addFields = (collection, expr, options) => {
   const newFields = Object.keys(expr);
-  if (newFields.length === 0)
-    return collection;
+  if (newFields.length === 0) return collection;
   return collection.map((obj) => {
     const newObj = { ...obj };
     for (const field of newFields) {