@andrew_l/toolkit 0.2.8 → 0.2.9

package/dist/index.cjs

@@ -48,6 +48,7 @@ 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 isRegExp = (val) => val instanceof RegExp;
 const isWeakSet = (val) => val instanceof WeakSet;
 const isMap = (val) => val instanceof Map;
 const isWeakMap = (val) => val instanceof WeakMap;
@@ -171,7 +172,7 @@ const isEmpty = (obj) => {
   return false;
 };
 function isPromise(value) {
-  return value && typeof value === "object" && "then" in value && "catch" in value && typeof value.then === "function" && typeof value.catch === "function";
+  return value instanceof Promise || !!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"])
@@ -404,9 +405,9 @@ function equal(actual, expected, message) {
     });
   }
 }
-function empty$1(value, message) {
-  if (isEmpty(value)) {
-    throw toError$1(empty$1, value, message, "Expected not empty value.");
+function notEmpty(value, message) {
+  if (!isEmpty(value)) {
+    throw toError$1(notEmpty, value, message, "Expected not empty value.");
   }
 }
 function object(value, message) {
@@ -445,7 +446,7 @@ function date(value, message) {
   }
 }
 function fn(value, message) {
-  if (!isNumber(value)) {
+  if (!isFunction(value)) {
     throw toError$1(fn, value, message, "Expected function value.");
   }
 }
@@ -503,11 +504,11 @@ const assert = {
   arrayStrings: arrayStrings,
   boolean: boolean,
   date: date,
-  empty: empty$1,
   equal: equal,
   fn: fn,
   greaterThan: greaterThan,
   lessThan: lessThan,
+  notEmpty: notEmpty,
   notEmptyString: notEmptyString,
   number: number$1,
   object: object,
@@ -3264,28 +3265,84 @@ function parseDecimal(value, dights) {
 }
 
 const CODE_TO_MESSAGE = Object.freeze({
+  100: "Continue",
   101: "Switching Protocols",
   102: "Processing",
-  200: "Ok",
+  103: "Early Hints",
+  200: "OK",
   201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
   204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  300: "Multiple Choices",
   301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
   400: "Bad Request",
   401: "Unauthorized",
+  402: "Payment Required",
   403: "Forbidden",
   404: "Not Found",
-  409: "Already Exists",
-  500: "Internal Server Error"
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  422: "Unprocessable Entity",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
 });
 class AppError extends Error {
+  /**
+   * HTTP valid status code
+   */
+  statusCode;
+  /**
+   * Custom error code
+   */
   code;
-  constructor(messageOrCode, code = 500, options) {
+  constructor(...args) {
     let message = "Unknown error";
-    if (isNumber(messageOrCode)) {
-      code = messageOrCode;
-      message = CODE_TO_MESSAGE[code] || "Unknown error";
+    let statusCode = 500;
+    let code = "ERR_UNKNOWN";
+    let options;
+    if (isNumber(args[0])) {
+      statusCode = args[0];
+      message = CODE_TO_MESSAGE[statusCode] || message;
+      options = args[1];
     } else {
-      message = messageOrCode || CODE_TO_MESSAGE[code] || "Unknown error";
+      message = args[0] || CODE_TO_MESSAGE[statusCode] || message;
+      statusCode = isNumber(args[1]) ? args[1] : statusCode;
+      options = args[2];
     }
     super(message, options);
     if (typeof Error.captureStackTrace !== "function") {
@@ -3293,13 +3350,8 @@ class AppError extends Error {
     } else {
       Error.captureStackTrace(this, AppError);
     }
-    this.code = code;
-  }
-  /**
-   * alias for `code` property
-   */
-  get statusCode() {
-    return this.code;
+    this.statusCode = statusCode;
+    this.code = options?.code ?? code;
   }
   get name() {
     return "AppError";
@@ -3345,13 +3397,6 @@ const BrowserAssertionError$1 = {
   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;
@@ -3407,432 +3452,327 @@ function humanFileSize(bytes, digits = 1, withSpace = true) {
   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 + "'";
+function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis = void 0;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
     }
-    default: {
-      try {
-        return JSON.stringify(o);
-      } catch (e) {
-        return '"[Circular]"';
-      }
-    }
-  }
-}
-
-const LEVEL_NUM = {
-  debug: 0,
-  log: 1,
-  info: 2,
-  warn: 3,
-  error: 4
-};
-let currentLogLevel = LEVEL_NUM.log;
-const loggerSetLevel = (level) => {
-  number$1(LEVEL_NUM[level], `Invalid log level: ${level}`);
-  currentLogLevel = LEVEL_NUM[level];
-};
-const logger = (...baseArgs) => {
-  if (isString(baseArgs[0]?.url)) {
-    baseArgs[0] = baseArgs[0]?.url;
-  }
-  if (typeof baseArgs[0] === "string" && baseArgs[0][0] !== "[") {
-    baseArgs[0] = `[${baseArgs[0].split("/").at(-1).split("?", 1)[0]}]`;
-  }
-  const writeLog = (level, ...[pattern, ...args]) => {
-    const levelNum = LEVEL_NUM[level];
-    if (levelNum < currentLogLevel) {
-      return;
+  };
+  const onTimerEnd = () => {
+    if (trailing) {
+      invoke();
     }
-    if (!isString(pattern)) {
-      console[level](...baseArgs, pattern, ...args);
-      return;
+    cancel();
+  };
+  let timeoutId = null;
+  const schedule = () => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
     }
-    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 cancel = () => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
   };
-  const instance = {
-    log,
-    info,
-    warn,
-    error,
-    debug,
-    extend
+  const flush = () => {
+    cancelTimer();
+    invoke();
   };
-  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);
+  const debounced = function(...args) {
+    if (signal?.aborted) {
+      return;
     }
-  }
-  return result;
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
 }
 
-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 isSuccess(value) {
+  return value.success === true;
 }
-function fastIdlePromise() {
-  return new Promise((resolve) => idle(resolve));
+function isSkip(value) {
+  return value.skip === true;
 }
 
-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);
-        }
-      });
+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(value)) return "weakset";
+      if (isMap(value)) return "map";
+      if (isWeakMap(value)) return "weakmap";
+      if (isDate(value)) return "date";
+      if (isObject(value)) return "object";
+      return "unknown";
     }
-    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];
+    default: {
+      return type;
     }
-    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);
+const qs = {
+  toParams,
+  stringify,
+  stringifyValue,
+  parse,
+  parseValue,
+  merge
 };
-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);
-          });
+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;
         }
-      } 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 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;
     }
-    return this;
-  }
-  removeAllListeners(eventName) {
-    if (eventName === void 0) {
-      this.#listeners.clear();
-      return this;
+    const strValue = stringifyValue(value);
+    if (excludeEmpty && strValue === "") {
+      continue;
     }
-    this.#listeners.delete(eventName);
-    return this;
+    result[key] = strValue;
   }
+  return result;
 }
-
-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;
+function parse(value, defaults) {
+  const objValue = isString(value) ? Object.fromEntries(new URLSearchParams(value).entries()) : value;
+  if (!defaults) {
+    return { ...objValue };
   }
-  async put(item) {
-    if (this.#limit && this.items.length >= this.#limit) {
-      await SimpleEventEmitter.once(this.#events, "get");
+  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;
     }
-    this.items.push(item);
-    this.#events.emit("put");
   }
+  return result;
 }
-
-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");
+function stringifyValue(value) {
+  const valueType = typeOf(value);
+  switch (valueType) {
+    case "undefined": {
+      return "";
     }
-    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 };
+    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 { 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;
+    }
+    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);
+    }
   }
-  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);
+function parseValue(value, asType) {
+  const type = typeOf(value);
+  if (type === asType) {
+    return value;
+  } else if (type !== "string") {
+    return void 0;
   }
-  cancel() {
-    if (this.#isCancelled) return;
-    this.#isCancelled = true;
-    for (const fn of this.#cancelFns) {
-      catchError(fn);
+  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 (_) {
   }
-  static from(promise) {
-    return new CancellablePromise((resolve, reject) => {
-      promise.then(resolve).catch(reject);
-    });
+  return void 0;
+}
+
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {
+    resolve,
+    reject,
+    promise
+  };
+}
+
+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 delay(amount = "tick") {
@@ -3845,352 +3785,546 @@ function delay(amount = "tick") {
   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);
+const noopShouldRetryBasedOnError = () => true;
+function retryOnError({
+  beforeRetryCallback,
+  shouldRetryBasedOnError = noopShouldRetryBasedOnError,
+  maxRetriesNumber,
+  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);
     }
-    if (!fastRafFallbackTimeout) {
-      fastRafFallbackTimeout = setTimeout(() => {
-        const currentTimeoutCallbacks = fastRafFallbackCallbacks;
-        if (fastRafCallbacks) {
-          currentTimeoutCallbacks.forEach(
-            fastRafCallbacks.delete,
-            fastRafCallbacks
+    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);
+          }
         }
-        fastRafFallbackCallbacks = void 0;
-        if (fastRafFallbackTimeout) {
-          clearTimeout(fastRafFallbackTimeout);
-          fastRafFallbackTimeout = void 0;
-        }
-        currentTimeoutCallbacks.forEach((cb) => cb());
-      }, FAST_RAF_TIMEOUT_FALLBACK_MS);
+        return run(...args);
+      }
+      throw e;
     }
-  }
-}
-function rafPromise() {
-  return new Promise((resolve) => {
-    fastRaf(resolve);
-  });
+  };
+  return run;
 }
 
-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 throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
+  let pendingAt = null;
+  const debounced = debounce(func, throttleMs, { signal, edges });
+  const throttled = function(...args) {
+    if (pendingAt == null) {
+      pendingAt = Date.now();
+    } else {
+      if (Date.now() - pendingAt >= throttleMs) {
+        pendingAt = Date.now();
+        debounced.cancel();
+        debounced(...args);
+      }
+    }
+    debounced(...args);
+  };
+  throttled.cancel = debounced.cancel;
+  throttled.flush = debounced.flush;
+  return throttled;
 }
 
-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(value)) return "weakset";
-      if (isMap(value)) return "map";
-      if (isWeakMap(value)) return "weakmap";
-      if (isDate(value)) return "date";
-      if (isObject(value)) return "object";
-      return "unknown";
-    }
-    default: {
-      return type;
+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;
     }
-  }
-}
-
-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;
+    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;
       }
-      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;
-        }
+      // '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 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;
+function tryStringify(o) {
+  switch (typeof o) {
+    case "function": {
+      return o.name || "<anonymous>";
     }
-    const strValue = stringifyValue(value);
-    if (excludeEmpty && strValue === "") {
-      continue;
+    case "string": {
+      return "'" + o + "'";
+    }
+    default: {
+      try {
+        return JSON.stringify(o);
+      } catch (e) {
+        return '"[Circular]"';
+      }
     }
-    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 LEVEL_NUM = {
+  debug: 0,
+  log: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+let currentLogLevel = LEVEL_NUM.log;
+const loggerSetLevel = (level) => {
+  number$1(LEVEL_NUM[level], `Invalid log level: ${level}`);
+  currentLogLevel = LEVEL_NUM[level];
+};
+const logger = (...baseArgs) => {
+  if (isString(baseArgs[0]?.url)) {
+    baseArgs[0] = baseArgs[0]?.url;
   }
-  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;
+  if (typeof baseArgs[0] === "string" && baseArgs[0][0] !== "[") {
+    baseArgs[0] = `[${baseArgs[0].split("/").at(-1).split("?", 1)[0]}]`;
+  }
+  const writeLog = (level, ...[pattern, ...args]) => {
+    const levelNum = LEVEL_NUM[level];
+    if (levelNum < currentLogLevel) {
+      return;
+    }
+    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
+  };
+  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;
 }
-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;
+
+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 {
-          result += sep + stringifyValue(item);
-          sep = ",";
+          setTimeout(resolve, delay);
         }
-      }
-      return result;
-    }
-    case "date": {
-      return value.toISOString();
+      });
     }
-    case "map": {
-      return JSON.stringify(Array.from(value.entries()));
+    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];
     }
-    case "set": {
-      return JSON.stringify(Array.from(value.values()));
+    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;
+  }
+}
+
+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());
     }
-    case "boolean":
-    case "number":
-    case "string":
-    case "bigint": {
-      return String(value);
+    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);
+      }
     }
-    case "object": {
-      return JSON.stringify(value);
+    return this;
+  }
+  removeAllListeners(eventName) {
+    if (eventName === void 0) {
+      this.#listeners.clear();
+      return this;
     }
-    case "unknown": {
-      if (isFunction(value?.toString)) {
-        return value.toString();
-      }
+    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");
     }
-    default: {
-      throw new Error("Attempt to stringify unsupported type: " + valueType);
+    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");
   }
 }
-function parseValue(value, asType) {
-  const type = typeOf(value);
-  if (type === asType) {
-    return value;
-  } else if (type !== "string") {
-    return void 0;
+
+class AsyncIterableQueue {
+  _queue;
+  _closed = false;
+  static QUEUE_END_MARKER = Symbol("QUEUE_END_MARKER");
+  constructor() {
+    this._queue = new Queue();
   }
-  try {
-    switch (asType) {
-      case "undefined": {
-        return void 0;
-      }
-      case "array": {
-        if (value.startsWith("[") && value.endsWith("]")) {
-          return JSON.parse(value);
+  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 };
         }
-        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);
+        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);
     }
-  } catch (_) {
   }
-  return void 0;
+  static from(promise) {
+    return new CancellablePromise((resolve, reject) => {
+      promise.then(resolve).catch(reject);
+    });
+  }
 }
 
-const noopShouldRetryBasedOnError = () => true;
-function retryOnError({
-  beforeRetryCallback,
-  shouldRetryBasedOnError = noopShouldRetryBasedOnError,
-  maxRetriesNumber,
-  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 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);
     }
-    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 (!fastRafFallbackTimeout) {
+      fastRafFallbackTimeout = setTimeout(() => {
+        const currentTimeoutCallbacks = fastRafFallbackCallbacks;
+        if (fastRafCallbacks) {
+          currentTimeoutCallbacks.forEach(
+            fastRafCallbacks.delete,
+            fastRafCallbacks
           );
-          if (newParams) {
-            return run(newParams);
-          }
         }
-        return run(...args);
-      }
-      throw e;
+        fastRafFallbackCallbacks = void 0;
+        if (fastRafFallbackTimeout) {
+          clearTimeout(fastRafFallbackTimeout);
+          fastRafFallbackTimeout = void 0;
+        }
+        currentTimeoutCallbacks.forEach((cb) => cb());
+      }, FAST_RAF_TIMEOUT_FALLBACK_MS);
     }
-  };
-  return run;
+  }
+}
+function rafPromise() {
+  return new Promise((resolve) => {
+    fastRaf(resolve);
+  });
+}
+
+function timeout(ms, promiseOrCallback, timeoutError = new AppError(408)) {
+  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 capitalize(str) {
@@ -4497,6 +4631,7 @@ exports.createWithCache = createWithCache;
 exports.cssVariable = cssVariable;
 exports.dateInDays = dateInDays;
 exports.dateInSeconds = dateInSeconds;
+exports.debounce = debounce;
 exports.deepAssign = deepAssign;
 exports.deepClone = deepClone;
 exports.deepCloneWith = deepCloneWith;
@@ -4561,6 +4696,7 @@ exports.isOneEmoji = isOneEmoji;
 exports.isPlainObject = isPlainObject;
 exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
 exports.isSet = isSet;
 exports.isSkip = isSkip;
 exports.isString = isString;
@@ -4610,6 +4746,7 @@ exports.sprintf = sprintf;
 exports.startCase = startCase;
 exports.strAssign = strAssign;
 exports.sum = sum;
+exports.throttle = throttle;
 exports.timeFromMinutes = timeFromMinutes;
 exports.timeStringify = timeStringify;
 exports.timeToMinutes = timeToMinutes;