@andrew_l/toolkit 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3267 @@
+import _get from 'lodash/get';
+import _cloneDeep from 'lodash/cloneDeep';
+import _cloneDeepWith from 'lodash/cloneDeepWith';
+import _defaultsDeep from 'lodash/defaultsDeep';
+import _set from 'lodash/set';
+import _unset from 'lodash/unset';
+import { isWeakSet as isWeakSet$1, isWeakMap as isWeakMap$1 } from 'lodash';
+
+const isClient = typeof globalThis?.window !== "undefined";
+const isDef = (val) => typeof val !== "undefined";
+const toString = Object.prototype.toString;
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+const isBigInt = (val) => typeof val === "bigint";
+const isBoolean = (val) => typeof val === "boolean";
+const isFunction = (val) => typeof val === "function";
+const isNumber = (val) => typeof val === "number" && !isNaN(val);
+const isString = (val) => typeof val === "string";
+const isObject = (val) => toString.call(val) === "[object Object]";
+const isDate = (val) => val instanceof Date && !isNaN(val);
+const noop = () => {
+};
+const isError = (val) => val instanceof Error || //@ts-expect-error
+isObject(val) && isString(val.message) && isString(val.stack);
+const isSymbol = (val) => typeof val == "symbol";
+const isSet = (val) => val instanceof Set;
+const isWeakSet = (val) => val instanceof WeakSet;
+const isMap = (val) => val instanceof Map;
+const isWeakMap = (val) => val instanceof WeakMap;
+function isEqual(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  if (Array.from(new Set(aKeys.concat(bKeys))).length !== aKeys.length) {
+    return false;
+  }
+  for (let i = 0; i < aKeys.length; i++) {
+    const propKey = aKeys[i];
+    const aProp = a[propKey];
+    const bProp = b[propKey];
+    if (!isEqual(aProp, bProp)) {
+      return false;
+    }
+  }
+  return true;
+}
+const isEmpty = (obj) => {
+  if (obj === null || obj === void 0) return true;
+  switch (obj?.constructor) {
+    case Object: {
+      for (const _ in obj) {
+        return false;
+      }
+      return true;
+    }
+    case Array: {
+      for (const _ in obj) {
+        return false;
+      }
+      return true;
+    }
+    case String: {
+      return !obj.length;
+    }
+    case Map: {
+      return !obj.size;
+    }
+    case Set: {
+      return !obj.size;
+    }
+  }
+  return false;
+};
+function isPromise(value) {
+  return value && typeof value === "object" && "then" in value && "catch" in value && typeof value.then === "function" && typeof value.catch === "function";
+}
+const primitiveTypeofSet = Object.freeze(
+  /* @__PURE__ */ new Set(["string", "number", "boolean", "bigint", "symbol", "undefined"])
+);
+const isPrimitive = (value) => {
+  return value === null || primitiveTypeofSet.has(typeof value);
+};
+
+function arrayable(value) {
+  const result = Array.isArray(value) ? value : value === null ? [] : value === void 0 ? [] : isString(value) ? value.split(",").map((v) => v.trim()).filter(Boolean) : [value];
+  return result;
+}
+
+const avg = (values) => {
+  let sum = 0;
+  let amount = 0;
+  for (const item of values) {
+    if (!isNumber(item)) continue;
+    sum += item;
+    amount++;
+  }
+  if (amount === 0) return 0;
+  return sum / amount;
+};
+
+function chunk(list, size = 1) {
+  return list.reduce((res, item, index) => {
+    if (index % size === 0) {
+      res.push([]);
+    }
+    res[res.length - 1].push(item);
+    return res;
+  }, []);
+}
+
+function chunkSeries(list, step = 1) {
+  const result = [];
+  if (!list.length) {
+    return result;
+  }
+  const sortedList = [...list].sort();
+  let currentRange = [list[0]];
+  let currentValue;
+  for (let idx = 1; idx < sortedList.length; idx++) {
+    currentValue = sortedList[idx];
+    if (currentValue - currentRange.at(-1) > step) {
+      result.push(currentRange);
+      currentRange = [currentValue];
+    } else {
+      currentRange[1] = currentValue;
+    }
+  }
+  result.push(currentRange);
+  return result;
+}
+
+function keyBy(array, keyBy2, objectMode) {
+  const getItemKey = isFunction(keyBy2) ? keyBy2 : (item) => item?.[keyBy2];
+  if (objectMode === true) {
+    const result2 = {};
+    for (const item of array) {
+      result2[getItemKey(item)] = item;
+    }
+    return result2;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    result.set(getItemKey(item), item);
+  }
+  return result;
+}
+
+function compareAscending(value, other) {
+  if (value !== other) {
+    const valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+    const othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
+    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+      return 1;
+    }
+    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+function orderBy(array, fields, orders) {
+  return [...array].sort((a, b) => {
+    let index = -1, length = fields.length, ordersLength = orders.length;
+    while (++index < length) {
+      const field = fields[index];
+      const filedFn = isFunction(field);
+      const objCriteria = filedFn ? field(a) : a?.[field];
+      const othCriteria = filedFn ? field(b) : b?.[field];
+      const result = compareAscending(objCriteria, othCriteria);
+      if (result) {
+        if (index >= ordersLength) {
+          return result;
+        }
+        return result * (orders[index] === "desc" ? -1 : 1);
+      }
+    }
+    return 0;
+  });
+}
+
+const sum = (values) => {
+  return values.reduce((a, b) => a + (isNumber(b) ? b : 0), 0);
+};
+
+function uniq(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return [...new Set(value)];
+}
+
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+
+const get = _get;
+
+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);
+    }
+    return !hasSeen;
+  });
+}
+
+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 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 object(value, message) {
+  if (!isObject(value)) {
+    throw toError$1(object, value, message, "Expected object value.");
+  }
+}
+function string(value, message) {
+  if (!isString(value)) {
+    throw toError$1(string, value, message, "Expected string value.");
+  }
+}
+function boolean(value, message) {
+  if (!isBoolean(value)) {
+    throw toError$1(boolean, value, message, "Expected boolean value.");
+  }
+}
+function notEmptyString(value, message) {
+  if (!isString(value) || !value.trim()) {
+    throw toError$1(
+      notEmptyString,
+      value,
+      message,
+      "Expected not empty string value."
+    );
+  }
+}
+function number$1(value, message) {
+  if (!isNumber(value)) {
+    throw toError$1(number$1, value, message, "Expected number value.");
+  }
+}
+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,
+  equal: equal,
+  notEmptyString: notEmptyString,
+  number: number$1,
+  object: object,
+  ok: ok,
+  string: string
+};
+
+const def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
+
+const rndCharacters = "abcdefghijklmnopqrstuvwxyz0123456789";
+const charactersLength = rndCharacters.length;
+function randomString(length) {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += rndCharacters.charAt(
+      Math.floor(Math.random() * charactersLength)
+    );
+  }
+  return result;
+}
+
+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);
+}
+
+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 = (...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;
+    }
+    const newValue = fn(...args);
+    if (isPromise(newValue)) {
+      return newValue.then((value) => {
+        storage.set(cacheKey, value);
+        return value;
+      });
+    }
+    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);
+    }
+    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);
+    }
+    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);
+      }
+    }
+    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;
+  }
+  get(key) {
+    const pointer = this.items.get(key);
+    if (pointer === void 0) return;
+    this.splayOnTop(pointer);
+    return this.V[pointer];
+  }
+  /**
+   * Method used to get the value attached to the given key. Does not modify
+   * the ordering of the underlying linked list.
+   */
+  peek(key) {
+    const pointer = this.items.get(key);
+    if (pointer === void 0) return;
+    return this.V[pointer];
+  }
+  /**
+   * Method used to create an iterator over the cache's keys from most
+   * recently used to least recently used.
+   */
+  keys() {
+    let i = 0, l = this.size;
+    let pointer = this.head, keys = this.K, forward = this.forward;
+    const iterator = {
+      next: () => {
+        if (i >= l) return { done: true, value: void 0 };
+        const key = keys[pointer];
+        i++;
+        if (i < l) pointer = forward[pointer];
+        if (this.peek(key) === void 0) return iterator.next();
+        return {
+          done: false,
+          value: key
+        };
+      }
+    };
+    return {
+      ...iterator,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Method used to create an iterator over the cache's values from most
+   * recently used to least recently used.
+   *
+   */
+  values() {
+    let i = 0, l = this.size;
+    let pointer = this.head, values = this.V, forward = this.forward;
+    const iterator = {
+      next: () => {
+        if (i >= l) return { done: true, value: void 0 };
+        const value = values[pointer];
+        i++;
+        if (i < l) pointer = forward[pointer];
+        if (value === void 0) return iterator.next();
+        return {
+          done: false,
+          value
+        };
+      }
+    };
+    return {
+      ...iterator,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Method used to create an iterator over the cache's entries from most
+   * recently used to least recently used.
+   *
+   * @return {IterableIterator<[TKey, TValue | undefined]>}
+   */
+  entries() {
+    let i = 0, l = this.size;
+    let pointer = this.head, keys = this.K, values = this.V, forward = this.forward;
+    const iterator = {
+      next() {
+        if (i >= l) return { done: true, value: void 0 };
+        const key = keys[pointer], value = values[pointer];
+        i++;
+        if (i < l) pointer = forward[pointer];
+        return {
+          done: false,
+          value: [key, value]
+        };
+      }
+    };
+    return {
+      ...iterator,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Method used to splay a value on top.
+   *
+   * @param  {number}   pointer - Pointer of the value to splay on top.
+   */
+  splayOnTop(pointer) {
+    const oldHead = this.head;
+    if (this.head === pointer) return this;
+    const previous = this.backward[pointer], next = this.forward[pointer];
+    if (this.tail === pointer) {
+      this.tail = previous;
+    } else {
+      this.backward[next] = previous;
+    }
+    this.forward[previous] = next;
+    this.backward[oldHead] = pointer;
+    this.head = pointer;
+    this.forward[pointer] = oldHead;
+    return this;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+const MAX_8BIT_INTEGER = Math.pow(2, 8) - 1, MAX_16BIT_INTEGER = Math.pow(2, 16) - 1, MAX_32BIT_INTEGER = Math.pow(2, 32) - 1;
+function pointerArray(size) {
+  const maxIndex = size - 1;
+  if (maxIndex <= MAX_8BIT_INTEGER) return new Uint8Array(size);
+  if (maxIndex <= MAX_16BIT_INTEGER) return new Uint16Array(size);
+  if (maxIndex <= MAX_32BIT_INTEGER) return new Uint32Array(size);
+  throw new Error("Pointer Array of size > 4294967295 is not supported.");
+}
+
+const cacheLRU = /* @__PURE__ */ new WeakMap();
+function withCacheLRU({ capacity, cachePointer, ...options }, fn) {
+  const pointer = cachePointer || fn;
+  const getPointer = () => {
+    return pointer;
+  };
+  const getBucket = () => {
+    let fnCache = cacheLRU.get(pointer);
+    if (!fnCache) {
+      fnCache = new LruCache(capacity);
+      cacheLRU.set(pointer, fnCache);
+    }
+    return fnCache;
+  };
+  return createWithCache({
+    fn,
+    getBucket,
+    getPointer,
+    ...options
+  });
+}
+
+function dropCache(cachePointer, ...args) {
+  let argToKeyOptions = { objectStrategy: "ref" };
+  let removed = false;
+  if (isWithCache(cachePointer)) {
+    argToKeyOptions = cachePointer.$cache.argToKeyOptions;
+  }
+  const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
+  if (isWithCache(cachePointer)) {
+    if (cachePointer.$cache.getBucket().has(cacheKey)) {
+      removed = true;
+      cachePointer.$cache.getBucket().delete(cacheKey);
+    }
+    cachePointer = cachePointer.$cache.getPointer();
+  }
+  [cache, cacheFixed, cacheBucket, cacheLRU].forEach((map) => {
+    if (map.get(cachePointer)?.has(cacheKey)) {
+      removed = true;
+      map.get(cachePointer)?.delete(cacheKey);
+    }
+  });
+  return removed;
+}
+
+class FixedWeakMap extends WeakMap {
+  constructor(_capacity) {
+    assertCapacity(_capacity);
+    super();
+    this._capacity = _capacity;
+    this._tail = [];
+  }
+  _tail;
+  set(key, value) {
+    if (!super.has(key)) {
+      this._tail.push(key);
+    }
+    super.set(key, value);
+    this._drain();
+    return this;
+  }
+  delete(key) {
+    const removed = super.delete(key);
+    if (removed) {
+      const idx = this._tail.findIndex((v) => v === key);
+      if (idx > -1) {
+        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 (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(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(value);
+};
+
+const WITH_CUSTOMIZER_FACTORY_SYM = Symbol();
+function deepCloneWith(value, customizer) {
+  const fns = prepareCustomizes(customizer);
+  return _cloneDeepWith(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;
+
+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 processed = /* @__PURE__ */ new WeakSet();
+  const handle = (node, prefix, initial) => {
+    if (processed.has(node)) return;
+    if (isObjectCompare(node)) {
+      processed.add(node);
+      prefix = prefix && !initial ? `${prefix}${separator}` : prefix;
+      for (const [key, value] of Object.entries(node)) {
+        handle(value, `${prefix}${key}`);
+      }
+      return;
+    }
+    if (Array.isArray(node) && withArrays) {
+      processed.add(node);
+      prefix = prefix && !initial ? `${prefix}${separator}` : prefix;
+      node.forEach((value, idx) => handle(value, `${prefix}${idx}`));
+      return;
+    }
+    result[prefix] = node;
+  };
+  handle(obj, initialPrefix, true);
+  return result;
+}
+
+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;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (excludesSet.has(key)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+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 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 pickPrefixed(obj, options) {
+  let prefix;
+  let prefixTrim = false;
+  if (typeof options === "string") {
+    prefix = options;
+  } else {
+    prefix = options.prefix;
+    prefixTrim = options.prefixTrim === true;
+  }
+  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 set = _set;
+
+const toMap = (obj) => {
+  const map = new Map(Object.entries(obj));
+  for (const symbol of Object.getOwnPropertySymbols(obj)) {
+    map.set(symbol, obj[symbol]);
+  }
+  return map;
+};
+
+function unflatten(obj, separator = "_") {
+  const result = {};
+  Object.keys(obj).forEach((path) => {
+    set(result, path.split(separator), obj[path]);
+  });
+  return result;
+}
+
+const unset = _unset;
+
+function withDeepClone(fn) {
+  const wrapFn = function(...args) {
+    const result = fn.apply(this, args);
+    if (isPromise(result)) {
+      return result.then(deepClone);
+    }
+    return deepClone(result);
+  };
+  if (isWithCache(fn)) {
+    wrapFn.$cache = fn.$cache;
+  }
+  if ("$cache" in fn) {
+    wrapFn.$cache = fn.$cache;
+    def(wrapFn, SYM_WITH_CACHE, true);
+  }
+  return wrapFn;
+}
+
+function withPointerCache(pointer, dependencies, fn) {
+  const cacheKey = dependencies.map(String).join("_");
+  let fnCache = cache.get(pointer);
+  if (fnCache) {
+    const cached = fnCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+  } else {
+    fnCache = /* @__PURE__ */ new Map();
+    cache.set(pointer, fnCache);
+  }
+  const newValue = fn();
+  fnCache.set(cacheKey, newValue);
+  return newValue;
+}
+
+function captureStackTrace(till) {
+  const err = new Error("");
+  if ("captureStackTrace" in Error) {
+    Error.captureStackTrace(err, till);
+  }
+  return (err.stack || "").slice(6);
+}
+
+function toError(value, unknownMessage = "Unknown error") {
+  if (isError(value)) {
+    return value;
+  }
+  const error = new Error(unknownMessage, { cause: value });
+  Error.captureStackTrace(error, toError);
+  return error;
+}
+
+function catchError(fn) {
+  try {
+    const res = fn();
+    if (isPromise(res)) {
+      return res.then((r) => [void 0, r]).catch(onError$1);
+    }
+    return [void 0, res];
+  } catch (err) {
+    return onError$1(err);
+  }
+}
+function onError$1(error) {
+  const err = toError(error);
+  return [err, void 0];
+}
+
+const clamp = (num, min, max) => {
+  if (!isNumber(num)) return min;
+  return Math.min(max, Math.max(min, num));
+};
+
+function parseAlpha(value, fallback = 1) {
+  let a = value;
+  if (isString(value)) {
+    a = value.endsWith("%") ? parseFloat(value) / 100 : parseFloat(value);
+  }
+  if (!isNumber(a)) {
+    a = fallback;
+  }
+  return clamp(a, 0, 1);
+}
+
+const hexReg = new RegExp(
+  /^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\b$/,
+  "i"
+);
+function parseHEX(value) {
+  if (!isString(value)) return null;
+  const parsed = hexReg.exec(value);
+  if (!parsed) return null;
+  let a = 1;
+  let hex = parsed[0].replace(/^#/, "");
+  if (hex.length === 8) {
+    a = Number.parseInt(hex.slice(6, 8), 16) / 255;
+    hex = hex.slice(0, 6);
+  }
+  if (hex.length === 4) {
+    a = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255;
+    hex = hex.slice(0, 3);
+  }
+  if (hex.length === 3) hex = hex + hex;
+  return [
+    parseInt(hex.slice(0, 2), 16),
+    parseInt(hex.slice(2, 4), 16),
+    parseInt(hex.slice(4, 6), 16),
+    parseAlpha(a)
+  ];
+}
+
+function parsePercentage(value) {
+  const parsed = parseFloat(value);
+  if (!isNumber(parsed)) return 0;
+  return clamp(parsed, 0, 100);
+}
+
+const float = "-?\\d*(?:\\.\\d+)";
+const number = `(${float}?)`;
+const percentage = `(${float}?%)`;
+const numberOrPercentage = `(${float}?%?)`;
+function isColorChannels(value) {
+  return Array.isArray(value) && value.length === 4;
+}
+
+const hsl = new RegExp(
+  `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*,
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, "")
+);
+const hsla = new RegExp(
+  `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*
+    \\s+${percentage}
+    \\s+${percentage}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, "")
+);
+function parseHSL(value) {
+  const parsed = hsla.exec(value) || hsl.exec(value);
+  if (!parsed) return null;
+  const [, h, s, l, a = 1] = parsed;
+  let hh = h;
+  if (hh.endsWith("turn")) {
+    hh = parseFloat(hh) * 360 / 1;
+  } else if (hh.endsWith("rad")) {
+    hh = Math.round(parseFloat(hh) * 180 / Math.PI);
+  } else {
+    hh = parseFloat(hh);
+  }
+  return {
+    h: hh,
+    s: parsePercentage(s),
+    l: parsePercentage(l),
+    a: parseAlpha(a === null ? 1 : a)
+  };
+}
+
+function checkBitmask(scope, flag) {
+  return (scope & flag) === flag;
+}
+
+function getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+class Randomizer {
+  _pool = [];
+  _step = 0;
+  _min;
+  _max;
+  _pregenerateAmount;
+  _transform;
+  constructor({ min, max, pregenerateAmount, transform }) {
+    this._min = min;
+    this._max = max;
+    this._pregenerateAmount = pregenerateAmount;
+    this._transform = transform;
+  }
+  /**
+   * Returns the current step of the randomizer.
+   *
+   * @returns {number} The current step.
+   */
+  getCurrentStep() {
+    return this._step;
+  }
+  /**
+   * Sets the current step of the randomizer.
+   *
+   * @param {number} value - The step to set.
+   * @throws {Error} If the provided value is not a valid number or less than 0.
+   */
+  setCurrentStep(value) {
+    number$1(value, "Current step must be an number");
+    ok(value >= 0, "Current step must be getter or equal 0");
+    this._step = value;
+  }
+  /**
+   * Retrieves a random number either from the current step or a specific step if provided.
+   *
+   * @param {number} [fromStep] - The step from which to retrieve the random number (optional).
+   * @returns {number} The random number at the current or specified step.
+   */
+  get(fromStep) {
+    if (fromStep === void 0) {
+      return this._lookup(this._step++);
+    }
+    return this._lookup(fromStep);
+  }
+  /**
+   * Resets the current step to 0.
+   */
+  resetStep() {
+    this._step = 0;
+  }
+  /**
+   * Resets the random number pool, clearing and repopulating it with new random values.
+   */
+  resetPool() {
+    const size = this._pregenerateAmount;
+    this._pool = Array.from({ length: size });
+    for (let step = 0; step < size; step++) {
+      this._pool[step] = this._rand();
+    }
+  }
+  _rand() {
+    return this._transform(getRandomInt(this._min, this._max));
+  }
+  _lookup(step) {
+    if (this._pool[step] === void 0) {
+      this._pool[step] = this._rand();
+    }
+    return this._pool[step];
+  }
+}
+const noopTransform = (v) => v;
+function createRandomizer({
+  min = Number.MIN_SAFE_INTEGER,
+  max = Number.MAX_SAFE_INTEGER,
+  pregenerateAmount = 100,
+  transform = noopTransform
+}) {
+  return new Randomizer({ min, max, pregenerateAmount, transform });
+}
+
+class FindMean {
+  #count = 0;
+  #value = 0;
+  constructor(initialValue) {
+    this.reset(initialValue);
+  }
+  /**
+   * Resets the current progress of the mean calculation.
+   * Optionally, you can pass an initial value to start the calculation.
+   *
+   * @param {number} [initialValue] - The initial value to start the mean calculation with.
+   * @returns {FindMean} The current instance of the FindMean class for chaining.
+   *
+   * @example
+   * const avg = findMean();
+   * avg.push(2, 4);
+   * avg.reset();
+   * console.log(avg.value); // Output: 0
+   */
+  reset(initialValue) {
+    if (initialValue === void 0) {
+      this.#count = 0;
+      this.#value = 0;
+    } else {
+      this.#count = 1;
+      this.#value = initialValue;
+    }
+    return this;
+  }
+  /**
+   * Retrieves the current mean value (average).
+   *
+   * @returns {number} The current mean value.
+   *
+   * @example
+   * const avg = findMean();
+   * avg.push(5, 10);
+   * console.log(avg.value); // Output: 7.5 (average of 5, 10)
+   */
+  get value() {
+    return this.#value;
+  }
+  /**
+   * Retrieves the count of numbers added so far.
+   *
+   * @returns {number} The count of numbers in the set.
+   *
+   * @example
+   * const avg = findMean();
+   * avg.push(10, 20);
+   * console.log(avg.count); // Output: 2
+   */
+  get count() {
+    return this.#count;
+  }
+  /**
+   * Adds values to the set and updates the running mean.
+   *
+   * @param {...number} values - The values to add to the set.
+   * @returns {FindMean} The current instance of the FindMean class for chaining.
+   *
+   * @example
+   * const avg = findMean();
+   * avg.push(1, 2, 3);
+   * console.log(avg.value); // Output: 2 (average of 1, 2, 3)
+   * console.log(avg.count); // Output: 3
+   */
+  push(...values) {
+    for (const item of values) {
+      this.#count++;
+      this.#value += (item - this.#value) / this.#count;
+    }
+    return this;
+  }
+}
+function findMean(value) {
+  return new FindMean(value);
+}
+
+const defaultFormat = {
+  /**
+   * Symbol to separate thousands parts
+   */
+  thousands: ",",
+  /**
+   * Symbol to separate decimal part
+   */
+  decimal: "."
+};
+const regExp = /\B(?=(\d{3})+(?!\d))/g;
+function formatNumber(value, format = defaultFormat) {
+  if (isString(value)) {
+    return formatNumber(parseFloat(value), format);
+  }
+  if (!isNumber(value)) return "";
+  const [integerPart, decimalPart] = value.toFixed(2).split(".");
+  let result = String(integerPart).replace(regExp, format.thousands);
+  if (decimalPart !== "00") {
+    result += format.decimal + decimalPart;
+  }
+  return result;
+}
+
+function round2digits(value, digits = 2) {
+  if (digits === 0) {
+    return value << 0;
+  }
+  return Number(Math.round(value + "e" + digits) + "e-" + digits);
+}
+
+const CURRENCY_FORMAT = /* @__PURE__ */ new Map([
+  ["USD", { symbol: "$", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["EUR", { symbol: "\u20AC", thousands: ".", decimal: ",", symbolBefore: true }],
+  ["GBP", { symbol: "\xA3", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["JPY", { symbol: "\xA5", thousands: ",", decimal: "", symbolBefore: true }],
+  ["AUD", { symbol: "A$", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["CAD", { symbol: "C$", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["CHF", { symbol: "CHF", thousands: "'", decimal: ".", symbolBefore: true }],
+  ["CNY", { symbol: "\xA5", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["INR", { symbol: "\u20B9", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["KRW", { symbol: "\u20A9", thousands: ",", decimal: "", symbolBefore: true }],
+  ["RUB", { symbol: "\u20BD", thousands: " ", decimal: ",", symbolBefore: false }],
+  ["UAH", { symbol: "\u20B4", thousands: " ", decimal: ",", symbolBefore: false }],
+  ["BRL", { symbol: "R$", thousands: ".", decimal: ",", symbolBefore: true }],
+  ["MXN", { symbol: "$", thousands: ",", decimal: ".", symbolBefore: true }],
+  ["ZAR", { symbol: "R", thousands: " ", decimal: ",", symbolBefore: true }],
+  ["UAH", { symbol: "\u20B4", thousands: " ", decimal: ",", symbolBefore: true }]
+]);
+const DEF_FORMAT = {
+  decimal: " ",
+  thousands: ",",
+  symbol: "",
+  symbolBefore: false
+};
+function formatMoney(amount, formatOrCode = "USD", intMode = false) {
+  if (intMode) {
+    amount = round2digits(amount / 100, 2);
+  }
+  const format = isString(formatOrCode) ? CURRENCY_FORMAT.get(formatOrCode) || {
+    ...DEF_FORMAT,
+    symbol: formatOrCode
+  } : formatOrCode;
+  const formattedNumber = formatNumber(amount, format);
+  return format.symbolBefore ? format.symbol + formattedNumber : formattedNumber + format.symbol;
+}
+
+function humanize(input, decimals = 1) {
+  if (input === null || input === void 0) {
+    return String(input);
+  }
+  decimals = Math.max(decimals, 0);
+  const number = parseInt(input, 10);
+  if (!Number.isFinite(number)) {
+    return String(input);
+  }
+  const signString = number < 0 ? "-" : "";
+  const unsignedNumber = Math.abs(number);
+  const unsignedNumberString = String(unsignedNumber);
+  const numberLength = unsignedNumberString.length;
+  const numberLengths = [13, 10, 7, 4];
+  const bigNumPrefixes = ["T", "B", "M", "k"];
+  if (unsignedNumber < 1e3) {
+    return `${signString}${unsignedNumberString}`;
+  }
+  if (numberLength > numberLengths[0] + 3) {
+    return number.toExponential(decimals).replace("e+", "x10^");
+  }
+  let length = 0;
+  for (let i = 0; i < numberLengths.length; i++) {
+    const _length = numberLengths[i];
+    if (numberLength >= _length) {
+      length = _length;
+      break;
+    }
+  }
+  const decimalIndex = numberLength - length + 1;
+  const unsignedNumberCharacterArray = unsignedNumberString.split("");
+  const wholePartArray = unsignedNumberCharacterArray.slice(0, decimalIndex);
+  const decimalPartArray = unsignedNumberCharacterArray.slice(
+    decimalIndex,
+    decimalIndex + decimals + 1
+  );
+  const wholePart = wholePartArray.join("");
+  let decimalPart = decimalPartArray.join("");
+  if (decimalPart.length < decimals) {
+    decimalPart += `${Array(decimals - decimalPart.length + 1).join("0")}`;
+  }
+  if (decimalPart[0] === "0") {
+    decimals = 0;
+  }
+  let output;
+  if (decimals === 0) {
+    output = `${signString}${wholePart}${bigNumPrefixes[numberLengths.indexOf(length)]}`;
+  } else {
+    const outputNumber = Number(`${wholePart}.${decimalPart}`).toFixed(
+      decimals
+    );
+    output = `${signString}${outputNumber}${bigNumPrefixes[numberLengths.indexOf(length)]}`;
+  }
+  return output;
+}
+
+function parseAllNumbers(value) {
+  if (isNumber(value)) {
+    return [value];
+  }
+  if (!isString(value)) {
+    return [];
+  }
+  const matches = value.replace(/,/g, ".").match(/-?\d+(\.\d+)?/g);
+  if (!matches) {
+    return [];
+  }
+  return matches.map(Number).filter(isNumber);
+}
+
+function percentOf(value, percent, digits) {
+  let result = percent / 100 * value;
+  if (digits) {
+    result = round2digits(result, digits);
+  }
+  return result;
+}
+
+function timestamp(fromValue = Date.now()) {
+  if (isDate(fromValue)) {
+    fromValue = fromValue.getTime();
+  }
+  return Math.floor(fromValue / 1e3);
+}
+
+function timestampToDate(value) {
+  if (!isNumber(value)) return null;
+  return new Date(value * 1e3);
+}
+
+const rgb3Numbers = new RegExp(
+  `^
+  rgba?\\(
+    \\s*${number}\\s*,
+    \\s*${number}\\s*,
+    \\s*${number}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, "")
+);
+const rgb3Percent = new RegExp(
+  `^
+  rgba?\\(
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, "")
+);
+const rgb4Numbers = new RegExp(
+  `^
+  rgba?\\(
+    \\s*${number}
+    \\s+${number}
+    \\s+${number}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, "")
+);
+const rgb4Percent = new RegExp(
+  `^
+  rgba?\\(
+    \\s*${percentage}
+    \\s+${percentage}
+    \\s+${percentage}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, "")
+);
+const parseValue$1 = (num) => {
+  let n = num;
+  if (!isNumber(n))
+    n = n.endsWith("%") ? parseFloat(n) * 255 / 100 : parseFloat(n);
+  return clamp(Math.round(n), 0, 255);
+};
+function parseRGB(value) {
+  if (!isString(value)) return null;
+  const rgb = rgb4Numbers.exec(value) || rgb4Percent.exec(value) || rgb3Numbers.exec(value) || rgb3Percent.exec(value);
+  if (!rgb) return null;
+  const [, r, g, b, a] = rgb;
+  return {
+    r: parseValue$1(r),
+    g: parseValue$1(g),
+    b: parseValue$1(b),
+    a: parseAlpha(a)
+  };
+}
+
+function buildCssColor([r, g, b, a = 1], opacity = 1) {
+  return `rgba(${r}, ${g}, ${b}, ${a * opacity})`;
+}
+
+function hexToChannels(hexWithAlpha) {
+  const [hex, alpha] = hexWithAlpha.split("/");
+  const channels = parseHEX(hex);
+  if (!channels) return [0, 0, 0, 0];
+  if (alpha) {
+    channels[3] = parseAlpha(alpha);
+  }
+  return channels;
+}
+
+function hslToChannels(value) {
+  const parsed = parseHSL(value);
+  if (!parsed) return [0, 0, 0, 0];
+  let { h, s, l, a } = parsed;
+  s /= 100;
+  l /= 100;
+  const k = (n) => (n + h / 30) % 12;
+  const p = s * Math.min(l, 1 - l);
+  const f = (n) => l - p * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [
+    Math.round(255 * f(0)),
+    Math.round(255 * f(8)),
+    Math.round(255 * f(4)),
+    a
+  ];
+}
+
+function rgbToChannels(value) {
+  const rgb = parseRGB(value);
+  if (!rgb) return [0, 0, 0, 0];
+  return [rgb.r, rgb.g, rgb.b, rgb.a];
+}
+
+function colorToChannels(color) {
+  if (isColorChannels(color)) {
+    return color;
+  }
+  if (isString(color)) {
+    color = color.trim();
+    if (color[0] === "#") {
+      return hexToChannels(color);
+    } else if (color.startsWith("rgb")) {
+      return rgbToChannels(color);
+    } else if (color.startsWith("rgba")) {
+      return rgbToChannels(color);
+    } else if (color.startsWith("hsl")) {
+      return hslToChannels(color);
+    } else if (color.includes(",")) {
+      const channels = color.split(",").map((v) => parseFloat(v)).filter(isNumber).slice(0, 4);
+      while (channels.length < 3) {
+        channels.push(0);
+      }
+      return [...channels, 1].slice(0, 4);
+    }
+  }
+  console.warn("Failed to convert color into channels", typeof color, color);
+  return [0, 0, 0, 1];
+}
+
+function alpha(color, newAlpha) {
+  const [r, g, b] = colorToChannels(color);
+  return buildCssColor([r, g, b, parseAlpha(newAlpha)], 1);
+}
+
+function blendColors(color1, color2, factor) {
+  const [r1, g1, b1, a1] = colorToChannels(color1);
+  const [r2, g2, b2, a2] = colorToChannels(color2);
+  return [
+    Math.round(r1 * (1 - factor) + r2 * factor),
+    Math.round(g1 * (1 - factor) + g2 * factor),
+    Math.round(b1 * (1 - factor) + b2 * factor),
+    Math.round(a1 * (1 - factor) + a2 * factor)
+  ];
+}
+
+function channelsToHex(channels, withAlpha = true) {
+  const [r, g, b, a] = channels;
+  const outParts = [
+    r.toString(16).toUpperCase().padStart(2, "0"),
+    g.toString(16).toUpperCase().padStart(2, "0"),
+    b.toString(16).toUpperCase().padStart(2, "0")
+  ];
+  if (withAlpha && isNumber(a)) {
+    outParts.push(
+      Math.round(a * 255).toString(16).substring(0, 2).toUpperCase().padStart(2, "0")
+    );
+  }
+  return "#" + outParts.join("");
+}
+
+function channelsToHSL([r, g, b, a]) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+    if (max === r) {
+      h = (g - b) / delta % 6;
+    } else if (max === g) {
+      h = (b - r) / delta + 2;
+    } else if (max === b) {
+      h = (r - g) / delta + 4;
+    }
+    h *= 60;
+    if (h < 0) {
+      h += 360;
+    }
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100),
+    a: parseAlpha(a)
+  };
+}
+
+function channelsToRGB([r, g, b, a]) {
+  return {
+    r,
+    g,
+    b,
+    a
+  };
+}
+
+function contrastRatio(l1, l2) {
+  return round2digits((Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05), 4);
+}
+
+const defaultWindow$2 = globalThis?.window;
+function cssVariable(container) {
+  if (!defaultWindow$2) return noop;
+  const computedStyles = defaultWindow$2.getComputedStyle(container);
+  return (name) => {
+    const patterns = name.split("/", 2);
+    if (patterns[0]?.startsWith("--")) {
+      let value = computedStyles.getPropertyValue(patterns[0])?.trim();
+      if (patterns[0].startsWith("--v")) {
+        value = `rgb(${value})`;
+      }
+      patterns[0] = value;
+    }
+    return patterns.join("/");
+  };
+}
+
+function interpolateColor(color1, color2, factor) {
+  const [r1, g1, b1, a1] = colorToChannels(color1);
+  const [r2, g2, b2, a2] = colorToChannels(color2);
+  return [
+    Math.round(r1 + factor * (r2 - r1)),
+    Math.round(g1 + factor * (g2 - g1)),
+    Math.round(b1 + factor * (b2 - b1)),
+    a1 + factor * (a2 - a1)
+  ];
+}
+
+function luminance([r, g, b]) {
+  const a = [r, g, b].map(function(v) {
+    v /= 255;
+    return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  });
+  return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+}
+
+function tintedTextColor(background, tintPercentage = 0.2) {
+  const bgColor = colorToChannels(background);
+  const bgLuminance = luminance(bgColor);
+  const whiteLuminance = luminance([255, 255, 255, 1]);
+  const blackLuminance = luminance([0, 0, 0, 1]);
+  const contrastWithWhite = contrastRatio(bgLuminance, whiteLuminance);
+  const contrastWithBlack = contrastRatio(bgLuminance, blackLuminance);
+  const baseTextColor = contrastWithWhite >= contrastWithBlack ? [255, 255, 255, 1] : [0, 0, 0, 1];
+  const tintedColor = blendColors(baseTextColor, bgColor, tintPercentage);
+  const tintedLuminance = luminance(tintedColor);
+  const finalContrast = contrastRatio(bgLuminance, tintedLuminance);
+  if (finalContrast < 4.5) {
+    return baseTextColor;
+  }
+  return tintedColor;
+}
+
+const ColorParser = {
+  HSL: parseHSL,
+  RGB: parseRGB,
+  HEX: parseHEX
+};
+
+const T0 = signed_crc_table();
+function signed_crc_table() {
+  var c = 0, table = new Array(256);
+  for (var n = 0; n != 256; ++n) {
+    c = n;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    c = c & 1 ? -2097792136 ^ c >>> 1 : c >>> 1;
+    table[n] = c;
+  }
+  return Int32Array ? new Int32Array(table) : table;
+}
+function crc32(str, seed = 0) {
+  var C = seed ^ -1;
+  for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {
+    c = str.charCodeAt(i++);
+    if (c < 128) {
+      C = C >>> 8 ^ T0[(C ^ c) & 255];
+    } else if (c < 2048) {
+      C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+    } else if (c >= 55296 && c < 57344) {
+      c = (c & 1023) + 64;
+      d = str.charCodeAt(i++) & 1023;
+      C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];
+    } else {
+      C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];
+      C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+    }
+  }
+  return ~C;
+}
+
+const env = (() => {
+  if (globalThis?.process) {
+    return createEnvParser(process.env);
+  } else {
+    return createEnvParser(import.meta.env);
+  }
+})();
+function createEnvParser(targetObject) {
+  return Object.freeze({
+    isDevelopment: targetObject.NODE_ENV === "development",
+    isProduction: targetObject.NODE_ENV === "production",
+    isStage: targetObject.NODE_ENV === "state",
+    isTest: targetObject.NODE_ENV === "test",
+    bool(key, defaultValue = false) {
+      if (!(key in targetObject)) {
+        return defaultValue;
+      }
+      return parseBoolean(targetObject[key]) ?? defaultValue;
+    },
+    int(key, defaultValue = 0) {
+      if (!(key in targetObject)) {
+        return defaultValue;
+      }
+      return _parseInt(targetObject[key]) ?? defaultValue;
+    },
+    decimal(key, dights = void 0, defaultValue = 0) {
+      if (!(key in targetObject)) {
+        return isNumber(dights) ? round2digits(defaultValue, dights) : defaultValue;
+      }
+      return parseDecimal(targetObject[key], dights) ?? defaultValue;
+    },
+    string(key, defaultValue = "") {
+      return targetObject[key] || defaultValue;
+    },
+    list(key, type, defaultValue = []) {
+      if (!(key in targetObject)) {
+        return defaultValue;
+      }
+      const parsers = {
+        int: _parseInt,
+        bool: parseBoolean,
+        decimal: (v) => parseDecimal(v, 2),
+        string: (v) => v
+      };
+      return targetObject[key].split(",").map((value, idx) => {
+        const parsedValue = parsers[type](value.trim());
+        if (parsedValue === void 0) {
+          console.warn("Warn! Failed to parse list item as " + type, {
+            key,
+            idx,
+            type,
+            value
+          });
+        }
+        return parsedValue;
+      }).filter((v) => v !== void 0);
+    },
+    json(key, defaultValue = null) {
+      if (!(key in targetObject)) {
+        return defaultValue;
+      }
+      try {
+        return JSON.parse(targetObject[key]);
+      } catch (err) {
+        console.warn("Failed to parse json env variable", key);
+        return defaultValue;
+      }
+    }
+  });
+}
+function parseBoolean(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function _parseInt(value) {
+  const parsed = parseInt(value);
+  return isNumber(parsed) ? parsed : void 0;
+}
+function parseDecimal(value, dights) {
+  const parsed = parseFloat(value);
+  return isNumber(parsed) ? isNumber(dights) ? round2digits(parsed, dights) : parsed : void 0;
+}
+
+const CODE_TO_MESSAGE = Object.freeze({
+  101: "Switching Protocols",
+  102: "Processing",
+  200: "Ok",
+  201: "Created",
+  204: "No Content",
+  301: "Moved Permanently",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Already Exists",
+  500: "Internal Server Error"
+});
+class AppError extends Error {
+  code;
+  constructor(messageOrCode, code = 500, options) {
+    let message = "Unknown error";
+    if (isNumber(messageOrCode)) {
+      code = messageOrCode;
+      message = CODE_TO_MESSAGE[code] || "Unknown error";
+    } else {
+      message = messageOrCode || CODE_TO_MESSAGE[code] || "Unknown error";
+    }
+    super(message, options);
+    if (typeof Error.captureStackTrace !== "function") {
+      this.stack = new Error().stack;
+    } else {
+      Error.captureStackTrace(this, AppError);
+    }
+    this.code = code;
+  }
+  /**
+   * alias for `code` property
+   */
+  get statusCode() {
+    return this.code;
+  }
+  get name() {
+    return "AppError";
+  }
+  static is(value) {
+    return value instanceof AppError || value?.name === "AppError";
+  }
+}
+
+class BrowserAssertionError extends Error {
+  /**
+   * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
+   */
+  actual;
+  /**
+   * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
+   */
+  expected;
+  /**
+   * Set to the passed in operator value.
+   */
+  operator;
+  /**
+   * Indicates if the message was auto-generated (`true`) or not.
+   */
+  generatedMessage;
+  /**
+   * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
+   */
+  code;
+  constructor(options) {
+    super(options?.message);
+    this.actual = options?.actual;
+    this.expected = options?.expected;
+    this.operator = options?.operator ?? "none";
+    this.generatedMessage = false;
+    this.code = "ERR_ASSERTION";
+  }
+}
+
+const BrowserAssertionError$1 = {
+  __proto__: null,
+  BrowserAssertionError: BrowserAssertionError
+};
+
+function isSuccess(value) {
+  return value.success === true;
+}
+function isSkip(value) {
+  return value.skip === true;
+}
+
+function getFileExtension(name, withDot = true) {
+  if (!isString(name)) {
+    return null;
+  }
+  const ext = name.split(".").at(-1)?.split("?")?.at(0);
+  return ext ? withDot ? ext : `.${ext}` : null;
+}
+
+const DEF_PROTOCOLS = ["http://", "https://"];
+function hasProtocol(url, protocols = DEF_PROTOCOLS) {
+  if (!isString(url)) return false;
+  return protocols.some((v) => url.startsWith(v));
+}
+
+function getFileName(value) {
+  if (hasProtocol(value)) {
+    return getFileName(decodeURI(value.split("/").at(-1)?.split("?")?.at(0)));
+  }
+  if (!isString(value)) return null;
+  const ext = getFileExtension(value, true);
+  if (!ext) {
+    return value;
+  }
+  return value.slice(0, -ext.length - 1);
+}
+
+function humanFileSize(bytes, digits = 1, withSpace = true) {
+  const thresh = 1024;
+  const units = ["KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  if (Math.abs(bytes) < thresh) {
+    return (bytes / thresh).toFixed(digits) + ` ${units[0]}`;
+  }
+  let u = -1;
+  const r = 10 ** digits;
+  do {
+    bytes /= thresh;
+    ++u;
+  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+  return bytes.toFixed(digits) + (withSpace ? " " : "") + units[u];
+}
+
+function sprintf(line, args, unusedArgs = []) {
+  let result = "";
+  const argsLen = args.length;
+  const lineLen = line.length;
+  let opened = false;
+  let currentChar = -1;
+  let lastPos = 0;
+  let argsIndex = 0;
+  for (let idx = 0; idx < lineLen; idx++) {
+    currentChar = line.charCodeAt(idx);
+    if (currentChar === 37) {
+      opened = true;
+      continue;
+    }
+    if (!opened) continue;
+    opened = false;
+    switch (currentChar) {
+      // 'd'
+      case 100:
+      // 'f'
+      case 102: {
+        result += line.slice(lastPos, idx - 1);
+        result += Number(args[argsIndex]);
+        lastPos = idx + 1;
+        argsIndex++;
+        break;
+      }
+      // 'i'
+      case 105: {
+        result += line.slice(lastPos, idx - 1);
+        result += Math.floor(Number(args[argsIndex]));
+        lastPos = idx + 1;
+        argsIndex++;
+        break;
+      }
+      // 'O'
+      case 79:
+      // 'o'
+      case 111:
+      // 'j'
+      case 106: {
+        result += line.slice(lastPos, idx - 1);
+        result += tryStringify(args[argsIndex]);
+        lastPos = idx + 1;
+        argsIndex++;
+        break;
+      }
+      // 's'
+      case 115: {
+        result += line.slice(lastPos, idx - 1);
+        result += String(args[argsIndex]);
+        lastPos = idx + 1;
+        argsIndex++;
+        break;
+      }
+    }
+    if (argsIndex >= argsLen) break;
+  }
+  if (lastPos < lineLen) {
+    result += line.slice(lastPos, lineLen);
+  }
+  if (argsIndex < argsLen) {
+    unusedArgs.push(...args.slice(argsIndex, argsLen));
+  }
+  return result;
+}
+function tryStringify(o) {
+  switch (typeof o) {
+    case "function": {
+      return o.name || "<anonymous>";
+    }
+    case "string": {
+      return "'" + o + "'";
+    }
+    default: {
+      try {
+        return JSON.stringify(o);
+      } catch (e) {
+        return '"[Circular]"';
+      }
+    }
+  }
+}
+
+const IS_DEV = env.isDevelopment || env.bool("DEV", false);
+const logger = (...baseArgs) => {
+  if (typeof baseArgs[0] === "string" && baseArgs[0][0] !== "[") {
+    baseArgs[0] = `[${baseArgs[0].split("/").at(-1).split("?", 1)[0]}]`;
+  }
+  const writeLog = (level, ...[pattern, ...args]) => {
+    if (!isString(pattern)) {
+      console[level](...baseArgs, pattern, ...args);
+      return;
+    }
+    const unusedArgs = [];
+    const formatted = sprintf(pattern, args, unusedArgs);
+    console[level](...baseArgs, ...formatted, ...unusedArgs);
+  };
+  const log = writeLog.bind(null, "log");
+  const info = writeLog.bind(null, "info");
+  const warn = writeLog.bind(null, "warn");
+  const error = writeLog.bind(null, "error");
+  const debug = writeLog.bind(null, "debug");
+  const extend = (...args) => {
+    return logger(...baseArgs, ...args);
+  };
+  const instance = {
+    log,
+    info,
+    warn,
+    error,
+    debug,
+    extend
+  };
+  Object.defineProperty(instance, "debug", {
+    get: () => IS_DEV ? debug : noop
+  });
+  return instance;
+};
+
+async function asyncFilter(array, predicate) {
+  const result = [];
+  const cooldown = nextTickIteration(10);
+  for (let idx = 0; idx < array.length; idx++) {
+    await cooldown();
+    const value = array[idx];
+    const valid = await predicate(value, idx, array);
+    if (valid) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+const defaultWindow$1 = globalThis?.window;
+const idle = (() => {
+  if (defaultWindow$1?.requestIdleCallback) {
+    return defaultWindow$1.requestIdleCallback;
+  } else if (defaultWindow$1?.requestAnimationFrame) {
+    return defaultWindow$1.requestAnimationFrame;
+  } else if (isFunction(process?.nextTick)) {
+    return process.nextTick;
+  } else {
+    return (fn) => setTimeout(fn, 0);
+  }
+})();
+function fastIdle(callback) {
+  return idle(callback);
+}
+function fastIdlePromise() {
+  return new Promise((resolve) => idle(resolve));
+}
+
+function nextTickIteration(amount, delay = "tick") {
+  let counter = 0;
+  const tickInterval = delay === "tick";
+  return () => {
+    counter++;
+    if (counter >= amount) {
+      counter = 0;
+      return new Promise((resolve) => {
+        if (tickInterval) {
+          fastIdle(resolve);
+        } else {
+          setTimeout(resolve, delay);
+        }
+      });
+    }
+    return Promise.resolve();
+  };
+}
+
+async function asyncFind(array, callbackfn) {
+  const cooldown = nextTickIteration(10);
+  let i = 0;
+  while (i < array.length) {
+    await cooldown();
+    const result = await callbackfn(array[i], i, array);
+    if (Boolean(result)) {
+      return array[i];
+    }
+    i++;
+  }
+  return void 0;
+}
+
+async function asyncForEach(array, callbackfn, { concurrency = 1 } = {}) {
+  const cooldown = nextTickIteration(10);
+  let i = 0;
+  const handle = (value, index) => {
+    return callbackfn(value, i + index, array);
+  };
+  while (i < array.length) {
+    await cooldown();
+    const batch = await Promise.all(
+      array.slice(i, i + concurrency).map(handle)
+    );
+    i += batch.length;
+  }
+}
+
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {
+    resolve,
+    reject,
+    promise
+  };
+}
+
+const onError = (error) => {
+  console.error(error);
+};
+class SimpleEventEmitter {
+  #listeners = /* @__PURE__ */ new Map();
+  constructor() {
+    this.on("error", onError);
+  }
+  static once(emitter, eventName) {
+    const q = defer();
+    emitter.once(eventName, (...args) => q.resolve(args));
+    return q.promise;
+  }
+  emit(eventName, ...args) {
+    const set = this.#listeners.get(eventName);
+    if (!set) return false;
+    set.forEach((fn) => {
+      try {
+        const result = fn();
+        if (isPromise(result)) {
+          result.catch((err) => {
+            this.emit("error", err);
+          });
+        }
+      } catch (err) {
+        this.emit("error", err);
+      }
+    });
+    return true;
+  }
+  on(eventName, listener) {
+    if (!this.#listeners.has(eventName)) {
+      this.#listeners.set(eventName, /* @__PURE__ */ new Set());
+    }
+    const set = this.#listeners.get(eventName);
+    set.add(listener);
+    return this;
+  }
+  once(eventName, listener) {
+    const wrapped = (...args) => {
+      this.off(eventName, wrapped);
+      listener(...args);
+    };
+    this.on(eventName, wrapped);
+    return this;
+  }
+  off(eventName, listener) {
+    const set = this.#listeners.get(eventName);
+    if (set) {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.#listeners.delete(eventName);
+      }
+    }
+    return this;
+  }
+  removeAllListeners(eventName) {
+    if (eventName === void 0) {
+      this.#listeners.clear();
+      return this;
+    }
+    this.#listeners.delete(eventName);
+    return this;
+  }
+}
+
+class Queue {
+  items = [];
+  #limit;
+  #events = new SimpleEventEmitter();
+  constructor(limit) {
+    this.#limit = limit;
+  }
+  async get() {
+    if (this.items.length === 0) {
+      await SimpleEventEmitter.once(this.#events, "put");
+    }
+    const item = this.items.shift();
+    this.#events.emit("get");
+    return item;
+  }
+  async put(item) {
+    if (this.#limit && this.items.length >= this.#limit) {
+      await SimpleEventEmitter.once(this.#events, "get");
+    }
+    this.items.push(item);
+    this.#events.emit("put");
+  }
+}
+
+class AsyncIterableQueue {
+  _queue;
+  _closed = false;
+  static QUEUE_END_MARKER = Symbol("QUEUE_END_MARKER");
+  constructor() {
+    this._queue = new Queue();
+  }
+  get closed() {
+    return this._closed;
+  }
+  put(item) {
+    if (this._closed) {
+      throw new Error("Queue is closed");
+    }
+    this._queue.put(item);
+  }
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._queue.put(AsyncIterableQueue.QUEUE_END_MARKER);
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this._closed && this._queue.items.length === 0) {
+          return { value: void 0, done: true };
+        }
+        const item = await this._queue.get();
+        if (item === AsyncIterableQueue.QUEUE_END_MARKER && this._closed) {
+          return { value: void 0, done: true };
+        }
+        return { value: item, done: false };
+      }
+    };
+  }
+}
+
+async function asyncMap(array, callbackfn, { concurrency = 1 } = {}) {
+  let result = [];
+  concurrency = Math.max(concurrency, 1);
+  const cooldown = nextTickIteration(10);
+  let i = 0;
+  const handle = (value, index) => {
+    return callbackfn(value, i + index, array);
+  };
+  while (i < array.length) {
+    await cooldown();
+    const batch = await Promise.all(
+      array.slice(i, i + concurrency).map(handle)
+    );
+    result = result.concat(batch);
+    i += batch.length;
+  }
+  return result;
+}
+
+class CancellablePromise {
+  #promise;
+  #cancelFns;
+  #isCancelled = false;
+  #error = null;
+  constructor(executor) {
+    this.#cancelFns = [];
+    this.#promise = new Promise((resolve, reject) => {
+      executor(
+        resolve,
+        (reason) => {
+          this.#error = toError(reason, "Unknown rejection reason.");
+          reject(reason);
+        },
+        (fn) => {
+          this.#cancelFns.push(fn);
+        }
+      );
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return this.#promise[Symbol.toStringTag] + (this.isCancelled ? " (Cancelled)" : "");
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+  get error() {
+    return this.#error;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#promise.finally(onfinally);
+  }
+  cancel() {
+    if (this.#isCancelled) return;
+    this.#isCancelled = true;
+    for (const fn of this.#cancelFns) {
+      catchError(fn);
+    }
+  }
+  static from(promise) {
+    return new CancellablePromise((resolve, reject) => {
+      promise.then(resolve).catch(reject);
+    });
+  }
+}
+
+function delay(amount = "tick") {
+  const d = defer();
+  if (amount === "tick") {
+    fastIdle(d.resolve);
+  } else {
+    setTimeout(d.resolve, amount);
+  }
+  return d.promise;
+}
+
+const FAST_RAF_TIMEOUT_FALLBACK_MS = 300;
+const defaultWindow = globalThis?.window;
+const raf = defaultWindow?.requestAnimationFrame || ((cb) => setTimeout(cb, 0));
+let fastRafCallbacks;
+let fastRafFallbackCallbacks;
+let fastRafFallbackTimeout;
+function fastRaf(callback, withTimeoutFallback = false) {
+  if (!fastRafCallbacks) {
+    fastRafCallbacks = /* @__PURE__ */ new Set([callback]);
+    raf(() => {
+      const currentCallbacks = fastRafCallbacks;
+      fastRafCallbacks = void 0;
+      fastRafFallbackCallbacks = void 0;
+      if (fastRafFallbackTimeout) {
+        clearTimeout(fastRafFallbackTimeout);
+        fastRafFallbackTimeout = void 0;
+      }
+      currentCallbacks.forEach((cb) => cb());
+    });
+  } else {
+    fastRafCallbacks.add(callback);
+  }
+  if (withTimeoutFallback) {
+    if (!fastRafFallbackCallbacks) {
+      fastRafFallbackCallbacks = /* @__PURE__ */ new Set([callback]);
+    } else {
+      fastRafFallbackCallbacks.add(callback);
+    }
+    if (!fastRafFallbackTimeout) {
+      fastRafFallbackTimeout = setTimeout(() => {
+        const currentTimeoutCallbacks = fastRafFallbackCallbacks;
+        if (fastRafCallbacks) {
+          currentTimeoutCallbacks.forEach(
+            fastRafCallbacks.delete,
+            fastRafCallbacks
+          );
+        }
+        fastRafFallbackCallbacks = void 0;
+        if (fastRafFallbackTimeout) {
+          clearTimeout(fastRafFallbackTimeout);
+          fastRafFallbackTimeout = void 0;
+        }
+        currentTimeoutCallbacks.forEach((cb) => cb());
+      }, FAST_RAF_TIMEOUT_FALLBACK_MS);
+    }
+  }
+}
+function rafPromise() {
+  return new Promise((resolve) => {
+    fastRaf(resolve);
+  });
+}
+
+function timeout(ms, promiseOrCallback, timeoutError = new Error("Timeout")) {
+  const abortController = new AbortController();
+  let taskResult;
+  if (isFunction(promiseOrCallback)) {
+    taskResult = promiseOrCallback(abortController.signal);
+  } else if (isPromise(promiseOrCallback)) {
+    taskResult = promiseOrCallback;
+  } else {
+    throw new TypeError(
+      "Expected promise or callback as second argument, received: " + String(promiseOrCallback)
+    );
+  }
+  if (!isPromise(taskResult)) {
+    return Promise.resolve(taskResult);
+  }
+  let timer;
+  return Promise.race([
+    taskResult,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        abortController.abort();
+        reject(timeoutError);
+      }, ms);
+    })
+  ]).finally(() => {
+    timer && clearTimeout(timer);
+    timer = void 0;
+  });
+}
+
+function typeOf(value) {
+  const type = typeof value;
+  switch (type) {
+    case "number":
+      return isNumber(value) ? "number" : "unknown";
+    case "object": {
+      if (value === null) return "null";
+      if (Array.isArray(value)) return "array";
+      if (isSet(value)) return "set";
+      if (isWeakSet$1(value)) return "weakset";
+      if (isMap(value)) return "map";
+      if (isWeakMap$1(value)) return "weakmap";
+      if (isDate(value)) return "date";
+      if (isObject(value)) return "object";
+      return "unknown";
+    }
+    default: {
+      return type;
+    }
+  }
+}
+
+const qs = {
+  toParams,
+  stringify,
+  stringifyValue,
+  parse,
+  parseValue,
+  merge
+};
+function merge(...values) {
+  const result = {};
+  for (const filter of values) {
+    for (const [key, value] of Object.entries(filter)) {
+      const currentValue = result[key];
+      const currentType = typeOf(currentValue);
+      const filterType = typeOf(value);
+      if (currentType !== filterType) {
+        result[key] = value;
+        continue;
+      }
+      switch (currentType) {
+        case "array": {
+          result[key] = Array.from(/* @__PURE__ */ new Set([...currentValue, ...value]));
+          break;
+        }
+        case "object": {
+          result[key] = {};
+          deepAssign(result[key], currentValue);
+          deepAssign(result[key], value);
+          break;
+        }
+        case "map": {
+          result[key] = new Map([
+            ...Array.from(currentValue.entries()),
+            ...Array.from(value.entries())
+          ]);
+          break;
+        }
+        case "set": {
+          result[key] = /* @__PURE__ */ new Set([
+            ...Array.from(currentValue),
+            ...Array.from(value)
+          ]);
+          break;
+        }
+        default: {
+          result[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function stringify(obj, options) {
+  return new URLSearchParams(toParams(obj, options)).toString();
+}
+function toParams(obj, options) {
+  const result = {};
+  const excludeEmpty = options?.excludeEmpty !== false;
+  const excludeDefaults = options?.excludeDefaults;
+  for (const [key, value] of Object.entries(obj)) {
+    if (excludeEmpty && isEmpty(value)) continue;
+    if (excludeDefaults && key in excludeDefaults) {
+      const defValue = excludeDefaults[key];
+      if (isEqual(value, defValue)) continue;
+    }
+    const strValue = stringifyValue(value);
+    if (excludeEmpty && strValue === "") {
+      continue;
+    }
+    result[key] = strValue;
+  }
+  return result;
+}
+function parse(value, defaults) {
+  const objValue = isString(value) ? Object.fromEntries(new URLSearchParams(value).entries()) : value;
+  if (!defaults) {
+    return { ...objValue };
+  }
+  const result = {};
+  for (const [key, defValue] of Object.entries(defaults)) {
+    const defType = typeOf(defValue);
+    let parsedValue = parseValue(objValue[key], defType);
+    if (parsedValue !== void 0 || defType === "undefined") {
+      if (defType === "array" && defValue[0] !== void 0) {
+        const itemValue = typeOf(defValue[0]);
+        parsedValue = parsedValue.map((v) => parseValue(v, itemValue));
+      }
+      result[key] = parsedValue;
+    } else {
+      result[key] = defValue;
+    }
+  }
+  return result;
+}
+function stringifyValue(value) {
+  const valueType = typeOf(value);
+  switch (valueType) {
+    case "undefined": {
+      return "";
+    }
+    case "null": {
+      return "";
+    }
+    case "array": {
+      let result = "";
+      let sep = "";
+      for (const item of value) {
+        if (item === void 0) continue;
+        if (isObject(item) || Array.isArray(item) || isString(item) && item.includes(",")) {
+          result = JSON.stringify(value);
+          break;
+        } else {
+          result += sep + stringifyValue(item);
+          sep = ",";
+        }
+      }
+      return result;
+    }
+    case "date": {
+      return value.toISOString();
+    }
+    case "map": {
+      return JSON.stringify(Array.from(value.entries()));
+    }
+    case "set": {
+      return JSON.stringify(Array.from(value.values()));
+    }
+    case "boolean":
+    case "number":
+    case "string":
+    case "bigint": {
+      return String(value);
+    }
+    case "object": {
+      return JSON.stringify(value);
+    }
+    case "unknown": {
+      if (isFunction(value?.toString)) {
+        return value.toString();
+      }
+    }
+    default: {
+      throw new Error("Attempt to stringify unsupported type: " + valueType);
+    }
+  }
+}
+function parseValue(value, asType) {
+  const type = typeOf(value);
+  if (type === asType) {
+    return value;
+  } else if (type !== "string") {
+    return void 0;
+  }
+  try {
+    switch (asType) {
+      case "undefined": {
+        return void 0;
+      }
+      case "array": {
+        if (value.startsWith("[") && value.endsWith("]")) {
+          return JSON.parse(value);
+        }
+        return value.split(",");
+      }
+      case "boolean": {
+        return value === "true";
+      }
+      case "date": {
+        const parsed = new Date(value);
+        return isDate(parsed) ? parsed : void 0;
+      }
+      case "map": {
+        return new Map(JSON.parse(value));
+      }
+      case "number": {
+        const parsed = parseFloat(value);
+        return isNumber(parsed) ? parsed : void 0;
+      }
+      case "object": {
+        return JSON.parse(value);
+      }
+      case "set": {
+        return new Set(JSON.parse(value));
+      }
+      case "null": {
+        return value === "" || value === void 0 ? null : void 0;
+      }
+      case "string": {
+        return value;
+      }
+      case "bigint": {
+        return BigInt(value);
+      }
+    }
+  } catch (_) {
+  }
+  return void 0;
+}
+
+function retryOnError({
+  beforeRetryCallback,
+  maxRetriesNumber,
+  shouldRetryBasedOnError,
+  delayFactor = 0,
+  delayMaxMs = 1e3,
+  delayMinMs = 100
+}, fn) {
+  let retryCount = maxRetriesNumber;
+  let delayMs = 0;
+  delayMinMs = Math.max(delayMinMs, 1);
+  delayMaxMs = Math.max(delayMaxMs, 1);
+  const run = async (...args) => {
+    if (delayFactor >= 1 && delayMs > 0) {
+      await delay(delayMs);
+    }
+    const currentAttempt = 1 + maxRetriesNumber - retryCount;
+    try {
+      const res = await fn(...args);
+      return res;
+    } catch (e) {
+      if (retryCount > 1 && shouldRetryBasedOnError(e, currentAttempt)) {
+        retryCount--;
+        delayMs = Math.floor(
+          Math.min(Math.max(delayMs, delayMinMs) * delayFactor, delayMaxMs)
+        );
+        if (beforeRetryCallback) {
+          const newParams = await beforeRetryCallback(
+            currentAttempt,
+            retryCount === 0
+          );
+          if (newParams) {
+            return run(newParams);
+          }
+        }
+        return run(...args);
+      }
+      throw e;
+    }
+  };
+  return run;
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
+function getWords(str) {
+  if (!isString(str)) return [];
+  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
+}
+
+function camelCase(str) {
+  const words = getWords(str);
+  if (words.length === 0) {
+    return "";
+  }
+  const [first, ...rest] = words;
+  return `${first.toLowerCase()}${rest.map((word) => capitalize(word)).join("")}`;
+}
+
+function convertToUnit(str, unit = "px") {
+  if (str == null || str === "") {
+    return void 0;
+  } else if (isNaN(+str)) {
+    return String(str);
+  } else {
+    return `${Number(str)}${unit}`;
+  }
+}
+
+const htmlEscapes = Object.freeze({
+  38: "&amp;",
+  // &
+  60: "&lt;",
+  // <
+  62: "&gt;",
+  // >
+  34: "&quot;",
+  // "
+  39: "&#39;"
+  // '
+});
+function escapeHtml(unsafe) {
+  if (typeof unsafe !== "string") {
+    return "";
+  }
+  let result = "";
+  let strLen = unsafe.length;
+  let char;
+  for (let idx = 0; idx < strLen; idx++) {
+    char = unsafe.charCodeAt(idx);
+    result += htmlEscapes[char] || String.fromCharCode(char);
+  }
+  return result;
+}
+
+function escapeNumeric(str) {
+  const result = String(str).replace(/\D/g, "");
+  if (!result.length) {
+    return void 0;
+  }
+  return result;
+}
+
+function escapeRegExp(str) {
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+}
+
+const vs16RegExp = /\uFE0F/g;
+const zeroWidthJoiner = String.fromCharCode(8205);
+function removeVS16s(rawEmoji) {
+  return rawEmoji.indexOf(zeroWidthJoiner) < 0 ? rawEmoji.replace(vs16RegExp, "") : rawEmoji;
+}
+const TWEMOJI_REGEX = /(?:\ud83d\udc68\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83e\uddd1\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83e\uddd1\ud83c[\udffc-\udfff]|\ud83e\uddd1\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83e\uddd1\ud83c[\udffb\udffd-\udfff]|\ud83e\uddd1\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83e\uddd1\ud83c[\udffb\udffc\udffe\udfff]|\ud83e\uddd1\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83e\uddd1\ud83c[\udffb-\udffd\udfff]|\ud83e\uddd1\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83e\uddd1\ud83c[\udffb-\udffe]|\ud83d\udc68\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffb\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffc-\udfff]|\ud83d\udc68\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffc\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb\udffd-\udfff]|\ud83d\udc68\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffd\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb\udffc\udffe\udfff]|\ud83d\udc68\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udffe\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb-\udffd\udfff]|\ud83d\udc68\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc68\ud83c\udfff\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb-\udffe]|\ud83d\udc69\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffb\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffc-\udfff]|\ud83d\udc69\ud83c\udffb\u200d\ud83e\udd1d\u200d\ud83d\udc69\ud83c[\udffc-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb\udffd-\udfff]|\ud83d\udc69\ud83c\udffc\u200d\ud83e\udd1d\u200d\ud83d\udc69\ud83c[\udffb\udffd-\udfff]|\ud83d\udc69\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffd\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb\udffc\udffe\udfff]|\ud83d\udc69\ud83c\udffd\u200d\ud83e\udd1d\u200d\ud83d\udc69\ud83c[\udffb\udffc\udffe\udfff]|\ud83d\udc69\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udffe\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb-\udffd\udfff]|\ud83d\udc69\ud83c\udffe\u200d\ud83e\udd1d\u200d\ud83d\udc69\ud83c[\udffb-\udffd\udfff]|\ud83d\udc69\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc68\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83d\udc69\ud83c[\udffb-\udfff]|\ud83d\udc69\ud83c\udfff\u200d\ud83e\udd1d\u200d\ud83d\udc68\ud83c[\udffb-\udffe]|\ud83d\udc69\ud83c\udfff\u200d\ud83e\udd1d\u200d\ud83d\udc69\ud83c[\udffb-\udffe]|\ud83e\uddd1\ud83c\udffb\u200d\u2764\ufe0f\u200d\ud83e\uddd1\ud83c[\udffc-\udfff]|\ud83e\uddd1\ud83c\udffb\u200d\ud83e\udd1d\u200d\ud83e\uddd1\ud83c[\udffb-\udfff]|\ud83e\uddd1\ud83c\udffc\u200d\u2764\ufe0f\u200d\ud83e\uddd1\ud83c[\udffb\udffd-\udfff]|\ud83e\uddd1\ud83c\udffc\u200d\ud83e\udd1d\u200d\ud83e\uddd1\ud83c[\udffb-\udfff]|\ud83e\uddd1\ud83c\udffd\u200d\u2764\ufe0f\u200d\ud83e\uddd1\ud83c[\udffb\udffc\udffe\udfff]|\ud83e\uddd1\ud83c\udffd\u200d\ud83e\udd1d\u200d\ud83e\uddd1\ud83c[\udffb-\udfff]|\ud83e\uddd1\ud83c\udffe\u200d\u2764\ufe0f\u200d\ud83e\uddd1\ud83c[\udffb-\udffd\udfff]|\ud83e\uddd1\ud83c\udffe\u200d\ud83e\udd1d\u200d\ud83e\uddd1\ud83c[\udffb-\udfff]|\ud83e\uddd1\ud83c\udfff\u200d\u2764\ufe0f\u200d\ud83e\uddd1\ud83c[\udffb-\udffe]|\ud83e\uddd1\ud83c\udfff\u200d\ud83e\udd1d\u200d\ud83e\uddd1\ud83c[\udffb-\udfff]|\ud83d\udc68\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d\udc68|\ud83d\udc69\u200d\u2764\ufe0f\u200d\ud83d\udc8b\u200d\ud83d[\udc68\udc69]|\ud83e\udef1\ud83c\udffb\u200d\ud83e\udef2\ud83c[\udffc-\udfff]|\ud83e\udef1\ud83c\udffc\u200d\ud83e\udef2\ud83c[\udffb\udffd-\udfff]|\ud83e\udef1\ud83c\udffd\u200d\ud83e\udef2\ud83c[\udffb\udffc\udffe\udfff]|\ud83e\udef1\ud83c\udffe\u200d\ud83e\udef2\ud83c[\udffb-\udffd\udfff]|\ud83e\udef1\ud83c\udfff\u200d\ud83e\udef2\ud83c[\udffb-\udffe]|\ud83d\udc68\u200d\u2764\ufe0f\u200d\ud83d\udc68|\ud83d\udc69\u200d\u2764\ufe0f\u200d\ud83d[\udc68\udc69]|\ud83e\uddd1\u200d\ud83e\udd1d\u200d\ud83e\uddd1|\ud83d\udc6b\ud83c[\udffb-\udfff]|\ud83d\udc6c\ud83c[\udffb-\udfff]|\ud83d\udc6d\ud83c[\udffb-\udfff]|\ud83d\udc8f\ud83c[\udffb-\udfff]|\ud83d\udc91\ud83c[\udffb-\udfff]|\ud83e\udd1d\ud83c[\udffb-\udfff]|\ud83d[\udc6b-\udc6d\udc8f\udc91]|\ud83e\udd1d)|(?:\ud83d[\udc68\udc69]|\ud83e\uddd1)(?:\ud83c[\udffb-\udfff])?\u200d(?:\u2695\ufe0f|\u2696\ufe0f|\u2708\ufe0f|\ud83c[\udf3e\udf73\udf7c\udf84\udf93\udfa4\udfa8\udfeb\udfed]|\ud83d[\udcbb\udcbc\udd27\udd2c\ude80\ude92]|\ud83e[\uddaf-\uddb3\uddbc\uddbd])|(?:\ud83c[\udfcb\udfcc]|\ud83d[\udd74\udd75]|\u26f9)((?:\ud83c[\udffb-\udfff]|\ufe0f)\u200d[\u2640\u2642]\ufe0f)|(?:\ud83c[\udfc3\udfc4\udfca]|\ud83d[\udc6e\udc70\udc71\udc73\udc77\udc81\udc82\udc86\udc87\ude45-\ude47\ude4b\ude4d\ude4e\udea3\udeb4-\udeb6]|\ud83e[\udd26\udd35\udd37-\udd39\udd3d\udd3e\uddb8\uddb9\uddcd-\uddcf\uddd4\uddd6-\udddd])(?:\ud83c[\udffb-\udfff])?\u200d[\u2640\u2642]\ufe0f|(?:\ud83d\udc68\u200d\ud83d\udc68\u200d\ud83d\udc66\u200d\ud83d\udc66|\ud83d\udc68\u200d\ud83d\udc68\u200d\ud83d\udc67\u200d\ud83d[\udc66\udc67]|\ud83d\udc68\u200d\ud83d\udc69\u200d\ud83d\udc66\u200d\ud83d\udc66|\ud83d\udc68\u200d\ud83d\udc69\u200d\ud83d\udc67\u200d\ud83d[\udc66\udc67]|\ud83d\udc69\u200d\ud83d\udc69\u200d\ud83d\udc66\u200d\ud83d\udc66|\ud83d\udc69\u200d\ud83d\udc69\u200d\ud83d\udc67\u200d\ud83d[\udc66\udc67]|\ud83d\udc68\u200d\ud83d\udc66\u200d\ud83d\udc66|\ud83d\udc68\u200d\ud83d\udc67\u200d\ud83d[\udc66\udc67]|\ud83d\udc68\u200d\ud83d\udc68\u200d\ud83d[\udc66\udc67]|\ud83d\udc68\u200d\ud83d\udc69\u200d\ud83d[\udc66\udc67]|\ud83d\udc69\u200d\ud83d\udc66\u200d\ud83d\udc66|\ud83d\udc69\u200d\ud83d\udc67\u200d\ud83d[\udc66\udc67]|\ud83d\udc69\u200d\ud83d\udc69\u200d\ud83d[\udc66\udc67]|\ud83c\udff3\ufe0f\u200d\u26a7\ufe0f|\ud83c\udff3\ufe0f\u200d\ud83c\udf08|\ud83d\ude36\u200d\ud83c\udf2b\ufe0f|\u2764\ufe0f\u200d\ud83d\udd25|\u2764\ufe0f\u200d\ud83e\ude79|\ud83c\udff4\u200d\u2620\ufe0f|\ud83d\udc15\u200d\ud83e\uddba|\ud83d\udc3b\u200d\u2744\ufe0f|\ud83d\udc41\u200d\ud83d\udde8|\ud83d\udc68\u200d\ud83d[\udc66\udc67]|\ud83d\udc69\u200d\ud83d[\udc66\udc67]|\ud83d\udc6f\u200d\u2640\ufe0f|\ud83d\udc6f\u200d\u2642\ufe0f|\ud83d\ude2e\u200d\ud83d\udca8|\ud83d\ude35\u200d\ud83d\udcab|\ud83e\udd3c\u200d\u2640\ufe0f|\ud83e\udd3c\u200d\u2642\ufe0f|\ud83e\uddde\u200d\u2640\ufe0f|\ud83e\uddde\u200d\u2642\ufe0f|\ud83e\udddf\u200d\u2640\ufe0f|\ud83e\udddf\u200d\u2642\ufe0f|\ud83d\udc08\u200d\u2b1b)|[#*0-9]\ufe0f?\u20e3|(?:[©®\u2122\u265f]\ufe0f)|(?:\ud83c[\udc04\udd70\udd71\udd7e\udd7f\ude02\ude1a\ude2f\ude37\udf21\udf24-\udf2c\udf36\udf7d\udf96\udf97\udf99-\udf9b\udf9e\udf9f\udfcd\udfce\udfd4-\udfdf\udff3\udff5\udff7]|\ud83d[\udc3f\udc41\udcfd\udd49\udd4a\udd6f\udd70\udd73\udd76-\udd79\udd87\udd8a-\udd8d\udda5\udda8\uddb1\uddb2\uddbc\uddc2-\uddc4\uddd1-\uddd3\udddc-\uddde\udde1\udde3\udde8\uddef\uddf3\uddfa\udecb\udecd-\udecf\udee0-\udee5\udee9\udef0\udef3]|[\u203c\u2049\u2139\u2194-\u2199\u21a9\u21aa\u231a\u231b\u2328\u23cf\u23ed-\u23ef\u23f1\u23f2\u23f8-\u23fa\u24c2\u25aa\u25ab\u25b6\u25c0\u25fb-\u25fe\u2600-\u2604\u260e\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262a\u262e\u262f\u2638-\u263a\u2640\u2642\u2648-\u2653\u2660\u2663\u2665\u2666\u2668\u267b\u267f\u2692-\u2697\u2699\u269b\u269c\u26a0\u26a1\u26a7\u26aa\u26ab\u26b0\u26b1\u26bd\u26be\u26c4\u26c5\u26c8\u26cf\u26d1\u26d3\u26d4\u26e9\u26ea\u26f0-\u26f5\u26f8\u26fa\u26fd\u2702\u2708\u2709\u270f\u2712\u2714\u2716\u271d\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u2764\u27a1\u2934\u2935\u2b05-\u2b07\u2b1b\u2b1c\u2b50\u2b55\u3030\u303d\u3297\u3299])(?:\ufe0f|(?!\ufe0e))|(?:(?:\ud83c[\udfcb\udfcc]|\ud83d[\udd74\udd75\udd90]|[\u261d\u26f7\u26f9\u270c\u270d])(?:\ufe0f|(?!\ufe0e))|(?:\ud83c[\udf85\udfc2-\udfc4\udfc7\udfca]|\ud83d[\udc42\udc43\udc46-\udc50\udc66-\udc69\udc6e\udc70-\udc78\udc7c\udc81-\udc83\udc85-\udc87\udcaa\udd7a\udd95\udd96\ude45-\ude47\ude4b-\ude4f\udea3\udeb4-\udeb6\udec0\udecc]|\ud83e[\udd0c\udd0f\udd18-\udd1c\udd1e\udd1f\udd26\udd30-\udd39\udd3d\udd3e\udd77\uddb5\uddb6\uddb8\uddb9\uddbb\uddcd-\uddcf\uddd1-\udddd\udec3-\udec5\udef0-\udef6]|[\u270a\u270b]))(?:\ud83c[\udffb-\udfff])?|(?:\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc65\udb40\udc6e\udb40\udc67\udb40\udc7f|\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc73\udb40\udc63\udb40\udc74\udb40\udc7f|\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc77\udb40\udc6c\udb40\udc73\udb40\udc7f|\ud83c\udde6\ud83c[\udde8-\uddec\uddee\uddf1\uddf2\uddf4\uddf6-\uddfa\uddfc\uddfd\uddff]|\ud83c\udde7\ud83c[\udde6\udde7\udde9-\uddef\uddf1-\uddf4\uddf6-\uddf9\uddfb\uddfc\uddfe\uddff]|\ud83c\udde8\ud83c[\udde6\udde8\udde9\uddeb-\uddee\uddf0-\uddf5\uddf7\uddfa-\uddff]|\ud83c\udde9\ud83c[\uddea\uddec\uddef\uddf0\uddf2\uddf4\uddff]|\ud83c\uddea\ud83c[\udde6\udde8\uddea\uddec\udded\uddf7-\uddfa]|\ud83c\uddeb\ud83c[\uddee-\uddf0\uddf2\uddf4\uddf7]|\ud83c\uddec\ud83c[\udde6\udde7\udde9-\uddee\uddf1-\uddf3\uddf5-\uddfa\uddfc\uddfe]|\ud83c\udded\ud83c[\uddf0\uddf2\uddf3\uddf7\uddf9\uddfa]|\ud83c\uddee\ud83c[\udde8-\uddea\uddf1-\uddf4\uddf6-\uddf9]|\ud83c\uddef\ud83c[\uddea\uddf2\uddf4\uddf5]|\ud83c\uddf0\ud83c[\uddea\uddec-\uddee\uddf2\uddf3\uddf5\uddf7\uddfc\uddfe\uddff]|\ud83c\uddf1\ud83c[\udde6-\udde8\uddee\uddf0\uddf7-\uddfb\uddfe]|\ud83c\uddf2\ud83c[\udde6\udde8-\udded\uddf0-\uddff]|\ud83c\uddf3\ud83c[\udde6\udde8\uddea-\uddec\uddee\uddf1\uddf4\uddf5\uddf7\uddfa\uddff]|\ud83c\uddf4\ud83c\uddf2|\ud83c\uddf5\ud83c[\udde6\uddea-\udded\uddf0-\uddf3\uddf7-\uddf9\uddfc\uddfe]|\ud83c\uddf6\ud83c\udde6|\ud83c\uddf7\ud83c[\uddea\uddf4\uddf8\uddfa\uddfc]|\ud83c\uddf8\ud83c[\udde6-\uddea\uddec-\uddf4\uddf7-\uddf9\uddfb\uddfd-\uddff]|\ud83c\uddf9\ud83c[\udde6\udde8\udde9\uddeb-\udded\uddef-\uddf4\uddf7\uddf9\uddfb\uddfc\uddff]|\ud83c\uddfa\ud83c[\udde6\uddec\uddf2\uddf3\uddf8\uddfe\uddff]|\ud83c\uddfb\ud83c[\udde6\udde8\uddea\uddec\uddee\uddf3\uddfa]|\ud83c\uddfc\ud83c[\uddeb\uddf8]|\ud83c\uddfd\ud83c\uddf0|\ud83c\uddfe\ud83c[\uddea\uddf9]|\ud83c\uddff\ud83c[\udde6\uddf2\uddfc]|\ud83c[\udccf\udd8e\udd91-\udd9a\udde6-\uddff\ude01\ude32-\ude36\ude38-\ude3a\ude50\ude51\udf00-\udf20\udf2d-\udf35\udf37-\udf7c\udf7e-\udf84\udf86-\udf93\udfa0-\udfc1\udfc5\udfc6\udfc8\udfc9\udfcf-\udfd3\udfe0-\udff0\udff4\udff8-\udfff]|\ud83d[\udc00-\udc3e\udc40\udc44\udc45\udc51-\udc65\udc6a\udc6f\udc79-\udc7b\udc7d-\udc80\udc84\udc88-\udc8e\udc90\udc92-\udca9\udcab-\udcfc\udcff-\udd3d\udd4b-\udd4e\udd50-\udd67\udda4\uddfb-\ude44\ude48-\ude4a\ude80-\udea2\udea4-\udeb3\udeb7-\udebf\udec1-\udec5\uded0-\uded2\uded5-\uded7\udedd-\udedf\udeeb\udeec\udef4-\udefc\udfe0-\udfeb\udff0]|\ud83e[\udd0d\udd0e\udd10-\udd17\udd20-\udd25\udd27-\udd2f\udd3a\udd3c\udd3f-\udd45\udd47-\udd76\udd78-\uddb4\uddb7\uddba\uddbc-\uddcc\uddd0\uddde-\uddff\ude70-\ude74\ude78-\ude7c\ude80-\ude86\ude90-\udeac\udeb0-\udeba\udec0-\udec2\uded0-\uded9\udee0-\udee7]|[\u23e9-\u23ec\u23f0\u23f3\u267e\u26ce\u2705\u2728\u274c\u274e\u2753-\u2755\u2795-\u2797\u27b0\u27bf\ue50a])|\ufe0f/g;
+
+function isOneEmoji(text) {
+  return !!(typeof text === "string" && text && (text.match(TWEMOJI_REGEX) || [])[0]?.length === text.length);
+}
+
+const IGNORED_TITLES = Object.freeze(
+  /* @__PURE__ */ new Set([
+    "dr.",
+    "mr.",
+    "mrs.",
+    "miss",
+    "ms.",
+    "prof.",
+    "sir",
+    "rev.",
+    "hon."
+  ])
+);
+function getInitials(fullName) {
+  if (!isString(fullName)) return "";
+  let [first, ...rest] = fullName.replace(/\s{2,}/g, " ").replace(/[,+/#!$@%^&*;:{}=\-_`~()]/g, "").trim().split(" ").filter((word) => !IGNORED_TITLES.has(word.toLowerCase())).map((v) => v.replaceAll(".", "").trim()).filter(Boolean);
+  let last = rest[rest.length - 1];
+  if (rest.length > 1) {
+    if (isOneEmoji(first)) {
+      first = rest[0];
+    } else if (isOneEmoji(last)) {
+      last = rest[0];
+    }
+  }
+  return [first, last].filter(Boolean).map((letter = "") => [...letter.toUpperCase()][0]).join("");
+}
+
+const byteToHex = [];
+for (let n = 0; n <= 255; ++n) {
+  const hexOctet = n.toString(16).padStart(2, "0");
+  byteToHex.push(hexOctet);
+}
+function hex(value) {
+  const buff = Array.isArray(value) ? new Uint8Array(value) : value;
+  const hexOctets = new Array(buff.length);
+  for (let i = 0; i < buff.length; ++i) {
+    hexOctets[i] = byteToHex[buff[i]];
+  }
+  return hexOctets.join("");
+}
+
+function isoToFlagEmoji(iso) {
+  const code = iso.toUpperCase();
+  if (!/^[A-Z]{2}$/.test(code)) return iso;
+  const codePoints = [...code].map((c) => c.codePointAt(0) + 127397);
+  return String.fromCodePoint(...codePoints);
+}
+
+function kebabCase(str) {
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("-");
+}
+
+const lowerCase = (str) => {
+  return getWords(str).map((word) => word.toLowerCase()).join(" ");
+};
+
+function maskingWords(value, withChar = "*") {
+  return getWords(value).map((word) => {
+    const len = word.length;
+    if (len < 2) {
+      return "".padEnd(len, withChar);
+    } else if (len < 3) {
+      return word[0].padEnd(len, withChar);
+    } else {
+      return word[0].padEnd(len - 2, withChar) + word.at(-1);
+    }
+  }).join(" ");
+}
+
+function maskingEmail(value) {
+  if (!isString(value)) return "";
+  const [username, host] = value.split("@", 2);
+  if (!username || !host) return "";
+  return `${maskingWords(username)}@${host}`;
+}
+
+function maskingPhone(value, fromPosition = 2, toPosition = 4, withChar = "X") {
+  if (!isString(value)) return "";
+  const numbersAmount = value.replace(/\D/g, "").length;
+  const fromIdx = fromPosition - 1;
+  let toIdx = numbersAmount - toPosition;
+  if (toIdx <= 0) {
+    toIdx = numbersAmount;
+  }
+  let i = -1;
+  return value.replace(/\d/g, (char) => {
+    i++;
+    return i > fromIdx && i < toIdx ? withChar : char;
+  });
+}
+
+let index = Math.floor(Math.random() * 16777215);
+const buffer = new Uint8Array(12);
+function objectId(fromValue = Date.now()) {
+  const value = timestamp(fromValue);
+  const inc = getInc();
+  buffer[0] = value >> 24;
+  buffer[1] = value >> 16;
+  buffer[2] = value >> 8;
+  buffer[3] = value;
+  buffer[4] = Math.floor(Math.random() * 256);
+  buffer[5] = Math.floor(Math.random() * 256);
+  buffer[6] = Math.floor(Math.random() * 256);
+  buffer[7] = Math.floor(Math.random() * 256);
+  buffer[8] = Math.floor(Math.random() * 256);
+  buffer[11] = inc & 255;
+  buffer[10] = inc >> 8 & 255;
+  buffer[9] = inc >> 16 & 255;
+  return hex(buffer);
+}
+function getInc() {
+  return index = (index + 1) % 16777215;
+}
+
+const snakeCase = (str) => {
+  return getWords(str).map((word) => word.toLowerCase()).join("_");
+};
+
+const startCase = (value) => {
+  return getWords(value).map(capitalize).join(" ");
+};
+
+const DEF_STR_ASSIGN_REGEXP = /\{{([A-z-_. ]*)\}}/g;
+const DEF_STR_ASSIGN_METHOD = (obj, key) => obj[key];
+function strAssign(str, obj, method = DEF_STR_ASSIGN_METHOD) {
+  return str.replace(DEF_STR_ASSIGN_REGEXP, (match, p1) => {
+    const key = p1.trim();
+    const value = method(obj, key);
+    if (value === void 0 || value === null) {
+      return match;
+    }
+    return value;
+  });
+}
+
+function truncate(value, maxLength = 120, insignificantThreshold = 0.05) {
+  if (!shouldTruncate(value, maxLength, insignificantThreshold)) {
+    return value;
+  }
+  let truncated = value.slice(0, maxLength).trim();
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > 0) {
+    truncated = truncated.slice(0, lastSpace);
+  }
+  return `${truncated}...`;
+}
+function shouldTruncate(text, maxLength, insignificantThreshold) {
+  return text.length - maxLength > maxLength * insignificantThreshold;
+}
+
+function wrapText(value, maxLength = 30) {
+  if (value.length > maxLength) {
+    return value.slice(0, maxLength) + "...";
+  }
+  return value;
+}
+
+export { AppError, AsyncIterableQueue, BrowserAssertionError, CancellablePromise, ColorParser, FixedMap, FixedWeakMap, LruCache, Queue, SimpleEventEmitter, TWEMOJI_REGEX, TimeBucket, alpha, arrayable, assert, asyncFilter, asyncFind, asyncForEach, asyncMap, avg, blendColors, buildCssColor, cache, cacheBucket, cacheFixed, cacheLRU, camelCase, capitalize, captureStackTrace, catchError, channelsToHSL, channelsToHex, channelsToRGB, checkBitmask, chunk, chunkSeries, clamp, cleanEmpty, cleanObject, colorToChannels, contrastRatio, convertToUnit, crc32, createCustomizer, createCustomizerFactory, createDeepCloneWith, createEnvParser, createRandomizer, createSecureCustomizer, createWithCache, cssVariable, deepAssign, deepClone, deepCloneWith, deepDefaults, deepFreeze, def, defer, delay, dropCache, env, escapeHtml, escapeNumeric, escapeRegExp, fastIdle, fastIdlePromise, fastRaf, findMean, flagsToMap, flatten, formatMoney, formatNumber, get, getFileExtension, getFileName, getInitials, getRandomInt, getWords, has, hasOwn, hasProtocol, hex, hexToChannels, hslToChannels, humanFileSize, humanize, interpolateColor, isBigInt, isBoolean, isCached, isClient, isColorChannels, isCustomizerFactory, isDate, isDef, isEmpty, isEqual, isError, isFunction, isMap, isNullOrUndefined, isNumber, isObject, isOneEmoji, isPrimitive, isPromise, isSet, isSkip, isString, isSuccess, isSymbol, isWeakMap, isWeakSet, isWithCache, isoToFlagEmoji, kebabCase, keyBy, logger, lowerCase, luminance, maskingEmail, maskingPhone, maskingWords, nextTickIteration, noop, objectId, omit, omitPrefixed, orderBy, parseAllNumbers, parseAlpha, parsePercentage, percentOf, pick, pickPrefixed, qs, rafPromise, randomString, removeVS16s, retryOnError, rgbToChannels, round2digits, set, snakeCase, sprintf, startCase, strAssign, sum, timeout, timestamp, timestampToDate, tintedTextColor, toError, toMap, truncate, typeOf, unflatten, union, uniq, uniqBy, unset, withCache, withCacheBucket, withCacheBucketBatch, withCacheFixed, withCacheLRU, withDeepClone, withPointerCache, wrapText };
+//# sourceMappingURL=index.mjs.map