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

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

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inc_exports = {};
+__export(inc_exports, {
+  $inc: () => $inc
+});
+module.exports = __toCommonJS(inc_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $inc = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    if (!node.child) {
+      const n = (0, import_util.resolve)(obj, node.parent);
+      (0, import_util.assert)(
+        n === void 0 || (0, import_util.isNumber)(n),
+        `cannot apply $inc to a value of non-numeric type`
+      );
+    }
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        o[k] = (o[k] ||= 0) + val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $inc
+});

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

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+module.exports = __toCommonJS(update_exports);
+__reExport(update_exports, require("./addToSet"), module.exports);
+__reExport(update_exports, require("./bit"), module.exports);
+__reExport(update_exports, require("./currentDate"), module.exports);
+__reExport(update_exports, require("./inc"), module.exports);
+__reExport(update_exports, require("./max"), module.exports);
+__reExport(update_exports, require("./min"), module.exports);
+__reExport(update_exports, require("./mul"), module.exports);
+__reExport(update_exports, require("./pop"), module.exports);
+__reExport(update_exports, require("./pull"), module.exports);
+__reExport(update_exports, require("./pullAll"), module.exports);
+__reExport(update_exports, require("./push"), module.exports);
+__reExport(update_exports, require("./rename"), module.exports);
+__reExport(update_exports, require("./set"), module.exports);
+__reExport(update_exports, require("./unset"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./addToSet"),
+  ...require("./bit"),
+  ...require("./currentDate"),
+  ...require("./inc"),
+  ...require("./max"),
+  ...require("./min"),
+  ...require("./mul"),
+  ...require("./pop"),
+  ...require("./pull"),
+  ...require("./pullAll"),
+  ...require("./push"),
+  ...require("./rename"),
+  ...require("./set"),
+  ...require("./unset")
+});

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

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_exports = {};
+__export(max_exports, {
+  $max: () => $max
+});
+module.exports = __toCommonJS(max_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $max = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) > -1)
+          return false;
+        o[k] = val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $max
+});

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

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var min_exports = {};
+__export(min_exports, {
+  $min: () => $min
+});
+module.exports = __toCommonJS(min_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $min = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) < 1)
+          return false;
+        o[k] = val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $min
+});

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mul_exports = {};
+__export(mul_exports, {
+  $mul: () => $mul
+});
+module.exports = __toCommonJS(mul_exports);
+var import_internal = require("./_internal");
+const $mul = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const prev = o[k];
+        o[k] = o[k] === void 0 ? 0 : o[k] * val;
+        return o[k] !== prev;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $mul
+});

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

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pop_exports = {};
+__export(pop_exports, {
+  $pop: () => $pop
+});
+module.exports = __toCommonJS(pop_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $pop = (obj, expr, arrayFilters = [], 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];
+      (0, import_util.assert)(
+        (0, import_util.isArray)(arr),
+        `path '${node.selector}' contains an element of non-array type.`
+      );
+      if (!arr.length)
+        return false;
+      if (val === -1) {
+        arr.splice(0, 1);
+      } else {
+        arr.pop();
+      }
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $pop
+});

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

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pull_exports = {};
+__export(pull_exports, {
+  $pull: () => $pull
+});
+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 = {}) => {
+  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(
+      wrap ? { k: val } : val,
+      options.queryOptions
+    );
+    const pred = wrap ? (v) => query.test({ k: v }) : (v) => query.test(v);
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      const prev = o[k];
+      const curr = new Array();
+      const found = prev.map((v) => {
+        const b = pred(v);
+        if (!b)
+          curr.push(v);
+        return b;
+      }).some(Boolean);
+      if (!found)
+        return false;
+      o[k] = curr;
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $pull
+});

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

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pullAll_exports = {};
+__export(pullAll_exports, {
+  $pullAll: () => $pullAll
+});
+module.exports = __toCommonJS(pullAll_exports);
+var import_pull = require("./pull");
+const $pullAll = (obj, expr, arrayFilters = [], options = {}) => {
+  const pullExpr = {};
+  Object.entries(expr).forEach(([k, v]) => {
+    pullExpr[k] = { $in: v };
+  });
+  return (0, import_pull.$pull)(obj, pullExpr, arrayFilters, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $pullAll
+});

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

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var push_exports = {};
+__export(push_exports, {
+  $push: () => $push
+});
+module.exports = __toCommonJS(push_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const OPERATOR_MODIFIERS = Object.freeze([
+  "$each",
+  "$slice",
+  "$sort",
+  "$position"
+]);
+const $push = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    const args = {
+      $each: [val]
+    };
+    if ((0, import_util.isObject)(val) && OPERATOR_MODIFIERS.some((m) => (0, import_util.has)(val, m))) {
+      Object.assign(args, val);
+    }
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const arr = o[k] ||= [];
+        const prev = arr.slice(0, args.$slice || arr.length);
+        const oldsize = arr.length;
+        const pos = (0, import_util.isNumber)(args.$position) ? args.$position : arr.length;
+        arr.splice(
+          pos,
+          0,
+          ...(0, import_internal.clone)(options.cloneMode, args.$each)
+        );
+        if (args.$sort) {
+          const sortKey = (0, import_util.isObject)(args.$sort) ? Object.keys(args.$sort || {}).pop() : "";
+          const order = !sortKey ? args.$sort : args.$sort[sortKey];
+          const f = !sortKey ? (a) => a : (a) => (0, import_util.resolve)(a, sortKey);
+          arr.sort((a, b) => order * (0, import_util.compare)(f(a), f(b)));
+        }
+        if ((0, import_util.isNumber)(args.$slice)) {
+          if (args.$slice < 0)
+            arr.splice(0, arr.length + args.$slice);
+          else
+            arr.splice(args.$slice);
+        }
+        return oldsize != arr.length || !(0, import_util.isEqual)(prev, arr);
+      },
+      { descendArray: true, buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $push
+});

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rename_exports = {};
+__export(rename_exports, {
+  $rename: () => $rename
+});
+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 res = [];
+  const changed = (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      if (!(0, import_util.has)(o, k))
+        return false;
+      res.push(...(0, import_set.$set)(obj, { [val]: o[k] }, arrayFilters, options));
+      delete o[k];
+      return true;
+    });
+  });
+  return Array.from(new Set(changed.concat(res)));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $rename
+});

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

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  $set: () => $set
+});
+module.exports = __toCommonJS(set_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $set = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if ((0, import_util.isEqual)(o[k], val))
+          return false;
+        o[k] = (0, import_internal.clone)(options.cloneMode, val);
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $set
+});

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unset_exports = {};
+__export(unset_exports, {
+  $unset: () => $unset
+});
+module.exports = __toCommonJS(unset_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+const $unset = (obj, expr, arrayFilters = [], 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;
+      if ((0, import_util.isArray)(o)) {
+        o[k] = null;
+      } else {
+        delete o[k];
+      }
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $unset
+});

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

@@ -0,0 +1,102 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  MILLIS_PER_UNIT: () => MILLIS_PER_UNIT,
+  rank: () => rank,
+  withMemo: () => withMemo
+});
+module.exports = __toCommonJS(internal_exports);
+var import_util = require("../../util");
+var import_accumulator = require("../accumulator");
+var import_internal = require("../expression/date/_internal");
+var import_internal2 = require("../pipeline/_internal");
+const MILLIS_PER_UNIT = {
+  week: import_internal.MILLIS_PER_DAY * 7,
+  day: import_internal.MILLIS_PER_DAY,
+  hour: import_internal.MILLIS_PER_DAY / 24,
+  minute: 6e4,
+  second: 1e3,
+  millisecond: 1
+};
+const memo = /* @__PURE__ */ new WeakMap();
+function withMemo(collection, expr, cacheFn, fn) {
+  if (!(0, import_internal2.isUnbounded)(expr.parentExpr.output[expr.field].window)) {
+    return fn(cacheFn());
+  }
+  if (!memo.has(collection)) {
+    memo.set(collection, { [expr.field]: cacheFn() });
+  }
+  const data = memo.get(collection);
+  if (data[expr.field] === void 0) {
+    data[expr.field] = cacheFn();
+  }
+  let failed = false;
+  try {
+    return fn(data[expr.field]);
+  } catch (e) {
+    failed = true;
+  } finally {
+    if (failed || expr.documentNumber === collection.length) {
+      delete data[expr.field];
+      if (Object.keys(data).length === 0)
+        memo.delete(collection);
+    }
+  }
+}
+function rank(_, collection, expr, options, dense) {
+  return withMemo(
+    collection,
+    expr,
+    () => {
+      const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
+      const values = (0, import_accumulator.$push)(collection, sortKey, options);
+      const groups = (0, import_util.groupBy)(
+        values,
+        (_2, n) => values[n],
+        options.hashFunction
+      );
+      return { values, groups };
+    },
+    (input) => {
+      const { values, groups: partitions } = input;
+      if (partitions.size == collection.length) {
+        return expr.documentNumber;
+      }
+      const current = values[expr.documentNumber - 1];
+      let i = 0;
+      let offset = 0;
+      for (const key of partitions.keys()) {
+        if ((0, import_util.isEqual)(current, key)) {
+          return dense ? i + 1 : offset + 1;
+        }
+        i++;
+        offset += partitions.get(key).length;
+      }
+      throw new import_util.MingoError(
+        "rank: invalid return value. please submit a bug report."
+      );
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MILLIS_PER_UNIT,
+  rank,
+  withMemo
+});