@valkey/valkey-glide-darwin-arm64 1.3.0-rc2 → 1.3.0

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

@@ -22,125 +22,118 @@ __export(project_exports, {
 module.exports = __toCommonJS(project_exports);
 var import_core = require("../../core");
 var import_util = require("../../util");
-const DESCRIPTORS = new Set(Array.from([0, 1, false, true]));
 const $project = (collection, expr, options) => {
   if ((0, import_util.isEmpty)(expr)) return collection;
-  const expressionKeys = Object.keys(expr);
   validateExpression(expr, options);
-  const ID_KEY = options.idKey;
-  if (!expressionKeys.includes(ID_KEY)) {
-    expressionKeys.push(ID_KEY);
-  }
-  const copts = import_core.ComputeOptions.init(options);
-  return collection.map((obj) => processObject(obj, expr, copts.update(obj), expressionKeys));
+  return collection.map(createHandler(expr, import_core.ComputeOptions.init(options)));
 };
-function processObject(obj, expr, options, expressionKeys) {
-  let newObj = {};
-  let foundSlice = false;
-  let foundExclusion = false;
-  const idOnlyExcluded = expr[options.idKey] === 0 && expressionKeys.length === 1;
-  const dropKeys = [];
-  if (idOnlyExcluded) {
-    dropKeys.push(options.idKey);
-  }
+function createHandler(expr, options, isRoot = true) {
+  const idKey = options.idKey;
+  const expressionKeys = Object.keys(expr);
+  const excludedKeys = new Array();
+  const includedKeys = new Array();
+  const handlers = {};
   for (const key of expressionKeys) {
-    let value = void 0;
     const subExpr = expr[key];
-    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {
-      foundExclusion = true;
-    }
-    if (key === options.idKey && (0, import_util.isEmpty)(subExpr)) {
-      value = obj[key];
-    } else if ((0, import_util.isString)(subExpr)) {
-      value = (0, import_core.computeValue)(obj, subExpr, key, options);
-    } else if (subExpr === 1 || subExpr === true) {
+    if ((0, import_util.isNumber)(subExpr) || (0, import_util.isBoolean)(subExpr)) {
+      if (subExpr) {
+        includedKeys.push(key);
+      } else {
+        excludedKeys.push(key);
+      }
     } else if ((0, import_util.isArray)(subExpr)) {
-      value = subExpr.map((v) => {
-        const r = (0, import_core.computeValue)(obj, v, null, options);
-        if ((0, import_util.isNil)(r)) return null;
-        return r;
-      });
+      handlers[key] = (o) => subExpr.map((v) => (0, import_core.computeValue)(o, v, null, options.update(o)) ?? null);
     } else if ((0, import_util.isObject)(subExpr)) {
-      const subExprObj = subExpr;
       const subExprKeys = Object.keys(subExpr);
       const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
-      const call = (0, import_core.getOperator)(
+      const projectFn = (0, import_core.getOperator)(
         "projection",
         operator,
         options
       );
-      if (call) {
-        if (operator === "$slice") {
-          if ((0, import_util.ensureArray)(subExprObj[operator]).every(import_util.isNumber)) {
-            value = call(obj, subExprObj[operator], key, options);
-            foundSlice = true;
-          } else {
-            value = (0, import_core.computeValue)(obj, subExprObj, key, options);
-          }
+      if (projectFn) {
+        const foundSlice = operator === "$slice";
+        if (foundSlice && !(0, import_util.ensureArray)(subExpr[operator]).every(import_util.isNumber)) {
+          handlers[key] = (o) => (0, import_core.computeValue)(o, subExpr, key, options.update(o));
         } else {
-          value = call(obj, subExprObj[operator], key, options);
+          handlers[key] = (o) => projectFn(o, subExpr[operator], key, options.update(o));
         }
       } else if ((0, import_util.isOperator)(operator)) {
-        value = (0, import_core.computeValue)(obj, subExprObj[operator], operator, options);
-      } else if ((0, import_util.has)(obj, key)) {
-        validateExpression(subExprObj, options);
-        let target = obj[key];
-        if ((0, import_util.isArray)(target)) {
-          value = target.map(
-            (o) => processObject(o, subExprObj, options, subExprKeys)
-          );
-        } else {
-          target = (0, import_util.isObject)(target) ? target : obj;
-          value = processObject(
-            target,
-            subExprObj,
-            options,
-            subExprKeys
-          );
-        }
+        handlers[key] = (o) => (0, import_core.computeValue)(o, subExpr[operator], operator, options);
       } else {
-        value = (0, import_core.computeValue)(obj, subExpr, null, options);
+        validateExpression(subExpr, options);
+        handlers[key] = (o) => {
+          if (!(0, import_util.has)(o, key)) return (0, import_core.computeValue)(o, subExpr, null, options);
+          if (isRoot) options.update(o);
+          const target = (0, import_util.resolve)(o, key);
+          const fn = createHandler(subExpr, options, false);
+          if ((0, import_util.isArray)(target)) return target.map(fn);
+          if ((0, import_util.isObject)(target)) return fn(target);
+          return fn(o);
+        };
       }
     } else {
-      dropKeys.push(key);
-      continue;
+      handlers[key] = (0, import_util.isString)(subExpr) && subExpr[0] === "$" ? (o) => (0, import_core.computeValue)(o, subExpr, key, options) : (_) => subExpr;
     }
-    const objPathGraph = (0, import_util.resolveGraph)(obj, key, {
-      preserveMissing: true
-    });
-    if ((0, import_util.isObject)(objPathGraph)) {
-      (0, import_util.merge)(newObj, objPathGraph);
+  }
+  const handlerKeys = Object.keys(handlers);
+  const idKeyExcluded = excludedKeys.includes(idKey);
+  const idKeyOnlyExcluded = isRoot && idKeyExcluded && excludedKeys.length === 1 && !includedKeys.length && !handlerKeys.length;
+  if (idKeyOnlyExcluded) {
+    return (o) => {
+      const newObj = { ...o };
+      delete newObj[idKey];
+      return newObj;
+    };
+  }
+  const idKeyImplicit = isRoot && !idKeyExcluded && !includedKeys.includes(idKey);
+  const opts = {
+    preserveMissing: true
+  };
+  return (o) => {
+    const newObj = {};
+    if (excludedKeys.length && !includedKeys.length) {
+      (0, import_util.merge)(newObj, o);
+      for (const k of excludedKeys) {
+        (0, import_util.removeValue)(newObj, k, { descendArray: true });
+      }
+    }
+    for (const k of includedKeys) {
+      const pathObj = (0, import_util.resolveGraph)(o, k, opts) ?? {};
+      (0, import_util.merge)(newObj, pathObj);
     }
-    if (!DESCRIPTORS.has(subExpr)) {
+    if (includedKeys.length) (0, import_util.filterMissing)(newObj);
+    for (const k of handlerKeys) {
+      const value = handlers[k](o);
       if (value === void 0) {
-        (0, import_util.removeValue)(newObj, key, { descendArray: true });
+        (0, import_util.removeValue)(newObj, k, { descendArray: true });
       } else {
-        (0, import_util.setValue)(newObj, key, value);
+        (0, import_util.setValue)(newObj, k, value);
       }
     }
-  }
-  (0, import_util.filterMissing)(newObj);
-  if (foundSlice || foundExclusion || idOnlyExcluded) {
-    newObj = (0, import_util.into)({}, obj, newObj);
-    if (dropKeys.length > 0) {
-      for (const k of dropKeys) {
-        (0, import_util.removeValue)(newObj, k, { descendArray: true });
-      }
+    if (idKeyImplicit && (0, import_util.has)(o, idKey)) {
+      newObj[idKey] = (0, import_util.resolve)(o, idKey);
     }
-  }
-  return newObj;
+    return newObj;
+  };
 }
 function validateExpression(expr, options) {
-  const check = [false, false];
+  let exclusions = false;
+  let inclusions = false;
   for (const [k, v] of Object.entries(expr)) {
-    if (k === options?.idKey) return;
+    (0, import_util.assert)(!k.startsWith("$"), "Field names may not start with '$'.");
+    (0, import_util.assert)(
+      !k.endsWith(".$"),
+      "Positional projection operator '$' is not supported."
+    );
+    if (k === options?.idKey) continue;
     if (v === 0 || v === false) {
-      check[0] = true;
+      exclusions = true;
     } else if (v === 1 || v === true) {
-      check[1] = true;
+      inclusions = true;
     }
     (0, import_util.assert)(
-      !(check[0] && check[1]),
+      !(exclusions && inclusions),
       "Projection cannot have a mix of inclusion and exclusion."
     );
   }

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

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,17 +16,36 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var internal_exports = {};
 __export(internal_exports, {
+  UPDATE_OPTIONS: () => UPDATE_OPTIONS,
   applyUpdate: () => applyUpdate,
   clone: () => clone,
   tokenizePath: () => tokenizePath,
   walkExpression: () => walkExpression
 });
 module.exports = __toCommonJS(internal_exports);
+var import_core = require("../../core");
+var booleanOperators = __toESM(require("../../operators/expression/boolean"));
+var comparisonOperators = __toESM(require("../../operators/expression/comparison"));
+var queryOperators = __toESM(require("../../operators/query"));
 var import_query = require("../../query");
 var import_util = require("../../util");
+const UPDATE_OPTIONS = {
+  cloneMode: "copy",
+  queryOptions: (0, import_core.initOptions)({
+    context: import_core.Context.init().addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators)
+  })
+};
 const clone = (mode, val) => {
   switch (mode) {
     case "deep":
@@ -104,6 +125,7 @@ function walkExpression(expr, arrayFilter, options, callback) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  UPDATE_OPTIONS,
   applyUpdate,
   clone,
   tokenizePath,

package/rust-client/node_modules/mingo/dist/cjs/operators/update/addToSet.js

@@ -22,7 +22,7 @@ __export(addToSet_exports, {
 module.exports = __toCommonJS(addToSet_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $addToSet = (obj, expr, arrayFilters = [], options = {}) => {
+const $addToSet = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     const args = { $each: [val] };
     if ((0, import_util.isObject)(val) && (0, import_util.has)(val, "$each")) {

package/rust-client/node_modules/mingo/dist/cjs/operators/update/bit.js

@@ -23,7 +23,7 @@ module.exports = __toCommonJS(bit_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
 const BIT_OPS = /* @__PURE__ */ new Set(["and", "or", "xor"]);
-const $bit = (obj, expr, arrayFilters = [], options = {}) => {
+const $bit = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     const op = Object.keys(val);
     (0, import_util.assert)(

package/rust-client/node_modules/mingo/dist/cjs/operators/update/currentDate.js

@@ -21,7 +21,7 @@ __export(currentDate_exports, {
 });
 module.exports = __toCommonJS(currentDate_exports);
 var import_internal = require("./_internal");
-const $currentDate = (obj, expr, arrayFilters = [], options = {}) => {
+const $currentDate = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   const now = Date.now();
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {
     return (0, import_internal.applyUpdate)(

package/rust-client/node_modules/mingo/dist/cjs/operators/update/inc.js

@@ -22,7 +22,7 @@ __export(inc_exports, {
 module.exports = __toCommonJS(inc_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $inc = (obj, expr, arrayFilters = [], options = {}) => {
+const $inc = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     if (!node.child) {
       const n = (0, import_util.resolve)(obj, node.parent);

package/rust-client/node_modules/mingo/dist/cjs/operators/update/max.js

@@ -22,7 +22,7 @@ __export(max_exports, {
 module.exports = __toCommonJS(max_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $max = (obj, expr, arrayFilters = [], options = {}) => {
+const $max = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(
       obj,

package/rust-client/node_modules/mingo/dist/cjs/operators/update/min.js

@@ -22,7 +22,7 @@ __export(min_exports, {
 module.exports = __toCommonJS(min_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $min = (obj, expr, arrayFilters = [], options = {}) => {
+const $min = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(
       obj,

package/rust-client/node_modules/mingo/dist/cjs/operators/update/mul.js

@@ -21,7 +21,7 @@ __export(mul_exports, {
 });
 module.exports = __toCommonJS(mul_exports);
 var import_internal = require("./_internal");
-const $mul = (obj, expr, arrayFilters = [], options = {}) => {
+const $mul = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(
       obj,

package/rust-client/node_modules/mingo/dist/cjs/operators/update/pop.js

@@ -22,7 +22,7 @@ __export(pop_exports, {
 module.exports = __toCommonJS(pop_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $pop = (obj, expr, arrayFilters = [], options = {}) => {
+const $pop = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
       const arr = o[k];

package/rust-client/node_modules/mingo/dist/cjs/operators/update/pull.js

@@ -23,7 +23,7 @@ module.exports = __toCommonJS(pull_exports);
 var import_query = require("../../query");
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $pull = (obj, expr, arrayFilters = [], options = {}) => {
+const $pull = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     const wrap = !(0, import_util.isObject)(val) || Object.keys(val).some(import_util.isOperator);
     const query = new import_query.Query(

package/rust-client/node_modules/mingo/dist/cjs/operators/update/pullAll.js

@@ -20,8 +20,9 @@ __export(pullAll_exports, {
   $pullAll: () => $pullAll
 });
 module.exports = __toCommonJS(pullAll_exports);
+var import_internal = require("./_internal");
 var import_pull = require("./pull");
-const $pullAll = (obj, expr, arrayFilters = [], options = {}) => {
+const $pullAll = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   const pullExpr = {};
   Object.entries(expr).forEach(([k, v]) => {
     pullExpr[k] = { $in: v };

package/rust-client/node_modules/mingo/dist/cjs/operators/update/push.js

@@ -28,7 +28,7 @@ const OPERATOR_MODIFIERS = Object.freeze([
   "$sort",
   "$position"
 ]);
-const $push = (obj, expr, arrayFilters = [], options = {}) => {
+const $push = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     const args = {
       $each: [val]

package/rust-client/node_modules/mingo/dist/cjs/operators/update/rename.js

@@ -23,7 +23,7 @@ module.exports = __toCommonJS(rename_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
 var import_set = require("./set");
-const $rename = (obj, expr, arrayFilters = [], options = {}) => {
+const $rename = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   const res = [];
   const changed = (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {

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

@@ -22,7 +22,7 @@ __export(set_exports, {
 module.exports = __toCommonJS(set_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $set = (obj, expr, arrayFilters = [], options = {}) => {
+const $set = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
     return (0, import_internal.applyUpdate)(
       obj,

package/rust-client/node_modules/mingo/dist/cjs/operators/update/unset.js

@@ -22,7 +22,7 @@ __export(unset_exports, {
 module.exports = __toCommonJS(unset_exports);
 var import_util = require("../../util");
 var import_internal = require("./_internal");
-const $unset = (obj, expr, arrayFilters = [], options = {}) => {
+const $unset = (obj, expr, arrayFilters = [], options = import_internal.UPDATE_OPTIONS) => {
   return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {
     return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
       if (!(0, import_util.has)(o, k)) return false;

package/rust-client/node_modules/mingo/dist/cjs/query.js

@@ -31,7 +31,7 @@ class Query {
   #options;
   #condition;
   constructor(condition, options) {
-    this.#condition = condition;
+    this.#condition = (0, import_util.cloneDeep)(condition);
     this.#options = (0, import_core.initOptions)(options);
     this.#compiled = [];
     this.compile();
@@ -44,6 +44,10 @@ class Query {
     const whereOperator = {};
     for (const [field, expr] of Object.entries(this.#condition)) {
       if ("$where" === field) {
+        (0, import_util.assert)(
+          this.#options.scriptEnabled,
+          "$where operator requires 'scriptEnabled' option to be true."
+        );
         Object.assign(whereOperator, { field, expr });
       } else if (TOP_LEVEL_OPS.has(field)) {
         this.processOperator(field, field, expr);
@@ -66,25 +70,17 @@ class Query {
   }
   processOperator(field, operator, value) {
     const call = (0, import_core.getOperator)("query", operator, this.#options);
-    if (!call) {
-      throw new import_util.MingoError(`unknown query operator ${operator}`);
-    }
-    const fn = call(field, value, this.#options);
-    this.#compiled.push(fn);
+    (0, import_util.assert)(!!call, `unknown query operator ${operator}`);
+    this.#compiled.push(call(field, value, this.#options));
   }
   /**
    * Checks if the object passes the query criteria. Returns true if so, false otherwise.
    *
    * @param obj The object to test
-   * @returns {boolean} True or false
+   * @returns {boolean}
    */
   test(obj) {
-    for (let i = 0, len = this.#compiled.length; i < len; i++) {
-      if (!this.#compiled[i](obj)) {
-        return false;
-      }
-    }
-    return true;
+    return this.#compiled.every((p) => p(obj));
   }
   /**
    * Returns a cursor to select matching documents from the input source.
@@ -96,7 +92,7 @@ class Query {
   find(collection, projection) {
     return new import_cursor.Cursor(
       collection,
-      (x) => this.test(x),
+      (o) => this.test(o),
       projection || {},
       this.#options
     );

package/rust-client/node_modules/mingo/dist/cjs/updater.js

@@ -32,27 +32,13 @@ __export(updater_exports, {
   updateObject: () => updateObject
 });
 module.exports = __toCommonJS(updater_exports);
-var import_core = require("./core");
-var booleanOperators = __toESM(require("./operators/expression/boolean"));
-var comparisonOperators = __toESM(require("./operators/expression/comparison"));
-var queryOperators = __toESM(require("./operators/query"));
 var UPDATE_OPERATORS = __toESM(require("./operators/update"));
+var import_internal = require("./operators/update/_internal");
 var import_query = require("./query");
 var import_util = require("./util");
 function createUpdater(defaultOptions) {
-  defaultOptions = defaultOptions || {};
-  defaultOptions = {
-    ...defaultOptions,
-    queryOptions: (0, import_core.initOptions)(defaultOptions.queryOptions)
-  };
-  defaultOptions.queryOptions.context.addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators);
-  return (obj, expr, arrayFilters = [], condition = {}, options = {}) => {
-    const opts = Object.assign({ cloneMode: "copy" }, defaultOptions, options);
-    Object.assign(opts, {
-      queryOptions: (0, import_core.initOptions)(
-        Object.assign({ useStrictMode: false }, opts?.queryOptions)
-      )
-    });
+  defaultOptions = defaultOptions ?? import_internal.UPDATE_OPTIONS;
+  return (obj, expr, arrayFilters = [], condition = {}, options = defaultOptions) => {
     const entry = Object.entries(expr);
     (0, import_util.assert)(
       entry.length === 1,
@@ -65,10 +51,10 @@ function createUpdater(defaultOptions) {
     );
     const mutate = UPDATE_OPERATORS[op];
     if (Object.keys(condition).length) {
-      const q = condition instanceof import_query.Query ? condition : new import_query.Query(condition, opts.queryOptions);
+      const q = new import_query.Query(condition, options.queryOptions);
       if (!q.test(obj)) return [];
     }
-    return mutate(obj, args, arrayFilters, opts);
+    return mutate(obj, args, arrayFilters, options);
   };
 }
 const update = createUpdater();

package/rust-client/node_modules/mingo/dist/cjs/util.js

@@ -72,9 +72,6 @@ const DEFAULT_HASH_FUNCTION = (value) => {
   while (i) hash = (hash << 5) - hash ^ s.charCodeAt(--i);
   return hash >>> 0;
 };
-const objectProto = Object.prototype;
-const arrayProto = Array.prototype;
-const getPrototypeOf = Object.getPrototypeOf;
 const isPrimitive = (v) => typeof v !== "object" && typeof v !== "function" || v === null;
 const isScalar = (v) => isPrimitive(v) || isDate(v) || isRegExp(v);
 const SORT_ORDER = {
@@ -184,7 +181,7 @@ function assert(condition, message) {
   if (!condition) throw new MingoError(message);
 }
 const typeOf = (v) => {
-  const s = objectProto.toString.call(v);
+  const s = Object.prototype.toString.call(v);
   const t = s.substring(8, s.length - 1).toLowerCase();
   if (t !== "object") return t;
   const ctor = v.constructor;
@@ -209,7 +206,7 @@ const isNil = (v) => v === null || v === void 0;
 const truthy = (arg, strict = true) => !!arg || strict && arg === "";
 const isEmpty = (x) => isNil(x) || isString(x) && !x || isArray(x) && x.length === 0 || isObject(x) && Object.keys(x).length === 0;
 const ensureArray = (x) => isArray(x) ? x : [x];
-const has = (obj, prop) => !!obj && objectProto.hasOwnProperty.call(obj, prop);
+const has = (obj, prop) => !!obj && Object.prototype.hasOwnProperty.call(obj, prop);
 const isTypedArray = (v) => typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v);
 const cloneDeep = (v, refs) => {
   if (isNil(v) || isBoolean(v) || isNumber(v) || isString(v)) return v;
@@ -284,23 +281,39 @@ function flatten(xs, depth = 1) {
   flatten2(xs, depth);
   return arr;
 }
+const objToString = Object.prototype.toString;
+function hasCustomToString(o) {
+  if (isTypedArray(o)) return true;
+  if (typeof o.toString === "function") {
+    let proto = Object.getPrototypeOf(o);
+    while (proto !== null) {
+      if (has(proto, "toString") && proto.toString !== objToString) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+  }
+  return false;
+}
 function isEqual(a, b) {
   if (a === b || Object.is(a, b)) return true;
-  const ctor = !!a && a.constructor || a;
-  if (a === null || b === null || a === void 0 || b === void 0 || ctor !== b.constructor || ctor === Function) {
-    return false;
-  }
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (a.constructor !== b.constructor) return false;
+  if (a instanceof Date) return +a === +b;
+  if (a instanceof RegExp) return a.toString() === b.toString();
+  const ctor = a.constructor;
   if (ctor === Array || ctor === Object) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
     if (aKeys.length !== bKeys.length) return false;
-    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length) return false;
-    for (const k of aKeys) if (!isEqual(a[k], b[k])) return false;
+    for (let i = 0, k = aKeys[i]; i < aKeys.length; k = aKeys[++i]) {
+      if (k !== bKeys[i] || !isEqual(a[k], b[k])) return false;
+    }
     return true;
   }
-  const proto = getPrototypeOf(a);
-  const cmp = isTypedArray(a) || proto !== objectProto && proto !== arrayProto && has(proto, "toString");
-  return cmp && a.toString() === b.toString();
+  return hasCustomToString(a) && a.toString() === b.toString();
 }
 function unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {
   const m = ValueMap.init(hashFunction);
@@ -325,8 +338,7 @@ const stringify = (v, refs) => {
       const keys = Object.keys(v).sort();
       return "{" + keys.map((k) => `${k}:${stringify(v[k], refs)}`).join() + "}";
     }
-    const proto = Object.getPrototypeOf(v);
-    if (proto !== objectProto && proto !== arrayProto && has(proto, "toString")) {
+    if (hasCustomToString(v)) {
       return typeOf(v) + "(" + JSON.stringify(v.toString()) + ")";
     }
     throw new Error(

package/rust-client/node_modules/mingo/dist/esm/aggregator.js

@@ -4,7 +4,7 @@ import {
   ProcessingMode
 } from "./core";
 import { Lazy } from "./lazy";
-import { assert, cloneDeep, intersection, isEmpty } from "./util";
+import { assert, cloneDeep, isEmpty } from "./util";
 class Aggregator {
   #pipeline;
   #options;
@@ -15,34 +15,30 @@ class Aggregator {
   /**
    * Returns an {@link Iterator} for lazy evaluation of the pipeline.
    *
-   * @param {*} collection An array or iterator object
+   * @param collection An array or iterator object
    * @returns {Iterator} an iterator object
    */
   stream(collection, options) {
-    let iterator = Lazy(collection);
+    let iter = Lazy(collection);
     const opts = options ?? this.#options;
     const mode = opts.processingMode;
-    if (mode == ProcessingMode.CLONE_ALL || mode == ProcessingMode.CLONE_INPUT) {
-      iterator.map(cloneDeep);
-    }
+    if (mode & ProcessingMode.CLONE_INPUT) iter.map(cloneDeep);
     const stages = new Array();
     if (!isEmpty(this.#pipeline)) {
-      for (const operator of this.#pipeline) {
-        const operatorKeys = Object.keys(operator);
-        const opName = operatorKeys[0];
+      for (const opExpr of this.#pipeline) {
+        const opKeys = Object.keys(opExpr);
+        const opName = opKeys[0];
         const call = getOperator("pipeline", opName, opts);
         assert(
-          operatorKeys.length === 1 && !!call,
+          opKeys.length === 1 && !!call,
           `invalid pipeline operator ${opName}`
         );
         stages.push(opName);
-        iterator = call(iterator, operator[opName], opts);
+        iter = call(iter, opExpr[opName], opts);
       }
     }
-    if (mode == ProcessingMode.CLONE_OUTPUT || mode == ProcessingMode.CLONE_ALL && !!intersection([["$group", "$unwind"], stages]).length) {
-      iterator.map(cloneDeep);
-    }
-    return iterator;
+    if (mode & ProcessingMode.CLONE_OUTPUT) iter.map(cloneDeep);
+    return iter;
   }
   /**
    * Return the results of the aggregation as an array.