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

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/stdDevPop.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 stdDevPop_exports = {};
+__export(stdDevPop_exports, {
+  $stdDevPop: () => $stdDevPop
+});
+module.exports = __toCommonJS(stdDevPop_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+var import_push = require("./push");
+const $stdDevPop = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), false);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $stdDevPop
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/stdDevSamp.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 stdDevSamp_exports = {};
+__export(stdDevSamp_exports, {
+  $stdDevSamp: () => $stdDevSamp
+});
+module.exports = __toCommonJS(stdDevSamp_exports);
+var import_util = require("../../util");
+var import_internal = require("./_internal");
+var import_push = require("./push");
+const $stdDevSamp = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $stdDevSamp
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/sum.js

@@ -0,0 +1,36 @@
+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 sum_exports = {};
+__export(sum_exports, {
+  $sum: () => $sum
+});
+module.exports = __toCommonJS(sum_exports);
+var import_util = require("../../util");
+var import_push = require("./push");
+const $sum = (collection, expr, options) => {
+  if (!(0, import_util.isArray)(collection))
+    return 0;
+  if ((0, import_util.isNumber)(expr))
+    return collection.length * expr;
+  const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);
+  return nums.reduce((acc, n) => acc + n, 0);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $sum
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/top.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 top_exports = {};
+__export(top_exports, {
+  $top: () => $top
+});
+module.exports = __toCommonJS(top_exports);
+var import_topN = require("./topN");
+const $top = (collection, expr, options) => (0, import_topN.$topN)(collection, { ...expr, n: 1 }, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $top
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/topN.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 topN_exports = {};
+__export(topN_exports, {
+  $topN: () => $topN
+});
+module.exports = __toCommonJS(topN_exports);
+var import_aggregator = require("../../aggregator");
+var import_core = require("../../core");
+var import_push = require("./push");
+const $topN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const { n, sortBy } = (0, import_core.computeValue)(
+    copts.local.groupId,
+    expr,
+    null,
+    copts
+  );
+  const result = new import_aggregator.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(
+    collection
+  );
+  return (0, import_push.$push)(result, expr.output, copts);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $topN
+});

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

@@ -0,0 +1,59 @@
+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, {
+  truncate: () => truncate
+});
+module.exports = __toCommonJS(internal_exports);
+function truncate(num, places = 0, roundOff = false) {
+  const sign = Math.abs(num) === num ? 1 : -1;
+  num = Math.abs(num);
+  let result = Math.trunc(num);
+  const decimals = parseFloat((num - result).toFixed(places + 1));
+  if (places === 0) {
+    const firstDigit = Math.trunc(10 * decimals);
+    if (roundOff && ((result & 1) === 1 && firstDigit >= 5 || firstDigit > 5)) {
+      result++;
+    }
+  } else if (places > 0) {
+    const offset = Math.pow(10, places);
+    let remainder = Math.trunc(decimals * offset);
+    const lastDigit = Math.trunc(decimals * offset * 10) % 10;
+    if (roundOff && lastDigit > 5) {
+      remainder += 1;
+    }
+    result = (result * offset + remainder) / offset;
+  } else if (places < 0) {
+    const offset = Math.pow(10, -1 * places);
+    let excess = result % offset;
+    result = Math.max(0, result - excess);
+    if (roundOff && sign === -1) {
+      while (excess > 10) {
+        excess -= excess % 10;
+      }
+      if (result > 0 && excess >= 5) {
+        result += offset;
+      }
+    }
+  }
+  return result * sign;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  truncate
+});

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

@@ -0,0 +1,32 @@
+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 abs_exports = {};
+__export(abs_exports, {
+  $abs: () => $abs
+});
+module.exports = __toCommonJS(abs_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $abs = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isNil)(n) ? null : Math.abs(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $abs
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/add.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 add_exports = {};
+__export(add_exports, {
+  $add: () => $add
+});
+module.exports = __toCommonJS(add_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $add = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  let foundDate = false;
+  const result = args.reduce((acc, val) => {
+    if ((0, import_util.isDate)(val)) {
+      (0, import_util.assert)(!foundDate, "'$add' can only have one date value");
+      foundDate = true;
+      val = val.getTime();
+    }
+    acc += val;
+    return acc;
+  }, 0);
+  return foundDate ? new Date(result) : result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $add
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/ceil.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 ceil_exports = {};
+__export(ceil_exports, {
+  $ceil: () => $ceil
+});
+module.exports = __toCommonJS(ceil_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $ceil = (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) || isNaN(n), "$ceil expression must resolve to a number.");
+  return Math.ceil(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $ceil
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/divide.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 divide_exports = {};
+__export(divide_exports, {
+  $divide: () => $divide
+});
+module.exports = __toCommonJS(divide_exports);
+var import_core = require("../../../core");
+const $divide = (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 = {
+  $divide
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/exp.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 exp_exports = {};
+__export(exp_exports, {
+  $exp: () => $exp
+});
+module.exports = __toCommonJS(exp_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $exp = (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) || isNaN(n), "$exp expression must resolve to a number.");
+  return Math.exp(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $exp
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/floor.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 floor_exports = {};
+__export(floor_exports, {
+  $floor: () => $floor
+});
+module.exports = __toCommonJS(floor_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $floor = (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) || isNaN(n),
+    "$floor expression must resolve to a number."
+  );
+  return Math.floor(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $floor
+});

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

@@ -0,0 +1,51 @@
+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 arithmetic_exports = {};
+module.exports = __toCommonJS(arithmetic_exports);
+__reExport(arithmetic_exports, require("./abs"), module.exports);
+__reExport(arithmetic_exports, require("./add"), module.exports);
+__reExport(arithmetic_exports, require("./ceil"), module.exports);
+__reExport(arithmetic_exports, require("./divide"), module.exports);
+__reExport(arithmetic_exports, require("./exp"), module.exports);
+__reExport(arithmetic_exports, require("./floor"), module.exports);
+__reExport(arithmetic_exports, require("./ln"), module.exports);
+__reExport(arithmetic_exports, require("./log"), module.exports);
+__reExport(arithmetic_exports, require("./log10"), module.exports);
+__reExport(arithmetic_exports, require("./mod"), module.exports);
+__reExport(arithmetic_exports, require("./multiply"), module.exports);
+__reExport(arithmetic_exports, require("./pow"), module.exports);
+__reExport(arithmetic_exports, require("./round"), module.exports);
+__reExport(arithmetic_exports, require("./sqrt"), module.exports);
+__reExport(arithmetic_exports, require("./subtract"), module.exports);
+__reExport(arithmetic_exports, require("./trunc"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./abs"),
+  ...require("./add"),
+  ...require("./ceil"),
+  ...require("./divide"),
+  ...require("./exp"),
+  ...require("./floor"),
+  ...require("./ln"),
+  ...require("./log"),
+  ...require("./log10"),
+  ...require("./mod"),
+  ...require("./multiply"),
+  ...require("./pow"),
+  ...require("./round"),
+  ...require("./sqrt"),
+  ...require("./subtract"),
+  ...require("./trunc")
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/ln.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 ln_exports = {};
+__export(ln_exports, {
+  $ln: () => $ln
+});
+module.exports = __toCommonJS(ln_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $ln = (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) || isNaN(n), "$ln expression must resolve to a number.");
+  return Math.log(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $ln
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/log.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 log_exports = {};
+__export(log_exports, {
+  $log: () => $log
+});
+module.exports = __toCommonJS(log_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $log = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const msg = "$log expression must resolve to array(2) of numbers";
+  (0, import_util.assert)((0, import_util.isArray)(args) && args.length === 2, msg);
+  if (args.some(import_util.isNil))
+    return null;
+  (0, import_util.assert)(args.some(isNaN) || args.every(import_util.isNumber), msg);
+  return Math.log10(args[0]) / Math.log10(args[1]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $log
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/log10.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 log10_exports = {};
+__export(log10_exports, {
+  $log10: () => $log10
+});
+module.exports = __toCommonJS(log10_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $log10 = (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) || isNaN(n),
+    "$log10 expression must resolve to a number."
+  );
+  return Math.log10(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $log10
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/arithmetic/mod.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 mod_exports = {};
+__export(mod_exports, {
+  $mod: () => $mod
+});
+module.exports = __toCommonJS(mod_exports);
+var import_core = require("../../../core");
+const $mod = (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 = {
+  $mod
+});