@andrew_l/toolkit 0.2.15 → 0.2.16

package/dist/index.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
-const _get = require('lodash/get.js');
 const _cloneDeep = require('lodash/cloneDeep.js');
 const _cloneDeepWith = require('lodash/cloneDeepWith.js');
 const _defaultsDeep = require('lodash/defaultsDeep.js');
+const _get = require('lodash/get.js');
 const _set = require('lodash/set.js');
 const _unset = require('lodash/unset.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const _get__default = /*#__PURE__*/_interopDefaultCompat(_get);
 const _cloneDeep__default = /*#__PURE__*/_interopDefaultCompat(_cloneDeep);
 const _cloneDeepWith__default = /*#__PURE__*/_interopDefaultCompat(_cloneDeepWith);
 const _defaultsDeep__default = /*#__PURE__*/_interopDefaultCompat(_defaultsDeep);
+const _get__default = /*#__PURE__*/_interopDefaultCompat(_get);
 const _set__default = /*#__PURE__*/_interopDefaultCompat(_set);
 const _unset__default = /*#__PURE__*/_interopDefaultCompat(_unset);
 
@@ -357,797 +357,1128 @@ function shuffle(arr) {
   return result;
 }
 
-class SortedArray extends Array {
-  #compareFn;
-  /**
-   * Creates a new SortedArray instance.
-   *
-   * @param compareFn The comparison function to determine the sort order
-   * @param items Optional initial items to add to the array (will be sorted immediately)
-   */
-  constructor(compareFn, items = []) {
-    super();
-    this.#compareFn = compareFn;
-    if (items.length > 0) {
-      super.push.apply(this, items.toSorted(this.#compareFn));
-    }
-  }
-  /**
-   * Inserts multiple items while maintaining sort order
-   * @param items The items to insert
-   * @returns The new length of the array
-   */
-  push(...items) {
-    var newItems = items.toSorted(this.#compareFn);
-    var newItemsLen = newItems.length;
-    var originalLen = this.length;
-    var result = new Array(originalLen + newItemsLen);
-    var i = 0, j = 0, k = 0;
-    while (i < originalLen && j < newItemsLen) {
-      if (this.#compareFn(this[i], newItems[j]) <= 0) {
-        result[k++] = this[i++];
-      } else {
-        result[k++] = newItems[j++];
-      }
-    }
-    while (i < originalLen) {
-      result[k++] = this[i++];
-    }
-    while (j < newItemsLen) {
-      result[k++] = newItems[j++];
-    }
-    this.length = 0;
-    super.push.apply(this, result);
-    return this.length;
-  }
-  /**
-   * Override Array methods that would break the sorted order
-   */
-  unshift(...items) {
-    return this.push(...items);
-  }
-  /**
-   * Creates a new SortedArray with the same comparison function
-   * @returns A new SortedArray instance
-   */
-  slice(start, end) {
-    var result = new SortedArray(this.#compareFn);
-    var sliced = super.slice(start, end);
-    super.push.apply(result, sliced);
-    return result;
-  }
-  /**
-   * Concatenates arrays or values while maintaining sort order
-   * @param items Arrays or values to concatenate
-   * @returns A new SortedArray with the concatenated elements
-   */
-  concat(...items) {
-    var result = new SortedArray(this.#compareFn, this);
-    for (const item of items) {
-      if (Array.isArray(item)) {
-        result.push.apply(result, item);
-      } else {
-        result.push(item);
-      }
+function cleanEmpty(obj) {
+  let value;
+  for (const key of Object.keys(obj)) {
+    value = obj[key];
+    if (isEmpty(value)) {
+      delete obj[key];
     }
-    return result;
   }
+  return obj;
 }
-["map", "filter", "flatMap", "flat", "reverse", "sort"].forEach((key) => {
-  SortedArray.prototype[key] = function() {
-    const arr = Array.prototype[key].apply(this, arguments);
-    Object.setPrototypeOf(arr, Array.prototype);
-    return arr;
-  };
-});
 
-const sum = (values) => {
-  return values.reduce((a, b) => a + (isNumber(b) ? b : 0), 0);
+const cleanObject = (input) => {
+  [...Object.keys(input), ...Object.getOwnPropertySymbols(input)].forEach(
+    (key) => {
+      delete input[key];
+    }
+  );
 };
 
-function uniq(value) {
-  if (!Array.isArray(value)) {
-    return [];
+const deepAssign = (dest, source) => {
+  for (const key of Object.keys(source)) {
+    const destValue = dest[key];
+    const sourceValue = source[key];
+    if (isObject(destValue) && isObject(sourceValue)) {
+      deepAssign(destValue, sourceValue);
+    } else {
+      dest[key] = sourceValue;
+    }
   }
-  return [...new Set(value)];
-}
+};
 
-function union(...arrays) {
-  if (arrays.length === 0) return [];
-  if (arrays.length === 1) return [...arrays[0]];
-  const [first, ...rest] = arrays;
-  return uniq(first.concat(...rest));
-}
+const deepClone = (value) => {
+  return _cloneDeep__default(value);
+};
 
-const get = _get__default;
+const def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
 
-function uniqBy(array, comparator) {
-  const seen = /* @__PURE__ */ new Set();
-  if (!isFunction(comparator)) {
-    const key = comparator;
-    comparator = (value) => get(value, key);
-  }
-  return array.filter((value) => {
-    const computed = comparator(value);
-    const hasSeen = seen.has(computed);
-    if (!hasSeen) {
-      seen.add(computed);
+const WITH_CUSTOMIZER_FACTORY_SYM = Symbol();
+function deepCloneWith(value, customizer) {
+  const fns = prepareCustomizes(customizer);
+  return _cloneDeepWith__default(value, (value2, key) => {
+    let newValue;
+    let replaced = false;
+    for (const fn of fns) {
+      newValue = fn(value2, key);
+      if (newValue !== void 0) {
+        value2 = newValue;
+        replaced = true;
+      }
     }
-    return !hasSeen;
+    if (replaced) return value2;
   });
 }
-
-let AssertionError;
-(async () => {
-  AssertionError = globalThis.window ? await Promise.resolve().then(function () { return BrowserAssertionError$1; }).then(
-    (r) => r.BrowserAssertionError
-  ) : await import('node:assert').then((r) => r.AssertionError);
-})();
-
-function ok(value, message) {
-  if (!value) {
-    throw toError$1(
-      ok,
-      value,
-      message,
-      "The expression evaluated to a falsy value."
-    );
-  }
+function createDeepCloneWith(customizer) {
+  return (value) => {
+    return deepCloneWith(value, customizer);
+  };
 }
-function equal(actual, expected, message) {
-  if (actual !== expected) {
-    new AssertionError({
-      actual,
-      expected,
-      message: isString(message) ? message : "The actual value not as expected.",
-      operator: "equal",
-      stackStartFn: equal
-    });
-  }
+function prepareCustomizes(value) {
+  return arrayable(value).map((v) => isCustomizerFactory(v) ? v() : v);
 }
-function notEmpty(value, message) {
-  if (isEmpty(value)) {
-    throw toError$1(notEmpty, value, message, "Expected not empty value.");
-  }
+function isCustomizerFactory(value) {
+  return value?.[WITH_CUSTOMIZER_FACTORY_SYM] === true;
 }
-function object(value, message) {
-  if (!isObject(value)) {
-    throw toError$1(object, value, message, "Expected object value.");
-  }
+function createCustomizer(fn) {
+  return fn;
 }
-function string(value, message) {
-  if (!isString(value)) {
-    throw toError$1(string, value, message, "Expected string value.");
-  }
+function createCustomizerFactory(fn) {
+  def(fn, WITH_CUSTOMIZER_FACTORY_SYM, true);
+  return fn;
 }
-function boolean(value, message) {
-  if (!isBoolean(value)) {
-    throw toError$1(boolean, value, message, "Expected boolean value.");
+function createSecureCustomizer(properties) {
+  const secureLabel = `<** secure **>`;
+  const circularLabel = `<** circular **>`;
+  const propertiesSet = Object.freeze(
+    new Set(properties.map((v) => v.toLocaleLowerCase()))
+  );
+  const withCustomizer = (seenSet, value, key) => {
+    if (isPrimitive(value)) {
+      if (!isString(key)) return;
+      if (!propertiesSet.has(key.toLocaleLowerCase())) return;
+      return secureLabel;
+    }
+    if (seenSet.has(value)) {
+      return circularLabel;
+    }
+    seenSet.add(value);
+    if (isError(value)) {
+      return {
+        message: value.message,
+        stack: value.stack,
+        name: value.name
+      };
+    }
+  };
+  return createCustomizerFactory(() => {
+    const seenSet = /* @__PURE__ */ new WeakSet();
+    return withCustomizer.bind(null, seenSet);
+  });
+}
+
+const deepDefaults = _defaultsDeep__default;
+
+function deepFreeze(value) {
+  let currentValue = value;
+  if (!currentValue || typeof currentValue !== "object") return currentValue;
+  Object.freeze(currentValue);
+  if (Array.isArray(currentValue)) {
+    for (const item of currentValue) {
+      deepFreeze(item);
+    }
+    return currentValue;
+  } else {
+    for (const value2 of Object.values(currentValue)) {
+      deepFreeze(value2);
+    }
   }
+  return currentValue;
 }
-function notEmptyString(value, message) {
-  if (!isString(value) || !value.trim()) {
-    throw toError$1(
-      notEmptyString,
-      value,
-      message,
-      "Expected not empty string value."
-    );
+
+function flagsToMap(value, bitmaskMap) {
+  const result = {};
+  const compare = typeof value === "bigint" ? 0n : 0;
+  for (const [key, mask] of Object.entries(bitmaskMap)) {
+    result[key] = (value & mask) !== compare;
   }
+  return result;
 }
-function number$1(value, message) {
-  if (!isNumber(value)) {
-    throw toError$1(number$1, value, message, "Expected number value.");
+
+function flatten(obj, {
+  separator = "_",
+  initialPrefix = "",
+  withArrays = true,
+  isObjectCompare = isObject
+} = {}) {
+  const result = {};
+  const seen = /* @__PURE__ */ new WeakSet();
+  if (isObjectCompare(obj)) {
+    iter(
+      result,
+      seen,
+      isObjectCompare,
+      separator,
+      withArrays,
+      obj,
+      initialPrefix,
+      true
+    );
   }
+  return result;
 }
-function date(value, message) {
-  if (!isDate(value)) {
-    throw toError$1(date, value, message, "Expected date value.");
+function iter(output, seen, isObjectCompare, separator, withArrays, val, key, initial) {
+  if (seen.has(val)) return;
+  let k, pfx = key && !initial ? key + separator : key;
+  if (Array.isArray(val)) {
+    seen.add(val);
+    if (!withArrays) {
+      output[key] = val;
+      return;
+    }
+    for (k = 0; k < val.length; k++) {
+      iter(
+        output,
+        seen,
+        isObjectCompare,
+        separator,
+        withArrays,
+        val[k],
+        pfx + k
+      );
+    }
+  } else if (isObjectCompare(val)) {
+    seen.add(val);
+    for (k in val) {
+      iter(
+        output,
+        seen,
+        isObjectCompare,
+        separator,
+        withArrays,
+        val[k],
+        pfx + k
+      );
+    }
+  } else {
+    output[key] = val;
   }
 }
-function fn(value, message) {
-  if (!isFunction(value)) {
-    throw toError$1(fn, value, message, "Expected function value.");
+
+const get = _get__default;
+
+function has(value, keys) {
+  if (!isObject(value)) return false;
+  for (let idx = 0; idx < keys.length; idx++) {
+    const element = keys[idx];
+    if (!(element in value)) return false;
   }
+  return true;
 }
-function greaterThan(value, target, message) {
-  if (!isNumber(value) || value < target) {
-    throw toError$1(
-      greaterThan,
-      value,
-      message,
-      "Expected number value greater then " + target + "."
-    );
+
+const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
+
+function omit(obj, excludes) {
+  const excludesSet = Array.isArray(excludes) ? new Set(excludes) : excludes instanceof Set ? excludes : void 0;
+  if (!excludesSet) {
+    return obj;
   }
-}
-function lessThan(value, target, message) {
-  if (!isNumber(value) || value > target) {
-    throw toError$1(
-      lessThan,
-      value,
-      message,
-      "Expected number value less then " + target + "."
-    );
+  const result = {};
+  if (!isObject(obj)) {
+    return result;
   }
-}
-function array(value, message) {
-  if (!Array.isArray(value)) {
-    throw toError$1(array, value, message, "Expected array value.");
+  for (const [key, value] of Object.entries(obj)) {
+    if (excludesSet.has(key)) continue;
+    result[key] = value;
   }
+  return result;
 }
-function arrayStrings(value, message) {
-  if (!Array.isArray(value) || !value.every(isString)) {
-    throw toError$1(arrayStrings, value, message, "Expected strings list value.");
+
+function omitPrefixed(obj, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith(prefix)) continue;
+    result[key] = value;
   }
+  return result;
 }
-function arrayNumbers(value, message) {
-  if (!Array.isArray(value) || !value.every(isNumber)) {
-    throw toError$1(arrayNumbers, value, message, "Expected numbers list value.");
+
+function pick(obj, keys) {
+  const keysSet = Array.isArray(keys) ? new Set(keys) : keys instanceof Set ? keys : void 0;
+  const result = {};
+  if (!keysSet || !isObject(obj)) {
+    return result;
+  }
+  for (const key of keysSet.values()) {
+    if (hasOwn(obj, key)) {
+      result[key] = obj[key];
+    }
   }
+  return result;
 }
-function toError$1(operator, actual, message, unknownMessage = "Unknown error") {
-  if (isError(message)) {
-    return message;
+
+function pickPrefixed(obj, options) {
+  let prefix;
+  let prefixTrim = false;
+  if (typeof options === "string") {
+    prefix = options;
+  } else {
+    prefix = options.prefix;
+    prefixTrim = options.prefixTrim === true;
   }
-  return new AssertionError({
-    actual,
-    message: isString(message) ? message : unknownMessage,
-    operator: operator.name,
-    stackStartFn: operator
-  });
+  const result = {};
+  for (let [key, value] of Object.entries(obj)) {
+    if (!key.startsWith(prefix)) continue;
+    if (prefixTrim) key = key.substring(prefix.length);
+    result[key] = value;
+  }
+  return result;
 }
 
-const assert = {
-  __proto__: null,
-  array: array,
-  arrayNumbers: arrayNumbers,
-  arrayStrings: arrayStrings,
-  boolean: boolean,
-  date: date,
-  equal: equal,
-  fn: fn,
-  greaterThan: greaterThan,
-  lessThan: lessThan,
-  notEmpty: notEmpty,
-  notEmptyString: notEmptyString,
-  number: number$1,
-  object: object,
-  ok: ok,
-  string: string
-};
+const set = _set__default;
 
-function weightedRoundRobin(arr) {
-  ok(arr.length > 0, "Array must contain at least one item.");
-  const instance = new WeightedRoundRobin(
-    arr.map((v) => ({
-      item: v.item,
-      weight: Math.min(v.weight ?? 1, 1)
-    }))
-  );
-  return () => instance.nextItem();
-}
-const gcd = (a, b) => !b ? a : gcd(b, a % b);
-class WeightedRoundRobin {
-  constructor(items) {
-    this.items = items;
-    this.maxWeight = this._calculateMaxWeight();
-    this.gcdWeight = this._calculateGCD();
-  }
-  currentIndex = -1;
-  currentWeight = 0;
-  maxWeight;
-  gcdWeight;
-  _calculateGCD() {
-    return this.items.reduce(
-      (acc, curr) => gcd(acc, curr.weight),
-      this.items[0].weight
-    );
+const toMap = (obj) => {
+  const map = new Map(Object.entries(obj));
+  for (const symbol of Object.getOwnPropertySymbols(obj)) {
+    map.set(symbol, obj[symbol]);
   }
-  _calculateMaxWeight() {
-    return Math.max(...this.items.map((s) => s.weight));
+  return map;
+};
+
+const badKeys = Object.freeze(
+  /* @__PURE__ */ new Set(["constructor", "__proto__", "prototype"])
+);
+function unflatten(input, separator = "_") {
+  if (!isObject(input)) {
+    return {};
   }
-  nextItem() {
-    const n = this.items.length;
-    while (true) {
-      this.currentIndex = (this.currentIndex + 1) % n;
-      if (this.currentIndex === 0) {
-        this.currentWeight -= this.gcdWeight;
-        if (this.currentWeight <= 0) {
-          this.currentWeight = this.maxWeight;
+  let arr, tmp, output;
+  let i = 0, k, key;
+  for (k in input) {
+    tmp = output;
+    arr = k.split(separator);
+    for (i = 0; i < arr.length; ) {
+      key = arr[i++];
+      if (tmp == null) {
+        tmp = empty(+key);
+        output = output || tmp;
+      }
+      if (badKeys.has(key)) break;
+      if (i < arr.length) {
+        if (key in tmp) {
+          tmp = tmp[key];
+        } else {
+          tmp = tmp[key] = empty(+arr[i]);
         }
-      }
-      if (this.items[this.currentIndex].weight >= this.currentWeight) {
-        return this.items[this.currentIndex].item;
+      } else {
+        tmp[key] = input[k];
       }
     }
   }
+  return output;
+}
+function empty(key) {
+  return key === key ? [] : {};
 }
 
-class Base64Encoding {
-  alphabet;
-  padding;
-  decodeMap = /* @__PURE__ */ new Map();
-  constructor(alphabet, options) {
-    if (alphabet.length !== 64) {
-      throw new Error("Invalid alphabet");
-    }
-    this.alphabet = alphabet;
-    this.padding = options?.padding ?? "=";
-    if (this.alphabet.includes(this.padding) || this.padding.length !== 1) {
-      throw new Error("Invalid padding");
-    }
-    for (let i = 0; i < alphabet.length; i++) {
-      this.decodeMap.set(alphabet[i], i);
+const unset = _unset__default;
+
+const SYM_COMPARE_FN = Symbol("SYM_COMPARE_FN");
+class SortedArray extends Array {
+  // @ts-expect-error
+  [SYM_COMPARE_FN];
+  /**
+   * Creates a new SortedArray instance.
+   *
+   * @param compareFn The comparison function to determine the sort order
+   * @param items Optional initial items to add to the array (will be sorted immediately)
+   */
+  constructor(compareFn, items = []) {
+    super();
+    def(this, SYM_COMPARE_FN, compareFn);
+    if (items.length > 0) {
+      super.push.apply(this, items.toSorted(compareFn));
     }
   }
-  encode(data, options) {
-    let result = "";
-    let buffer = 0;
-    let shift = 0;
-    for (let i = 0; i < data.length; i++) {
-      buffer = buffer << 8 | data[i];
-      shift += 8;
-      while (shift >= 6) {
-        shift += -6;
-        result += this.alphabet[buffer >> shift & 63];
+  /**
+   * Inserts multiple items while maintaining sort order
+   * @param items The items to insert
+   * @returns The new length of the array
+   */
+  push(...items) {
+    var newItems = items.toSorted(this[SYM_COMPARE_FN]);
+    var newItemsLen = newItems.length;
+    var originalLen = this.length;
+    var result = new Array(originalLen + newItemsLen);
+    var i = 0, j = 0, k = 0;
+    while (i < originalLen && j < newItemsLen) {
+      if (this[SYM_COMPARE_FN](this[i], newItems[j]) <= 0) {
+        result[k++] = this[i++];
+      } else {
+        result[k++] = newItems[j++];
       }
     }
-    if (shift > 0) {
-      result += this.alphabet[buffer << 6 - shift & 63];
+    while (i < originalLen) {
+      result[k++] = this[i++];
     }
-    const includePadding = options?.includePadding ?? true;
-    if (includePadding) {
-      const padCount = (4 - result.length % 4) % 4;
-      for (let i = 0; i < padCount; i++) {
-        result += "=";
-      }
+    while (j < newItemsLen) {
+      result[k++] = newItems[j++];
     }
+    this.length = 0;
+    super.push.apply(this, result);
+    return this.length;
+  }
+  /**
+   * Override Array methods that would break the sorted order
+   */
+  unshift(...items) {
+    return this.push(...items);
+  }
+  /**
+   * Creates a new SortedArray with the same comparison function
+   * @returns A new SortedArray instance
+   */
+  slice(start, end) {
+    var result = new SortedArray(this[SYM_COMPARE_FN]);
+    var sliced = super.slice(start, end);
+    super.push.apply(result, sliced);
     return result;
   }
-  decode(data, options) {
-    const strict = options?.strict ?? true;
-    const chunkCount = Math.ceil(data.length / 4);
-    const result = [];
-    for (let i = 0; i < chunkCount; i++) {
-      let padCount = 0;
-      let buffer = 0;
-      for (let j = 0; j < 4; j++) {
-        const encoded = data[i * 4 + j];
-        if (encoded === "=") {
-          if (i + 1 !== chunkCount) {
-            throw new Error(`Invalid character: ${encoded}`);
-          }
-          padCount += 1;
-          continue;
-        }
-        if (encoded === void 0) {
-          if (strict) {
-            throw new Error("Invalid data");
-          }
-          padCount += 1;
-          continue;
-        }
-        const value = this.decodeMap.get(encoded) ?? null;
-        if (value === null) {
-          throw new Error(`Invalid character: ${encoded}`);
-        }
-        buffer += value << 6 * (3 - j);
-      }
-      result.push(buffer >> 16 & 255);
-      if (padCount < 2) {
-        result.push(buffer >> 8 & 255);
-      }
-      if (padCount < 1) {
-        result.push(buffer & 255);
+  /**
+   * Concatenates arrays or values while maintaining sort order
+   * @param items Arrays or values to concatenate
+   * @returns A new SortedArray with the concatenated elements
+   */
+  concat(...items) {
+    var result = new SortedArray(this[SYM_COMPARE_FN], this);
+    for (const item of items) {
+      if (Array.isArray(item)) {
+        result.push.apply(result, item);
+      } else {
+        result.push(item);
       }
     }
-    return Uint8Array.from(result);
+    return result;
   }
 }
+["map", "filter", "flatMap", "flat", "reverse", "sort"].forEach((key) => {
+  SortedArray.prototype[key] = function() {
+    const arr = Array.prototype[key].apply(this, arguments);
+    Object.setPrototypeOf(arr, Array.prototype);
+    return arr;
+  };
+});
 
-const base64 = new Base64Encoding(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-);
-const base64url = new Base64Encoding(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-);
+const sum = (values) => {
+  return values.reduce((a, b) => a + (isNumber(b) ? b : 0), 0);
+};
 
-function base64ToBytes(data, { encoding = "base64", strict } = {}) {
-  if (encoding === "base64") {
-    return base64.decode(data, { strict: strict ?? true });
-  } else if (encoding === "base64url") {
-    return base64url.decode(data, { strict: strict ?? false });
+function uniq(value) {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  ok(false, "Invalid encoding options: " + encoding);
+  return [...new Set(value)];
 }
 
-function bigIntBytes(value) {
-  if (value < 0n) {
-    value = value * -1n;
-  }
-  let byteLength = 1;
-  while (value > 2n ** BigInt(byteLength * 8) - 1n) {
-    byteLength++;
-  }
-  const encoded = new Uint8Array(byteLength);
-  for (let i = 0; i < encoded.byteLength; i++) {
-    encoded[i] = Number(
-      value >> BigInt((encoded.byteLength - i - 1) * 8) & 0xffn
-    );
-  }
-  return encoded;
+function union(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return [...arrays[0]];
+  const [first, ...rest] = arrays;
+  return uniq(first.concat(...rest));
 }
 
-function bigIntFromBytes(bytes) {
-  ok(bytes.byteLength > 0, "Empty Uint8Array");
-  let decoded = 0n;
-  for (let i = 0; i < bytes.byteLength; i++) {
-    decoded += BigInt(bytes[i]) << BigInt((bytes.byteLength - 1 - i) * 8);
+function uniqBy(array, comparator) {
+  const seen = /* @__PURE__ */ new Set();
+  if (!isFunction(comparator)) {
+    const key = comparator;
+    comparator = (value) => get(value, key);
   }
-  return decoded;
+  return array.filter((value) => {
+    const computed = comparator(value);
+    const hasSeen = seen.has(computed);
+    if (!hasSeen) {
+      seen.add(computed);
+    }
+    return !hasSeen;
+  });
 }
 
-function bytesToBase64(data, { encoding = "base64", padding } = {}) {
-  if (encoding === "base64") {
-    return base64.encode(data, { includePadding: padding ?? true });
-  } else if (encoding === "base64url") {
-    return base64url.encode(data, { includePadding: padding ?? false });
+let AssertionError;
+(async () => {
+  AssertionError = globalThis.window ? await Promise.resolve().then(function () { return BrowserAssertionError$1; }).then(
+    (r) => r.BrowserAssertionError
+  ) : await import('node:assert').then((r) => r.AssertionError);
+})();
+
+function ok(value, message) {
+  if (!value) {
+    throw toError$1(
+      ok,
+      value,
+      message,
+      "The expression evaluated to a falsy value."
+    );
   }
-  ok(false, "Invalid encoding options: " + encoding);
 }
-
-function compareBytes(a, b) {
-  if (a.byteLength !== b.byteLength) {
-    return false;
+function equal(actual, expected, message) {
+  if (actual !== expected) {
+    new AssertionError({
+      actual,
+      expected,
+      message: isString(message) ? message : "The actual value not as expected.",
+      operator: "equal",
+      stackStartFn: equal
+    });
   }
-  for (let i = 0; i < b.byteLength; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
+}
+function notEmpty(value, message) {
+  if (isEmpty(value)) {
+    throw toError$1(notEmpty, value, message, "Expected not empty value.");
   }
-  return true;
 }
-
-function concatenateBytes(a, b) {
-  const result = new Uint8Array(a.byteLength + b.byteLength);
-  result.set(a);
-  result.set(b, a.byteLength);
-  return result;
+function object(value, message) {
+  if (!isObject(value)) {
+    throw toError$1(object, value, message, "Expected object value.");
+  }
 }
-
-function uint16ToUint8(value) {
-  const uint8Array = new Uint8Array(value.length * 2);
-  for (let i = 0; i < value.length; i++) {
-    uint8Array[i * 2] = value[i] & 255;
-    uint8Array[i * 2 + 1] = value[i] >> 8;
+function string(value, message) {
+  if (!isString(value)) {
+    throw toError$1(string, value, message, "Expected string value.");
   }
-  return uint8Array;
 }
-
-function uint32ToUint8(value) {
-  const uint8Array = new Uint8Array(value.length * 4);
-  for (let i = 0; i < value.length; i++) {
-    uint8Array[i * 4] = value[i] & 255;
-    uint8Array[i * 4 + 1] = value[i] >> 8 & 255;
-    uint8Array[i * 4 + 2] = value[i] >> 16 & 255;
-    uint8Array[i * 4 + 3] = value[i] >> 24 & 255;
+function boolean(value, message) {
+  if (!isBoolean(value)) {
+    throw toError$1(boolean, value, message, "Expected boolean value.");
   }
-  return uint8Array;
 }
-
-function uint8ToUint16(value) {
-  ok(
-    value.length % 2 === 0,
-    "Uint8Array length must be even for conversion to Uint16Array"
-  );
-  const uint16Array = new Uint16Array(value.length / 2);
-  for (let i = 0; i < uint16Array.length; i++) {
-    uint16Array[i] = value[i * 2] << 8 | value[i * 2 + 1];
+function notEmptyString(value, message) {
+  if (!isString(value) || !value.trim()) {
+    throw toError$1(
+      notEmptyString,
+      value,
+      message,
+      "Expected not empty string value."
+    );
   }
-  return uint16Array;
 }
-
-function uint8ToUint32(value) {
-  ok(
-    value.length % 4 === 0,
-    "Uint8Array length must be a multiple of 4 for conversion to Uint32Array"
-  );
-  const uint32Array = new Uint32Array(value.length / 4);
-  for (let i = 0; i < uint32Array.length; i++) {
-    uint32Array[i] = value[i * 4] << 24 | value[i * 4 + 1] << 16 | value[i * 4 + 2] << 8 | value[i * 4 + 3];
+function number$1(value, message) {
+  if (!isNumber(value)) {
+    throw toError$1(number$1, value, message, "Expected number value.");
   }
-  return uint32Array;
 }
-
-const def = (obj, key, value, writable = false) => {
-  Object.defineProperty(obj, key, {
-    configurable: true,
-    enumerable: false,
-    writable,
-    value
+function date(value, message) {
+  if (!isDate(value)) {
+    throw toError$1(date, value, message, "Expected date value.");
+  }
+}
+function fn(value, message) {
+  if (!isFunction(value)) {
+    throw toError$1(fn, value, message, "Expected function value.");
+  }
+}
+function greaterThan(value, target, message) {
+  if (!isNumber(value) || value < target) {
+    throw toError$1(
+      greaterThan,
+      value,
+      message,
+      "Expected number value greater then " + target + "."
+    );
+  }
+}
+function lessThan(value, target, message) {
+  if (!isNumber(value) || value > target) {
+    throw toError$1(
+      lessThan,
+      value,
+      message,
+      "Expected number value less then " + target + "."
+    );
+  }
+}
+function array(value, message) {
+  if (!Array.isArray(value)) {
+    throw toError$1(array, value, message, "Expected array value.");
+  }
+}
+function arrayStrings(value, message) {
+  if (!Array.isArray(value) || !value.every(isString)) {
+    throw toError$1(arrayStrings, value, message, "Expected strings list value.");
+  }
+}
+function arrayNumbers(value, message) {
+  if (!Array.isArray(value) || !value.every(isNumber)) {
+    throw toError$1(arrayNumbers, value, message, "Expected numbers list value.");
+  }
+}
+function toError$1(operator, actual, message, unknownMessage = "Unknown error") {
+  if (isError(message)) {
+    return message;
+  }
+  return new AssertionError({
+    actual,
+    message: isString(message) ? message : unknownMessage,
+    operator: operator.name,
+    stackStartFn: operator
   });
+}
+
+const assert = {
+  __proto__: null,
+  array: array,
+  arrayNumbers: arrayNumbers,
+  arrayStrings: arrayStrings,
+  boolean: boolean,
+  date: date,
+  equal: equal,
+  fn: fn,
+  greaterThan: greaterThan,
+  lessThan: lessThan,
+  notEmpty: notEmpty,
+  notEmptyString: notEmptyString,
+  number: number$1,
+  object: object,
+  ok: ok,
+  string: string
 };
 
-const rndCharacters = "abcdefghijklmnopqrstuvwxyz0123456789";
-const charactersLength = rndCharacters.length;
-function randomString(length) {
-  let str = "";
-  let num = isNumber(length) ? Math.max(0, length) : 0;
-  while (num--) {
-    str += rndCharacters[charactersLength * Math.random() | 0];
+function weightedRoundRobin(arr) {
+  ok(arr.length > 0, "Array must contain at least one item.");
+  const instance = new WeightedRoundRobin(
+    arr.map((v) => ({
+      item: v.item,
+      weight: Math.min(v.weight ?? 1, 1)
+    }))
+  );
+  return () => instance.nextItem();
+}
+const gcd = (a, b) => !b ? a : gcd(b, a % b);
+class WeightedRoundRobin {
+  constructor(items) {
+    this.items = items;
+    this.maxWeight = this._calculateMaxWeight();
+    this.gcdWeight = this._calculateGCD();
+  }
+  currentIndex = -1;
+  currentWeight = 0;
+  maxWeight;
+  gcdWeight;
+  _calculateGCD() {
+    return this.items.reduce(
+      (acc, curr) => gcd(acc, curr.weight),
+      this.items[0].weight
+    );
+  }
+  _calculateMaxWeight() {
+    return Math.max(...this.items.map((s) => s.weight));
+  }
+  nextItem() {
+    const n = this.items.length;
+    while (true) {
+      this.currentIndex = (this.currentIndex + 1) % n;
+      if (this.currentIndex === 0) {
+        this.currentWeight -= this.gcdWeight;
+        if (this.currentWeight <= 0) {
+          this.currentWeight = this.maxWeight;
+        }
+      }
+      if (this.items[this.currentIndex].weight >= this.currentWeight) {
+        return this.items[this.currentIndex].item;
+      }
+    }
   }
-  return str;
 }
 
-const objectKeys = /* @__PURE__ */ new WeakMap();
-const BSON_TYPES = Object.freeze(/* @__PURE__ */ new Set(["ObjectID", "ObjectId"]));
-const SYM_WITH_CACHE = Symbol();
-const argToKey = (value, options = { objectStrategy: "ref" }) => {
-  let result = "";
-  if (isObject(value)) {
-    if (BSON_TYPES.has(value?._bsontype)) {
-      return String(value);
+function basex(alphabet) {
+  var BASE = BigInt(alphabet.length);
+  var ZERO_CHAR = alphabet[0];
+  var CHAR_INDEX = {};
+  for (let idx = 0; idx < alphabet.length; idx++) {
+    CHAR_INDEX[alphabet[idx]] = idx;
+  }
+  return {
+    alphabet,
+    padding: "",
+    encode,
+    decode
+  };
+  function encode(input) {
+    var value = 0n;
+    var i = 0;
+    var result = new Array((input.length * 8 / 5 | 0) + 1);
+    var pos = result.length;
+    var leadingZeros = 0;
+    var rem = 0n;
+    for (i = 0; i < input.length; i++) {
+      value = (value << 8n) + BigInt(input[i]);
+    }
+    while (value > 0) {
+      rem = value % BASE;
+      result[--pos] = alphabet[Number(rem)];
+      value = value / BASE;
+    }
+    while (leadingZeros < input.length && input[leadingZeros] === 0) {
+      result[--pos] = ZERO_CHAR;
+      leadingZeros++;
+    }
+    return result.slice(pos).join("");
+  }
+  function decode(input) {
+    var value = 0n;
+    var leadingZeros = 0;
+    var i = 0;
+    var char = "";
+    var index = 0;
+    var bytes = new Uint8Array(input.length * 1.25 | 0);
+    var pos = bytes.length;
+    while (leadingZeros < input.length && input[leadingZeros] === ZERO_CHAR) {
+      leadingZeros++;
+    }
+    for (i = leadingZeros; i < input.length; i++) {
+      char = input[i];
+      index = CHAR_INDEX[char];
+      if (index === void 0) throw new Error("Invalid base62 character");
+      value = value * BASE + BigInt(index);
+    }
+    while (value > 0) {
+      bytes[--pos] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+    return bytes.subarray(pos - leadingZeros);
+  }
+}
+
+const base62 = basex(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+);
+
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var ENCODE_TABLE = new TextEncoder().encode(ALPHABET);
+var DECODE_TABLE = new Uint8Array(256);
+for (let i = 0; i < ENCODE_TABLE.length; ++i) {
+  DECODE_TABLE[ENCODE_TABLE[i]] = i;
+}
+var LOG2_TABLE = new Uint8Array(62);
+LOG2_TABLE[0] = 1;
+for (let i = 1; i < 62; ++i) {
+  LOG2_TABLE[i] = Math.ceil(Math.log2(i + 1));
+}
+const allocEncode = createAllocator();
+const base62Fast = {
+  alphabet: ALPHABET,
+  padding: "",
+  /**
+   * Encodes a Uint8Array into a Base62 string using a custom 5/6-bit variable length scheme.
+   * Processes bits from right to left (most significant bit first conceptually).
+   * @param input The Uint8Array to encode.
+   * @returns The encoded Base62 string.
+   */
+  encode(input) {
+    var position = input.length * 8;
+    var output = allocEncode((position / 5 | 0) + 1);
+    var outputIndex = 0;
+    var chunkSize;
+    var remainderBits;
+    var byteIndex;
+    var extractedBits;
+    var value;
+    while (position > 0) {
+      chunkSize = 6;
+      remainderBits = position & 7;
+      byteIndex = position >>> 3;
+      if (remainderBits === 0) {
+        byteIndex -= 1;
+        remainderBits = 8;
+      }
+      extractedBits = input[byteIndex] >> 8 - remainderBits;
+      if (remainderBits < 6 && byteIndex > 0) {
+        extractedBits |= input[byteIndex - 1] << remainderBits;
+      }
+      value = extractedBits & 63;
+      if ((value & 30) === 30) {
+        if (position > 6 || value > 31) {
+          chunkSize = 5;
+          value &= 31;
+        }
+      }
+      output[outputIndex] = ENCODE_TABLE[additiveCipher(value, outputIndex % 63)];
+      outputIndex++;
+      position -= chunkSize;
     }
-    let key;
-    if (options.objectStrategy === "json") {
-      key = JSON.stringify(value);
-    } else {
-      key = objectKeys.get(value);
-      if (!key) {
-        key = createRadomKey();
-        objectKeys.set(value, key);
+    return new TextDecoder().decode(output.subarray(0, outputIndex));
+  },
+  /**
+   * Decodes a Base62 string generated by the custom encoder back into a Uint8Array.
+   * @param input The Base62 string to decode.
+   * @returns The decoded Uint8Array.
+   */
+  decode(input) {
+    var inputLength = input.length;
+    var maxOutputLength = inputLength * 6 / 8 | 0;
+    var output = new Uint8Array(maxOutputLength);
+    var writeIndex = maxOutputLength;
+    var bitPosition = 0;
+    var buffer = 0;
+    var charCode = 0;
+    var value = 0;
+    for (var readIndex = 0; readIndex < inputLength; readIndex++) {
+      charCode = input.charCodeAt(readIndex);
+      value = DECODE_TABLE[charCode];
+      value = DECODE_TABLE[ENCODE_TABLE[additiveCipherReverse(value, readIndex % 63)]];
+      if (isNaN(charCode) || value === void 0) {
+        throw new Error(
+          "Invalid Base62 input: contains non-alphabet characters. Index: " + readIndex
+        );
+      }
+      buffer |= value << bitPosition;
+      if (readIndex === inputLength - 1) {
+        if (LOG2_TABLE[value] === void 0) {
+          throw new Error(
+            "Invalid Base62 input: unexpected value for last character."
+          );
+        }
+        bitPosition += LOG2_TABLE[value];
+      } else if ((value & 30) === 30) {
+        bitPosition += 5;
+      } else {
+        bitPosition += 6;
+      }
+      if (bitPosition >= 8) {
+        output[--writeIndex] = buffer;
+        bitPosition &= 7;
+        buffer >>= 8;
       }
     }
-    return key;
-  } else if (Array.isArray(value)) {
-    result += value.map((v) => argToKey(v, options)).join("/");
-  } else {
-    result = String(value);
+    if (bitPosition > 0) {
+      output[--writeIndex] = buffer;
+    }
+    return output.subarray(writeIndex);
   }
-  return result;
 };
-function createRadomKey() {
-  return Date.now() + "_" + randomString(16);
+function createAllocator() {
+  var currentBuffer = new Uint8Array(512);
+  var currentSize = 512;
+  return (size) => {
+    if (currentSize < size) {
+      currentBuffer = new Uint8Array(size);
+      currentSize = size;
+    }
+    return currentBuffer;
+  };
+}
+function additiveCipher(value, shift) {
+  return (value + shift) % 62;
+}
+function additiveCipherReverse(obscured, shift) {
+  return (obscured - shift + 62) % 62;
 }
 
-function createWithCache({
-  fn,
-  getPointer,
-  getBucket,
-  objectStrategy = "ref"
-}) {
-  const isAsync = fn.constructor.name === "AsyncFunction";
-  const argToKeyOptions = { objectStrategy };
-  const $cache = {
-    getBucket: () => getBucket(getPointer()),
-    getPointer,
-    argToKeyOptions
-  };
-  const wrapFn = function(...args) {
-    const storage = getBucket(getPointer());
-    const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
-    if (storage.has(cacheKey)) {
-      const value = storage.get(cacheKey);
-      return isAsync ? Promise.resolve(value) : value;
+class Base64Encoding {
+  alphabet;
+  padding;
+  decodeMap = /* @__PURE__ */ new Map();
+  constructor(alphabet, options) {
+    if (alphabet.length !== 64) {
+      throw new Error("Invalid alphabet");
     }
-    const newValue = fn.apply(this, args);
-    if (isPromise(newValue)) {
-      return newValue.then((value) => {
-        storage.set(cacheKey, value);
-        return value;
-      });
+    this.alphabet = alphabet;
+    this.padding = options?.padding ?? "=";
+    if (this.alphabet.includes(this.padding) || this.padding.length !== 1) {
+      throw new Error("Invalid padding");
     }
-    storage.set(cacheKey, newValue);
-    return newValue;
-  };
-  wrapFn.$cache = $cache;
-  def(wrapFn, SYM_WITH_CACHE, true);
-  return wrapFn;
-}
-function isWithCache(value) {
-  return !!value && value[SYM_WITH_CACHE] === true;
-}
-
-const cache = /* @__PURE__ */ new WeakMap();
-function withCache(...args) {
-  let options = {};
-  let fn = noop;
-  if (isFunction(args[0])) {
-    fn = args[0];
-  } else if (isFunction(args[1])) {
-    options = args[0] || {};
-    fn = args[1];
-  }
-  const pointer = options.cachePointer || fn;
-  const getPointer = () => pointer;
-  const getBucket = (pointer2) => {
-    let fnCache = cache.get(pointer2);
-    if (!fnCache) {
-      fnCache = /* @__PURE__ */ new Map();
-      cache.set(pointer2, fnCache);
+    for (let i = 0; i < alphabet.length; i++) {
+      this.decodeMap.set(alphabet[i], i);
     }
-    return fnCache;
-  };
-  return createWithCache({
-    fn,
-    getBucket,
-    getPointer,
-    ...options
-  });
-}
-
-function assertCapacity(value) {
-  number$1(value, "capacity must be a number");
-  ok(value > 0, "capacity must be more then 0.");
-}
-
-class FixedMap extends Map {
-  constructor(_capacity) {
-    assertCapacity(_capacity);
-    super();
-    this._capacity = _capacity;
-    this._tail = [];
   }
-  _tail;
-  set(key, value) {
-    if (!super.has.call(this, key)) {
-      this._tail.push(key);
+  /**
+   * Encodes binary data into a base64 string representation
+   *
+   * @param input - The binary data to encode
+   * @returns The encoded string
+   *
+   * @example
+   * ```typescript
+   * const data = new Uint8Array([255, 255]);
+   * console.log(base64.encode(data));
+   * ```
+   */
+  encode(data, options) {
+    let result = "";
+    let buffer = 0;
+    let shift = 0;
+    for (let i = 0; i < data.length; i++) {
+      buffer = buffer << 8 | data[i];
+      shift += 8;
+      while (shift >= 6) {
+        shift += -6;
+        result += this.alphabet[buffer >> shift & 63];
+      }
     }
-    super.set.call(this, key, value);
-    this._drain();
-    return this;
-  }
-  delete(key) {
-    const removed = super.delete.call(this, key);
-    if (removed) {
-      const idx = this._tail.findIndex((v) => v === key);
-      if (idx > -1) {
-        this._tail.splice(idx, 1);
+    if (shift > 0) {
+      result += this.alphabet[buffer << 6 - shift & 63];
+    }
+    const includePadding = options?.includePadding ?? true;
+    if (includePadding) {
+      const padCount = (4 - result.length % 4) % 4;
+      for (let i = 0; i < padCount; i++) {
+        result += "=";
       }
     }
-    return removed;
-  }
-  clear() {
-    delete this._tail;
-    this._tail = [];
-    super.clear.call(this);
-  }
-  get capacity() {
-    return this._capacity;
-  }
-  set capacity(value) {
-    assertCapacity(value);
-    this._capacity = value;
-    this._drain();
+    return result;
   }
-  _drain() {
-    while (this._tail.length > this._capacity) {
-      const key = this._tail.shift();
-      key !== void 0 && this.delete(key);
+  /**
+   * Decodes a base64 string back into binary data
+   *
+   * @param input - The encoded string to decode
+   * @returns The decoded binary data
+   * @throws {Error} When the input contains invalid characters or format
+   *
+   * @example
+   * ```typescript
+   * const encoded = "AA==";
+   * console.log(base64.decode(encoded)); // Uint8Array [255, 255]
+   * ```
+   */
+  decode(data, options) {
+    const strict = options?.strict ?? true;
+    const chunkCount = Math.ceil(data.length / 4);
+    const result = [];
+    for (let i = 0; i < chunkCount; i++) {
+      let padCount = 0;
+      let buffer = 0;
+      for (let j = 0; j < 4; j++) {
+        const encoded = data[i * 4 + j];
+        if (encoded === "=") {
+          if (i + 1 !== chunkCount) {
+            throw new Error(`Invalid character: ${encoded}`);
+          }
+          padCount += 1;
+          continue;
+        }
+        if (encoded === void 0) {
+          if (strict) {
+            throw new Error("Invalid data");
+          }
+          padCount += 1;
+          continue;
+        }
+        const value = this.decodeMap.get(encoded) ?? null;
+        if (value === null) {
+          throw new Error(`Invalid character: ${encoded}`);
+        }
+        buffer += value << 6 * (3 - j);
+      }
+      result.push(buffer >> 16 & 255);
+      if (padCount < 2) {
+        result.push(buffer >> 8 & 255);
+      }
+      if (padCount < 1) {
+        result.push(buffer & 255);
+      }
     }
+    return Uint8Array.from(result);
   }
 }
 
-class TimeBucket {
-  _pointer;
-  _sizeMs;
-  _bucket;
-  constructor({ capacity = Infinity, sizeMs }) {
-    assetSizeMs(sizeMs);
-    this._sizeMs = sizeMs;
-    this._pointer = 0;
-    this._bucket = capacity === Infinity ? /* @__PURE__ */ new Map() : new FixedMap(capacity);
-  }
-  get capacity() {
-    if (this._bucket instanceof FixedMap) {
-      return this._bucket.capacity;
-    }
-    return Infinity;
-  }
-  get sizeMs() {
-    return this.sizeMs;
+const base64 = new Base64Encoding(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+);
+const base64url = new Base64Encoding(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+);
+
+function base64ToBytes(data, { encoding = "base64", strict } = {}) {
+  if (encoding === "base64") {
+    return base64.decode(data, { strict: strict ?? true });
+  } else if (encoding === "base64url") {
+    return base64url.decode(data, { strict: strict ?? false });
   }
-  set sizeMs(value) {
-    assetSizeMs(value);
-    this._sizeMs = value;
-    this._drainBucket();
+  ok(false, "Invalid encoding options: " + encoding);
+}
+
+function bigIntBytes(value) {
+  if (value < 0n) {
+    value = value * -1n;
   }
-  get size() {
-    this._drainBucket();
-    return this._bucket.size;
+  let byteLength = 1;
+  while (value > 2n ** BigInt(byteLength * 8) - 1n) {
+    byteLength++;
   }
-  set(key, value) {
-    this._drainBucket();
-    this._bucket.set(key, value);
-    return this;
+  const encoded = new Uint8Array(byteLength);
+  for (let i = 0; i < encoded.byteLength; i++) {
+    encoded[i] = Number(
+      value >> BigInt((encoded.byteLength - i - 1) * 8) & 0xffn
+    );
   }
-  get(key) {
-    this._drainBucket();
-    return this._bucket.get(key);
+  return encoded;
+}
+
+function bigIntFromBytes(bytes) {
+  ok(bytes.byteLength > 0, "Empty Uint8Array");
+  let decoded = 0n;
+  for (let i = 0; i < bytes.byteLength; i++) {
+    decoded += BigInt(bytes[i]) << BigInt((bytes.byteLength - 1 - i) * 8);
   }
-  has(key) {
-    this._drainBucket();
-    return this._bucket.has(key);
+  return decoded;
+}
+
+function bytesToBase64(data, { encoding = "base64", padding } = {}) {
+  if (encoding === "base64") {
+    return base64.encode(data, { includePadding: padding ?? true });
+  } else if (encoding === "base64url") {
+    return base64url.encode(data, { includePadding: padding ?? false });
   }
-  delete(key) {
-    this._drainBucket();
-    return this._bucket.delete(key);
+  ok(false, "Invalid encoding options: " + encoding);
+}
+
+function compareBytes(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
   }
-  clear() {
-    this._pointer = 0;
-    this._drainBucket();
+  for (let i = 0; i < b.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
   }
-  keys() {
-    this._drainBucket();
-    return this._bucket.keys();
-  }
-  values() {
-    this._drainBucket();
-    return this._bucket.values();
-  }
-  entries() {
-    this._drainBucket();
-    return this._bucket.entries();
+  return true;
+}
+
+function concatenateBytes(a, b) {
+  const result = new Uint8Array(a.byteLength + b.byteLength);
+  result.set(a);
+  result.set(b, a.byteLength);
+  return result;
+}
+
+function uint16ToUint8(value) {
+  const uint8Array = new Uint8Array(value.length * 2);
+  for (let i = 0; i < value.length; i++) {
+    uint8Array[i * 2] = value[i] & 255;
+    uint8Array[i * 2 + 1] = value[i] >> 8;
   }
-  forEach(callbackfn, thisArg) {
-    this._drainBucket();
-    return this._bucket.forEach((value, key) => {
-      callbackfn(value, key, this);
-    });
+  return uint8Array;
+}
+
+function uint32ToUint8(value) {
+  const uint8Array = new Uint8Array(value.length * 4);
+  for (let i = 0; i < value.length; i++) {
+    uint8Array[i * 4] = value[i] & 255;
+    uint8Array[i * 4 + 1] = value[i] >> 8 & 255;
+    uint8Array[i * 4 + 2] = value[i] >> 16 & 255;
+    uint8Array[i * 4 + 3] = value[i] >> 24 & 255;
   }
-  _drainBucket() {
-    const newPointer = bucketPointer(this._sizeMs);
-    if (newPointer !== this._pointer) {
-      const capacity = this._bucket instanceof FixedMap ? this._bucket.capacity : Infinity;
-      delete this._bucket;
-      this._pointer = newPointer;
-      this._bucket = capacity === Infinity ? /* @__PURE__ */ new Map() : new FixedMap(capacity);
-    }
+  return uint8Array;
+}
+
+function uint8ToUint16(value) {
+  ok(
+    value.length % 2 === 0,
+    "Uint8Array length must be even for conversion to Uint16Array"
+  );
+  const uint16Array = new Uint16Array(value.length / 2);
+  for (let i = 0; i < uint16Array.length; i++) {
+    uint16Array[i] = value[i * 2] << 8 | value[i * 2 + 1];
   }
+  return uint16Array;
 }
-function assetSizeMs(value) {
-  if (typeof value !== "number" || isNaN(value)) {
-    throw new TypeError("msSize must be a number");
+
+function uint8ToUint32(value) {
+  ok(
+    value.length % 4 === 0,
+    "Uint8Array length must be a multiple of 4 for conversion to Uint32Array"
+  );
+  const uint32Array = new Uint32Array(value.length / 4);
+  for (let i = 0; i < uint32Array.length; i++) {
+    uint32Array[i] = value[i * 4] << 24 | value[i * 4 + 1] << 16 | value[i * 4 + 2] << 8 | value[i * 4 + 3];
   }
-  if (value <= 0) {
-    throw new TypeError("msSize must be more then 0.");
+  return uint32Array;
+}
+
+const rndCharacters = "abcdefghijklmnopqrstuvwxyz0123456789";
+const charactersLength = rndCharacters.length;
+function randomString(length) {
+  let str = "";
+  let num = isNumber(length) ? Math.max(0, length) : 0;
+  while (num--) {
+    str += rndCharacters[charactersLength * Math.random() | 0];
   }
+  return str;
 }
-function bucketPointer(size) {
-  return Math.floor(Date.now() / size) * size;
+
+const objectKeys = /* @__PURE__ */ new WeakMap();
+const BSON_TYPES = Object.freeze(/* @__PURE__ */ new Set(["ObjectID", "ObjectId"]));
+const SYM_WITH_CACHE = Symbol();
+const argToKey = (value, options = { objectStrategy: "ref" }) => {
+  let result = "";
+  if (isObject(value)) {
+    if (BSON_TYPES.has(value?._bsontype)) {
+      return String(value);
+    }
+    let key;
+    if (options.objectStrategy === "json") {
+      key = JSON.stringify(value);
+    } else {
+      key = objectKeys.get(value);
+      if (!key) {
+        key = createRadomKey();
+        objectKeys.set(value, key);
+      }
+    }
+    return key;
+  } else if (Array.isArray(value)) {
+    result += value.map((v) => argToKey(v, options)).join("/");
+  } else {
+    result = String(value);
+  }
+  return result;
+};
+function createRadomKey() {
+  return Date.now() + "_" + randomString(16);
 }
 
-const cacheBucket = /* @__PURE__ */ new WeakMap();
-function withCacheBucket({ capacity, sizeMs, cachePointer, ...options }, fn) {
-  const pointer = cachePointer || fn;
-  const getPointer = () => {
-    return pointer;
+function createWithCache({
+  fn,
+  getPointer,
+  getBucket,
+  objectStrategy = "ref"
+}) {
+  const isAsync = fn.constructor.name === "AsyncFunction";
+  const argToKeyOptions = { objectStrategy };
+  const $cache = {
+    getBucket: () => getBucket(getPointer()),
+    getPointer,
+    argToKeyOptions
   };
-  const getBucket = () => {
-    let fnCache = cacheBucket.get(pointer);
-    if (!fnCache) {
-      fnCache = new TimeBucket({ sizeMs, capacity });
-      cacheBucket.set(pointer, fnCache);
+  const wrapFn = function(...args) {
+    const storage = getBucket(getPointer());
+    const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
+    if (storage.has(cacheKey)) {
+      const value = storage.get(cacheKey);
+      return isAsync ? Promise.resolve(value) : value;
     }
-    return fnCache;
+    const newValue = fn.apply(this, args);
+    if (isPromise(newValue)) {
+      return newValue.then((value) => {
+        storage.set(cacheKey, value);
+        return value;
+      });
+    }
+    storage.set(cacheKey, newValue);
+    return newValue;
   };
-  return createWithCache({
-    fn,
-    getBucket,
-    getPointer,
-    ...options
-  });
+  wrapFn.$cache = $cache;
+  def(wrapFn, SYM_WITH_CACHE, true);
+  return wrapFn;
+}
+function isWithCache(value) {
+  return !!value && value[SYM_WITH_CACHE] === true;
 }
 
-const cacheFixed = /* @__PURE__ */ new WeakMap();
-function withCacheFixed({ capacity, cachePointer, ...options }, fn) {
-  const pointer = cachePointer || fn;
-  const getPointer = () => fn;
-  const getBucket = () => {
-    let fnCache = cacheFixed.get(pointer);
+const cache = /* @__PURE__ */ new WeakMap();
+function withCache(...args) {
+  let options = {};
+  let fn = noop;
+  if (isFunction(args[0])) {
+    fn = args[0];
+  } else if (isFunction(args[1])) {
+    options = args[0] || {};
+    fn = args[1];
+  }
+  const pointer = options.cachePointer || fn;
+  const getPointer = () => pointer;
+  const getBucket = (pointer2) => {
+    let fnCache = cache.get(pointer2);
     if (!fnCache) {
-      fnCache = new FixedMap(capacity);
-      cacheFixed.set(pointer, fnCache);
+      fnCache = /* @__PURE__ */ new Map();
+      cache.set(pointer2, fnCache);
     }
     return fnCache;
   };
@@ -1159,63 +1490,246 @@ function withCacheFixed({ capacity, cachePointer, ...options }, fn) {
   });
 }
 
-class LruCache {
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.capacity = Math.max(isNumber(capacity) ? capacity : 0, 0);
-    this.forward = pointerArray(this.capacity);
-    this.backward = pointerArray(this.capacity);
-    this.K = new Array(capacity);
-    this.V = new Array(capacity);
-    this.items = /* @__PURE__ */ new Map();
-    this.size = 0;
-    this.head = 0;
-    this.tail = 0;
-  }
-  items;
-  forward;
-  backward;
-  K;
-  V;
-  size;
-  head;
-  tail;
-  /**
-   * Method used to clear the structure.
-   */
-  clear() {
-    this.size = 0;
-    this.head = 0;
-    this.tail = 0;
-    this.items.clear();
+function assertCapacity(value) {
+  number$1(value, "capacity must be a number");
+  ok(value > 0, "capacity must be more then 0.");
+}
+
+class FixedMap extends Map {
+  constructor(_capacity) {
+    assertCapacity(_capacity);
+    super();
+    this._capacity = _capacity;
+    this._tail = [];
   }
+  _tail;
   set(key, value) {
-    let pointer = this.items.get(key);
-    if (pointer !== void 0) {
-      this.splayOnTop(pointer);
-      this.V[pointer] = value;
-      return this;
-    }
-    if (this.size < this.capacity) {
-      pointer = this.size++;
-    } else {
-      pointer = this.tail;
-      this.tail = this.backward[pointer];
-      this.items.delete(this.K[pointer]);
+    if (!super.has.call(this, key)) {
+      this._tail.push(key);
     }
-    this.items.set(key, pointer);
-    this.K[pointer] = key;
-    this.V[pointer] = value;
-    this.forward[pointer] = this.head;
-    this.backward[this.head] = pointer;
-    this.head = pointer;
+    super.set.call(this, key, value);
+    this._drain();
     return this;
   }
-  has(key) {
-    return this.peek(key) !== void 0;
-  }
   delete(key) {
-    const pointer = this.items.get(key);
+    const removed = super.delete.call(this, key);
+    if (removed) {
+      const idx = this._tail.findIndex((v) => v === key);
+      if (idx > -1) {
+        this._tail.splice(idx, 1);
+      }
+    }
+    return removed;
+  }
+  clear() {
+    delete this._tail;
+    this._tail = [];
+    super.clear.call(this);
+  }
+  get capacity() {
+    return this._capacity;
+  }
+  set capacity(value) {
+    assertCapacity(value);
+    this._capacity = value;
+    this._drain();
+  }
+  _drain() {
+    while (this._tail.length > this._capacity) {
+      const key = this._tail.shift();
+      key !== void 0 && this.delete(key);
+    }
+  }
+}
+
+class TimeBucket {
+  _pointer;
+  _sizeMs;
+  _bucket;
+  constructor({ capacity = Infinity, sizeMs }) {
+    assetSizeMs(sizeMs);
+    this._sizeMs = sizeMs;
+    this._pointer = 0;
+    this._bucket = capacity === Infinity ? /* @__PURE__ */ new Map() : new FixedMap(capacity);
+  }
+  get capacity() {
+    if (this._bucket instanceof FixedMap) {
+      return this._bucket.capacity;
+    }
+    return Infinity;
+  }
+  get sizeMs() {
+    return this.sizeMs;
+  }
+  set sizeMs(value) {
+    assetSizeMs(value);
+    this._sizeMs = value;
+    this._drainBucket();
+  }
+  get size() {
+    this._drainBucket();
+    return this._bucket.size;
+  }
+  set(key, value) {
+    this._drainBucket();
+    this._bucket.set(key, value);
+    return this;
+  }
+  get(key) {
+    this._drainBucket();
+    return this._bucket.get(key);
+  }
+  has(key) {
+    this._drainBucket();
+    return this._bucket.has(key);
+  }
+  delete(key) {
+    this._drainBucket();
+    return this._bucket.delete(key);
+  }
+  clear() {
+    this._pointer = 0;
+    this._drainBucket();
+  }
+  keys() {
+    this._drainBucket();
+    return this._bucket.keys();
+  }
+  values() {
+    this._drainBucket();
+    return this._bucket.values();
+  }
+  entries() {
+    this._drainBucket();
+    return this._bucket.entries();
+  }
+  forEach(callbackfn, thisArg) {
+    this._drainBucket();
+    return this._bucket.forEach((value, key) => {
+      callbackfn(value, key, this);
+    });
+  }
+  _drainBucket() {
+    const newPointer = bucketPointer(this._sizeMs);
+    if (newPointer !== this._pointer) {
+      const capacity = this._bucket instanceof FixedMap ? this._bucket.capacity : Infinity;
+      delete this._bucket;
+      this._pointer = newPointer;
+      this._bucket = capacity === Infinity ? /* @__PURE__ */ new Map() : new FixedMap(capacity);
+    }
+  }
+}
+function assetSizeMs(value) {
+  if (typeof value !== "number" || isNaN(value)) {
+    throw new TypeError("msSize must be a number");
+  }
+  if (value <= 0) {
+    throw new TypeError("msSize must be more then 0.");
+  }
+}
+function bucketPointer(size) {
+  return Math.floor(Date.now() / size) * size;
+}
+
+const cacheBucket = /* @__PURE__ */ new WeakMap();
+function withCacheBucket({ capacity, sizeMs, cachePointer, ...options }, fn) {
+  const pointer = cachePointer || fn;
+  const getPointer = () => {
+    return pointer;
+  };
+  const getBucket = () => {
+    let fnCache = cacheBucket.get(pointer);
+    if (!fnCache) {
+      fnCache = new TimeBucket({ sizeMs, capacity });
+      cacheBucket.set(pointer, fnCache);
+    }
+    return fnCache;
+  };
+  return createWithCache({
+    fn,
+    getBucket,
+    getPointer,
+    ...options
+  });
+}
+
+const cacheFixed = /* @__PURE__ */ new WeakMap();
+function withCacheFixed({ capacity, cachePointer, ...options }, fn) {
+  const pointer = cachePointer || fn;
+  const getPointer = () => fn;
+  const getBucket = () => {
+    let fnCache = cacheFixed.get(pointer);
+    if (!fnCache) {
+      fnCache = new FixedMap(capacity);
+      cacheFixed.set(pointer, fnCache);
+    }
+    return fnCache;
+  };
+  return createWithCache({
+    fn,
+    getBucket,
+    getPointer,
+    ...options
+  });
+}
+
+class LruCache {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.capacity = Math.max(isNumber(capacity) ? capacity : 0, 0);
+    this.forward = pointerArray(this.capacity);
+    this.backward = pointerArray(this.capacity);
+    this.K = new Array(capacity);
+    this.V = new Array(capacity);
+    this.items = /* @__PURE__ */ new Map();
+    this.size = 0;
+    this.head = 0;
+    this.tail = 0;
+  }
+  items;
+  forward;
+  backward;
+  K;
+  V;
+  size;
+  head;
+  tail;
+  /**
+   * Method used to clear the structure.
+   */
+  clear() {
+    this.size = 0;
+    this.head = 0;
+    this.tail = 0;
+    this.items.clear();
+  }
+  set(key, value) {
+    let pointer = this.items.get(key);
+    if (pointer !== void 0) {
+      this.splayOnTop(pointer);
+      this.V[pointer] = value;
+      return this;
+    }
+    if (this.size < this.capacity) {
+      pointer = this.size++;
+    } else {
+      pointer = this.tail;
+      this.tail = this.backward[pointer];
+      this.items.delete(this.K[pointer]);
+    }
+    this.items.set(key, pointer);
+    this.K[pointer] = key;
+    this.V[pointer] = value;
+    this.forward[pointer] = this.head;
+    this.backward[this.head] = pointer;
+    this.head = pointer;
+    return this;
+  }
+  has(key) {
+    return this.peek(key) !== void 0;
+  }
+  delete(key) {
+    const pointer = this.items.get(key);
     if (pointer === void 0) return;
     this.V[pointer] = void 0;
   }
@@ -1419,425 +1933,122 @@ class FixedWeakMap extends WeakMap {
         this._tail.splice(idx, 1);
       }
     }
-    return removed;
-  }
-  clear() {
-    for (const item of this._tail) {
-      super.delete(item);
-    }
-    delete this._tail;
-    this._tail = [];
-  }
-  get size() {
-    return this._tail.length;
-  }
-  get capacity() {
-    return this._capacity;
-  }
-  set capacity(value) {
-    assertCapacity(value);
-    this._capacity = value;
-    this._drain();
-  }
-  _drain() {
-    while (this._tail.length > this._capacity) {
-      const key = this._tail.shift();
-      key !== void 0 && this.delete(key);
-    }
-  }
-}
-
-function isCached(fn, ...args) {
-  let argToKeyOptions = { objectStrategy: "ref" };
-  let cachePointer = fn;
-  let cached = false;
-  if (isWithCache(fn)) {
-    argToKeyOptions = fn.$cache.argToKeyOptions;
-  }
-  const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
-  if (isWithCache(fn)) {
-    cached = fn.$cache.getBucket().has(cacheKey);
-    cachePointer = fn.$cache.getPointer();
-    if (cached) return true;
-  }
-  return !![cache, cacheFixed, cacheBucket, cacheLRU].some(
-    (storage) => storage.get(cachePointer)?.has(cacheKey)
-  );
-}
-
-const EMPTY_SYM = Symbol("empty");
-function withCacheBucketBatch({
-  capacity,
-  sizeMs,
-  key,
-  batchSize = 10,
-  cachePointer,
-  retryEmpty = true
-}, resolver) {
-  const pointer = cachePointer || resolver;
-  const argToKeyOptions = {
-    objectStrategy: "json"
-  };
-  const getPointer = () => {
-    return pointer;
-  };
-  const getBucket = () => {
-    let fnCache = cacheBucket.get(pointer);
-    if (!fnCache) {
-      fnCache = new TimeBucket({ sizeMs, capacity });
-      cacheBucket.set(pointer, fnCache);
-    }
-    return fnCache;
-  };
-  const wrapFn = async function(values) {
-    const result = /* @__PURE__ */ new Map();
-    let fnCache = getBucket();
-    const batchSet = /* @__PURE__ */ new Set();
-    const drainMaybe = async () => {
-      if (!batchSet.size) return;
-      const items = await resolver.call(this, Array.from(batchSet));
-      for (let idx = 0; idx < items.length; idx++) {
-        const item = items[idx];
-        if (!isObject(item)) continue;
-        const id = argToKey(item[key], argToKeyOptions);
-        batchSet.delete(id);
-        result.set(id, item);
-        fnCache?.set(id, item);
-      }
-      for (const batchItem of batchSet.values()) {
-        fnCache?.set(batchItem, EMPTY_SYM);
-      }
-      batchSet.clear();
-    };
-    let pos = 0;
-    while (pos < values.length) {
-      const id = argToKey(values[pos], argToKeyOptions);
-      const item = fnCache.get(id);
-      if (item) {
-        if (item === EMPTY_SYM) {
-          if (retryEmpty) batchSet.add(id);
-        } else {
-          result.set(id, item);
-        }
-      } else {
-        batchSet.add(id);
-      }
-      if (batchSet.size >= batchSize) {
-        await drainMaybe();
-      }
-      pos++;
-    }
-    await drainMaybe();
-    return result;
-  };
-  wrapFn.$cache = { getBucket, getPointer, argToKeyOptions };
-  def(wrapFn, SYM_WITH_CACHE, true);
-  return wrapFn;
-}
-
-function cleanEmpty(obj) {
-  let value;
-  for (const key of Object.keys(obj)) {
-    value = obj[key];
-    if (isEmpty(value)) {
-      delete obj[key];
-    }
-  }
-  return obj;
-}
-
-const cleanObject = (input) => {
-  [...Object.keys(input), ...Object.getOwnPropertySymbols(input)].forEach(
-    (key) => {
-      delete input[key];
-    }
-  );
-};
-
-const deepAssign = (dest, source) => {
-  for (const key of Object.keys(source)) {
-    const destValue = dest[key];
-    const sourceValue = source[key];
-    if (isObject(destValue) && isObject(sourceValue)) {
-      deepAssign(destValue, sourceValue);
-    } else {
-      dest[key] = sourceValue;
-    }
-  }
-};
-
-const deepClone = (value) => {
-  return _cloneDeep__default(value);
-};
-
-const WITH_CUSTOMIZER_FACTORY_SYM = Symbol();
-function deepCloneWith(value, customizer) {
-  const fns = prepareCustomizes(customizer);
-  return _cloneDeepWith__default(value, (value2, key) => {
-    let newValue;
-    let replaced = false;
-    for (const fn of fns) {
-      newValue = fn(value2, key);
-      if (newValue !== void 0) {
-        value2 = newValue;
-        replaced = true;
-      }
-    }
-    if (replaced) return value2;
-  });
-}
-function createDeepCloneWith(customizer) {
-  return (value) => {
-    return deepCloneWith(value, customizer);
-  };
-}
-function prepareCustomizes(value) {
-  return arrayable(value).map((v) => isCustomizerFactory(v) ? v() : v);
-}
-function isCustomizerFactory(value) {
-  return value?.[WITH_CUSTOMIZER_FACTORY_SYM] === true;
-}
-function createCustomizer(fn) {
-  return fn;
-}
-function createCustomizerFactory(fn) {
-  def(fn, WITH_CUSTOMIZER_FACTORY_SYM, true);
-  return fn;
-}
-function createSecureCustomizer(properties) {
-  const secureLabel = `<** secure **>`;
-  const circularLabel = `<** circular **>`;
-  const propertiesSet = Object.freeze(
-    new Set(properties.map((v) => v.toLocaleLowerCase()))
-  );
-  const withCustomizer = (seenSet, value, key) => {
-    if (isPrimitive(value)) {
-      if (!isString(key)) return;
-      if (!propertiesSet.has(key.toLocaleLowerCase())) return;
-      return secureLabel;
-    }
-    if (seenSet.has(value)) {
-      return circularLabel;
-    }
-    seenSet.add(value);
-    if (isError(value)) {
-      return {
-        message: value.message,
-        stack: value.stack,
-        name: value.name
-      };
-    }
-  };
-  return createCustomizerFactory(() => {
-    const seenSet = /* @__PURE__ */ new WeakSet();
-    return withCustomizer.bind(null, seenSet);
-  });
-}
-
-const deepDefaults = _defaultsDeep__default;
-
-function deepFreeze(value) {
-  let currentValue = value;
-  if (!currentValue || typeof currentValue !== "object") return currentValue;
-  Object.freeze(currentValue);
-  if (Array.isArray(currentValue)) {
-    for (const item of currentValue) {
-      deepFreeze(item);
-    }
-    return currentValue;
-  } else {
-    for (const value2 of Object.values(currentValue)) {
-      deepFreeze(value2);
-    }
-  }
-  return currentValue;
-}
-
-function flagsToMap(value, bitmaskMap) {
-  const result = {};
-  const compare = typeof value === "bigint" ? 0n : 0;
-  for (const [key, mask] of Object.entries(bitmaskMap)) {
-    result[key] = (value & mask) !== compare;
-  }
-  return result;
-}
-
-function flatten(obj, {
-  separator = "_",
-  initialPrefix = "",
-  withArrays = true,
-  isObjectCompare = isObject
-} = {}) {
-  const result = {};
-  const seen = /* @__PURE__ */ new WeakSet();
-  if (isObjectCompare(obj)) {
-    iter(
-      result,
-      seen,
-      isObjectCompare,
-      separator,
-      withArrays,
-      obj,
-      initialPrefix,
-      true
-    );
-  }
-  return result;
-}
-function iter(output, seen, isObjectCompare, separator, withArrays, val, key, initial) {
-  if (seen.has(val)) return;
-  let k, pfx = key && !initial ? key + separator : key;
-  if (Array.isArray(val)) {
-    seen.add(val);
-    if (!withArrays) {
-      output[key] = val;
-      return;
-    }
-    for (k = 0; k < val.length; k++) {
-      iter(
-        output,
-        seen,
-        isObjectCompare,
-        separator,
-        withArrays,
-        val[k],
-        pfx + k
-      );
-    }
-  } else if (isObjectCompare(val)) {
-    seen.add(val);
-    for (k in val) {
-      iter(
-        output,
-        seen,
-        isObjectCompare,
-        separator,
-        withArrays,
-        val[k],
-        pfx + k
-      );
-    }
-  } else {
-    output[key] = val;
-  }
-}
-
-function has(value, keys) {
-  if (!isObject(value)) return false;
-  for (let idx = 0; idx < keys.length; idx++) {
-    const element = keys[idx];
-    if (!(element in value)) return false;
-  }
-  return true;
-}
-
-const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
-
-function omit(obj, excludes) {
-  const excludesSet = Array.isArray(excludes) ? new Set(excludes) : excludes instanceof Set ? excludes : void 0;
-  if (!excludesSet) {
-    return obj;
-  }
-  const result = {};
-  if (!isObject(obj)) {
-    return result;
+    return removed;
   }
-  for (const [key, value] of Object.entries(obj)) {
-    if (excludesSet.has(key)) continue;
-    result[key] = value;
+  clear() {
+    for (const item of this._tail) {
+      super.delete(item);
+    }
+    delete this._tail;
+    this._tail = [];
   }
-  return result;
-}
-
-function omitPrefixed(obj, prefix) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (key.startsWith(prefix)) continue;
-    result[key] = value;
+  get size() {
+    return this._tail.length;
   }
-  return result;
-}
-
-function pick(obj, keys) {
-  const keysSet = Array.isArray(keys) ? new Set(keys) : keys instanceof Set ? keys : void 0;
-  const result = {};
-  if (!keysSet || !isObject(obj)) {
-    return result;
+  get capacity() {
+    return this._capacity;
   }
-  for (const key of keysSet.values()) {
-    if (hasOwn(obj, key)) {
-      result[key] = obj[key];
+  set capacity(value) {
+    assertCapacity(value);
+    this._capacity = value;
+    this._drain();
+  }
+  _drain() {
+    while (this._tail.length > this._capacity) {
+      const key = this._tail.shift();
+      key !== void 0 && this.delete(key);
     }
   }
-  return result;
 }
 
-function pickPrefixed(obj, options) {
-  let prefix;
-  let prefixTrim = false;
-  if (typeof options === "string") {
-    prefix = options;
-  } else {
-    prefix = options.prefix;
-    prefixTrim = options.prefixTrim === true;
+function isCached(fn, ...args) {
+  let argToKeyOptions = { objectStrategy: "ref" };
+  let cachePointer = fn;
+  let cached = false;
+  if (isWithCache(fn)) {
+    argToKeyOptions = fn.$cache.argToKeyOptions;
   }
-  const result = {};
-  for (let [key, value] of Object.entries(obj)) {
-    if (!key.startsWith(prefix)) continue;
-    if (prefixTrim) key = key.substring(prefix.length);
-    result[key] = value;
+  const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
+  if (isWithCache(fn)) {
+    cached = fn.$cache.getBucket().has(cacheKey);
+    cachePointer = fn.$cache.getPointer();
+    if (cached) return true;
   }
-  return result;
+  return !![cache, cacheFixed, cacheBucket, cacheLRU].some(
+    (storage) => storage.get(cachePointer)?.has(cacheKey)
+  );
 }
 
-const set = _set__default;
-
-const toMap = (obj) => {
-  const map = new Map(Object.entries(obj));
-  for (const symbol of Object.getOwnPropertySymbols(obj)) {
-    map.set(symbol, obj[symbol]);
-  }
-  return map;
-};
-
-const badKeys = Object.freeze(
-  /* @__PURE__ */ new Set(["constructor", "__proto__", "prototype"])
-);
-function unflatten(input, separator = "_") {
-  if (!isObject(input)) {
-    return {};
-  }
-  let arr, tmp, output;
-  let i = 0, k, key;
-  for (k in input) {
-    tmp = output;
-    arr = k.split(separator);
-    for (i = 0; i < arr.length; ) {
-      key = arr[i++];
-      if (tmp == null) {
-        tmp = empty(+key);
-        output = output || tmp;
+const EMPTY_SYM = Symbol("empty");
+function withCacheBucketBatch({
+  capacity,
+  sizeMs,
+  key,
+  batchSize = 10,
+  cachePointer,
+  retryEmpty = true
+}, resolver) {
+  const pointer = cachePointer || resolver;
+  const argToKeyOptions = {
+    objectStrategy: "json"
+  };
+  const getPointer = () => {
+    return pointer;
+  };
+  const getBucket = () => {
+    let fnCache = cacheBucket.get(pointer);
+    if (!fnCache) {
+      fnCache = new TimeBucket({ sizeMs, capacity });
+      cacheBucket.set(pointer, fnCache);
+    }
+    return fnCache;
+  };
+  const wrapFn = async function(values) {
+    const result = /* @__PURE__ */ new Map();
+    let fnCache = getBucket();
+    const batchSet = /* @__PURE__ */ new Set();
+    const drainMaybe = async () => {
+      if (!batchSet.size) return;
+      const items = await resolver.call(this, Array.from(batchSet));
+      for (let idx = 0; idx < items.length; idx++) {
+        const item = items[idx];
+        if (!isObject(item)) continue;
+        const id = argToKey(item[key], argToKeyOptions);
+        batchSet.delete(id);
+        result.set(id, item);
+        fnCache?.set(id, item);
       }
-      if (badKeys.has(key)) break;
-      if (i < arr.length) {
-        if (key in tmp) {
-          tmp = tmp[key];
+      for (const batchItem of batchSet.values()) {
+        fnCache?.set(batchItem, EMPTY_SYM);
+      }
+      batchSet.clear();
+    };
+    let pos = 0;
+    while (pos < values.length) {
+      const id = argToKey(values[pos], argToKeyOptions);
+      const item = fnCache.get(id);
+      if (item) {
+        if (item === EMPTY_SYM) {
+          if (retryEmpty) batchSet.add(id);
         } else {
-          tmp = tmp[key] = empty(+arr[i]);
+          result.set(id, item);
         }
       } else {
-        tmp[key] = input[k];
+        batchSet.add(id);
       }
+      if (batchSet.size >= batchSize) {
+        await drainMaybe();
+      }
+      pos++;
     }
-  }
-  return output;
-}
-function empty(key) {
-  return key === key ? [] : {};
+    await drainMaybe();
+    return result;
+  };
+  wrapFn.$cache = { getBucket, getPointer, argToKeyOptions };
+  def(wrapFn, SYM_WITH_CACHE, true);
+  return wrapFn;
 }
 
-const unset = _unset__default;
-
 function withDeepClone(fn) {
   const wrapFn = function(...args) {
     const result = fn.apply(this, args);
@@ -4625,6 +4836,308 @@ function rafPromise() {
   });
 }
 
+class ResourcePool extends SimpleEventEmitter {
+  poolSize;
+  auto;
+  createResource;
+  destroyResource;
+  state;
+  /**
+   * Creates a new ResourcePool instance.
+   *
+   * @param options Configuration options for the pool
+   *
+   * @example
+   * ```typescript
+   * const pool = new ResourcePool({
+   *   poolSize: 5,
+   *   auto: true,
+   *   createResource: async () => new DatabaseConnection(),
+   *   destroyResource: async (conn) => conn.close()
+   * });
+   * ```
+   */
+  constructor({
+    poolSize,
+    auto = false,
+    createResource,
+    destroyResource
+  }) {
+    super();
+    this.poolSize = poolSize;
+    this.auto = auto;
+    this.createResource = createResource;
+    this.destroyResource = destroyResource;
+    this.removeAllListeners("error");
+    this.state = {
+      availableResources: [],
+      inUseResources: /* @__PURE__ */ new Set(),
+      queueAcquire: [],
+      queueDrain: [],
+      queueDestroy: [],
+      destroying: false
+    };
+  }
+  /**
+   * Whether the pool is idle (no resources currently in use).
+   * Useful for determining if it's safe to destroy the pool.
+   */
+  get isIdle() {
+    return this.state.inUseResources.size === 0;
+  }
+  /** Number of resources currently available for acquisition */
+  get availableCount() {
+    return this.state.availableResources.length;
+  }
+  /** Number of resources currently in use */
+  get usedCount() {
+    return this.state.inUseResources.size;
+  }
+  /** Maximum number of resources this pool can manage */
+  get size() {
+    return this.poolSize;
+  }
+  /**
+   * Acquires a resource from the pool.
+   *
+   * This method will:
+   * 1. Return an available resource immediately if one exists
+   * 2. Create a new resource if auto mode is enabled and under the pool limit
+   * 3. Queue the request and wait if no resources are available
+   *
+   * @returns Promise that resolves to an acquired resource
+   * @throws Error if the pool is destroyed while waiting (when rejectAcquires is true)
+   *
+   * @example
+   * ```typescript
+   * const resource = await pool.acquire();
+   * try {
+   *   // Use the resource
+   *   await resource.doSomething();
+   * } finally {
+   *   pool.release(resource); // Always release in finally block
+   * }
+   * ```
+   */
+  async acquire() {
+    if (this.state.destroying) {
+      return this.enqueueAcquireRequest();
+    }
+    let availableResource = this.tryGetAvailableResource();
+    if (availableResource !== null) {
+      return availableResource;
+    }
+    const autoCreatedResource = await this.tryCreateAutoResource();
+    if (autoCreatedResource !== null) {
+      return autoCreatedResource;
+    }
+    availableResource = this.tryGetAvailableResource();
+    if (availableResource !== null) {
+      return availableResource;
+    }
+    return this.enqueueAcquireRequest();
+  }
+  /**
+   * Returns a resource to the pool, making it available for reuse.
+   *
+   * The resource will be made available to the next queued acquisition request,
+   * or returned to the available pool if no requests are pending.
+   *
+   * @param resource The resource to return to the pool
+   *
+   * @example
+   * ```typescript
+   * const resource = await pool.acquire();
+   * try {
+   *   // Use resource...
+   * } finally {
+   *   pool.release(resource); // Always release when done
+   * }
+   * ```
+   *
+   * @remarks
+   * - Safe to call multiple times with the same resource (idempotent)
+   * - Only resources that were acquired from this pool should be released
+   * - Triggers drain completion if this was the last resource in use
+   */
+  release(resource) {
+    if (!this.state.inUseResources.has(resource)) {
+      return;
+    }
+    this.processNextAcquireRequest(resource);
+    this.checkForDrainCompletion();
+  }
+  /**
+   * Manually add a resource to the pool.
+   *
+   * @param resource The resource to return to the pool
+   *
+   * @throws Error if resource already exists in the pool.
+   * @throws Error if size reached.
+   */
+  add(resource) {
+    ok(
+      this.poolSize > this.state.availableResources.length + this.state.inUseResources.size,
+      "Pool size reached"
+    );
+    ok(
+      !this.state.inUseResources.has(resource) && !this.state.availableResources.includes(resource),
+      "This resource already added to the pool"
+    );
+    this.state.inUseResources.add(resource);
+    this.processNextAcquireRequest(resource);
+  }
+  /**
+   * Waits for all currently acquired resources to be released.
+   *
+   * This is useful for graceful shutdown scenarios where you want to ensure
+   * all work is completed before destroying the pool.
+   *
+   * @returns Promise that resolves when all resources are returned to the pool
+   *
+   * @example
+   * ```typescript
+   * // Graceful shutdown
+   * console.log('Waiting for all connections to be released...');
+   * await pool.drain();
+   * console.log('All connections released, safe to destroy pool');
+   * await pool.destroy();
+   * ```
+   *
+   * @remarks
+   * - Resolves immediately if no resources are currently in use
+   * - Multiple drain calls can be made concurrently; they will all resolve together
+   * - Does not prevent new acquisitions; use destroy() to prevent new usage
+   */
+  async drain() {
+    if (this.isIdle) {
+      return;
+    }
+    const drainDefer = defer();
+    this.state.queueDrain.push(drainDefer);
+    return drainDefer.promise;
+  }
+  /**
+   * Destroys the pool and all its resources.
+   *
+   * This method will:
+   * 1. Wait for all resources to be released (drain)
+   * 2. Optionally reject any pending acquisition requests
+   * 3. Call destroyResource() on all available resources
+   * 4. Clean up internal state
+   *
+   * @param rejectAcquires Whether to reject pending acquire() requests with an error
+   *                       If false, pending requests will remain queued indefinitely
+   * @returns Promise that resolves when destruction is complete
+   *
+   * @example
+   * ```typescript
+   * // Graceful shutdown - let pending requests complete
+   * await pool.destroy(false);
+   *
+   * // Immediate shutdown - reject pending requests
+   * await pool.destroy(true);
+   * ```
+   *
+   * @remarks
+   * - Safe to call multiple times; subsequent calls will wait for the first to complete
+   * - The pool cannot be used after destruction
+   * - Resources currently in use will not be force-destroyed; drain() is called first
+   * - If destroyResource was not provided, resources are simply discarded
+   */
+  async destroy(rejectAcquires = false) {
+    if (this.state.destroying) {
+      return this.enqueueDestroyRequest();
+    }
+    this.state.destroying = true;
+    try {
+      await this.drain();
+      if (rejectAcquires) {
+        this.rejectPendingAcquires();
+      }
+      await this.destroyAllResources();
+      this.resetState();
+    } catch (err) {
+      this.emit("error", toError(err));
+    } finally {
+      this.state.destroying = false;
+      this.resolveDestroyQueue();
+    }
+  }
+  tryGetAvailableResource() {
+    if (this.state.availableResources.length === 0) {
+      return null;
+    }
+    const resource = this.state.availableResources.pop();
+    this.state.inUseResources.add(resource);
+    return resource;
+  }
+  async tryCreateAutoResource() {
+    if (!this.auto || this.state.inUseResources.size >= this.poolSize) {
+      return null;
+    }
+    const resource = await this.createResource();
+    this.state.inUseResources.add(resource);
+    return resource;
+  }
+  enqueueAcquireRequest() {
+    const acquireDefer = defer();
+    this.state.queueAcquire.push(acquireDefer);
+    return acquireDefer.promise;
+  }
+  moveResourceToAvailable(resource) {
+    this.state.inUseResources.delete(resource);
+    this.state.availableResources.push(resource);
+  }
+  processNextAcquireRequest(resource) {
+    if (this.state.destroying || this.state.queueAcquire.length === 0) {
+      this.moveResourceToAvailable(resource);
+      return;
+    }
+    const nextRequest = this.state.queueAcquire.shift();
+    nextRequest.resolve(resource);
+  }
+  checkForDrainCompletion() {
+    if (this.isIdle && this.state.queueDrain.length > 0) {
+      this.state.queueDrain.forEach((deferred) => deferred.resolve());
+      this.state.queueDrain = [];
+    }
+  }
+  enqueueDestroyRequest() {
+    const destroyDefer = defer();
+    this.state.queueDestroy.push(destroyDefer);
+    return destroyDefer.promise;
+  }
+  rejectPendingAcquires() {
+    const destroyError = new Error("ResourcePool destroyed");
+    this.state.queueAcquire.forEach((deferred) => deferred.reject(destroyError));
+    this.state.queueAcquire = [];
+  }
+  async destroyAllResources() {
+    if (!this.destroyResource || this.state.availableResources.length === 0) {
+      return;
+    }
+    await asyncForEach(
+      this.state.availableResources,
+      async (resource) => {
+        try {
+          await this.destroyResource(resource);
+        } catch (err) {
+          this.emit("error", toError(err));
+        }
+      },
+      { concurrency: 4 }
+    );
+  }
+  resetState() {
+    this.state.availableResources = [];
+  }
+  resolveDestroyQueue() {
+    this.state.queueDestroy.forEach((deferred) => deferred.resolve());
+    this.state.queueDestroy = [];
+  }
+}
+
 function timeout(ms, promiseOrCallback, timeoutError = new AppError(408)) {
   const abortController = new AbortController();
   let taskResult;
@@ -4904,6 +5417,7 @@ exports.FixedMap = FixedMap;
 exports.FixedWeakMap = FixedWeakMap;
 exports.LruCache = LruCache;
 exports.Queue = Queue;
+exports.ResourcePool = ResourcePool;
 exports.SimpleEventEmitter = SimpleEventEmitter;
 exports.SortedArray = SortedArray;
 exports.TWEMOJI_REGEX = TWEMOJI_REGEX;
@@ -4918,7 +5432,12 @@ exports.asyncForEach = asyncForEach;
 exports.asyncMap = asyncMap;
 exports.avg = avg;
 exports.avgCircular = avgCircular;
+exports.base62 = base62;
+exports.base62Fast = base62Fast;
+exports.base64 = base64;
 exports.base64ToBytes = base64ToBytes;
+exports.base64url = base64url;
+exports.basex = basex;
 exports.bigIntBytes = bigIntBytes;
 exports.bigIntFromBytes = bigIntFromBytes;
 exports.blendColors = blendColors;