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

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

@@ -0,0 +1,221 @@
+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 setWindowFields_exports = {};
+__export(setWindowFields_exports, {
+  $setWindowFields: () => $setWindowFields
+});
+module.exports = __toCommonJS(setWindowFields_exports);
+var import_core = require("../../core");
+var import_lazy = require("../../lazy");
+var import_util = require("../../util");
+var import_function = require("../expression/custom/function");
+var import_dateAdd = require("../expression/date/dateAdd");
+var import_internal = require("./_internal");
+var import_addFields = require("./addFields");
+var import_group = require("./group");
+var import_sort = require("./sort");
+const SORT_REQUIRED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$documentNumber",
+  "$first",
+  "$last",
+  "$linearFill",
+  "$rank",
+  "$shift"
+]);
+const WINDOW_UNBOUNDED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$expMovingAvg",
+  "$linearFill",
+  "$locf",
+  "$rank",
+  "$shift"
+]);
+const $setWindowFields = (collection, expr, options) => {
+  options = (0, import_core.initOptions)(options);
+  options.context.addExpressionOps({ $function: import_function.$function });
+  for (const outputExpr of Object.values(expr.output)) {
+    const keys = Object.keys(outputExpr);
+    const op = keys.find(import_util.isOperator);
+    (0, import_util.assert)(
+      !!(0, import_core.getOperator)(import_core.OperatorType.WINDOW, op, options) || !!(0, import_core.getOperator)(import_core.OperatorType.ACCUMULATOR, op, options),
+      `'${op}' is not a valid window operator`
+    );
+    (0, import_util.assert)(
+      keys.length > 0 && keys.length <= 2 && (keys.length == 1 || keys.includes("window")),
+      "'output' option should have a single window operator."
+    );
+    if (outputExpr?.window) {
+      const { documents, range } = outputExpr.window;
+      (0, import_util.assert)(
+        !!documents && !range || !documents && !!range || !documents && !range,
+        "'window' option supports only one of 'documents' or 'range'."
+      );
+    }
+  }
+  if (expr.sortBy) {
+    collection = (0, import_sort.$sort)(collection, expr.sortBy, options);
+  }
+  collection = (0, import_group.$group)(
+    collection,
+    {
+      _id: expr.partitionBy,
+      items: { $push: "$$CURRENT" }
+    },
+    options
+  );
+  return collection.transform((partitions) => {
+    const iterators = [];
+    const outputConfig = [];
+    for (const [field, outputExpr] of Object.entries(expr.output)) {
+      const op = Object.keys(outputExpr).find(import_util.isOperator);
+      const config = {
+        operatorName: op,
+        func: {
+          left: (0, import_core.getOperator)(
+            import_core.OperatorType.ACCUMULATOR,
+            op,
+            options
+          ),
+          right: (0, import_core.getOperator)(import_core.OperatorType.WINDOW, op, options)
+        },
+        args: outputExpr[op],
+        field,
+        window: outputExpr.window
+      };
+      (0, import_util.assert)(
+        !!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window),
+        `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : "bounded window operation"} requires a sortBy.`
+      );
+      (0, import_util.assert)(
+        !config.window || !WINDOW_UNBOUNDED_OPS.has(op),
+        `${op} does not accept a 'window' field.`
+      );
+      outputConfig.push(config);
+    }
+    partitions.forEach((group) => {
+      const items = group.items;
+      let iterator = (0, import_lazy.Lazy)(items);
+      const windowResultMap = {};
+      for (const config of outputConfig) {
+        const { func, args, field, window } = config;
+        const makeResultFunc = (getItemsFn) => {
+          let index = -1;
+          return (obj) => {
+            ++index;
+            if (func.left) {
+              return func.left(getItemsFn(obj, index), args, options);
+            } else if (func.right) {
+              return func.right(
+                obj,
+                getItemsFn(obj, index),
+                {
+                  parentExpr: expr,
+                  inputExpr: args,
+                  documentNumber: index + 1,
+                  field
+                },
+                // must use raw options only since it operates over a collection.
+                options
+              );
+            }
+          };
+        };
+        if (window) {
+          const { documents, range, unit } = window;
+          const boundary = documents || range;
+          if (!(0, import_internal.isUnbounded)(window)) {
+            const [begin, end] = boundary;
+            const toBeginIndex = (currentIndex) => {
+              if (begin == "current")
+                return currentIndex;
+              if (begin == "unbounded")
+                return 0;
+              return Math.max(begin + currentIndex, 0);
+            };
+            const toEndIndex = (currentIndex) => {
+              if (end == "current")
+                return currentIndex + 1;
+              if (end == "unbounded")
+                return items.length;
+              return end + currentIndex + 1;
+            };
+            const getItems = (current, index) => {
+              if (!!documents || boundary.every(import_util.isString)) {
+                return items.slice(toBeginIndex(index), toEndIndex(index));
+              }
+              const sortKey = Object.keys(expr.sortBy)[0];
+              let lower;
+              let upper;
+              if (unit) {
+                const getTime = (amount) => {
+                  return (0, import_dateAdd.$dateAdd)(
+                    current,
+                    {
+                      startDate: new Date(current[sortKey]),
+                      unit,
+                      amount
+                    },
+                    options
+                  ).getTime();
+                };
+                lower = (0, import_util.isNumber)(begin) ? getTime(begin) : -Infinity;
+                upper = (0, import_util.isNumber)(end) ? getTime(end) : Infinity;
+              } else {
+                const currentValue = current[sortKey];
+                lower = (0, import_util.isNumber)(begin) ? currentValue + begin : -Infinity;
+                upper = (0, import_util.isNumber)(end) ? currentValue + end : Infinity;
+              }
+              let array = items;
+              if (begin == "current")
+                array = items.slice(index);
+              if (end == "current")
+                array = items.slice(0, index + 1);
+              return array.filter((o) => {
+                const n = +o[sortKey];
+                return n >= lower && n <= upper;
+              });
+            };
+            windowResultMap[field] = makeResultFunc(getItems);
+          }
+        }
+        if (!windowResultMap[field]) {
+          windowResultMap[field] = makeResultFunc((_) => items);
+        }
+        iterator = (0, import_addFields.$addFields)(
+          iterator,
+          {
+            [field]: {
+              $function: {
+                body: (obj) => windowResultMap[field](obj),
+                args: ["$$CURRENT"]
+              }
+            }
+          },
+          options
+        );
+      }
+      iterators.push(iterator);
+    });
+    return (0, import_lazy.compose)(...iterators);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $setWindowFields
+});

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

@@ -0,0 +1,29 @@
+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 skip_exports = {};
+__export(skip_exports, {
+  $skip: () => $skip
+});
+module.exports = __toCommonJS(skip_exports);
+const $skip = (collection, expr, options) => {
+  return collection.drop(expr);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $skip
+});

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

@@ -0,0 +1,91 @@
+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 sort_exports = {};
+__export(sort_exports, {
+  $sort: () => $sort
+});
+module.exports = __toCommonJS(sort_exports);
+var import_util = require("../../util");
+const $sort = (collection, sortKeys, options) => {
+  if ((0, import_util.isEmpty)(sortKeys) || !(0, import_util.isObject)(sortKeys))
+    return collection;
+  let cmp = import_util.compare;
+  const collationSpec = options.collation;
+  if ((0, import_util.isObject)(collationSpec) && (0, import_util.isString)(collationSpec.locale)) {
+    cmp = collationComparator(collationSpec);
+  }
+  return collection.transform((coll) => {
+    const modifiers = Object.keys(sortKeys);
+    for (const key of modifiers.reverse()) {
+      const groups = (0, import_util.groupBy)(
+        coll,
+        (obj) => (0, import_util.resolve)(obj, key),
+        options.hashFunction
+      );
+      const sortedKeys = Array.from(groups.keys()).sort(cmp);
+      if (sortKeys[key] === -1)
+        sortedKeys.reverse();
+      coll = [];
+      sortedKeys.reduce(
+        (acc, key2) => (0, import_util.into)(acc, groups.get(key2)),
+        coll
+      );
+    }
+    return coll;
+  });
+};
+const COLLATION_STRENGTH = {
+  // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.
+  1: "base",
+  //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.
+  // Examples: a ≠ b, a ≠ á, a = A.
+  2: "accent",
+  // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.
+  // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A
+  3: "variant"
+  // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.
+};
+function collationComparator(spec) {
+  const localeOpt = {
+    sensitivity: COLLATION_STRENGTH[spec.strength || 3],
+    caseFirst: spec.caseFirst === "off" ? "false" : spec.caseFirst || "false",
+    numeric: spec.numericOrdering || false,
+    ignorePunctuation: spec.alternate === "shifted"
+  };
+  if ((spec.caseLevel || false) === true) {
+    if (localeOpt.sensitivity === "base")
+      localeOpt.sensitivity = "case";
+    if (localeOpt.sensitivity === "accent")
+      localeOpt.sensitivity = "variant";
+  }
+  const collator = new Intl.Collator(spec.locale, localeOpt);
+  return (a, b) => {
+    if (!(0, import_util.isString)(a) || !(0, import_util.isString)(b))
+      return (0, import_util.compare)(a, b);
+    const i = collator.compare(a, b);
+    if (i < 0)
+      return -1;
+    if (i > 0)
+      return 1;
+    return 0;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $sort
+});

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

@@ -0,0 +1,33 @@
+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 sortByCount_exports = {};
+__export(sortByCount_exports, {
+  $sortByCount: () => $sortByCount
+});
+module.exports = __toCommonJS(sortByCount_exports);
+var import_group = require("./group");
+var import_sort = require("./sort");
+const $sortByCount = (collection, expr, options) => {
+  const newExpr = { count: { $sum: 1 } };
+  newExpr["_id"] = expr;
+  return (0, import_sort.$sort)((0, import_group.$group)(collection, newExpr, options), { count: -1 }, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $sortByCount
+});

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

@@ -0,0 +1,37 @@
+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 unionWith_exports = {};
+__export(unionWith_exports, {
+  $unionWith: () => $unionWith
+});
+module.exports = __toCommonJS(unionWith_exports);
+var import_aggregator = require("../../aggregator");
+var import_lazy = require("../../lazy");
+var import_util = require("../../util");
+const $unionWith = (collection, expr, options) => {
+  const array = (0, import_util.isString)(expr.coll) ? options.collectionResolver(expr.coll) : expr.coll;
+  const iterators = [collection];
+  iterators.push(
+    expr.pipeline ? new import_aggregator.Aggregator(expr.pipeline, options).stream(array) : (0, import_lazy.Lazy)(array)
+  );
+  return (0, import_lazy.compose)(...iterators);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $unionWith
+});

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

@@ -0,0 +1,35 @@
+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_project = require("./project");
+const $unset = (collection, expr, options) => {
+  expr = (0, import_util.ensureArray)(expr);
+  const doc = {};
+  for (const k of expr)
+    doc[k] = 0;
+  return (0, import_project.$project)(collection, doc, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $unset
+});

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

@@ -0,0 +1,73 @@
+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 unwind_exports = {};
+__export(unwind_exports, {
+  $unwind: () => $unwind
+});
+module.exports = __toCommonJS(unwind_exports);
+var import_lazy = require("../../lazy");
+var import_util = require("../../util");
+const $unwind = (collection, expr, _options) => {
+  if ((0, import_util.isString)(expr))
+    expr = { path: expr };
+  const path = expr.path;
+  const field = path.substring(1);
+  const includeArrayIndex = expr?.includeArrayIndex || false;
+  const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;
+  const format = (o, i) => {
+    if (includeArrayIndex !== false)
+      o[includeArrayIndex] = i;
+    return o;
+  };
+  let value;
+  return (0, import_lazy.Lazy)(() => {
+    for (; ; ) {
+      if (value instanceof import_lazy.Iterator) {
+        const tmp = value.next();
+        if (!tmp.done)
+          return tmp;
+      }
+      const wrapper = collection.next();
+      if (wrapper.done)
+        return wrapper;
+      const obj = wrapper.value;
+      value = (0, import_util.resolve)(obj, field);
+      if (value instanceof Array) {
+        if (value.length === 0 && preserveNullAndEmptyArrays === true) {
+          value = null;
+          (0, import_util.removeValue)(obj, field);
+          return { value: format(obj, null), done: false };
+        } else {
+          value = (0, import_lazy.Lazy)(value).map((item, i) => {
+            const newObj = (0, import_util.resolveGraph)(obj, field, {
+              preserveKeys: true
+            });
+            (0, import_util.setValue)(newObj, field, item);
+            return format(newObj, i);
+          });
+        }
+      } else if (!(0, import_util.isEmpty)(value) || preserveNullAndEmptyArrays === true) {
+        return { value: format(obj, null), done: false };
+      }
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $unwind
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/projection/elemMatch.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 elemMatch_exports = {};
+__export(elemMatch_exports, {
+  $elemMatch: () => $elemMatch
+});
+module.exports = __toCommonJS(elemMatch_exports);
+var import_query = require("../../query");
+var import_util = require("../../util");
+const $elemMatch = (obj, expr, field, options) => {
+  const arr = (0, import_util.resolve)(obj, field);
+  const query = new import_query.Query(expr, options);
+  (0, import_util.assert)(arr instanceof Array, "$elemMatch: argument must resolve to array");
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (query.test(arr[i])) {
+      if (options.useStrictMode)
+        return [arr[i]];
+      result.push(arr[i]);
+    }
+  }
+  return result.length > 0 ? result : void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $elemMatch
+});

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

@@ -0,0 +1,23 @@
+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 projection_exports = {};
+module.exports = __toCommonJS(projection_exports);
+__reExport(projection_exports, require("./elemMatch"), module.exports);
+__reExport(projection_exports, require("./slice"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./elemMatch"),
+  ...require("./slice")
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/projection/slice.js

@@ -0,0 +1,39 @@
+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 slice_exports = {};
+__export(slice_exports, {
+  $slice: () => $slice
+});
+module.exports = __toCommonJS(slice_exports);
+var import_util = require("../../util");
+var import_slice = require("../expression/array/slice");
+const $slice = (obj, expr, field, options) => {
+  const xs = (0, import_util.resolve)(obj, field);
+  const exprAsArray = expr;
+  if (!(0, import_util.isArray)(xs))
+    return xs;
+  return (0, import_slice.$slice)(
+    obj,
+    expr instanceof Array ? [xs, ...exprAsArray] : [xs, expr],
+    options
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $slice
+});

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

@@ -0,0 +1,28 @@
+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 all_exports = {};
+__export(all_exports, {
+  $all: () => $all
+});
+module.exports = __toCommonJS(all_exports);
+var import_predicates = require("../../_predicates");
+const $all = (0, import_predicates.createQueryOperator)(import_predicates.$all);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $all
+});