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

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/substr.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 substr_exports = {};
+__export(substr_exports, {
+  $substr: () => $substr
+});
+module.exports = __toCommonJS(substr_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $substr = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const s = args[0];
+  const index = args[1];
+  const count = args[2];
+  if ((0, import_util.isString)(s)) {
+    if (index < 0) {
+      return "";
+    } else if (count < 0) {
+      return s.substr(index);
+    } else {
+      return s.substr(index, count);
+    }
+  }
+  return "";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $substr
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/substrBytes.js

@@ -0,0 +1,70 @@
+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 substrBytes_exports = {};
+__export(substrBytes_exports, {
+  $substrBytes: () => $substrBytes
+});
+module.exports = __toCommonJS(substrBytes_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const UTF8_MASK = [192, 224, 240];
+function toUtf8(n) {
+  if (n < 128)
+    return [n];
+  let count = n < 2048 && 1 || n < 65536 && 2 || 3;
+  const offset = UTF8_MASK[count - 1];
+  const utf8 = [(n >> 6 * count) + offset];
+  while (count > 0)
+    utf8.push(128 | n >> 6 * --count & 63);
+  return utf8;
+}
+function utf8Encode(s) {
+  const buf = [];
+  for (let i = 0, len = s.length; i < len; i++) {
+    buf.push(toUtf8(s.codePointAt(i)));
+  }
+  return buf;
+}
+const $substrBytes = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const s = args[0];
+  const index = args[1];
+  const count = args[2];
+  (0, import_util.assert)(
+    (0, import_util.isString)(s) && (0, import_util.isNumber)(index) && index >= 0 && (0, import_util.isNumber)(count) && count >= 0,
+    "$substrBytes: invalid arguments"
+  );
+  const buf = utf8Encode(s);
+  const validIndex = [];
+  let acc = 0;
+  for (let i = 0; i < buf.length; i++) {
+    validIndex.push(acc);
+    acc += buf[i].length;
+  }
+  const begin = validIndex.indexOf(index);
+  const end = validIndex.indexOf(index + count);
+  (0, import_util.assert)(
+    begin > -1 && end > -1,
+    "$substrBytes: invalid range, start or end index is a UTF-8 continuation byte."
+  );
+  return s.substring(begin, end);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $substrBytes
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/substrCP.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 substrCP_exports = {};
+__export(substrCP_exports, {
+  $substrCP: () => $substrCP
+});
+module.exports = __toCommonJS(substrCP_exports);
+var import_substr = require("./substr");
+const $substrCP = (obj, expr, options) => {
+  return (0, import_substr.$substr)(obj, expr, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $substrCP
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/toLower.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 toLower_exports = {};
+__export(toLower_exports, {
+  $toLower: () => $toLower
+});
+module.exports = __toCommonJS(toLower_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $toLower = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isEmpty)(value) ? "" : value.toLowerCase();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $toLower
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/toUpper.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 toUpper_exports = {};
+__export(toUpper_exports, {
+  $toUpper: () => $toUpper
+});
+module.exports = __toCommonJS(toUpper_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $toUpper = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isEmpty)(value) ? "" : value.toUpperCase();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $toUpper
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/string/trim.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 trim_exports = {};
+__export(trim_exports, {
+  $trim: () => $trim
+});
+module.exports = __toCommonJS(trim_exports);
+var import_internal = require("./_internal");
+const $trim = (obj, expr, options) => {
+  return (0, import_internal.trimString)(obj, expr, options, { left: true, right: true });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $trim
+});

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

@@ -0,0 +1,52 @@
+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, {
+  createTrignometryOperator: () => createTrignometryOperator
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const FIXED_POINTS = {
+  undefined: null,
+  null: null,
+  NaN: NaN,
+  Infinity: new Error(),
+  "-Infinity": new Error()
+};
+function createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {
+  const fp = Object.assign({}, FIXED_POINTS, fixedPoints);
+  const keySet = new Set(Object.keys(fp));
+  return (obj, expr, options) => {
+    const n = (0, import_core.computeValue)(obj, expr, null, options);
+    if (keySet.has(`${n}`)) {
+      const res = fp[`${n}`];
+      if (res instanceof Error) {
+        throw new import_util.MingoError(
+          `cannot apply $${f.name} to -inf, value must in (-inf,inf)`
+        );
+      }
+      return res;
+    }
+    return f(n);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTrignometryOperator
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/acos.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 acos_exports = {};
+__export(acos_exports, {
+  $acos: () => $acos
+});
+module.exports = __toCommonJS(acos_exports);
+var import_internal = require("./_internal");
+const $acos = (0, import_internal.createTrignometryOperator)(Math.acos, {
+  Infinity: Infinity,
+  0: new Error()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $acos
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/acosh.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 acosh_exports = {};
+__export(acosh_exports, {
+  $acosh: () => $acosh
+});
+module.exports = __toCommonJS(acosh_exports);
+var import_internal = require("./_internal");
+const $acosh = (0, import_internal.createTrignometryOperator)(Math.acosh, {
+  Infinity: Infinity,
+  0: new Error()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $acosh
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/asin.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 asin_exports = {};
+__export(asin_exports, {
+  $asin: () => $asin
+});
+module.exports = __toCommonJS(asin_exports);
+var import_internal = require("./_internal");
+const $asin = (0, import_internal.createTrignometryOperator)(Math.asin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $asin
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/asinh.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 asinh_exports = {};
+__export(asinh_exports, {
+  $asinh: () => $asinh
+});
+module.exports = __toCommonJS(asinh_exports);
+var import_internal = require("./_internal");
+const $asinh = (0, import_internal.createTrignometryOperator)(Math.asinh, {
+  Infinity: Infinity,
+  "-Infinity": -Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $asinh
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/atan.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 atan_exports = {};
+__export(atan_exports, {
+  $atan: () => $atan
+});
+module.exports = __toCommonJS(atan_exports);
+var import_internal = require("./_internal");
+const $atan = (0, import_internal.createTrignometryOperator)(Math.atan);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $atan
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/atan2.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 atan2_exports = {};
+__export(atan2_exports, {
+  $atan2: () => $atan2
+});
+module.exports = __toCommonJS(atan2_exports);
+var import_core = require("../../../core");
+var import_util = require("../../../util");
+const $atan2 = (obj, expr, options) => {
+  const [y, x] = (0, import_core.computeValue)(obj, expr, null, options);
+  if (isNaN(y) || (0, import_util.isNil)(y))
+    return y;
+  if (isNaN(x) || (0, import_util.isNil)(x))
+    return x;
+  return Math.atan2(y, x);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $atan2
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/atanh.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 atanh_exports = {};
+__export(atanh_exports, {
+  $atanh: () => $atanh
+});
+module.exports = __toCommonJS(atanh_exports);
+var import_internal = require("./_internal");
+const $atanh = (0, import_internal.createTrignometryOperator)(Math.atanh, {
+  1: Infinity,
+  "-1": -Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $atanh
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/cos.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 cos_exports = {};
+__export(cos_exports, {
+  $cos: () => $cos
+});
+module.exports = __toCommonJS(cos_exports);
+var import_internal = require("./_internal");
+const $cos = (0, import_internal.createTrignometryOperator)(Math.cos);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $cos
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/cosh.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 cosh_exports = {};
+__export(cosh_exports, {
+  $cosh: () => $cosh
+});
+module.exports = __toCommonJS(cosh_exports);
+var import_internal = require("./_internal");
+const $cosh = (0, import_internal.createTrignometryOperator)(Math.cosh, {
+  "-Infinity": Infinity,
+  Infinity: Infinity
+  // [Math.PI]: -1,
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $cosh
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/degreesToRadians.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 degreesToRadians_exports = {};
+__export(degreesToRadians_exports, {
+  $degreesToRadians: () => $degreesToRadians
+});
+module.exports = __toCommonJS(degreesToRadians_exports);
+var import_internal = require("./_internal");
+const RADIANS_FACTOR = Math.PI / 180;
+const $degreesToRadians = (0, import_internal.createTrignometryOperator)(
+  (n) => n * RADIANS_FACTOR,
+  {
+    Infinity: Infinity,
+    "-Infinity": Infinity
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $degreesToRadians
+});

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/trignometry/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 trignometry_exports = {};
+module.exports = __toCommonJS(trignometry_exports);
+__reExport(trignometry_exports, require("./acos"), module.exports);
+__reExport(trignometry_exports, require("./acosh"), module.exports);
+__reExport(trignometry_exports, require("./asin"), module.exports);
+__reExport(trignometry_exports, require("./asinh"), module.exports);
+__reExport(trignometry_exports, require("./atan"), module.exports);
+__reExport(trignometry_exports, require("./atan2"), module.exports);
+__reExport(trignometry_exports, require("./atanh"), module.exports);
+__reExport(trignometry_exports, require("./cos"), module.exports);
+__reExport(trignometry_exports, require("./cosh"), module.exports);
+__reExport(trignometry_exports, require("./degreesToRadians"), module.exports);
+__reExport(trignometry_exports, require("./radiansToDegrees"), module.exports);
+__reExport(trignometry_exports, require("./sin"), module.exports);
+__reExport(trignometry_exports, require("./sinh"), module.exports);
+__reExport(trignometry_exports, require("./tan"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./acos"),
+  ...require("./acosh"),
+  ...require("./asin"),
+  ...require("./asinh"),
+  ...require("./atan"),
+  ...require("./atan2"),
+  ...require("./atanh"),
+  ...require("./cos"),
+  ...require("./cosh"),
+  ...require("./degreesToRadians"),
+  ...require("./radiansToDegrees"),
+  ...require("./sin"),
+  ...require("./sinh"),
+  ...require("./tan")
+});