@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.3-rc0

package/rust-client/node_modules/mingo/dist/cjs/core.js

@@ -1,363 +0,0 @@
-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 core_exports = {};
-__export(core_exports, {
-  ComputeOptions: () => ComputeOptions,
-  Context: () => Context,
-  OperatorType: () => OperatorType,
-  ProcessingMode: () => ProcessingMode,
-  computeValue: () => computeValue,
-  getOperator: () => getOperator,
-  initOptions: () => initOptions,
-  redact: () => redact,
-  useOperators: () => useOperators
-});
-module.exports = __toCommonJS(core_exports);
-var import_util = require("./util");
-var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
-  ProcessingMode2[ProcessingMode2["CLONE_OFF"] = 0] = "CLONE_OFF";
-  ProcessingMode2[ProcessingMode2["CLONE_INPUT"] = 1] = "CLONE_INPUT";
-  ProcessingMode2[ProcessingMode2["CLONE_OUTPUT"] = 2] = "CLONE_OUTPUT";
-  ProcessingMode2[ProcessingMode2["CLONE_ALL"] = 3] = "CLONE_ALL";
-  return ProcessingMode2;
-})(ProcessingMode || {});
-class ComputeOptions {
-  #options;
-  /** Reference to the root object when processing subgraphs of the object. */
-  #root;
-  #local;
-  constructor(options, root, local) {
-    this.#options = options;
-    this.update(root, local);
-  }
-  /**
-   * Initialize new ComputeOptions.
-   * @returns {ComputeOptions}
-   */
-  static init(options, root, local) {
-    return !(options instanceof ComputeOptions) ? new ComputeOptions(options, root, local) : new ComputeOptions(options.#options, options.root ?? root, {
-      ...options.#local,
-      ...local,
-      variables: Object.assign(
-        {},
-        options.#local?.variables,
-        local?.variables
-      )
-    });
-  }
-  /**
-   * Updates the internal state.
-   *
-   * @param root The new root context for this object.
-   * @param local The new local state to merge into current if it exists.
-   * @returns
-   */
-  update(root, local) {
-    this.#root = root;
-    const variables = Object.assign(
-      {},
-      this.#local?.variables,
-      local?.variables
-    );
-    if (Object.keys(variables).length) {
-      this.#local = { ...local, variables };
-    } else {
-      this.#local = local ?? {};
-    }
-    return this;
-  }
-  getOptions() {
-    return Object.freeze({
-      ...this.#options,
-      context: Context.from(this.#options.context)
-    });
-  }
-  get root() {
-    return this.#root;
-  }
-  get local() {
-    return this.#local;
-  }
-  get idKey() {
-    return this.#options.idKey;
-  }
-  get collation() {
-    return this.#options?.collation;
-  }
-  get processingMode() {
-    return this.#options?.processingMode || 0 /* CLONE_OFF */;
-  }
-  get useStrictMode() {
-    return this.#options?.useStrictMode;
-  }
-  get scriptEnabled() {
-    return this.#options?.scriptEnabled;
-  }
-  get useGlobalContext() {
-    return this.#options?.useGlobalContext;
-  }
-  get hashFunction() {
-    return this.#options?.hashFunction;
-  }
-  get collectionResolver() {
-    return this.#options?.collectionResolver;
-  }
-  get jsonSchemaValidator() {
-    return this.#options?.jsonSchemaValidator;
-  }
-  get variables() {
-    return this.#options?.variables;
-  }
-  get context() {
-    return this.#options?.context;
-  }
-}
-function initOptions(options) {
-  return options instanceof ComputeOptions ? options.getOptions() : Object.freeze({
-    idKey: "_id",
-    scriptEnabled: true,
-    useStrictMode: true,
-    useGlobalContext: true,
-    processingMode: 0 /* CLONE_OFF */,
-    ...options,
-    context: options?.context ? Context.from(options?.context) : Context.init()
-  });
-}
-var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
-  OperatorType2["ACCUMULATOR"] = "accumulator";
-  OperatorType2["EXPRESSION"] = "expression";
-  OperatorType2["PIPELINE"] = "pipeline";
-  OperatorType2["PROJECTION"] = "projection";
-  OperatorType2["QUERY"] = "query";
-  OperatorType2["WINDOW"] = "window";
-  return OperatorType2;
-})(OperatorType || {});
-class Context {
-  #operators = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  static init() {
-    return new Context();
-  }
-  static from(ctx) {
-    const instance = Context.init();
-    if ((0, import_util.isNil)(ctx)) return instance;
-    ctx.#operators.forEach((v, k) => instance.addOperators(k, v));
-    return instance;
-  }
-  addOperators(type, operators) {
-    if (!this.#operators.has(type)) this.#operators.set(type, {});
-    for (const [name, fn] of Object.entries(operators)) {
-      if (!this.getOperator(type, name)) {
-        this.#operators.get(type)[name] = fn;
-      }
-    }
-    return this;
-  }
-  getOperator(type, name) {
-    const ops = this.#operators.get(type) ?? {};
-    return ops[name] ?? null;
-  }
-  addAccumulatorOps(ops) {
-    return this.addOperators("accumulator", ops);
-  }
-  addExpressionOps(ops) {
-    return this.addOperators("expression", ops);
-  }
-  addQueryOps(ops) {
-    return this.addOperators("query", ops);
-  }
-  addPipelineOps(ops) {
-    return this.addOperators("pipeline", ops);
-  }
-  addProjectionOps(ops) {
-    return this.addOperators("projection", ops);
-  }
-  addWindowOps(ops) {
-    return this.addOperators("window", ops);
-  }
-}
-const GLOBAL_CONTEXT = Context.init();
-function useOperators(type, operators) {
-  for (const [name, fn] of Object.entries(operators)) {
-    (0, import_util.assert)(
-      (0, import_util.isFunction)(fn) && (0, import_util.isOperator)(name),
-      `'${name}' is not a valid operator`
-    );
-    const currentFn = getOperator(type, name, null);
-    (0, import_util.assert)(
-      !currentFn || fn === currentFn,
-      `${name} already exists for '${type}' operators. Cannot change operator function once registered.`
-    );
-  }
-  switch (type) {
-    case "accumulator":
-      GLOBAL_CONTEXT.addAccumulatorOps(operators);
-      break;
-    case "expression":
-      GLOBAL_CONTEXT.addExpressionOps(operators);
-      break;
-    case "pipeline":
-      GLOBAL_CONTEXT.addPipelineOps(operators);
-      break;
-    case "projection":
-      GLOBAL_CONTEXT.addProjectionOps(operators);
-      break;
-    case "query":
-      GLOBAL_CONTEXT.addQueryOps(operators);
-      break;
-    case "window":
-      GLOBAL_CONTEXT.addWindowOps(operators);
-      break;
-  }
-}
-function getOperator(type, name, options) {
-  const { context: ctx, useGlobalContext: fallback } = options || {};
-  const fn = ctx ? ctx.getOperator(type, name) : null;
-  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, name) : fn;
-}
-function computeValue(obj, expr, operator, options) {
-  const copts = ComputeOptions.init(options, obj);
-  return !!operator && (0, import_util.isOperator)(operator) ? computeOperator(obj, expr, operator, copts) : computeExpression(obj, expr, copts);
-}
-const SYSTEM_VARS = ["$$ROOT", "$$CURRENT", "$$REMOVE", "$$NOW"];
-function computeExpression(obj, expr, options) {
-  if ((0, import_util.isString)(expr) && expr.length > 0 && expr[0] === "$") {
-    if (REDACT_ACTIONS.includes(expr)) return expr;
-    let ctx = options.root;
-    const arr = expr.split(".");
-    if (SYSTEM_VARS.includes(arr[0])) {
-      switch (arr[0]) {
-        case "$$ROOT":
-          break;
-        case "$$CURRENT":
-          ctx = obj;
-          break;
-        case "$$REMOVE":
-          ctx = void 0;
-          break;
-        case "$$NOW":
-          ctx = /* @__PURE__ */ new Date();
-          break;
-      }
-      expr = expr.slice(arr[0].length + 1);
-    } else if (arr[0].slice(0, 2) === "$$") {
-      ctx = Object.assign(
-        {},
-        // global vars
-        options.variables,
-        // current item is added before local variables because the binding may be changed.
-        { this: obj },
-        // local vars
-        options?.local?.variables
-      );
-      const name = arr[0].slice(2);
-      (0, import_util.assert)((0, import_util.has)(ctx, name), `Use of undefined variable: ${name}`);
-      expr = expr.slice(2);
-    } else {
-      expr = expr.slice(1);
-    }
-    return expr === "" ? ctx : (0, import_util.resolve)(ctx, expr);
-  }
-  if ((0, import_util.isArray)(expr)) {
-    return expr.map((item) => computeExpression(obj, item, options));
-  }
-  if ((0, import_util.isObject)(expr)) {
-    const result = {};
-    const elems = Object.entries(expr);
-    for (const [key, val] of elems) {
-      if ((0, import_util.isOperator)(key)) {
-        (0, import_util.assert)(elems.length == 1, "expression must have single operator.");
-        return computeOperator(obj, val, key, options);
-      }
-      result[key] = computeExpression(obj, val, options);
-    }
-    return result;
-  }
-  return expr;
-}
-function computeOperator(obj, expr, operator, options) {
-  const callExpression = getOperator(
-    "expression",
-    operator,
-    options
-  );
-  if (callExpression) return callExpression(obj, expr, options);
-  const callAccumulator = getOperator(
-    "accumulator",
-    operator,
-    options
-  );
-  (0, import_util.assert)(!!callAccumulator, `accumulator '${operator}' is not registered.`);
-  if (!(0, import_util.isArray)(obj)) {
-    obj = computeExpression(obj, expr, options);
-    expr = null;
-  }
-  (0, import_util.assert)((0, import_util.isArray)(obj), `arguments must resolve to array for ${operator}.`);
-  return callAccumulator(obj, expr, options);
-}
-const REDACT_ACTIONS = ["$$KEEP", "$$PRUNE", "$$DESCEND"];
-function redact(obj, expr, options) {
-  const action = computeValue(obj, expr, null, options);
-  switch (action) {
-    case "$$KEEP":
-      return obj;
-    case "$$PRUNE":
-      return void 0;
-    case "$$DESCEND": {
-      if (!(0, import_util.has)(expr, "$cond")) return obj;
-      const output = {};
-      for (const [key, value] of Object.entries(obj)) {
-        if ((0, import_util.isArray)(value)) {
-          const res = new Array();
-          for (let elem of value) {
-            if ((0, import_util.isObject)(elem)) {
-              elem = redact(elem, expr, options.update(elem));
-            }
-            if (!(0, import_util.isNil)(elem)) res.push(elem);
-          }
-          output[key] = res;
-        } else if ((0, import_util.isObject)(value)) {
-          const res = redact(
-            value,
-            expr,
-            options.update(value)
-          );
-          if (!(0, import_util.isNil)(res)) output[key] = res;
-        } else {
-          output[key] = value;
-        }
-      }
-      return output;
-    }
-    default:
-      return action;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ComputeOptions,
-  Context,
-  OperatorType,
-  ProcessingMode,
-  computeValue,
-  getOperator,
-  initOptions,
-  redact,
-  useOperators
-});

package/rust-client/node_modules/mingo/dist/cjs/cursor.js

@@ -1,166 +0,0 @@
-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 cursor_exports = {};
-__export(cursor_exports, {
-  Cursor: () => Cursor
-});
-module.exports = __toCommonJS(cursor_exports);
-var import_core = require("./core");
-var import_lazy = require("./lazy");
-var import_limit = require("./operators/pipeline/limit");
-var import_project = require("./operators/pipeline/project");
-var import_skip = require("./operators/pipeline/skip");
-var import_sort = require("./operators/pipeline/sort");
-var import_util = require("./util");
-const OPERATORS = { $sort: import_sort.$sort, $skip: import_skip.$skip, $limit: import_limit.$limit };
-class Cursor {
-  #source;
-  #predicate;
-  #projection;
-  #options;
-  #operators = {};
-  #result = null;
-  #buffer = [];
-  constructor(source, predicate, projection, options) {
-    this.#source = source;
-    this.#predicate = predicate;
-    this.#projection = projection;
-    this.#options = options;
-  }
-  /** Returns the iterator from running the query */
-  fetch() {
-    if (this.#result) return this.#result;
-    this.#result = (0, import_lazy.Lazy)(this.#source).filter(this.#predicate);
-    const mode = this.#options.processingMode;
-    if (mode & import_core.ProcessingMode.CLONE_INPUT) this.#result.map(import_util.cloneDeep);
-    for (const op of ["$sort", "$skip", "$limit"]) {
-      if ((0, import_util.has)(this.#operators, op)) {
-        this.#result = OPERATORS[op](
-          this.#result,
-          this.#operators[op],
-          this.#options
-        );
-      }
-    }
-    if (Object.keys(this.#projection).length) {
-      this.#result = (0, import_project.$project)(this.#result, this.#projection, this.#options);
-    }
-    if (mode & import_core.ProcessingMode.CLONE_OUTPUT) this.#result.map(import_util.cloneDeep);
-    return this.#result;
-  }
-  /** Returns an iterator with the buffered data included */
-  fetchAll() {
-    const buffered = (0, import_lazy.Lazy)([...this.#buffer]);
-    this.#buffer = [];
-    return (0, import_lazy.concat)(buffered, this.fetch());
-  }
-  /**
-   * Return remaining objects in the cursor as an array. This method exhausts the cursor
-   * @returns {Array}
-   */
-  all() {
-    return this.fetchAll().value();
-  }
-  /**
-   * Returns the number of objects return in the cursor. This method exhausts the cursor
-   * @returns {Number}
-   */
-  count() {
-    return this.all().length;
-  }
-  /**
-   * Returns a cursor that begins returning results only after passing or skipping a number of documents.
-   * @param {Number} n the number of results to skip.
-   * @return {Cursor} Returns the cursor, so you can chain this call.
-   */
-  skip(n) {
-    this.#operators["$skip"] = n;
-    return this;
-  }
-  /**
-   * Constrains the size of a cursor's result set.
-   * @param {Number} n the number of results to limit to.
-   * @return {Cursor} Returns the cursor, so you can chain this call.
-   */
-  limit(n) {
-    this.#operators["$limit"] = n;
-    return this;
-  }
-  /**
-   * Returns results ordered according to a sort specification.
-   * @param {AnyObject} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
-   * @return {Cursor} Returns the cursor, so you can chain this call.
-   */
-  sort(modifier) {
-    this.#operators["$sort"] = modifier;
-    return this;
-  }
-  /**
-   * Specifies the collation for the cursor returned by the `mingo.Query.find`
-   * @param {*} spec
-   */
-  collation(spec) {
-    this.#options = { ...this.#options, collation: spec };
-    return this;
-  }
-  /**
-   * Returns the next document in a cursor.
-   * @returns {AnyObject | Boolean}
-   */
-  next() {
-    if (this.#buffer.length > 0) {
-      return this.#buffer.pop();
-    }
-    const o = this.fetch().next();
-    if (o.done) return;
-    return o.value;
-  }
-  /**
-   * Returns true if the cursor has documents and can be iterated.
-   * @returns {boolean}
-   */
-  hasNext() {
-    if (this.#buffer.length > 0) return true;
-    const o = this.fetch().next();
-    if (o.done) return false;
-    this.#buffer.push(o.value);
-    return true;
-  }
-  /**
-   * Applies a function to each document in a cursor and collects the return values in an array.
-   * @param fn
-   * @returns {Array}
-   */
-  map(fn) {
-    return this.all().map(fn);
-  }
-  /**
-   * Applies a JavaScript function for every document in a cursor.
-   * @param fn
-   */
-  forEach(fn) {
-    this.all().forEach(fn);
-  }
-  [Symbol.iterator]() {
-    return this.fetchAll();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Cursor
-});

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

@@ -1,64 +0,0 @@
-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 index_exports = {};
-__export(index_exports, {
-  Aggregator: () => import_aggregator2.Aggregator,
-  Query: () => import_query2.Query,
-  aggregate: () => aggregate,
-  createUpdater: () => import_updater2.createUpdater,
-  default: () => index_default,
-  find: () => find,
-  remove: () => remove,
-  update: () => import_updater2.update
-});
-module.exports = __toCommonJS(index_exports);
-var import_basic = require("./init/basic");
-var import_aggregator = require("./aggregator");
-var import_query = require("./query");
-var import_updater = require("./updater");
-var import_aggregator2 = require("./aggregator");
-var import_query2 = require("./query");
-var import_updater2 = require("./updater");
-function find(collection, criteria, projection, options) {
-  return new import_query.Query(criteria, options).find(collection, projection);
-}
-function remove(collection, criteria, options) {
-  return new import_query.Query(criteria, options).remove(collection);
-}
-function aggregate(collection, pipeline, options) {
-  return new import_aggregator.Aggregator(pipeline, options).run(collection);
-}
-var index_default = {
-  Aggregator: import_aggregator.Aggregator,
-  Query: import_query.Query,
-  aggregate,
-  createUpdater: import_updater.createUpdater,
-  find,
-  remove,
-  update: import_updater.update
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Aggregator,
-  Query,
-  aggregate,
-  createUpdater,
-  find,
-  remove,
-  update
-});

package/rust-client/node_modules/mingo/dist/cjs/init/basic.js

@@ -1,40 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var import_core = require("../core");
-var booleanOperators = __toESM(require("../operators/expression/boolean"));
-var comparisonOperators = __toESM(require("../operators/expression/comparison"));
-var import_pipeline = require("../operators/pipeline");
-var projectionOperators = __toESM(require("../operators/projection"));
-var queryOperators = __toESM(require("../operators/query"));
-(0, import_core.useOperators)("expression", {
-  ...booleanOperators,
-  ...comparisonOperators
-});
-(0, import_core.useOperators)("pipeline", {
-  $project: import_pipeline.$project,
-  $skip: import_pipeline.$skip,
-  $limit: import_pipeline.$limit,
-  $sort: import_pipeline.$sort
-});
-(0, import_core.useOperators)("projection", projectionOperators);
-(0, import_core.useOperators)("query", queryOperators);

package/rust-client/node_modules/mingo/dist/cjs/init/system.js

@@ -1,35 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var import_core = require("../core");
-var accumulatorOperators = __toESM(require("../operators/accumulator"));
-var expressionOperators = __toESM(require("../operators/expression"));
-var pipelineOperators = __toESM(require("../operators/pipeline"));
-var projectionOperators = __toESM(require("../operators/projection"));
-var queryOperators = __toESM(require("../operators/query"));
-var windowOperators = __toESM(require("../operators/window"));
-(0, import_core.useOperators)("accumulator", accumulatorOperators);
-(0, import_core.useOperators)("expression", expressionOperators);
-(0, import_core.useOperators)("pipeline", pipelineOperators);
-(0, import_core.useOperators)("projection", projectionOperators);
-(0, import_core.useOperators)("query", queryOperators);
-(0, import_core.useOperators)("window", windowOperators);