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

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

@@ -0,0 +1,384 @@
+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["CLONE_ALL"] = "CLONE_ALL";
+  ProcessingMode2["CLONE_INPUT"] = "CLONE_INPUT";
+  ProcessingMode2["CLONE_OUTPUT"] = "CLONE_OUTPUT";
+  ProcessingMode2["CLONE_OFF"] = "CLONE_OFF";
+  return ProcessingMode2;
+})(ProcessingMode || {});
+class ComputeOptions {
+  constructor(_opts, _root, _local, timestamp = Date.now()) {
+    this._opts = _opts;
+    this._root = _root;
+    this._local = _local;
+    this.timestamp = timestamp;
+    this.update(_root, _local);
+  }
+  /**
+   * Initialize new ComputeOptions.
+   *
+   * @param options
+   * @param root
+   * @param local
+   * @returns {ComputeOptions}
+   */
+  static init(options, root, local) {
+    return options instanceof ComputeOptions ? new ComputeOptions(
+      options._opts,
+      (0, import_util.isNil)(options.root) ? root : options.root,
+      Object.assign({}, options.local, local)
+    ) : new ComputeOptions(options, root, local);
+  }
+  /** Updates the internal mutable state. */
+  update(root, local) {
+    this._root = root;
+    this._local = local ? Object.assign({}, local, {
+      variables: Object.assign({}, this._local?.variables, local?.variables)
+    }) : local;
+    return this;
+  }
+  getOptions() {
+    return Object.freeze({
+      ...this._opts,
+      context: Context.from(this._opts.context)
+    });
+  }
+  get root() {
+    return this._root;
+  }
+  get local() {
+    return this._local;
+  }
+  get idKey() {
+    return this._opts.idKey;
+  }
+  get collation() {
+    return this._opts?.collation;
+  }
+  get processingMode() {
+    return this._opts?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+  }
+  get useStrictMode() {
+    return this._opts?.useStrictMode;
+  }
+  get scriptEnabled() {
+    return this._opts?.scriptEnabled;
+  }
+  get useGlobalContext() {
+    return this._opts?.useGlobalContext;
+  }
+  get hashFunction() {
+    return this._opts?.hashFunction;
+  }
+  get collectionResolver() {
+    return this._opts?.collectionResolver;
+  }
+  get jsonSchemaValidator() {
+    return this._opts?.jsonSchemaValidator;
+  }
+  get variables() {
+    return this._opts?.variables;
+  }
+  get context() {
+    return this._opts?.context;
+  }
+}
+function initOptions(options) {
+  return options instanceof ComputeOptions ? options.getOptions() : Object.freeze({
+    idKey: "_id",
+    scriptEnabled: true,
+    useStrictMode: true,
+    useGlobalContext: true,
+    processingMode: "CLONE_OFF" /* 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 {
+  constructor(ops) {
+    this.operators = {
+      ["accumulator" /* ACCUMULATOR */]: {},
+      ["expression" /* EXPRESSION */]: {},
+      ["pipeline" /* PIPELINE */]: {},
+      ["projection" /* PROJECTION */]: {},
+      ["query" /* QUERY */]: {},
+      ["window" /* WINDOW */]: {}
+    };
+    for (const [type, operators] of Object.entries(ops)) {
+      this.addOperators(type, operators);
+    }
+  }
+  static init(ops = {}) {
+    return new Context(ops);
+  }
+  static from(ctx) {
+    return new Context(ctx.operators);
+  }
+  addOperators(type, ops) {
+    for (const [name, fn] of Object.entries(ops)) {
+      if (!this.getOperator(type, name)) {
+        this.operators[type][name] = fn;
+      }
+    }
+    return this;
+  }
+  // register
+  addAccumulatorOps(ops) {
+    return this.addOperators("accumulator" /* ACCUMULATOR */, ops);
+  }
+  addExpressionOps(ops) {
+    return this.addOperators("expression" /* EXPRESSION */, ops);
+  }
+  addQueryOps(ops) {
+    return this.addOperators("query" /* QUERY */, ops);
+  }
+  addPipelineOps(ops) {
+    return this.addOperators("pipeline" /* PIPELINE */, ops);
+  }
+  addProjectionOps(ops) {
+    return this.addOperators("projection" /* PROJECTION */, ops);
+  }
+  addWindowOps(ops) {
+    return this.addOperators("window" /* WINDOW */, ops);
+  }
+  // getters
+  getOperator(type, name) {
+    return type in this.operators ? this.operators[type][name] || null : null;
+  }
+}
+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" /* ACCUMULATOR */:
+      GLOBAL_CONTEXT.addAccumulatorOps(operators);
+      break;
+    case "expression" /* EXPRESSION */:
+      GLOBAL_CONTEXT.addExpressionOps(operators);
+      break;
+    case "pipeline" /* PIPELINE */:
+      GLOBAL_CONTEXT.addPipelineOps(operators);
+      break;
+    case "projection" /* PROJECTION */:
+      GLOBAL_CONTEXT.addProjectionOps(operators);
+      break;
+    case "query" /* QUERY */:
+      GLOBAL_CONTEXT.addQueryOps(operators);
+      break;
+    case "window" /* WINDOW */:
+      GLOBAL_CONTEXT.addWindowOps(operators);
+      break;
+  }
+}
+function getOperator(type, operator, options) {
+  const { context: ctx, useGlobalContext: fallback } = options || {};
+  const fn = ctx ? ctx.getOperator(type, operator) : null;
+  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, operator) : fn;
+}
+const systemVariables = {
+  $$ROOT(_obj, _expr, options) {
+    return options.root;
+  },
+  $$CURRENT(obj, _expr, _options) {
+    return obj;
+  },
+  $$REMOVE(_obj, _expr, _options) {
+    return void 0;
+  },
+  $$NOW(_obj, _expr, options) {
+    return new Date(options.timestamp);
+  }
+};
+const redactVariables = {
+  $$KEEP(obj, _expr, _options) {
+    return obj;
+  },
+  $$PRUNE(_obj, _expr, _options) {
+    return void 0;
+  },
+  $$DESCEND(obj, expr, options) {
+    if (!(0, import_util.has)(expr, "$cond"))
+      return obj;
+    let result;
+    for (const [key, current] of Object.entries(obj)) {
+      if ((0, import_util.isObjectLike)(current)) {
+        if (current instanceof Array) {
+          const array = [];
+          for (let elem of current) {
+            if ((0, import_util.isObject)(elem)) {
+              elem = redact(elem, expr, options.update(elem));
+            }
+            if (!(0, import_util.isNil)(elem)) {
+              array.push(elem);
+            }
+          }
+          result = array;
+        } else {
+          result = redact(
+            current,
+            expr,
+            options.update(current)
+          );
+        }
+        if ((0, import_util.isNil)(result)) {
+          delete obj[key];
+        } else {
+          obj[key] = result;
+        }
+      }
+    }
+    return obj;
+  }
+};
+function computeValue(obj, expr, operator, options) {
+  const copts = ComputeOptions.init(options, obj);
+  operator = operator || "";
+  if ((0, import_util.isOperator)(operator)) {
+    const callExpression = getOperator(
+      "expression" /* EXPRESSION */,
+      operator,
+      options
+    );
+    if (callExpression)
+      return callExpression(obj, expr, copts);
+    const callAccumulator = getOperator(
+      "accumulator" /* ACCUMULATOR */,
+      operator,
+      options
+    );
+    if (callAccumulator) {
+      if (!(obj instanceof Array)) {
+        obj = computeValue(obj, expr, null, copts);
+        expr = null;
+      }
+      (0, import_util.assert)(obj instanceof Array, `'${operator}' target must be an array.`);
+      return callAccumulator(
+        obj,
+        expr,
+        // reset the root object for accumulators.
+        copts.update(null, copts.local)
+      );
+    }
+    throw new import_util.MingoError(`operator '${operator}' is not registered`);
+  }
+  if ((0, import_util.isString)(expr) && expr.length > 0 && expr[0] === "$") {
+    if ((0, import_util.has)(redactVariables, expr)) {
+      return expr;
+    }
+    let context = copts.root;
+    const arr = expr.split(".");
+    if ((0, import_util.has)(systemVariables, arr[0])) {
+      context = systemVariables[arr[0]](
+        obj,
+        null,
+        copts
+      );
+      expr = expr.slice(arr[0].length + 1);
+    } else if (arr[0].slice(0, 2) === "$$") {
+      context = Object.assign(
+        {},
+        copts.variables,
+        // global vars
+        // current item is added before local variables because the binding may be changed.
+        { this: obj },
+        copts.local?.variables
+        // local vars
+      );
+      const prefix = arr[0].slice(2);
+      (0, import_util.assert)(
+        (0, import_util.has)(context, prefix),
+        `Use of undefined variable: ${prefix}`
+      );
+      expr = expr.slice(2);
+    } else {
+      expr = expr.slice(1);
+    }
+    if (expr === "")
+      return context;
+    return (0, import_util.resolve)(context, expr);
+  }
+  if ((0, import_util.isArray)(expr)) {
+    return expr.map((item) => computeValue(obj, item, null, copts));
+  } else if ((0, import_util.isObject)(expr)) {
+    const result = {};
+    for (const [key, val] of Object.entries(expr)) {
+      result[key] = computeValue(obj, val, key, copts);
+      if (["expression" /* EXPRESSION */, "accumulator" /* ACCUMULATOR */].some(
+        (t) => !!getOperator(t, key, options)
+      )) {
+        (0, import_util.assert)(
+          Object.keys(expr).length === 1,
+          "Invalid aggregation expression '" + JSON.stringify(expr) + "'"
+        );
+        return result[key];
+      }
+    }
+    return result;
+  }
+  return expr;
+}
+function redact(obj, expr, options) {
+  const result = computeValue(obj, expr, null, options);
+  return (0, import_util.has)(redactVariables, result) ? redactVariables[result](obj, expr, options) : result;
+}
+// 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

@@ -0,0 +1,154 @@
+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_aggregator = require("./aggregator");
+var import_lazy = require("./lazy");
+var import_util = require("./util");
+class Cursor {
+  constructor(source, predicate, projection, options) {
+    this.source = source;
+    this.predicate = predicate;
+    this.projection = projection;
+    this.options = options;
+    this.operators = [];
+    this.result = null;
+    this.buffer = [];
+  }
+  /** Returns the iterator from running the query */
+  fetch() {
+    if (this.result)
+      return this.result;
+    if ((0, import_util.isObject)(this.projection)) {
+      this.operators.push({ $project: this.projection });
+    }
+    this.result = (0, import_lazy.Lazy)(this.source).filter(this.predicate);
+    if (this.operators.length > 0) {
+      this.result = new import_aggregator.Aggregator(this.operators, this.options).stream(
+        this.result
+      );
+    }
+    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.compose)(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.push({ $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.push({ $limit: n });
+    return this;
+  }
+  /**
+   * Returns results ordered according to a sort specification.
+   * @param {Object} 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.push({ $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 {Object | 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

@@ -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 src_exports = {};
+__export(src_exports, {
+  Aggregator: () => import_aggregator2.Aggregator,
+  Query: () => import_query2.Query,
+  aggregate: () => aggregate,
+  default: () => src_default,
+  find: () => find,
+  remove: () => remove
+});
+module.exports = __toCommonJS(src_exports);
+var import_basic = require("./init/basic");
+var import_aggregator = require("./aggregator");
+var import_query = require("./query");
+var import_aggregator2 = require("./aggregator");
+var import_query2 = require("./query");
+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 src_default = {
+  Aggregator: import_aggregator.Aggregator,
+  Query: import_query.Query,
+  aggregate,
+  find,
+  remove
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Aggregator,
+  Query,
+  aggregate,
+  find,
+  remove
+});

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

@@ -0,0 +1,58 @@
+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 __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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_exports = {};
+__export(basic_exports, {
+  BASIC_CONTEXT: () => BASIC_CONTEXT
+});
+module.exports = __toCommonJS(basic_exports);
+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)(import_core.OperatorType.EXPRESSION, {
+  ...booleanOperators,
+  ...comparisonOperators
+});
+(0, import_core.useOperators)(import_core.OperatorType.PIPELINE, {
+  $project: import_pipeline.$project,
+  $skip: import_pipeline.$skip,
+  $limit: import_pipeline.$limit,
+  $sort: import_pipeline.$sort
+});
+(0, import_core.useOperators)(import_core.OperatorType.PROJECTION, projectionOperators);
+(0, import_core.useOperators)(import_core.OperatorType.QUERY, queryOperators);
+const BASIC_CONTEXT = import_core.Context.init().addExpressionOps({
+  ...booleanOperators,
+  ...comparisonOperators
+}).addPipelineOps({ $project: import_pipeline.$project, $skip: import_pipeline.$skip, $limit: import_pipeline.$limit, $sort: import_pipeline.$sort }).addProjectionOps(projectionOperators).addQueryOps(queryOperators);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASIC_CONTEXT
+});

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

@@ -0,0 +1,35 @@
+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)(import_core.OperatorType.ACCUMULATOR, accumulatorOperators);
+(0, import_core.useOperators)(import_core.OperatorType.EXPRESSION, expressionOperators);
+(0, import_core.useOperators)(import_core.OperatorType.PIPELINE, pipelineOperators);
+(0, import_core.useOperators)(import_core.OperatorType.PROJECTION, projectionOperators);
+(0, import_core.useOperators)(import_core.OperatorType.QUERY, queryOperators);
+(0, import_core.useOperators)(import_core.OperatorType.WINDOW, windowOperators);