@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc0

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

@@ -17,11 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var util_exports = {};
 __export(util_exports, {
-  MAX_INT: () => MAX_INT,
-  MAX_LONG: () => MAX_LONG,
-  MIN_INT: () => MIN_INT,
-  MIN_LONG: () => MIN_LONG,
   MingoError: () => MingoError,
+  ValueMap: () => ValueMap,
   assert: () => assert,
   cloneDeep: () => cloneDeep,
   compare: () => compare,
@@ -29,21 +26,17 @@ __export(util_exports, {
   filterMissing: () => filterMissing,
   findInsertIndex: () => findInsertIndex,
   flatten: () => flatten,
-  getType: () => getType,
   groupBy: () => groupBy,
   has: () => has,
   hashCode: () => hashCode,
-  inArray: () => inArray,
   intersection: () => intersection,
   into: () => into,
   isArray: () => isArray,
-  isBigInt: () => isBigInt,
   isBoolean: () => isBoolean,
   isDate: () => isDate,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
   isFunction: () => isFunction,
-  isMissing: () => isMissing,
   isNil: () => isNil,
   isNotNaN: () => isNotNaN,
   isNumber: () => isNumber,
@@ -53,256 +46,231 @@ __export(util_exports, {
   isRegExp: () => isRegExp,
   isString: () => isString,
   isSymbol: () => isSymbol,
-  memoize: () => memoize,
   merge: () => merge,
   normalize: () => normalize,
-  notInArray: () => notInArray,
   removeValue: () => removeValue,
   resolve: () => resolve,
   resolveGraph: () => resolveGraph,
   setValue: () => setValue,
-  sortBy: () => sortBy,
   stringify: () => stringify,
   truthy: () => truthy,
+  typeOf: () => typeOf,
   unique: () => unique,
   walk: () => walk
 });
 module.exports = __toCommonJS(util_exports);
 class MingoError extends Error {
 }
-const MAX_INT = 2147483647;
-const MIN_INT = -2147483648;
-const MAX_LONG = Number.MAX_SAFE_INTEGER;
-const MIN_LONG = Number.MIN_SAFE_INTEGER;
 const MISSING = Symbol("missing");
 const CYCLE_FOUND_ERROR = Object.freeze(
   new Error("mingo: cycle detected while processing object/array")
 );
-const OBJECT_TAG = "[object Object]";
-const OBJECT_TYPE_RE = /^\[object ([a-zA-Z0-9]+)\]$/;
 const DEFAULT_HASH_FUNCTION = (value) => {
   const s = stringify(value);
   let hash = 0;
   let i = s.length;
-  while (i)
-    hash = (hash << 5) - hash ^ s.charCodeAt(--i);
+  while (i) hash = (hash << 5) - hash ^ s.charCodeAt(--i);
   return hash >>> 0;
 };
-const JS_SIMPLE_TYPES = /* @__PURE__ */ new Set([
-  "null",
-  "undefined",
-  "boolean",
-  "number",
-  "string",
-  "date",
-  "regexp"
-]);
-const SORT_ORDER_BY_TYPE = {
-  null: 0,
-  undefined: 0,
-  number: 1,
-  string: 2,
-  object: 3,
-  array: 4,
-  boolean: 5,
-  date: 6,
-  regexp: 7,
-  function: 8
+const objectProto = Object.prototype;
+const arrayProto = Array.prototype;
+const getPrototypeOf = Object.getPrototypeOf;
+const isPrimitive = (v) => typeof v !== "object" && typeof v !== "function" || v === null;
+const isScalar = (v) => isPrimitive(v) || isDate(v) || isRegExp(v);
+const SORT_ORDER = {
+  undefined: 1,
+  null: 2,
+  number: 3,
+  string: 4,
+  symbol: 5,
+  object: 6,
+  array: 7,
+  arraybuffer: 8,
+  boolean: 9,
+  date: 10,
+  regexp: 11,
+  function: 12
 };
 const compare = (a, b) => {
-  if (a === MISSING)
-    a = void 0;
-  if (b === MISSING)
-    b = void 0;
-  const [u, v] = [a, b].map(
-    (n) => SORT_ORDER_BY_TYPE[getType(n).toLowerCase()]
-  );
-  if (u !== v)
-    return u - v;
-  if (u === 1 || u === 2 || u === 6) {
-    if (a < b)
-      return -1;
-    if (a > b)
-      return 1;
-    return 0;
-  }
-  if (isEqual(a, b))
-    return 0;
-  if (a < b)
-    return -1;
-  if (a > b)
-    return 1;
+  if (a === MISSING) a = void 0;
+  if (b === MISSING) b = void 0;
+  const [u, v] = [a, b].map((n) => SORT_ORDER[typeOf(n)]);
+  if (u !== v) return u - v;
+  if (isEqual(a, b)) return 0;
+  if (a < b) return -1;
+  if (a > b) return 1;
   return 0;
 };
+class ValueMap extends Map {
+  // The hash function
+  #hashFn = DEFAULT_HASH_FUNCTION;
+  // maps the hashcode to key set
+  #keyMap = /* @__PURE__ */ new Map();
+  // returns a tuple of [<masterKey>, <hash>]. Expects an object key.
+  #unpack = (key) => {
+    const hash = this.#hashFn(key);
+    return [(this.#keyMap.get(hash) || []).find((k) => isEqual(k, key)), hash];
+  };
+  constructor() {
+    super();
+  }
+  /**
+   * Returns a new {@link ValueMap} object.
+   * @param fn An optional custom hash function
+   */
+  static init(fn) {
+    const m = new ValueMap();
+    if (fn) m.#hashFn = fn;
+    return m;
+  }
+  clear() {
+    super.clear();
+    this.#keyMap.clear();
+  }
+  /**
+   * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+   */
+  delete(key) {
+    if (isPrimitive(key)) return super.delete(key);
+    const [masterKey, hash] = this.#unpack(key);
+    if (!super.delete(masterKey)) return false;
+    this.#keyMap.set(
+      hash,
+      this.#keyMap.get(hash).filter((k) => !isEqual(k, masterKey))
+    );
+    return true;
+  }
+  /**
+   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+   */
+  get(key) {
+    if (isPrimitive(key)) return super.get(key);
+    const [masterKey, _] = this.#unpack(key);
+    return super.get(masterKey);
+  }
+  /**
+   * @returns boolean indicating whether an element with the specified key exists or not.
+   */
+  has(key) {
+    if (isPrimitive(key)) return super.has(key);
+    const [masterKey, _] = this.#unpack(key);
+    return super.has(masterKey);
+  }
+  /**
+   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+   */
+  set(key, value) {
+    if (isPrimitive(key)) return super.set(key, value);
+    const [masterKey, hash] = this.#unpack(key);
+    if (super.has(masterKey)) {
+      super.set(masterKey, value);
+    } else {
+      super.set(key, value);
+      const keys = this.#keyMap.get(hash) || [];
+      keys.push(key);
+      this.#keyMap.set(hash, keys);
+    }
+    return this;
+  }
+  /**
+   * @returns the number of elements in the Map.
+   */
+  get size() {
+    return super.size;
+  }
+}
 function assert(condition, message) {
-  if (!condition)
-    throw new MingoError(message);
+  if (!condition) throw new MingoError(message);
 }
-const getType = (v) => OBJECT_TYPE_RE.exec(Object.prototype.toString.call(v))[1];
+const typeOf = (v) => {
+  const s = objectProto.toString.call(v);
+  const t = s.substring(8, s.length - 1).toLowerCase();
+  if (t !== "object") return t;
+  const ctor = v.constructor;
+  return ctor == null || ctor === Object ? t : ctor.name;
+};
 const isBoolean = (v) => typeof v === "boolean";
 const isString = (v) => typeof v === "string";
 const isSymbol = (v) => typeof v === "symbol";
 const isNumber = (v) => !isNaN(v) && typeof v === "number";
-const isBigInt = (v) => !isNaN(v) && typeof v === "bigint";
 const isNotNaN = (v) => !(isNaN(v) && typeof v === "number");
 const isArray = Array.isArray;
 const isObject = (v) => {
-  if (!v)
-    return false;
-  const proto = Object.getPrototypeOf(v);
-  return (proto === Object.prototype || proto === null) && OBJECT_TAG === Object.prototype.toString.call(v);
+  if (!v) return false;
+  const p = Object.getPrototypeOf(v);
+  return (p === Object.prototype || p === null) && typeOf(v) === "object";
 };
-const isObjectLike = (v) => v === Object(v);
+const isObjectLike = (v) => !isPrimitive(v);
 const isDate = (v) => v instanceof Date;
 const isRegExp = (v) => v instanceof RegExp;
 const isFunction = (v) => typeof v === "function";
 const isNil = (v) => v === null || v === void 0;
-const inArray = (arr, item) => arr.includes(item);
-const notInArray = (arr, item) => !inArray(arr, item);
 const truthy = (arg, strict = true) => !!arg || strict && arg === "";
-const isEmpty = (x) => isNil(x) || isString(x) && !x || x instanceof Array && x.length === 0 || isObject(x) && Object.keys(x).length === 0;
-const isMissing = (v) => v === MISSING;
-const ensureArray = (x) => x instanceof Array ? x : [x];
-const has = (obj, prop) => !!obj && Object.prototype.hasOwnProperty.call(obj, prop);
+const isEmpty = (x) => isNil(x) || isString(x) && !x || isArray(x) && x.length === 0 || isObject(x) && Object.keys(x).length === 0;
+const ensureArray = (x) => isArray(x) ? x : [x];
+const has = (obj, prop) => !!obj && objectProto.hasOwnProperty.call(obj, prop);
 const isTypedArray = (v) => typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v);
-const INSTANCE_CLONE = [isDate, isRegExp, isTypedArray];
-const cloneInternal = (val, refs) => {
-  if (isNil(val))
-    return val;
-  if (refs.has(val))
-    throw CYCLE_FOUND_ERROR;
-  const ctor = val.constructor;
-  if (INSTANCE_CLONE.some((f) => f(val)))
-    return new ctor(val);
+const cloneDeep = (v, refs) => {
+  if (isNil(v) || isBoolean(v) || isNumber(v) || isString(v)) return v;
+  if (isDate(v)) return new Date(v);
+  if (isRegExp(v)) return new RegExp(v);
+  if (isTypedArray(v)) {
+    const ctor = v.constructor;
+    return new ctor(v);
+  }
+  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();
+  if (refs.has(v)) throw CYCLE_FOUND_ERROR;
+  refs.add(v);
   try {
-    refs.add(val);
-    if (isArray(val))
-      return val.map((v) => cloneInternal(v, refs));
-    if (isObject(val)) {
-      const res = {};
-      for (const k in val)
-        res[k] = cloneInternal(val[k], refs);
-      return res;
+    if (isArray(v)) {
+      const arr = new Array(v.length);
+      for (let i = 0; i < v.length; i++) arr[i] = cloneDeep(v[i], refs);
+      return arr;
+    }
+    if (isObject(v)) {
+      const obj = {};
+      for (const k of Object.keys(v)) obj[k] = cloneDeep(v[k], refs);
+      return obj;
     }
   } finally {
-    refs.delete(val);
+    refs.delete(v);
   }
-  return val;
+  return v;
 };
-const cloneDeep = (obj) => cloneInternal(obj, /* @__PURE__ */ new Set());
-const mergeable = (left, right) => isObject(left) && isObject(right) || isArray(left) && isArray(right);
-function merge(target, obj, options) {
-  options = options || { flatten: false };
-  if (isMissing(target) || isNil(target))
-    return obj;
-  if (isMissing(obj) || isNil(obj))
-    return target;
-  if (!mergeable(target, obj)) {
-    if (options.skipValidation)
-      return obj || target;
-    throw Error("mismatched types. must both be array or object");
+const isMissing = (v) => v === MISSING;
+function merge(target, input) {
+  if (isMissing(target) || isNil(target)) return input;
+  if (isMissing(input) || isNil(input)) return target;
+  if (isPrimitive(target) || isPrimitive(input)) return input;
+  if (isArray(target) && isArray(input)) {
+    assert(
+      target.length === input.length,
+      "arrays must be of equal length to merge."
+    );
   }
-  options.skipValidation = true;
-  if (isArray(target)) {
-    const result = target;
-    const input = obj;
-    if (options.flatten) {
-      let i = 0;
-      let j = 0;
-      while (i < result.length && j < input.length) {
-        result[i] = merge(result[i++], input[j++], options);
-      }
-      while (j < input.length) {
-        result.push(obj[j++]);
-      }
-    } else {
-      into(result, input);
-    }
-  } else {
-    for (const k in obj) {
-      target[k] = merge(
-        target[k],
-        obj[k],
-        options
-      );
-    }
+  for (const k in input) {
+    target[k] = merge(target[k], input[k]);
   }
   return target;
 }
-function buildHashIndex(arr, hashFunction = DEFAULT_HASH_FUNCTION) {
-  const map = /* @__PURE__ */ new Map();
-  arr.forEach((o, i) => {
-    const h = hashCode(o, hashFunction);
-    if (map.has(h)) {
-      if (!map.get(h).some((j) => isEqual(arr[j], o))) {
-        map.get(h).push(i);
-      }
-    } else {
-      map.set(h, [i]);
-    }
-  });
-  return map;
-}
 function intersection(input, hashFunction = DEFAULT_HASH_FUNCTION) {
-  if (input.some((arr) => arr.length == 0))
-    return [];
-  if (input.length === 1)
-    return Array.from(input);
-  const sortedIndex = sortBy(
-    input.map((a, i) => [i, a.length]),
-    (a) => a[1]
-  );
-  const smallest = input[sortedIndex[0][0]];
-  const map = buildHashIndex(smallest, hashFunction);
-  const rmap = /* @__PURE__ */ new Map();
-  const results = new Array();
-  map.forEach((v, k) => {
-    const lhs = v.map((j) => smallest[j]);
-    const res = lhs.map((_) => 0);
-    const stable = lhs.map((_) => [sortedIndex[0][0], 0]);
-    let found = false;
-    for (let i = 1; i < input.length; i++) {
-      const [currIndex, _] = sortedIndex[i];
-      const arr = input[currIndex];
-      if (!rmap.has(i))
-        rmap.set(i, buildHashIndex(arr));
-      if (rmap.get(i).has(k)) {
-        const rhs = rmap.get(i).get(k).map((j) => arr[j]);
-        found = lhs.map(
-          (s, n) => rhs.some((t, m) => {
-            const p = res[n];
-            if (isEqual(s, t)) {
-              res[n]++;
-              if (currIndex < stable[n][0]) {
-                stable[n] = [currIndex, rmap.get(i).get(k)[m]];
-              }
-            }
-            return p < res[n];
-          })
-        ).some(Boolean);
-      }
-      if (!found)
-        return;
-    }
-    if (found) {
-      into(
-        results,
-        res.map((n, i) => {
-          return n === input.length - 1 ? [lhs[i], stable[i]] : MISSING;
-        }).filter((n) => n !== MISSING)
-      );
-    }
-  });
-  return results.sort((a, b) => {
-    const [_i, [u, m]] = a;
-    const [_j, [v, n]] = b;
-    const r = compare(u, v);
-    if (r !== 0)
-      return r;
-    return compare(m, n);
-  }).map((v) => v[0]);
+  const vmaps = [ValueMap.init(hashFunction), ValueMap.init(hashFunction)];
+  if (input.length === 0) return [];
+  if (input.some((arr) => arr.length === 0)) return [];
+  if (input.length === 1) return [...input];
+  input[input.length - 1].forEach((v) => vmaps[0].set(v, true));
+  for (let i = input.length - 2; i > -1; i--) {
+    input[i].forEach((v) => {
+      if (vmaps[0].has(v)) vmaps[1].set(v, true);
+    });
+    if (vmaps[1].size === 0) return [];
+    vmaps.reverse();
+    vmaps[1].clear();
+  }
+  return Array.from(vmaps[0].keys());
 }
-function flatten(xs, depth = 0) {
+function flatten(xs, depth = 1) {
   const arr = new Array();
   function flatten2(ys, n) {
     for (let i = 0, len = ys.length; i < len; i++) {
@@ -316,24 +284,8 @@ function flatten(xs, depth = 0) {
   flatten2(xs, depth);
   return arr;
 }
-const getMembersOf = (value) => {
-  let [proto, names] = [
-    Object.getPrototypeOf(value),
-    Object.getOwnPropertyNames(value)
-  ];
-  let activeProto = proto;
-  while (!names.length && proto !== Object.prototype && proto !== Array.prototype) {
-    activeProto = proto;
-    names = Object.getOwnPropertyNames(proto);
-    proto = Object.getPrototypeOf(proto);
-  }
-  const o = {};
-  names.forEach((k) => o[k] = value[k]);
-  return [o, activeProto];
-};
 function isEqual(a, b) {
-  if (a === b || Object.is(a, b))
-    return true;
+  if (a === b || Object.is(a, b)) return true;
   const ctor = !!a && a.constructor || a;
   if (a === null || b === null || a === void 0 || b === void 0 || ctor !== b.constructor || ctor === Function) {
     return false;
@@ -341,96 +293,56 @@ function isEqual(a, b) {
   if (ctor === Array || ctor === Object) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-      return false;
-    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length)
-      return false;
-    for (const k of aKeys)
-      if (!isEqual(a[k], b[k]))
-        return false;
+    if (aKeys.length !== bKeys.length) return false;
+    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length) return false;
+    for (const k of aKeys) if (!isEqual(a[k], b[k])) return false;
     return true;
   }
-  const proto = Object.getPrototypeOf(a);
-  const cmp = isTypedArray(a) || proto !== Object.prototype && proto !== Array.prototype && Object.prototype.hasOwnProperty.call(proto, "toString");
+  const proto = getPrototypeOf(a);
+  const cmp = isTypedArray(a) || proto !== objectProto && proto !== arrayProto && has(proto, "toString");
   return cmp && a.toString() === b.toString();
 }
 function unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {
-  const result = input.map((_) => MISSING);
-  buildHashIndex(input, hashFunction).forEach((v, _) => {
-    v.forEach((i) => result[i] = input[i]);
-  });
-  return result.filter((v) => v !== MISSING);
+  const m = ValueMap.init(hashFunction);
+  input.forEach((v) => m.set(v, true));
+  return Array.from(m.keys());
 }
-const toString = (v, cycle) => {
-  if (v === null)
-    return "null";
-  if (v === void 0)
-    return "undefined";
-  const ctor = v.constructor;
-  switch (ctor) {
-    case RegExp:
-    case Number:
-    case Boolean:
-    case Function:
-    case Symbol:
-      return v.toString();
-    case String:
-      return JSON.stringify(v);
-    case Date:
-      return v.toISOString();
-  }
+const stringify = (v, refs) => {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (isString(v) || isNumber(v) || isBoolean(v)) return JSON.stringify(v);
+  if (isDate(v)) return v.toISOString();
+  if (isRegExp(v) || isSymbol(v) || isFunction(v))
+    return v.toString();
   if (isTypedArray(v))
-    return ctor.name + "[" + v.toString() + "]";
-  if (cycle.has(v))
-    throw CYCLE_FOUND_ERROR;
+    return typeOf(v) + "[" + v.toString() + "]";
+  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();
+  if (refs.has(v)) throw CYCLE_FOUND_ERROR;
   try {
-    cycle.add(v);
-    if (isArray(v)) {
-      return "[" + v.map((s) => toString(s, cycle)).join(",") + "]";
-    }
-    if (ctor === Object) {
-      return "{" + Object.keys(v).sort().map((k) => k + ":" + toString(v[k], cycle)).join(",") + "}";
+    refs.add(v);
+    if (isArray(v)) return "[" + v.map((s) => stringify(s, refs)).join(",") + "]";
+    if (isObject(v)) {
+      const keys = Object.keys(v).sort();
+      return "{" + keys.map((k) => `${k}:${stringify(v[k], refs)}`).join() + "}";
     }
     const proto = Object.getPrototypeOf(v);
-    if (proto !== Object.prototype && proto !== Array.prototype && Object.prototype.hasOwnProperty.call(proto, "toString")) {
-      return ctor.name + "(" + JSON.stringify(v.toString()) + ")";
+    if (proto !== objectProto && proto !== arrayProto && has(proto, "toString")) {
+      return typeOf(v) + "(" + JSON.stringify(v.toString()) + ")";
     }
-    const [members, _] = getMembersOf(v);
-    return ctor.name + toString(members, cycle);
+    throw new Error(
+      "mingo: cannot stringify custom type without explicit toString() method."
+    );
   } finally {
-    cycle.delete(v);
+    refs.delete(v);
   }
 };
-const stringify = (value) => toString(value, /* @__PURE__ */ new Set());
 function hashCode(value, hashFunction) {
+  if (isNil(value)) return null;
   hashFunction = hashFunction || DEFAULT_HASH_FUNCTION;
-  if (isNil(value))
-    return null;
-  return hashFunction(value).toString();
-}
-function sortBy(collection, keyFn, comparator = compare) {
-  if (isEmpty(collection))
-    return collection;
-  const sorted = new Array();
-  const result = new Array();
-  for (let i = 0; i < collection.length; i++) {
-    const obj = collection[i];
-    const key = keyFn(obj, i);
-    if (isNil(key)) {
-      result.push(obj);
-    } else {
-      sorted.push([key, obj]);
-    }
-  }
-  sorted.sort((a, b) => comparator(a[0], b[0]));
-  return into(
-    result,
-    sorted.map((o) => o[1])
-  );
+  return hashFunction(value);
 }
 function groupBy(collection, keyFn, hashFunction = DEFAULT_HASH_FUNCTION) {
-  if (collection.length < 1)
-    return /* @__PURE__ */ new Map();
+  if (collection.length < 1) return /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < collection.length; i++) {
@@ -461,22 +373,19 @@ function groupBy(collection, keyFn, hashFunction = DEFAULT_HASH_FUNCTION) {
 }
 const MAX_ARRAY_PUSH = 5e4;
 function into(target, ...rest) {
-  if (target instanceof Array) {
-    return rest.reduce(
-      (acc, arr) => {
-        let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);
-        let begin = 0;
-        while (i-- > 0) {
-          Array.prototype.push.apply(
-            acc,
-            arr.slice(begin, begin + MAX_ARRAY_PUSH)
-          );
-          begin += MAX_ARRAY_PUSH;
-        }
-        return acc;
-      },
-      target
-    );
+  if (isArray(target)) {
+    for (const arr of rest) {
+      let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);
+      let begin = 0;
+      while (i-- > 0) {
+        Array.prototype.push.apply(
+          target,
+          arr.slice(begin, begin + MAX_ARRAY_PUSH)
+        );
+        begin += MAX_ARRAY_PUSH;
+      }
+    }
+    return target;
   } else {
     return rest.filter(isObjectLike).reduce((acc, item) => {
       Object.assign(acc, item);
@@ -484,27 +393,12 @@ function into(target, ...rest) {
     }, target);
   }
 }
-function memoize(fn, hashFunction = DEFAULT_HASH_FUNCTION) {
-  return /* @__PURE__ */ ((memo) => {
-    return (...args) => {
-      const key = hashCode(args, hashFunction) || "";
-      if (!has(memo, key)) {
-        memo[key] = fn.apply(this, args);
-      }
-      return memo[key];
-    };
-  })({
-    /* storage */
-  });
-}
 function getValue(obj, key) {
-  return isObjectLike(obj) ? obj[key] : void 0;
+  return isArray(obj) || isObject(obj) ? obj[key] : void 0;
 }
 function unwrap(arr, depth) {
-  if (depth < 1)
-    return arr;
-  while (depth-- && arr.length === 1)
-    arr = arr[0];
+  if (depth < 1) return arr;
+  while (depth-- && arr.length === 1) arr = arr[0];
   return arr;
 }
 function resolve(obj, selector, options) {
@@ -514,72 +408,68 @@ function resolve(obj, selector, options) {
     for (let i = 0; i < path.length; i++) {
       const field = path[i];
       const isText = /^\d+$/.exec(field) === null;
-      if (isText && value instanceof Array) {
-        if (i === 0 && depth > 0)
-          break;
+      if (isText && isArray(value)) {
+        if (i === 0 && depth > 0) break;
         depth += 1;
         const subpath = path.slice(i);
         value = value.reduce((acc, item) => {
           const v = resolve2(item, subpath);
-          if (v !== void 0)
-            acc.push(v);
+          if (v !== void 0) acc.push(v);
           return acc;
         }, []);
         break;
       } else {
         value = getValue(value, field);
       }
-      if (value === void 0)
-        break;
+      if (value === void 0) break;
     }
     return value;
   }
-  const result = JS_SIMPLE_TYPES.has(getType(obj).toLowerCase()) ? obj : resolve2(obj, selector.split("."));
-  return result instanceof Array && options?.unwrapArray ? unwrap(result, depth) : result;
+  const res = isScalar(obj) ? obj : resolve2(obj, selector.split("."));
+  return isArray(res) && options?.unwrapArray ? unwrap(res, depth) : res;
 }
 function resolveGraph(obj, selector, options) {
-  const names = selector.split(".");
-  const key = names[0];
-  const next = names.slice(1).join(".");
-  const isIndex = /^\d+$/.exec(key) !== null;
-  const hasNext = names.length > 1;
-  let result;
-  let value;
-  if (obj instanceof Array) {
+  const sep = selector.indexOf(".");
+  const key = sep == -1 ? selector : selector.substring(0, sep);
+  const next = selector.substring(sep + 1);
+  const hasNext = sep != -1;
+  if (isArray(obj)) {
+    const isIndex = /^\d+$/.test(key);
+    const arr = isIndex && options?.preserveIndex ? [...obj] : [];
     if (isIndex) {
-      result = getValue(obj, Number(key));
+      const index = parseInt(key);
+      let value2 = getValue(obj, index);
       if (hasNext) {
-        result = resolveGraph(result, next, options);
+        value2 = resolveGraph(value2, next, options);
+      }
+      if (options?.preserveIndex) {
+        arr[index] = value2;
+      } else {
+        arr.push(value2);
       }
-      result = [result];
     } else {
-      result = [];
       for (const item of obj) {
-        value = resolveGraph(item, selector, options);
+        const value2 = resolveGraph(item, selector, options);
         if (options?.preserveMissing) {
-          if (value === void 0) {
-            value = MISSING;
-          }
-          result.push(value);
-        } else if (value !== void 0) {
-          result.push(value);
+          arr.push(value2 == void 0 ? MISSING : value2);
+        } else if (value2 != void 0 || options?.preserveIndex) {
+          arr.push(value2);
         }
       }
     }
-  } else {
-    value = getValue(obj, key);
-    if (hasNext) {
-      value = resolveGraph(value, next, options);
-    }
-    if (value === void 0)
-      return void 0;
-    result = options?.preserveKeys ? { ...obj } : {};
-    result[key] = value;
+    return arr;
   }
-  return result;
+  const res = options?.preserveKeys ? { ...obj } : {};
+  let value = getValue(obj, key);
+  if (hasNext) {
+    value = resolveGraph(value, next, options);
+  }
+  if (value === void 0) return void 0;
+  res[key] = value;
+  return res;
 }
 function filterMissing(obj) {
-  if (obj instanceof Array) {
+  if (isArray(obj)) {
     for (let i = obj.length - 1; i >= 0; i--) {
       if (obj[i] === MISSING) {
         obj.splice(i, 1);
@@ -609,10 +499,9 @@ function walk(obj, selector, fn, options) {
       obj[key] = {};
     }
     const item = obj[key];
-    if (!item)
-      return;
+    if (!item) return;
     const isNextArrayIndex = !!(names.length > 1 && NUMBER_RE.test(names[1]));
-    if (item instanceof Array && options?.descendArray && !isNextArrayIndex) {
+    if (isArray(item) && options?.descendArray && !isNextArrayIndex) {
       item.forEach((e) => walk(e, next, fn, options));
     } else {
       walk(item, next, fn, options);
@@ -634,7 +523,7 @@ function removeValue(obj, selector, options) {
     obj,
     selector,
     (item, key) => {
-      if (item instanceof Array) {
+      if (isArray(item)) {
         if (/^\d+$/.test(key)) {
           item.splice(parseInt(key), 1);
         } else if (options && options.descendArray) {
@@ -656,14 +545,11 @@ function isOperator(name) {
   return OPERATOR_NAME_PATTERN.test(name);
 }
 function normalize(expr) {
-  if (JS_SIMPLE_TYPES.has(getType(expr).toLowerCase())) {
+  if (isScalar(expr)) {
     return isRegExp(expr) ? { $regex: expr } : { $eq: expr };
   }
   if (isObjectLike(expr)) {
-    const exprObj = expr;
-    if (!Object.keys(exprObj).some(isOperator)) {
-      return { $eq: expr };
-    }
+    if (!Object.keys(expr).some(isOperator)) return { $eq: expr };
     if (has(expr, "$regex")) {
       const newExpr = { ...expr };
       newExpr["$regex"] = new RegExp(
@@ -676,14 +562,14 @@ function normalize(expr) {
   }
   return expr;
 }
-function findInsertIndex(sorted, item) {
+function findInsertIndex(sorted, item, comparator = compare) {
   let lo = 0;
   let hi = sorted.length - 1;
   while (lo <= hi) {
     const mid = Math.round(lo + (hi - lo) / 2);
-    if (compare(item, sorted[mid]) < 0) {
+    if (comparator(item, sorted[mid]) < 0) {
       hi = mid - 1;
-    } else if (compare(item, sorted[mid]) > 0) {
+    } else if (comparator(item, sorted[mid]) > 0) {
       lo = mid + 1;
     } else {
       return mid;
@@ -693,11 +579,8 @@ function findInsertIndex(sorted, item) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MAX_INT,
-  MAX_LONG,
-  MIN_INT,
-  MIN_LONG,
   MingoError,
+  ValueMap,
   assert,
   cloneDeep,
   compare,
@@ -705,21 +588,17 @@ function findInsertIndex(sorted, item) {
   filterMissing,
   findInsertIndex,
   flatten,
-  getType,
   groupBy,
   has,
   hashCode,
-  inArray,
   intersection,
   into,
   isArray,
-  isBigInt,
   isBoolean,
   isDate,
   isEmpty,
   isEqual,
   isFunction,
-  isMissing,
   isNil,
   isNotNaN,
   isNumber,
@@ -729,17 +608,15 @@ function findInsertIndex(sorted, item) {
   isRegExp,
   isString,
   isSymbol,
-  memoize,
   merge,
   normalize,
-  notInArray,
   removeValue,
   resolve,
   resolveGraph,
   setValue,
-  sortBy,
   stringify,
   truthy,
+  typeOf,
   unique,
   walk
 });