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

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

@@ -24,7 +24,11 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $objectToArray = (obj, expr, options) => {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  (0, import_util.assert)((0, import_util.isObject)(val), "$objectToArray expression must resolve to an object");
+  if ((0, import_util.isNil)(val)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isObject)(val),
+    `$objectToArray requires a document input, found: ${(0, import_util.typeOf)(val)}`
+  );
   const entries = Object.entries(val);
   const result = new Array(entries.length);
   let i = 0;

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

@@ -23,21 +23,25 @@ module.exports = __toCommonJS(setField_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $setField = (obj, expr, options) => {
-  const args = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(args.input))
-    return null;
+  const { input, field, value } = (0, import_core.computeValue)(
+    obj,
+    expr,
+    null,
+    options
+  );
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)(
-    (0, import_util.isObject)(args.input),
+    (0, import_util.isObject)(input),
     "$setField expression 'input' must evaluate to an object"
   );
   (0, import_util.assert)(
-    (0, import_util.isString)(args.field),
+    (0, import_util.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/cjs/operators/expression/set/setDifference.js

@@ -24,7 +24,15 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $setDifference = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  return args[0].filter(import_util.notInArray.bind(null, args[1]));
+  if ((0, import_util.isNil)(args)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(args), "$setDifference must be an arrays.");
+  if (args.some(import_util.isNil)) return null;
+  (0, import_util.assert)(args.length == 2, `$setDifference takes exactly 2 arguments.`);
+  (0, import_util.assert)(args.every(import_util.isArray), "$setDifference operands must be arrays.");
+  const m = import_util.ValueMap.init(options.hashFunction);
+  args[0].forEach((v) => m.set(v, true));
+  args[1].forEach((v) => m.delete(v));
+  return Array.from(m.keys());
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,9 +24,23 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $setEquals = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  const xs = (0, import_util.unique)(args[0], options?.hashFunction);
-  const ys = (0, import_util.unique)(args[1], options?.hashFunction);
-  return xs.length === ys.length && xs.length === (0, import_util.intersection)([xs, ys], options?.hashFunction).length;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.every(import_util.isArray),
+    "$setEquals operands must be arrays."
+  );
+  const map = import_util.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;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

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

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

@@ -24,7 +24,21 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $setIsSubset = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  return (0, import_util.intersection)(args, options?.hashFunction).length === args[0].length;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.every(import_util.isArray),
+    "$setIsSubset operands must be arrays."
+  );
+  const first = args[0];
+  const second = args[1];
+  const map = import_util.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;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,11 +24,10 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $setUnion = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  (0, import_util.assert)(
-    (0, import_util.isArray)(args) && args.length == 2 && args.every(import_util.isArray),
-    "$setUnion: arguments must be arrays"
-  );
-  return (0, import_util.unique)(args[0].concat(args[1]), options?.hashFunction);
+  if ((0, import_util.isNil)(args)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(args), "$setUnion operands must be arrays.");
+  if (args.some(import_util.isNil)) return null;
+  return (0, import_util.unique)((0, import_util.flatten)(args), options?.hashFunction);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -68,8 +68,7 @@ const WHITESPACE_CHARS = [
 function trimString(obj, expr, options, trimOpts) {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
   const s = val.input;
-  if ((0, import_util.isNil)(s))
-    return null;
+  if ((0, import_util.isNil)(s)) return null;
   const codepoints = (0, import_util.isNil)(val.chars) ? WHITESPACE_CHARS : val.chars.split("").map((c) => c.codePointAt(0));
   let i = 0;
   let j = s.length - 1;
@@ -81,8 +80,7 @@ function trimString(obj, expr, options, trimOpts) {
 }
 function regexSearch(obj, expr, options, reOpts) {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  if (!(0, import_util.isString)(val.input))
-    return [];
+  if (!(0, import_util.isString)(val.input)) return [];
   const regexOptions = val.options;
   if (regexOptions) {
     (0, import_util.assert)(
@@ -102,11 +100,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/cjs/operators/expression/string/concat.js

@@ -24,8 +24,11 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $concat = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  if ([null, void 0].some(import_util.inArray.bind(null, args)))
-    return null;
+  (0, import_util.assert)(
+    args.every((v) => (0, import_util.isString)(v) || (0, import_util.isNil)(v)),
+    "$concat only supports strings."
+  );
+  if (args.some(import_util.isNil)) return null;
   return args.join("");
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -25,8 +25,7 @@ var import_util = require("../../../util");
 const $indexOfBytes = (obj, expr, options) => {
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
   const errorMsg = "$indexOfBytes expression resolves to invalid an argument";
-  if ((0, import_util.isNil)(arr[0]))
-    return null;
+  if ((0, import_util.isNil)(arr[0])) return null;
   (0, import_util.assert)((0, import_util.isString)(arr[0]) && (0, import_util.isString)(arr[1]), errorMsg);
   const str = arr[0];
   const searchStr = arr[1];
@@ -37,8 +36,7 @@ const $indexOfBytes = (obj, expr, options) => {
   (0, import_util.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/cjs/operators/expression/string/replaceAll.js

@@ -25,8 +25,7 @@ var import_util = require("../../../util");
 const $replaceAll = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   const arr = [args.input, args.find, args.replacement];
-  if (arr.some(import_util.isNil))
-    return null;
+  if (arr.some(import_util.isNil)) return null;
   (0, import_util.assert)(
     arr.every(import_util.isString),
     "$replaceAll expression fields must evaluate to string"

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

@@ -25,8 +25,7 @@ var import_util = require("../../../util");
 const $replaceOne = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   const arr = [args.input, args.find, args.replacement];
-  if (arr.some(import_util.isNil))
-    return null;
+  if (arr.some(import_util.isNil)) return null;
   (0, import_util.assert)(
     arr.every(import_util.isString),
     "$replaceOne expression fields must evaluate to string"

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

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $split = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(args[0]))
-    return null;
+  if ((0, import_util.isNil)(args[0])) return null;
   (0, import_util.assert)(
     args.every(import_util.isString),
     "$split expression must result to array(2) of strings"

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

@@ -26,8 +26,7 @@ const $strcasecmp = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   let a = args[0];
   let b = args[1];
-  if ((0, import_util.isEqual)(a, b) || args.every(import_util.isNil))
-    return 0;
+  if ((0, import_util.isEqual)(a, b) || args.every(import_util.isNil)) return 0;
   (0, import_util.assert)(
     args.every(import_util.isString),
     "$strcasecmp must resolve to array(2) of strings"

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

@@ -23,20 +23,10 @@ module.exports = __toCommonJS(substr_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $substr = (obj, expr, options) => {
-  const args = (0, import_core.computeValue)(obj, expr, null, options);
-  const s = args[0];
-  const index = args[1];
-  const count = args[2];
-  if ((0, import_util.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] = (0, import_core.computeValue)(obj, expr, null, options);
+  if (start < 0 || !(0, import_util.isString)(s)) return "";
+  if (count < 0) return s.substring(start);
+  return s.substring(start, start + count);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,13 +24,11 @@ var import_core = require("../../../core");
 var import_util = require("../../../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/cjs/operators/expression/trignometry/atan2.js

@@ -24,10 +24,8 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $atan2 = (obj, expr, options) => {
   const [y, x] = (0, import_core.computeValue)(obj, expr, null, options);
-  if (isNaN(y) || (0, import_util.isNil)(y))
-    return y;
-  if (isNaN(x) || (0, import_util.isNil)(x))
-    return x;
+  if (isNaN(y) || (0, import_util.isNil)(y)) return y;
+  if (isNaN(x) || (0, import_util.isNil)(x)) return x;
   return Math.atan2(y, x);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -24,7 +24,6 @@ var import_internal = require("./_internal");
 const $cosh = (0, import_internal.createTrignometryOperator)(Math.cosh, {
   "-Infinity": Infinity,
   Infinity: Infinity
-  // [Math.PI]: -1,
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -17,37 +17,47 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var internal_exports = {};
 __export(internal_exports, {
+  MAX_INT: () => MAX_INT,
+  MAX_LONG: () => MAX_LONG,
+  MIN_INT: () => MIN_INT,
+  MIN_LONG: () => MIN_LONG,
   TypeConvertError: () => TypeConvertError,
   toInteger: () => toInteger
 });
 module.exports = __toCommonJS(internal_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../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 = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.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 ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) return val.getTime();
   const n = Number(val);
   if ((0, import_util.isNumber)(n) && n >= min && n <= max) {
     if (!(0, import_util.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"}`
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MAX_INT,
+  MAX_LONG,
+  MIN_INT,
+  MIN_LONG,
   TypeConvertError,
   toInteger
 });

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

@@ -32,8 +32,7 @@ var import_toString = require("./toString");
 const $convert = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   args.onNull = args.onNull === void 0 ? null : args.onNull;
-  if ((0, import_util.isNil)(args.input))
-    return args.onNull;
+  if ((0, import_util.isNil)(args.input)) return args.onNull;
   try {
     switch (args.to) {
       case 2:
@@ -59,10 +58,9 @@ const $convert = (obj, expr, options) => {
       case "long":
         return (0, import_toLong.$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 import_internal.TypeConvertError(`could not convert to type ${args.to}.`);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -24,10 +24,8 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $toBool = (obj, expr, options) => {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(val))
-    return null;
-  if ((0, import_util.isString)(val))
-    return true;
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isString)(val)) return true;
   return Boolean(val);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -25,14 +25,11 @@ var import_util = require("../../../util");
 var import_internal = require("./_internal");
 const $toDate = (obj, expr, options) => {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  if (val instanceof Date)
-    return val;
-  if ((0, import_util.isNil)(val))
-    return null;
+  if ((0, import_util.isDate)(val)) return val;
+  if ((0, import_util.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 import_internal.TypeConvertError(`cannot convert '${val}' to date`);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -25,17 +25,12 @@ var import_util = require("../../../util");
 var import_internal = require("./_internal");
 const $toDouble = (obj, expr, options) => {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(val))
-    return null;
-  if (val instanceof Date)
-    return val.getTime();
-  if (val === true)
-    return 1;
-  if (val === false)
-    return 0;
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) return val.getTime();
+  if (val === true) return 1;
+  if (val === false) return 0;
   const n = Number(val);
-  if ((0, import_util.isNumber)(n))
-    return n;
+  if ((0, import_util.isNumber)(n)) return n;
   throw new import_internal.TypeConvertError(`cannot convert '${val}' to double/decimal`);
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -20,11 +20,8 @@ __export(toInt_exports, {
   $toInt: () => $toInt
 });
 module.exports = __toCommonJS(toInt_exports);
-var import_util = require("../../../util");
 var import_internal = require("./_internal");
-const $toInt = (obj, expr, options) => {
-  return (0, import_internal.toInteger)(obj, expr, options, import_util.MAX_INT, import_util.MIN_INT, "int");
-};
+const $toInt = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_INT, import_internal.MAX_INT);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $toInt

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

@@ -20,11 +20,8 @@ __export(toLong_exports, {
   $toLong: () => $toLong
 });
 module.exports = __toCommonJS(toLong_exports);
-var import_util = require("../../../util");
 var import_internal = require("./_internal");
-const $toLong = (obj, expr, options) => {
-  return (0, import_internal.toInteger)(obj, expr, options, import_util.MAX_LONG, import_util.MIN_LONG, "long");
-};
+const $toLong = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_LONG, import_internal.MAX_LONG);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $toLong

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

@@ -25,17 +25,18 @@ var import_util = require("../../../util");
 var import_dateToString = require("../date/dateToString");
 const $toString = (obj, expr, options) => {
   const val = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(val))
-    return null;
-  if (val instanceof Date) {
-    const dateExpr = {
-      date: expr,
-      format: "%Y-%m-%dT%H:%M:%S.%LZ"
-    };
-    return (0, import_dateToString.$dateToString)(obj, dateExpr, options);
-  } else {
-    return val.toString();
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) {
+    return (0, import_dateToString.$dateToString)(
+      obj,
+      {
+        date: expr,
+        format: "%Y-%m-%dT%H:%M:%S.%LZ"
+      },
+      options
+    );
   }
+  return val.toString();
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -22,22 +22,19 @@ __export(type_exports, {
 module.exports = __toCommonJS(type_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
+var import_internal = require("./_internal");
 const $type = (obj, expr, options) => {
-  const val = (0, import_core.computeValue)(obj, expr, null, options);
-  const typename = (0, import_util.getType)(val);
-  const nativeType = typename.toLowerCase();
-  switch (nativeType) {
-    case "boolean":
-      return "bool";
-    case "number":
-      if (val.toString().indexOf(".") >= 0)
-        return "double";
-      return val >= import_util.MIN_INT && val <= import_util.MAX_INT ? "int" : "long";
-    case "regexp":
-      return "regex";
-    default:
-      return nativeType;
+  const v = (0, import_core.computeValue)(obj, expr, null, options);
+  if (options.useStrictMode) {
+    if (v === void 0) return "missing";
+    if (v === true || v === false) return "bool";
+    if ((0, import_util.isNumber)(v)) {
+      if (v % 1 != 0) return "double";
+      return v >= import_internal.MIN_INT && v <= import_internal.MAX_INT ? "int" : "long";
+    }
+    if ((0, import_util.isRegExp)(v)) return "regex";
   }
+  return (0, import_util.typeOf)(v);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,8 +24,7 @@ var import_core = require("../../core");
 var import_util = require("../../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) {