@valkey/valkey-glide-darwin-arm64 1.3.0-rc1 → 1.3.0

package/rust-client/node_modules/mingo/dist/esm/aggregator.js

@@ -4,7 +4,7 @@ import {
   ProcessingMode
 } from "./core";
 import { Lazy } from "./lazy";
-import { assert, cloneDeep, intersection, isEmpty } from "./util";
+import { assert, cloneDeep, isEmpty } from "./util";
 class Aggregator {
   #pipeline;
   #options;
@@ -15,34 +15,30 @@ class Aggregator {
   /**
    * Returns an {@link Iterator} for lazy evaluation of the pipeline.
    *
-   * @param {*} collection An array or iterator object
+   * @param collection An array or iterator object
    * @returns {Iterator} an iterator object
    */
   stream(collection, options) {
-    let iterator = Lazy(collection);
+    let iter = Lazy(collection);
     const opts = options ?? this.#options;
     const mode = opts.processingMode;
-    if (mode == ProcessingMode.CLONE_ALL || mode == ProcessingMode.CLONE_INPUT) {
-      iterator.map(cloneDeep);
-    }
+    if (mode & ProcessingMode.CLONE_INPUT) iter.map(cloneDeep);
     const stages = new Array();
     if (!isEmpty(this.#pipeline)) {
-      for (const operator of this.#pipeline) {
-        const operatorKeys = Object.keys(operator);
-        const opName = operatorKeys[0];
+      for (const opExpr of this.#pipeline) {
+        const opKeys = Object.keys(opExpr);
+        const opName = opKeys[0];
         const call = getOperator("pipeline", opName, opts);
         assert(
-          operatorKeys.length === 1 && !!call,
+          opKeys.length === 1 && !!call,
           `invalid pipeline operator ${opName}`
         );
         stages.push(opName);
-        iterator = call(iterator, operator[opName], opts);
+        iter = call(iter, opExpr[opName], opts);
       }
     }
-    if (mode == ProcessingMode.CLONE_OUTPUT || mode == ProcessingMode.CLONE_ALL && !!intersection([["$group", "$unwind"], stages]).length) {
-      iterator.map(cloneDeep);
-    }
-    return iterator;
+    if (mode & ProcessingMode.CLONE_OUTPUT) iter.map(cloneDeep);
+    return iter;
   }
   /**
    * Return the results of the aggregation as an array.

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

@@ -10,10 +10,10 @@ import {
   resolve
 } from "./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";
+  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 {
@@ -27,23 +27,18 @@ class ComputeOptions {
   }
   /**
    * Initialize new ComputeOptions.
-   *
-   * @param options
-   * @param root
-   * @param local
    * @returns {ComputeOptions}
    */
   static init(options, root, local) {
-    return options instanceof ComputeOptions ? new ComputeOptions(options.#options, options.root ?? root, {
+    return !(options instanceof ComputeOptions) ? new ComputeOptions(options, root, local) : new ComputeOptions(options.#options, options.root ?? root, {
       ...options.#local,
       ...local,
-      // retain existing variables
       variables: Object.assign(
         {},
         options.#local?.variables,
         local?.variables
       )
-    }) : new ComputeOptions(options, root, local);
+    });
   }
   /**
    * Updates the internal state.
@@ -85,7 +80,7 @@ class ComputeOptions {
     return this.#options?.collation;
   }
   get processingMode() {
-    return this.#options?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+    return this.#options?.processingMode || 0 /* CLONE_OFF */;
   }
   get useStrictMode() {
     return this.#options?.useStrictMode;
@@ -118,7 +113,7 @@ function initOptions(options) {
     scriptEnabled: true,
     useStrictMode: true,
     useGlobalContext: true,
-    processingMode: "CLONE_OFF" /* CLONE_OFF */,
+    processingMode: 0 /* CLONE_OFF */,
     ...options,
     context: options?.context ? Context.from(options?.context) : Context.init()
   });

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

@@ -1,12 +1,19 @@
-import { Aggregator } from "./aggregator";
+import {
+  ProcessingMode
+} from "./core";
 import { concat, Lazy } from "./lazy";
-import { isObject } from "./util";
+import { $limit } from "./operators/pipeline/limit";
+import { $project } from "./operators/pipeline/project";
+import { $skip } from "./operators/pipeline/skip";
+import { $sort } from "./operators/pipeline/sort";
+import { cloneDeep, has } from "./util";
+const OPERATORS = { $sort, $skip, $limit };
 class Cursor {
   #source;
   #predicate;
   #projection;
   #options;
-  #operators = [];
+  #operators = {};
   #result = null;
   #buffer = [];
   constructor(source, predicate, projection, options) {
@@ -18,15 +25,22 @@ class Cursor {
   /** Returns the iterator from running the query */
   fetch() {
     if (this.#result) return this.#result;
-    if (isObject(this.#projection)) {
-      this.#operators.push({ $project: this.#projection });
-    }
     this.#result = Lazy(this.#source).filter(this.#predicate);
-    if (this.#operators.length > 0) {
-      this.#result = new Aggregator(this.#operators, this.#options).stream(
-        this.#result
-      );
+    const mode = this.#options.processingMode;
+    if (mode & ProcessingMode.CLONE_INPUT) this.#result.map(cloneDeep);
+    for (const op of ["$sort", "$skip", "$limit"]) {
+      if (has(this.#operators, op)) {
+        this.#result = OPERATORS[op](
+          this.#result,
+          this.#operators[op],
+          this.#options
+        );
+      }
+    }
+    if (Object.keys(this.#projection).length) {
+      this.#result = $project(this.#result, this.#projection, this.#options);
     }
+    if (mode & ProcessingMode.CLONE_OUTPUT) this.#result.map(cloneDeep);
     return this.#result;
   }
   /** Returns an iterator with the buffered data included */
@@ -55,7 +69,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   skip(n) {
-    this.#operators.push({ $skip: n });
+    this.#operators["$skip"] = n;
     return this;
   }
   /**
@@ -64,7 +78,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   limit(n) {
-    this.#operators.push({ $limit: n });
+    this.#operators["$limit"] = n;
     return this;
   }
   /**
@@ -73,7 +87,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   sort(modifier) {
-    this.#operators.push({ $sort: modifier });
+    this.#operators["$sort"] = modifier;
     return this;
   }
   /**

package/rust-client/node_modules/mingo/dist/esm/operators/_predicates.js

@@ -32,7 +32,6 @@ function createQueryOperator(predicate) {
       return predicate(lhs, value, { ...options, depth });
     };
   };
-  f.op = "query";
   return f;
 }
 function createExpressionOperator(predicate) {

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/bottomN.js

@@ -1,8 +1,9 @@
-import { Aggregator } from "../../aggregator";
 import {
   ComputeOptions,
   computeValue
 } from "../../core";
+import { Lazy } from "../../lazy";
+import { $sort } from "../pipeline/sort";
 import { $push } from "./push";
 const $bottomN = (collection, expr, options) => {
   const copts = ComputeOptions.init(options);
@@ -12,7 +13,7 @@ const $bottomN = (collection, expr, options) => {
     null,
     copts
   );
-  const result = new Aggregator([{ $sort: sortBy }], copts).run(collection);
+  const result = $sort(Lazy(collection), sortBy, options).value();
   const m = result.length;
   const p = n;
   return $push(m <= p ? result : result.slice(m - p), expr.output, copts);

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/topN.js

@@ -1,8 +1,9 @@
-import { Aggregator } from "../../aggregator";
 import {
   ComputeOptions,
   computeValue
 } from "../../core";
+import { Lazy } from "../../lazy";
+import { $sort } from "../pipeline/sort";
 import { $push } from "./push";
 const $topN = (collection, expr, options) => {
   const copts = ComputeOptions.init(options);
@@ -12,9 +13,7 @@ const $topN = (collection, expr, options) => {
     null,
     copts
   );
-  const result = new Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(
-    collection
-  );
+  const result = $sort(Lazy(collection), sortBy, options).take(n).value();
   return $push(result, expr.output, copts);
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/sortArray.js

@@ -1,12 +1,13 @@
-import { Aggregator } from "../../../aggregator";
 import { computeValue } from "../../../core";
+import { Lazy } from "../../../lazy";
 import { assert, compare, isArray, isNil, isObject } from "../../../util";
+import { $sort } from "../../pipeline/sort";
 const $sortArray = (obj, expr, options) => {
   const { input, sortBy } = computeValue(obj, expr, null, options);
   if (isNil(input)) return null;
   assert(isArray(input), "$sortArray expression must resolve to an array");
   if (isObject(sortBy)) {
-    return new Aggregator([{ $sort: sortBy }]).run(input);
+    return $sort(Lazy(input), sortBy, options).value();
   }
   const result = [...input];
   result.sort(compare);

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/fill.js

@@ -26,7 +26,7 @@ const $fill = (collection, expr, options) => {
   options = initOptions(options);
   options.context.addExpressionOps({ $ifNull });
   options.context.addWindowOps({ $locf, $linearFill });
-  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => `$${s}`);
+  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => "$" + s);
   const valueExpr = {};
   const methodExpr = {};
   for (const [k, m] of Object.entries(expr.output)) {

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/lookup.js

@@ -47,11 +47,10 @@ const $lookup = (collection, expr, options) => {
     }
   }
   const agg = new Aggregator(subQueryPipeline, options);
+  const opts = { ...options };
   return collection.map((obj) => {
-    const variables = computeValue(obj, letExpr, null, options);
-    const opts = Object.assign({}, options, {
-      variables: { ...options.variables, ...variables }
-    });
+    const vars = computeValue(obj, letExpr, null, options);
+    opts.variables = { ...options.variables, ...vars };
     const [ok, res] = lookupEq(obj);
     return {
       ...obj,

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/project.js

@@ -8,138 +8,131 @@ import {
   ensureArray,
   filterMissing,
   has,
-  into,
   isArray,
+  isBoolean,
   isEmpty,
-  isNil,
   isNumber,
   isObject,
   isOperator,
   isString,
   merge,
   removeValue,
+  resolve,
   resolveGraph,
   setValue
 } from "../../util";
-const DESCRIPTORS = new Set(Array.from([0, 1, false, true]));
 const $project = (collection, expr, options) => {
   if (isEmpty(expr)) return collection;
-  const expressionKeys = Object.keys(expr);
   validateExpression(expr, options);
-  const ID_KEY = options.idKey;
-  if (!expressionKeys.includes(ID_KEY)) {
-    expressionKeys.push(ID_KEY);
-  }
-  const copts = ComputeOptions.init(options);
-  return collection.map((obj) => processObject(obj, expr, copts.update(obj), expressionKeys));
+  return collection.map(createHandler(expr, ComputeOptions.init(options)));
 };
-function processObject(obj, expr, options, expressionKeys) {
-  let newObj = {};
-  let foundSlice = false;
-  let foundExclusion = false;
-  const idOnlyExcluded = expr[options.idKey] === 0 && expressionKeys.length === 1;
-  const dropKeys = [];
-  if (idOnlyExcluded) {
-    dropKeys.push(options.idKey);
-  }
+function createHandler(expr, options, isRoot = true) {
+  const idKey = options.idKey;
+  const expressionKeys = Object.keys(expr);
+  const excludedKeys = new Array();
+  const includedKeys = new Array();
+  const handlers = {};
   for (const key of expressionKeys) {
-    let value = void 0;
     const subExpr = expr[key];
-    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {
-      foundExclusion = true;
-    }
-    if (key === options.idKey && isEmpty(subExpr)) {
-      value = obj[key];
-    } else if (isString(subExpr)) {
-      value = computeValue(obj, subExpr, key, options);
-    } else if (subExpr === 1 || subExpr === true) {
+    if (isNumber(subExpr) || isBoolean(subExpr)) {
+      if (subExpr) {
+        includedKeys.push(key);
+      } else {
+        excludedKeys.push(key);
+      }
     } else if (isArray(subExpr)) {
-      value = subExpr.map((v) => {
-        const r = computeValue(obj, v, null, options);
-        if (isNil(r)) return null;
-        return r;
-      });
+      handlers[key] = (o) => subExpr.map((v) => computeValue(o, v, null, options.update(o)) ?? null);
     } else if (isObject(subExpr)) {
-      const subExprObj = subExpr;
       const subExprKeys = Object.keys(subExpr);
       const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
-      const call = getOperator(
+      const projectFn = getOperator(
         "projection",
         operator,
         options
       );
-      if (call) {
-        if (operator === "$slice") {
-          if (ensureArray(subExprObj[operator]).every(isNumber)) {
-            value = call(obj, subExprObj[operator], key, options);
-            foundSlice = true;
-          } else {
-            value = computeValue(obj, subExprObj, key, options);
-          }
+      if (projectFn) {
+        const foundSlice = operator === "$slice";
+        if (foundSlice && !ensureArray(subExpr[operator]).every(isNumber)) {
+          handlers[key] = (o) => computeValue(o, subExpr, key, options.update(o));
         } else {
-          value = call(obj, subExprObj[operator], key, options);
+          handlers[key] = (o) => projectFn(o, subExpr[operator], key, options.update(o));
         }
       } else if (isOperator(operator)) {
-        value = computeValue(obj, subExprObj[operator], operator, options);
-      } else if (has(obj, key)) {
-        validateExpression(subExprObj, options);
-        let target = obj[key];
-        if (isArray(target)) {
-          value = target.map(
-            (o) => processObject(o, subExprObj, options, subExprKeys)
-          );
-        } else {
-          target = isObject(target) ? target : obj;
-          value = processObject(
-            target,
-            subExprObj,
-            options,
-            subExprKeys
-          );
-        }
+        handlers[key] = (o) => computeValue(o, subExpr[operator], operator, options);
       } else {
-        value = computeValue(obj, subExpr, null, options);
+        validateExpression(subExpr, options);
+        handlers[key] = (o) => {
+          if (!has(o, key)) return computeValue(o, subExpr, null, options);
+          if (isRoot) options.update(o);
+          const target = resolve(o, key);
+          const fn = createHandler(subExpr, options, false);
+          if (isArray(target)) return target.map(fn);
+          if (isObject(target)) return fn(target);
+          return fn(o);
+        };
       }
     } else {
-      dropKeys.push(key);
-      continue;
+      handlers[key] = isString(subExpr) && subExpr[0] === "$" ? (o) => computeValue(o, subExpr, key, options) : (_) => subExpr;
     }
-    const objPathGraph = resolveGraph(obj, key, {
-      preserveMissing: true
-    });
-    if (isObject(objPathGraph)) {
-      merge(newObj, objPathGraph);
+  }
+  const handlerKeys = Object.keys(handlers);
+  const idKeyExcluded = excludedKeys.includes(idKey);
+  const idKeyOnlyExcluded = isRoot && idKeyExcluded && excludedKeys.length === 1 && !includedKeys.length && !handlerKeys.length;
+  if (idKeyOnlyExcluded) {
+    return (o) => {
+      const newObj = { ...o };
+      delete newObj[idKey];
+      return newObj;
+    };
+  }
+  const idKeyImplicit = isRoot && !idKeyExcluded && !includedKeys.includes(idKey);
+  const opts = {
+    preserveMissing: true
+  };
+  return (o) => {
+    const newObj = {};
+    if (excludedKeys.length && !includedKeys.length) {
+      merge(newObj, o);
+      for (const k of excludedKeys) {
+        removeValue(newObj, k, { descendArray: true });
+      }
+    }
+    for (const k of includedKeys) {
+      const pathObj = resolveGraph(o, k, opts) ?? {};
+      merge(newObj, pathObj);
     }
-    if (!DESCRIPTORS.has(subExpr)) {
+    if (includedKeys.length) filterMissing(newObj);
+    for (const k of handlerKeys) {
+      const value = handlers[k](o);
       if (value === void 0) {
-        removeValue(newObj, key, { descendArray: true });
+        removeValue(newObj, k, { descendArray: true });
       } else {
-        setValue(newObj, key, value);
+        setValue(newObj, k, value);
       }
     }
-  }
-  filterMissing(newObj);
-  if (foundSlice || foundExclusion || idOnlyExcluded) {
-    newObj = into({}, obj, newObj);
-    if (dropKeys.length > 0) {
-      for (const k of dropKeys) {
-        removeValue(newObj, k, { descendArray: true });
-      }
+    if (idKeyImplicit && has(o, idKey)) {
+      newObj[idKey] = resolve(o, idKey);
     }
-  }
-  return newObj;
+    return newObj;
+  };
 }
 function validateExpression(expr, options) {
-  const check = [false, false];
+  let exclusions = false;
+  let inclusions = false;
   for (const [k, v] of Object.entries(expr)) {
-    if (k === options?.idKey) return;
+    assert(!k.startsWith("$"), "Field names may not start with '$'.");
+    assert(
+      !k.endsWith(".$"),
+      "Positional projection operator '$' is not supported."
+    );
+    if (k === options?.idKey) continue;
     if (v === 0 || v === false) {
-      check[0] = true;
+      exclusions = true;
     } else if (v === 1 || v === true) {
-      check[1] = true;
+      inclusions = true;
     }
     assert(
-      !(check[0] && check[1]),
+      !(exclusions && inclusions),
       "Projection cannot have a mix of inclusion and exclusion."
     );
   }

package/rust-client/node_modules/mingo/dist/esm/operators/update/_internal.js

@@ -1,3 +1,7 @@
+import { Context, initOptions } from "../../core";
+import * as booleanOperators from "../../operators/expression/boolean";
+import * as comparisonOperators from "../../operators/expression/comparison";
+import * as queryOperators from "../../operators/query";
 import { Query } from "../../query";
 import {
   assert,
@@ -9,6 +13,12 @@ import {
   resolve,
   walk
 } from "../../util";
+const UPDATE_OPTIONS = {
+  cloneMode: "copy",
+  queryOptions: initOptions({
+    context: Context.init().addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators)
+  })
+};
 const clone = (mode, val) => {
   switch (mode) {
     case "deep":
@@ -87,6 +97,7 @@ function walkExpression(expr, arrayFilter, options, callback) {
   return res;
 }
 export {
+  UPDATE_OPTIONS,
   applyUpdate,
   clone,
   tokenizePath,

package/rust-client/node_modules/mingo/dist/esm/operators/update/addToSet.js

@@ -1,6 +1,11 @@
 import { has, intersection, isObject, unique } from "../../util";
-import { applyUpdate, clone, walkExpression } from "./_internal";
-const $addToSet = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  clone,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $addToSet = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     const args = { $each: [val] };
     if (isObject(val) && has(val, "$each")) {

package/rust-client/node_modules/mingo/dist/esm/operators/update/bit.js

@@ -1,7 +1,11 @@
 import { assert, isNumber } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
 const BIT_OPS = /* @__PURE__ */ new Set(["and", "or", "xor"]);
-const $bit = (obj, expr, arrayFilters = [], options = {}) => {
+const $bit = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     const op = Object.keys(val);
     assert(

package/rust-client/node_modules/mingo/dist/esm/operators/update/currentDate.js

@@ -1,5 +1,9 @@
-import { applyUpdate, walkExpression } from "./_internal";
-const $currentDate = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $currentDate = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   const now = Date.now();
   return walkExpression(expr, arrayFilters, options, (_, node, queries) => {
     return applyUpdate(

package/rust-client/node_modules/mingo/dist/esm/operators/update/inc.js

@@ -1,6 +1,6 @@
 import { assert, isNumber, resolve } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $inc = (obj, expr, arrayFilters = [], options = {}) => {
+import { applyUpdate, UPDATE_OPTIONS, walkExpression } from "./_internal";
+const $inc = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     if (!node.child) {
       const n = resolve(obj, node.parent);

package/rust-client/node_modules/mingo/dist/esm/operators/update/max.js

@@ -1,6 +1,10 @@
 import { compare } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $max = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $max = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(
       obj,

package/rust-client/node_modules/mingo/dist/esm/operators/update/min.js

@@ -1,6 +1,10 @@
 import { compare } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $min = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $min = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(
       obj,

package/rust-client/node_modules/mingo/dist/esm/operators/update/mul.js

@@ -1,5 +1,9 @@
-import { applyUpdate, walkExpression } from "./_internal";
-const $mul = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $mul = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(
       obj,

package/rust-client/node_modules/mingo/dist/esm/operators/update/pop.js

@@ -1,6 +1,10 @@
 import { assert, isArray } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $pop = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $pop = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(obj, node, queries, (o, k) => {
       const arr = o[k];

package/rust-client/node_modules/mingo/dist/esm/operators/update/pull.js

@@ -1,7 +1,11 @@
 import { Query } from "../../query";
 import { isObject, isOperator } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $pull = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $pull = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     const wrap = !isObject(val) || Object.keys(val).some(isOperator);
     const query = new Query(