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

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

@@ -0,0 +1,31 @@
+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 multiply_exports = {};
+__export(multiply_exports, {
+  $multiply: () => $multiply
+});
+module.exports = __toCommonJS(multiply_exports);
+var import_core = require("../../../core");
+const $multiply = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args.reduce((acc, num) => acc * num, 1);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $multiply
+});

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

@@ -0,0 +1,40 @@
+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 pow_exports = {};
+__export(pow_exports, {
+  $pow: () => $pow
+});
+module.exports = __toCommonJS(pow_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $pow = (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.isNumber),
+    "$pow expression must resolve to array(2) of numbers"
+  );
+  (0, import_util.assert)(
+    !(args[0] === 0 && args[1] < 0),
+    "$pow cannot raise 0 to a negative exponent"
+  );
+  return Math.pow(args[0], args[1]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $pow
+});

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

@@ -0,0 +1,38 @@
+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 round_exports = {};
+__export(round_exports, {
+  $round: () => $round
+});
+module.exports = __toCommonJS(round_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+var import_internal = require("./_internal");
+const $round = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const num = args[0];
+  const place = args[1];
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
+    return num;
+  (0, import_util.assert)((0, import_util.isNumber)(num), "$round expression must resolve to a number.");
+  return (0, import_internal.truncate)(num, place, true);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $round
+});

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

@@ -0,0 +1,38 @@
+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 sqrt_exports = {};
+__export(sqrt_exports, {
+  $sqrt: () => $sqrt
+});
+module.exports = __toCommonJS(sqrt_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $sqrt = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n))
+    return null;
+  (0, import_util.assert)(
+    (0, import_util.isNumber)(n) && n > 0 || isNaN(n),
+    "$sqrt expression must resolve to non-negative number."
+  );
+  return Math.sqrt(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $sqrt
+});

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

@@ -0,0 +1,31 @@
+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 subtract_exports = {};
+__export(subtract_exports, {
+  $subtract: () => $subtract
+});
+module.exports = __toCommonJS(subtract_exports);
+var import_core = require("../../../core");
+const $subtract = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args[0] - args[1];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $subtract
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/trunc.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 trunc_exports = {};
+__export(trunc_exports, {
+  $trunc: () => $trunc
+});
+module.exports = __toCommonJS(trunc_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+var import_internal = require("./_internal");
+const $trunc = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  const num = arr[0];
+  const places = arr[1];
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
+    return num;
+  (0, import_util.assert)((0, import_util.isNumber)(num), "$trunc expression must resolve to a number.");
+  (0, import_util.assert)(
+    (0, import_util.isNil)(places) || (0, import_util.isNumber)(places) && places > -20 && places < 100,
+    "$trunc expression has invalid place"
+  );
+  return (0, import_internal.truncate)(num, places, false);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $trunc
+});

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

@@ -0,0 +1,45 @@
+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 arrayElemAt_exports = {};
+__export(arrayElemAt_exports, {
+  $arrayElemAt: () => $arrayElemAt
+});
+module.exports = __toCommonJS(arrayElemAt_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $arrayElemAt = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    args instanceof Array && args.length === 2,
+    "$arrayElemAt expression must resolve to array(2)"
+  );
+  if (args.some(import_util.isNil))
+    return null;
+  const index = args[1];
+  const arr = args[0];
+  if (index < 0 && Math.abs(index) <= arr.length) {
+    return arr[(index + arr.length) % arr.length];
+  } else if (index >= 0 && index < arr.length) {
+    return arr[index];
+  }
+  return void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $arrayElemAt
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/arrayToObject.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 arrayToObject_exports = {};
+__export(arrayToObject_exports, {
+  $arrayToObject: () => $arrayToObject
+});
+module.exports = __toCommonJS(arrayToObject_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $arrayToObject = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$arrayToObject expression must resolve to an array");
+  return arr.reduce((newObj, val) => {
+    while ((0, import_util.isArray)(val) && val.length === 1)
+      val = val[0];
+    if (val instanceof Array && val.length == 2) {
+      newObj[val[0]] = val[1];
+    } else {
+      const valObj = val;
+      (0, import_util.assert)(
+        (0, import_util.isObject)(valObj) && (0, import_util.has)(valObj, "k") && (0, import_util.has)(valObj, "v"),
+        "$arrayToObject expression is invalid."
+      );
+      newObj[valObj.k] = valObj.v;
+    }
+    return newObj;
+  }, {});
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $arrayToObject
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/concatArrays.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 concatArrays_exports = {};
+__export(concatArrays_exports, {
+  $concatArrays: () => $concatArrays
+});
+module.exports = __toCommonJS(concatArrays_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $concatArrays = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$concatArrays must resolve to an array");
+  if (arr.some(import_util.isNil))
+    return null;
+  return arr.reduce((acc, item) => (0, import_util.into)(acc, item), []);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $concatArrays
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/filter.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 filter_exports = {};
+__export(filter_exports, {
+  $filter: () => $filter
+});
+module.exports = __toCommonJS(filter_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $filter = (obj, expr, options) => {
+  const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(input), "$filter 'input' expression must resolve to an array");
+  const copts = import_core.ComputeOptions.init(options, obj);
+  const k = expr.as || "this";
+  const local = {
+    variables: { [k]: null }
+  };
+  return input.filter((o) => {
+    local.variables[k] = o;
+    const b = (0, import_core.computeValue)(
+      obj,
+      expr.cond,
+      null,
+      copts.update(copts.root, local)
+    );
+    return (0, import_util.truthy)(b, options.useStrictMode);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $filter
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/first.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 first_exports = {};
+__export(first_exports, {
+  $first: () => $first
+});
+module.exports = __toCommonJS(first_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+var import_accumulator = require("../../accumulator");
+const $first = (obj, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  if (obj instanceof Array)
+    return (0, import_accumulator.$first)(obj, expr, copts.update());
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(arr))
+    return null;
+  (0, import_util.assert)((0, import_util.isArray)(arr), "Must resolve to an array/null or missing");
+  return (0, import_accumulator.$first)(arr, "$$this", options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $first
+});

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

@@ -0,0 +1,38 @@
+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 firstN_exports = {};
+__export(firstN_exports, {
+  $firstN: () => $firstN
+});
+module.exports = __toCommonJS(firstN_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+var import_firstN = require("../../accumulator/firstN");
+const $firstN = (obj, expr, options) => {
+  if (obj instanceof Array)
+    return (0, import_firstN.$firstN)(obj, expr, options);
+  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input))
+    return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
+  return (0, import_firstN.$firstN)(input, { n, input: "$$this" }, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $firstN
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/in.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 in_exports = {};
+__export(in_exports, {
+  $in: () => $in
+});
+module.exports = __toCommonJS(in_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $in = (obj, expr, options) => {
+  const [item, arr] = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$in second argument must be an array");
+  return arr.some(import_util.isEqual.bind(null, item));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $in
+});

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

@@ -0,0 +1,63 @@
+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 array_exports = {};
+module.exports = __toCommonJS(array_exports);
+__reExport(array_exports, require("./arrayElemAt"), module.exports);
+__reExport(array_exports, require("./arrayToObject"), module.exports);
+__reExport(array_exports, require("./concatArrays"), module.exports);
+__reExport(array_exports, require("./filter"), module.exports);
+__reExport(array_exports, require("./first"), module.exports);
+__reExport(array_exports, require("./firstN"), module.exports);
+__reExport(array_exports, require("./in"), module.exports);
+__reExport(array_exports, require("./indexOfArray"), module.exports);
+__reExport(array_exports, require("./isArray"), module.exports);
+__reExport(array_exports, require("./last"), module.exports);
+__reExport(array_exports, require("./lastN"), module.exports);
+__reExport(array_exports, require("./map"), module.exports);
+__reExport(array_exports, require("./maxN"), module.exports);
+__reExport(array_exports, require("./minN"), module.exports);
+__reExport(array_exports, require("./nin"), module.exports);
+__reExport(array_exports, require("./range"), module.exports);
+__reExport(array_exports, require("./reduce"), module.exports);
+__reExport(array_exports, require("./reverseArray"), module.exports);
+__reExport(array_exports, require("./size"), module.exports);
+__reExport(array_exports, require("./slice"), module.exports);
+__reExport(array_exports, require("./sortArray"), module.exports);
+__reExport(array_exports, require("./zip"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./arrayElemAt"),
+  ...require("./arrayToObject"),
+  ...require("./concatArrays"),
+  ...require("./filter"),
+  ...require("./first"),
+  ...require("./firstN"),
+  ...require("./in"),
+  ...require("./indexOfArray"),
+  ...require("./isArray"),
+  ...require("./last"),
+  ...require("./lastN"),
+  ...require("./map"),
+  ...require("./maxN"),
+  ...require("./minN"),
+  ...require("./nin"),
+  ...require("./range"),
+  ...require("./reduce"),
+  ...require("./reverseArray"),
+  ...require("./size"),
+  ...require("./slice"),
+  ...require("./sortArray"),
+  ...require("./zip")
+});

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

@@ -0,0 +1,56 @@
+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 indexOfArray_exports = {};
+__export(indexOfArray_exports, {
+  $indexOfArray: () => $indexOfArray
+});
+module.exports = __toCommonJS(indexOfArray_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $indexOfArray = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args))
+    return null;
+  let arr = args[0];
+  const searchValue = args[1];
+  if ((0, import_util.isNil)(arr))
+    return null;
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$indexOfArray expression must resolve to an array.");
+  const start = args[2] || 0;
+  let end = args[3];
+  if ((0, import_util.isNil)(end))
+    end = arr.length;
+  if (start > end)
+    return -1;
+  (0, import_util.assert)(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
+  if (start > 0 || end < arr.length) {
+    arr = arr.slice(start, end);
+  }
+  let index = -1;
+  arr.some((v, i) => {
+    const b = (0, import_util.isEqual)(v, searchValue);
+    if (b)
+      index = i;
+    return b;
+  });
+  return index + start;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $indexOfArray
+});

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

@@ -0,0 +1,30 @@
+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 isArray_exports = {};
+__export(isArray_exports, {
+  $isArray: () => $isArray
+});
+module.exports = __toCommonJS(isArray_exports);
+var import_core = require("../../../core");
+const $isArray = (obj, expr, options) => {
+  return (0, import_core.computeValue)(obj, expr[0], null, options) instanceof Array;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $isArray
+});