@vielzeug/toolkit 1.1.3 → 2.1.0

package/dist/async/parallel.js

@@ -1,28 +1,27 @@
-async function f(n, t, w, s) {
-  if (n < 1)
-    throw new Error("Limit must be at least 1");
-  if (s?.aborted)
-    throw new DOMException("Aborted", "AbortError");
-  const c = new Array(t.length);
-  let l = 0, e = !1, o;
-  const a = () => s?.aborted ? (e = !0, o = new DOMException("Aborted", "AbortError"), !0) : !1, h = async () => {
-    for (; l < t.length && !e && !a(); ) {
-      const r = l++;
-      try {
-        c[r] = await w(t[r], r, t);
-      } catch (b) {
-        e = !0, o = b;
-        break;
-      }
-    }
-  }, i = [], u = Math.min(n, t.length);
-  for (let r = 0; r < u; r++)
-    i.push(h());
-  if (await Promise.all(i), e)
-    throw o;
-  return c;
+//#region src/async/parallel.ts
+async function e(e, t, n, r) {
+	if (e < 1) throw Error("Limit must be at least 1");
+	if (r?.aborted) throw new DOMException("Aborted", "AbortError");
+	let i = Array(t.length), a = 0, o = !1, s, c = async () => {
+		for (; a < t.length && !o;) {
+			if (r?.aborted) {
+				o = !0, s = new DOMException("Aborted", "AbortError");
+				break;
+			}
+			let e = a++;
+			try {
+				i[e] = await n(t[e], e, t);
+			} catch (e) {
+				o = !0, s = e;
+				break;
+			}
+		}
+	}, l = [], u = Math.min(e, t.length);
+	for (let e = 0; e < u; e++) l.push(c());
+	if (await Promise.all(l), o) throw s;
+	return i;
 }
-export {
-  f as parallel
-};
-//# sourceMappingURL=parallel.js.map
+//#endregion
+export { e as parallel };
+
+//# sourceMappingURL=parallel.js.map

package/dist/async/parallel.js.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.js","sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  // Check for abort\n  const checkAbort = () => {\n    if (signal?.aborted) {\n      hasError = true;\n      error = new DOMException('Aborted', 'AbortError');\n      return true;\n    }\n    return false;\n  };\n\n  // Worker function that processes items from the queue\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (checkAbort()) {\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"names":["parallel","limit","array","callback","signal","results","currentIndex","hasError","error","checkAbort","worker","index","err","workers","workerCount","i"],"mappings":"AA6BA,eAAsBA,EACpBC,GACAC,GACAC,GACAC,GACc;AACd,MAAIH,IAAQ;AACV,UAAM,IAAI,MAAM,0BAA0B;AAG5C,MAAIG,GAAQ;AACV,UAAM,IAAI,aAAa,WAAW,YAAY;AAGhD,QAAMC,IAAe,IAAI,MAAMH,EAAM,MAAM;AAC3C,MAAII,IAAe,GACfC,IAAW,IACXC;AAGJ,QAAMC,IAAa,MACbL,GAAQ,WACVG,IAAW,IACXC,IAAQ,IAAI,aAAa,WAAW,YAAY,GACzC,MAEF,IAIHE,IAAS,YAA2B;AACxC,WAAOJ,IAAeJ,EAAM,UAAU,CAACK,KACjC,CAAAE,OAD2C;AAK/C,YAAME,IAAQL;AAEd,UAAI;AACF,QAAAD,EAAQM,CAAK,IAAI,MAAMR,EAASD,EAAMS,CAAK,GAAGA,GAAOT,CAAK;AAAA,MAC5D,SAASU,GAAK;AACZ,QAAAL,IAAW,IACXC,IAAQI;AACR;AAAA,MACF;AAAA,IACF;AAAA,EACF,GAGMC,IAA2B,CAAA,GAC3BC,IAAc,KAAK,IAAIb,GAAOC,EAAM,MAAM;AAEhD,WAASa,IAAI,GAAGA,IAAID,GAAaC;AAC/B,IAAAF,EAAQ,KAAKH,GAAQ;AAOvB,MAHA,MAAM,QAAQ,IAAIG,CAAO,GAGrBN;AACF,UAAMC;AAGR,SAAOH;AACT;"}
+{"version":3,"file":"parallel.js","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (signal?.aborted) {\n        hasError = true;\n        error = new DOMException('Aborted', 'AbortError');\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"mappings":";AA6BA,eAAsB,EACpB,GACA,GACA,GACA,GACc;AACd,KAAI,IAAQ,EACV,OAAU,MAAM,2BAA2B;AAG7C,KAAI,GAAQ,QACV,OAAM,IAAI,aAAa,WAAW,aAAa;CAGjD,IAAM,IAAmB,MAAM,EAAM,OAAO,EACxC,IAAe,GACf,IAAW,IACX,GAEE,IAAS,YAA2B;AACxC,SAAO,IAAe,EAAM,UAAU,CAAC,IAAU;AAC/C,OAAI,GAAQ,SAAS;AAEnB,IADA,IAAW,IACX,IAAQ,IAAI,aAAa,WAAW,aAAa;AACjD;;GAGF,IAAM,IAAQ;AAEd,OAAI;AACF,MAAQ,KAAS,MAAM,EAAS,EAAM,IAAQ,GAAO,EAAM;YACpD,GAAK;AAEZ,IADA,IAAW,IACX,IAAQ;AACR;;;IAMA,IAA2B,EAAE,EAC7B,IAAc,KAAK,IAAI,GAAO,EAAM,OAAO;AAEjD,MAAK,IAAI,IAAI,GAAG,IAAI,GAAa,IAC/B,GAAQ,KAAK,GAAQ,CAAC;AAOxB,KAHA,MAAM,QAAQ,IAAI,EAAQ,EAGtB,EACF,OAAM;AAGR,QAAO"}

package/dist/async/pool.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../function/assert.cjs");function u(e){a.assert(e>=1,"Pool limit must be at least 1",{args:{limit:e},type:RangeError});let t=0;const n=[],r=()=>{n.length>0&&t<e&&n.shift()?.()};return async o=>{for(;t>=e;)await new Promise(s=>n.push(s));t++;try{return await o()}finally{t--,r()}}}exports.pool=u;
-//# sourceMappingURL=pool.cjs.map
+const e=require(`../function/assert.cjs`);function t(t){e.assert(t>=1,`Pool limit must be at least 1`,{args:{limit:t},type:RangeError});let n=0,r=[],i=()=>{r.length>0&&n<t&&r.shift()?.()};return async e=>{for(;n>=t;)await new Promise(e=>r.push(e));n++;try{return await e()}finally{n--,i()}}}exports.pool=t;
+//# sourceMappingURL=pool.cjs.map

package/dist/async/pool.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pool.cjs","sources":["../../src/async/pool.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise pool that limits the number of concurrent promises.\n * Useful for rate limiting API calls or controlling resource usage.\n *\n * @example\n * ```ts\n * const requestPool = pool(3);\n *\n * const results = await Promise.all([\n *   requestPool(() => fetch('/api/1')),\n *   requestPool(() => fetch('/api/2')),\n *   requestPool(() => fetch('/api/3')),\n *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish\n * ]);\n * ```\n *\n * @param limit - Maximum number of concurrent promises\n * @returns Function that accepts a promise-returning function and executes it when a slot is available\n */\nexport function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T> {\n  assert(limit >= 1, 'Pool limit must be at least 1', { args: { limit }, type: RangeError });\n\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const dequeue = (): void => {\n    if (queue.length > 0 && activeCount < limit) {\n      const next = queue.shift();\n      next?.();\n    }\n  };\n\n  return async <T>(fn: () => Promise<T>): Promise<T> => {\n    while (activeCount >= limit) {\n      await new Promise<void>((resolve) => queue.push(resolve));\n    }\n\n    activeCount++;\n\n    try {\n      return await fn();\n    } finally {\n      activeCount--;\n      dequeue();\n    }\n  };\n}\n"],"names":["pool","limit","assert","activeCount","queue","dequeue","fn","resolve"],"mappings":"0HAqBO,SAASA,EAAKC,EAAwD,CAC3EC,SAAOD,GAAS,EAAG,gCAAiC,CAAE,KAAM,CAAE,MAAAA,CAAA,EAAS,KAAM,WAAY,EAEzF,IAAIE,EAAc,EAClB,MAAMC,EAA2B,CAAA,EAE3BC,EAAU,IAAY,CACtBD,EAAM,OAAS,GAAKD,EAAcF,GACvBG,EAAM,MAAA,IACnB,CAEJ,EAEA,MAAO,OAAUE,GAAqC,CACpD,KAAOH,GAAeF,GACpB,MAAM,IAAI,QAAeM,GAAYH,EAAM,KAAKG,CAAO,CAAC,EAG1DJ,IAEA,GAAI,CACF,OAAO,MAAMG,EAAA,CACf,QAAA,CACEH,IACAE,EAAA,CACF,CACF,CACF"}
+{"version":3,"file":"pool.cjs","names":[],"sources":["../../src/async/pool.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise pool that limits the number of concurrent promises.\n * Useful for rate limiting API calls or controlling resource usage.\n *\n * @example\n * ```ts\n * const requestPool = pool(3);\n *\n * const results = await Promise.all([\n *   requestPool(() => fetch('/api/1')),\n *   requestPool(() => fetch('/api/2')),\n *   requestPool(() => fetch('/api/3')),\n *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish\n * ]);\n * ```\n *\n * @param limit - Maximum number of concurrent promises\n * @returns Function that accepts a promise-returning function and executes it when a slot is available\n */\nexport function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T> {\n  assert(limit >= 1, 'Pool limit must be at least 1', { args: { limit }, type: RangeError });\n\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const dequeue = (): void => {\n    if (queue.length > 0 && activeCount < limit) {\n      const next = queue.shift();\n\n      next?.();\n    }\n  };\n\n  return async <T>(fn: () => Promise<T>): Promise<T> => {\n    while (activeCount >= limit) {\n      await new Promise<void>((resolve) => queue.push(resolve));\n    }\n\n    activeCount++;\n\n    try {\n      return await fn();\n    } finally {\n      activeCount--;\n      dequeue();\n    }\n  };\n}\n"],"mappings":"0CAqBA,SAAgB,EAAK,EAAwD,CAC3E,EAAA,OAAO,GAAS,EAAG,gCAAiC,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,WAAY,CAAC,CAE1F,IAAI,EAAc,EACZ,EAA2B,EAAE,CAE7B,MAAsB,CACtB,EAAM,OAAS,GAAK,EAAc,GACvB,EAAM,OAAO,IAElB,EAIZ,OAAO,KAAU,IAAqC,CACpD,KAAO,GAAe,GACpB,MAAM,IAAI,QAAe,GAAY,EAAM,KAAK,EAAQ,CAAC,CAG3D,IAEA,GAAI,CACF,OAAO,MAAM,GAAI,QACT,CACR,IACA,GAAS"}

package/dist/async/pool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a promise pool that limits the number of concurrent promises.
+ * Useful for rate limiting API calls or controlling resource usage.
+ *
+ * @example
+ * ```ts
+ * const requestPool = pool(3);
+ *
+ * const results = await Promise.all([
+ *   requestPool(() => fetch('/api/1')),
+ *   requestPool(() => fetch('/api/2')),
+ *   requestPool(() => fetch('/api/3')),
+ *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish
+ * ]);
+ * ```
+ *
+ * @param limit - Maximum number of concurrent promises
+ * @returns Function that accepts a promise-returning function and executes it when a slot is available
+ */
+export declare function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/async/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/async/pool.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA4B3E"}

package/dist/async/pool.js

@@ -1,22 +1,24 @@
-import { assert as s } from "../function/assert.js";
-function c(e) {
-  s(e >= 1, "Pool limit must be at least 1", { args: { limit: e }, type: RangeError });
-  let t = 0;
-  const n = [], r = () => {
-    n.length > 0 && t < e && n.shift()?.();
-  };
-  return async (o) => {
-    for (; t >= e; )
-      await new Promise((a) => n.push(a));
-    t++;
-    try {
-      return await o();
-    } finally {
-      t--, r();
-    }
-  };
+import { assert as e } from "../function/assert.js";
+//#region src/async/pool.ts
+function t(t) {
+	e(t >= 1, "Pool limit must be at least 1", {
+		args: { limit: t },
+		type: RangeError
+	});
+	let n = 0, r = [], i = () => {
+		r.length > 0 && n < t && r.shift()?.();
+	};
+	return async (e) => {
+		for (; n >= t;) await new Promise((e) => r.push(e));
+		n++;
+		try {
+			return await e();
+		} finally {
+			n--, i();
+		}
+	};
 }
-export {
-  c as pool
-};
-//# sourceMappingURL=pool.js.map
+//#endregion
+export { t as pool };
+
+//# sourceMappingURL=pool.js.map

package/dist/async/pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"pool.js","sources":["../../src/async/pool.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise pool that limits the number of concurrent promises.\n * Useful for rate limiting API calls or controlling resource usage.\n *\n * @example\n * ```ts\n * const requestPool = pool(3);\n *\n * const results = await Promise.all([\n *   requestPool(() => fetch('/api/1')),\n *   requestPool(() => fetch('/api/2')),\n *   requestPool(() => fetch('/api/3')),\n *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish\n * ]);\n * ```\n *\n * @param limit - Maximum number of concurrent promises\n * @returns Function that accepts a promise-returning function and executes it when a slot is available\n */\nexport function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T> {\n  assert(limit >= 1, 'Pool limit must be at least 1', { args: { limit }, type: RangeError });\n\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const dequeue = (): void => {\n    if (queue.length > 0 && activeCount < limit) {\n      const next = queue.shift();\n      next?.();\n    }\n  };\n\n  return async <T>(fn: () => Promise<T>): Promise<T> => {\n    while (activeCount >= limit) {\n      await new Promise<void>((resolve) => queue.push(resolve));\n    }\n\n    activeCount++;\n\n    try {\n      return await fn();\n    } finally {\n      activeCount--;\n      dequeue();\n    }\n  };\n}\n"],"names":["pool","limit","assert","activeCount","queue","dequeue","fn","resolve"],"mappings":";AAqBO,SAASA,EAAKC,GAAwD;AAC3E,EAAAC,EAAOD,KAAS,GAAG,iCAAiC,EAAE,MAAM,EAAE,OAAAA,EAAA,GAAS,MAAM,YAAY;AAEzF,MAAIE,IAAc;AAClB,QAAMC,IAA2B,CAAA,GAE3BC,IAAU,MAAY;AAC1B,IAAID,EAAM,SAAS,KAAKD,IAAcF,KACvBG,EAAM,MAAA,IACnB;AAAA,EAEJ;AAEA,SAAO,OAAUE,MAAqC;AACpD,WAAOH,KAAeF;AACpB,YAAM,IAAI,QAAc,CAACM,MAAYH,EAAM,KAAKG,CAAO,CAAC;AAG1D,IAAAJ;AAEA,QAAI;AACF,aAAO,MAAMG,EAAA;AAAA,IACf,UAAA;AACE,MAAAH,KACAE,EAAA;AAAA,IACF;AAAA,EACF;AACF;"}
+{"version":3,"file":"pool.js","names":[],"sources":["../../src/async/pool.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise pool that limits the number of concurrent promises.\n * Useful for rate limiting API calls or controlling resource usage.\n *\n * @example\n * ```ts\n * const requestPool = pool(3);\n *\n * const results = await Promise.all([\n *   requestPool(() => fetch('/api/1')),\n *   requestPool(() => fetch('/api/2')),\n *   requestPool(() => fetch('/api/3')),\n *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish\n * ]);\n * ```\n *\n * @param limit - Maximum number of concurrent promises\n * @returns Function that accepts a promise-returning function and executes it when a slot is available\n */\nexport function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T> {\n  assert(limit >= 1, 'Pool limit must be at least 1', { args: { limit }, type: RangeError });\n\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const dequeue = (): void => {\n    if (queue.length > 0 && activeCount < limit) {\n      const next = queue.shift();\n\n      next?.();\n    }\n  };\n\n  return async <T>(fn: () => Promise<T>): Promise<T> => {\n    while (activeCount >= limit) {\n      await new Promise<void>((resolve) => queue.push(resolve));\n    }\n\n    activeCount++;\n\n    try {\n      return await fn();\n    } finally {\n      activeCount--;\n      dequeue();\n    }\n  };\n}\n"],"mappings":";;AAqBA,SAAgB,EAAK,GAAwD;AAC3E,GAAO,KAAS,GAAG,iCAAiC;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAY,CAAC;CAE1F,IAAI,IAAc,GACZ,IAA2B,EAAE,EAE7B,UAAsB;AAC1B,EAAI,EAAM,SAAS,KAAK,IAAc,KACvB,EAAM,OAAO,IAElB;;AAIZ,QAAO,OAAU,MAAqC;AACpD,SAAO,KAAe,GACpB,OAAM,IAAI,SAAe,MAAY,EAAM,KAAK,EAAQ,CAAC;AAG3D;AAEA,MAAI;AACF,UAAO,MAAM,GAAI;YACT;AAER,GADA,KACA,GAAS"}

package/dist/async/predict.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function a(o,n={}){const{signal:t,timeout:e=7e3}=n,r=t?AbortSignal.any([AbortSignal.timeout(e),t]):AbortSignal.timeout(e);return Promise.race([o(r),new Promise((c,i)=>{r.addEventListener("abort",()=>i(new Error("Operation aborted")),{once:!0})})])}exports.predict=a;
-//# sourceMappingURL=predict.cjs.map
+function e(e,t={}){let{signal:n,timeout:r=7e3}=t,i=n?AbortSignal.any([AbortSignal.timeout(r),n]):AbortSignal.timeout(r);return Promise.race([e(i),new Promise((e,t)=>{i.addEventListener(`abort`,()=>t(i.reason),{once:!0})})])}exports.predict=e;
+//# sourceMappingURL=predict.cjs.map

package/dist/async/predict.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"predict.cjs","sources":["../../src/async/predict.ts"],"sourcesContent":["/**\n * Creates a Promise that can be aborted using an AbortController.\n *\n * @example\n * ```ts\n * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));\n * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));\n *\n * predict(slowFn); // rejects after 7 seconds\n * predict(fastFn); // resolves with 'fast' after 5 seconds\n * ```\n *\n * @param fn - The function to execute, which receives an AbortSignal.\n * @param options - The options for the abortable function.\n * @param [options.signal] - The AbortSignal to use for aborting the Promise.\n * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.\n *\n * @returns - A Promise that resolves with the result of the callback or rejects if aborted.\n */\nexport function predict<T>(\n  fn: (signal: AbortSignal) => Promise<T>,\n  options: { signal?: AbortSignal; timeout?: number } = {},\n): Promise<T> {\n  const { signal, timeout = 7000 } = options;\n  const abortSignal = signal ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : AbortSignal.timeout(timeout);\n\n  return Promise.race([\n    fn(abortSignal),\n    new Promise<never>((_, reject) => {\n      abortSignal.addEventListener('abort', () => reject(new Error('Operation aborted')), { once: true });\n    }),\n  ]);\n}\n"],"names":["predict","fn","options","signal","timeout","abortSignal","_","reject"],"mappings":"gFAmBO,SAASA,EACdC,EACAC,EAAsD,GAC1C,CACZ,KAAM,CAAE,OAAAC,EAAQ,QAAAC,EAAU,GAAA,EAASF,EAC7BG,EAAcF,EAAS,YAAY,IAAI,CAAC,YAAY,QAAQC,CAAO,EAAGD,CAAM,CAAC,EAAI,YAAY,QAAQC,CAAO,EAElH,OAAO,QAAQ,KAAK,CAClBH,EAAGI,CAAW,EACd,IAAI,QAAe,CAACC,EAAGC,IAAW,CAChCF,EAAY,iBAAiB,QAAS,IAAME,EAAO,IAAI,MAAM,mBAAmB,CAAC,EAAG,CAAE,KAAM,EAAA,CAAM,CACpG,CAAC,CAAA,CACF,CACH"}
+{"version":3,"file":"predict.cjs","names":[],"sources":["../../src/async/predict.ts"],"sourcesContent":["/**\n * Creates a Promise that can be aborted using an AbortController.\n *\n * @example\n * ```ts\n * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));\n * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));\n *\n * predict(slowFn); // rejects after 7 seconds\n * predict(fastFn); // resolves with 'fast' after 5 seconds\n * ```\n *\n * @param fn - The function to execute, which receives an AbortSignal.\n * @param options - The options for the abortable function.\n * @param [options.signal] - The AbortSignal to use for aborting the Promise.\n * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.\n *\n * @returns - A Promise that resolves with the result of the callback or rejects if aborted.\n */\nexport function predict<T>(\n  fn: (signal: AbortSignal) => Promise<T>,\n  options: { signal?: AbortSignal; timeout?: number } = {},\n): Promise<T> {\n  const { signal, timeout = 7000 } = options;\n  const abortSignal = signal ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : AbortSignal.timeout(timeout);\n\n  return Promise.race([\n    fn(abortSignal),\n    new Promise<never>((_, reject) => {\n      abortSignal.addEventListener('abort', () => reject(abortSignal.reason), { once: true });\n    }),\n  ]);\n}\n"],"mappings":"AAmBA,SAAgB,EACd,EACA,EAAsD,EAAE,CAC5C,CACZ,GAAM,CAAE,SAAQ,UAAU,KAAS,EAC7B,EAAc,EAAS,YAAY,IAAI,CAAC,YAAY,QAAQ,EAAQ,CAAE,EAAO,CAAC,CAAG,YAAY,QAAQ,EAAQ,CAEnH,OAAO,QAAQ,KAAK,CAClB,EAAG,EAAY,CACf,IAAI,SAAgB,EAAG,IAAW,CAChC,EAAY,iBAAiB,YAAe,EAAO,EAAY,OAAO,CAAE,CAAE,KAAM,GAAM,CAAC,EACvF,CACH,CAAC"}

package/dist/async/predict.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates a Promise that can be aborted using an AbortController.
+ *
+ * @example
+ * ```ts
+ * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));
+ * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));
+ *
+ * predict(slowFn); // rejects after 7 seconds
+ * predict(fastFn); // resolves with 'fast' after 5 seconds
+ * ```
+ *
+ * @param fn - The function to execute, which receives an AbortSignal.
+ * @param options - The options for the abortable function.
+ * @param [options.signal] - The AbortSignal to use for aborting the Promise.
+ * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.
+ *
+ * @returns - A Promise that resolves with the result of the callback or rejects if aborted.
+ */
+export declare function predict<T>(fn: (signal: AbortSignal) => Promise<T>, options?: {
+    signal?: AbortSignal;
+    timeout?: number;
+}): Promise<T>;
+//# sourceMappingURL=predict.d.ts.map

package/dist/async/predict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predict.d.ts","sourceRoot":"","sources":["../../src/async/predict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACvC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACvD,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/dist/async/predict.js

@@ -1,13 +1,11 @@
-function b(o, n = {}) {
-  const { signal: t, timeout: e = 7e3 } = n, r = t ? AbortSignal.any([AbortSignal.timeout(e), t]) : AbortSignal.timeout(e);
-  return Promise.race([
-    o(r),
-    new Promise((a, i) => {
-      r.addEventListener("abort", () => i(new Error("Operation aborted")), { once: !0 });
-    })
-  ]);
+//#region src/async/predict.ts
+function e(e, t = {}) {
+	let { signal: n, timeout: r = 7e3 } = t, i = n ? AbortSignal.any([AbortSignal.timeout(r), n]) : AbortSignal.timeout(r);
+	return Promise.race([e(i), new Promise((e, t) => {
+		i.addEventListener("abort", () => t(i.reason), { once: !0 });
+	})]);
 }
-export {
-  b as predict
-};
-//# sourceMappingURL=predict.js.map
+//#endregion
+export { e as predict };
+
+//# sourceMappingURL=predict.js.map

package/dist/async/predict.js.map

@@ -1 +1 @@
-{"version":3,"file":"predict.js","sources":["../../src/async/predict.ts"],"sourcesContent":["/**\n * Creates a Promise that can be aborted using an AbortController.\n *\n * @example\n * ```ts\n * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));\n * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));\n *\n * predict(slowFn); // rejects after 7 seconds\n * predict(fastFn); // resolves with 'fast' after 5 seconds\n * ```\n *\n * @param fn - The function to execute, which receives an AbortSignal.\n * @param options - The options for the abortable function.\n * @param [options.signal] - The AbortSignal to use for aborting the Promise.\n * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.\n *\n * @returns - A Promise that resolves with the result of the callback or rejects if aborted.\n */\nexport function predict<T>(\n  fn: (signal: AbortSignal) => Promise<T>,\n  options: { signal?: AbortSignal; timeout?: number } = {},\n): Promise<T> {\n  const { signal, timeout = 7000 } = options;\n  const abortSignal = signal ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : AbortSignal.timeout(timeout);\n\n  return Promise.race([\n    fn(abortSignal),\n    new Promise<never>((_, reject) => {\n      abortSignal.addEventListener('abort', () => reject(new Error('Operation aborted')), { once: true });\n    }),\n  ]);\n}\n"],"names":["predict","fn","options","signal","timeout","abortSignal","_","reject"],"mappings":"AAmBO,SAASA,EACdC,GACAC,IAAsD,IAC1C;AACZ,QAAM,EAAE,QAAAC,GAAQ,SAAAC,IAAU,IAAA,IAASF,GAC7BG,IAAcF,IAAS,YAAY,IAAI,CAAC,YAAY,QAAQC,CAAO,GAAGD,CAAM,CAAC,IAAI,YAAY,QAAQC,CAAO;AAElH,SAAO,QAAQ,KAAK;AAAA,IAClBH,EAAGI,CAAW;AAAA,IACd,IAAI,QAAe,CAACC,GAAGC,MAAW;AAChC,MAAAF,EAAY,iBAAiB,SAAS,MAAME,EAAO,IAAI,MAAM,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAA,CAAM;AAAA,IACpG,CAAC;AAAA,EAAA,CACF;AACH;"}
+{"version":3,"file":"predict.js","names":[],"sources":["../../src/async/predict.ts"],"sourcesContent":["/**\n * Creates a Promise that can be aborted using an AbortController.\n *\n * @example\n * ```ts\n * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));\n * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));\n *\n * predict(slowFn); // rejects after 7 seconds\n * predict(fastFn); // resolves with 'fast' after 5 seconds\n * ```\n *\n * @param fn - The function to execute, which receives an AbortSignal.\n * @param options - The options for the abortable function.\n * @param [options.signal] - The AbortSignal to use for aborting the Promise.\n * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.\n *\n * @returns - A Promise that resolves with the result of the callback or rejects if aborted.\n */\nexport function predict<T>(\n  fn: (signal: AbortSignal) => Promise<T>,\n  options: { signal?: AbortSignal; timeout?: number } = {},\n): Promise<T> {\n  const { signal, timeout = 7000 } = options;\n  const abortSignal = signal ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : AbortSignal.timeout(timeout);\n\n  return Promise.race([\n    fn(abortSignal),\n    new Promise<never>((_, reject) => {\n      abortSignal.addEventListener('abort', () => reject(abortSignal.reason), { once: true });\n    }),\n  ]);\n}\n"],"mappings":";AAmBA,SAAgB,EACd,GACA,IAAsD,EAAE,EAC5C;CACZ,IAAM,EAAE,WAAQ,aAAU,QAAS,GAC7B,IAAc,IAAS,YAAY,IAAI,CAAC,YAAY,QAAQ,EAAQ,EAAE,EAAO,CAAC,GAAG,YAAY,QAAQ,EAAQ;AAEnH,QAAO,QAAQ,KAAK,CAClB,EAAG,EAAY,EACf,IAAI,SAAgB,GAAG,MAAW;AAChC,IAAY,iBAAiB,eAAe,EAAO,EAAY,OAAO,EAAE,EAAE,MAAM,IAAM,CAAC;GACvF,CACH,CAAC"}

package/dist/async/queue.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../function/assert.cjs");function g(o={}){const{concurrency:u=1}=o;a.assert(u>=1,"Concurrency must be at least 1",{args:{concurrency:u},type:RangeError});let n=0,r=null,l=null;const e=[],s=()=>{if(n<u&&e.length>0){const t=e.shift();n++,t.fn().then(t.resolve).catch(t.reject).finally(()=>{n--,s(),n===0&&e.length===0&&l&&(l(),r=null,l=null)})}};return{add:t=>new Promise((i,c)=>{e.push({fn:t,reject:c,resolve:i}),s()}),clear:()=>{e.length=0},onIdle:()=>n===0&&e.length===0?Promise.resolve():(r||(r=new Promise(t=>{l=t})),r),get pending(){return n},get size(){return e.length}}}exports.queue=g;
-//# sourceMappingURL=queue.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`./scheduler.cjs`);function n(n={}){let{concurrency:r=1}=n;e.assert(r>=1,`Concurrency must be at least 1`,{args:{concurrency:r},type:RangeError});let i=0,a=null,o=null,s=[],c=!1,l=()=>{c||(c=!0,new t.Scheduler().postTask(()=>{c=!1,u()},{priority:`user-visible`}))},u=()=>{if(i<r&&s.length>0){let e=s.shift();i++,e.fn().then(e.resolve).catch(e.reject).finally(()=>{i--,l(),i===0&&s.length===0&&o&&(o(),a=null,o=null)})}};return{add:e=>{let{promise:t,reject:n,resolve:r}=Promise.withResolvers();return s.push({fn:e,reject:n,resolve:r}),l(),t},clear:()=>{s.length=0},onIdle:()=>{if(i===0&&s.length===0)return Promise.resolve();if(!a){let e=Promise.withResolvers();a=e.promise,o=e.resolve}return a},get pending(){return i},get size(){return s.length}}}exports.queue=n;
+//# sourceMappingURL=queue.cjs.map

package/dist/async/queue.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"queue.cjs","sources":["../../src/async/queue.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise queue that processes promises sequentially with optional concurrency limit.\n *\n * @example\n * ```ts\n * const requestQueue = queue({ concurrency: 2 });\n *\n * requestQueue.add(() => fetch('/api/1'));\n * requestQueue.add(() => fetch('/api/2'));\n * requestQueue.add(() => fetch('/api/3'));\n *\n * await requestQueue.onIdle(); // Wait for all tasks to complete\n * ```\n *\n * @param options - Queue configuration\n * @param options.concurrency - Maximum number of concurrent promises (default: 1)\n * @returns Queue instance with add, onIdle, and clear methods\n */\nexport function queue(options: { concurrency?: number } = {}) {\n  const { concurrency = 1 } = options;\n\n  assert(concurrency >= 1, 'Concurrency must be at least 1', {\n    args: { concurrency },\n    type: RangeError,\n  });\n\n  let activeCount = 0;\n  let idlePromise: Promise<void> | null = null;\n  let idleResolve: (() => void) | null = null;\n\n  const queue: Array<{\n    fn: () => Promise<unknown>;\n    resolve: (value: unknown) => void;\n    reject: (error: unknown) => void;\n  }> = [];\n\n  const next = (): void => {\n    if (activeCount < concurrency && queue.length > 0) {\n      const task = queue.shift()!;\n      activeCount++;\n\n      task\n        .fn()\n        .then(task.resolve)\n        .catch(task.reject)\n        .finally(() => {\n          activeCount--;\n          next();\n\n          if (activeCount === 0 && queue.length === 0 && idleResolve) {\n            idleResolve();\n            idlePromise = null;\n            idleResolve = null;\n          }\n        });\n    }\n  };\n\n  return {\n    /**\n     * Adds a promise-returning function to the queue\n     */\n    add: <T>(fn: () => Promise<T>): Promise<T> => {\n      return new Promise<T>((resolve, reject) => {\n        queue.push({\n          fn: fn as () => Promise<unknown>,\n          reject,\n          resolve: resolve as (value: unknown) => void,\n        });\n        next();\n      });\n    },\n\n    /**\n     * Clears all pending tasks from the queue\n     */\n    clear: (): void => {\n      queue.length = 0;\n    },\n\n    /**\n     * Returns a promise that resolves when the queue becomes idle\n     */\n    onIdle: (): Promise<void> => {\n      if (activeCount === 0 && queue.length === 0) {\n        return Promise.resolve();\n      }\n\n      if (!idlePromise) {\n        idlePromise = new Promise<void>((resolve) => {\n          idleResolve = resolve;\n        });\n      }\n\n      return idlePromise;\n    },\n\n    /**\n     * Returns the number of currently active promises\n     */\n    get pending(): number {\n      return activeCount;\n    },\n\n    /**\n     * Returns the current size of the queue\n     */\n    get size(): number {\n      return queue.length;\n    },\n  };\n}\n"],"names":["queue","options","concurrency","assert","activeCount","idlePromise","idleResolve","next","task","fn","resolve","reject"],"mappings":"0HAoBO,SAASA,EAAMC,EAAoC,GAAI,CAC5D,KAAM,CAAE,YAAAC,EAAc,CAAA,EAAMD,EAE5BE,SAAOD,GAAe,EAAG,iCAAkC,CACzD,KAAM,CAAE,YAAAA,CAAA,EACR,KAAM,UAAA,CACP,EAED,IAAIE,EAAc,EACdC,EAAoC,KACpCC,EAAmC,KAEvC,MAAMN,EAID,CAAA,EAECO,EAAO,IAAY,CACvB,GAAIH,EAAcF,GAAeF,EAAM,OAAS,EAAG,CACjD,MAAMQ,EAAOR,EAAM,MAAA,EACnBI,IAEAI,EACG,GAAA,EACA,KAAKA,EAAK,OAAO,EACjB,MAAMA,EAAK,MAAM,EACjB,QAAQ,IAAM,CACbJ,IACAG,EAAA,EAEIH,IAAgB,GAAKJ,EAAM,SAAW,GAAKM,IAC7CA,EAAA,EACAD,EAAc,KACdC,EAAc,KAElB,CAAC,CACL,CACF,EAEA,MAAO,CAIL,IAASG,GACA,IAAI,QAAW,CAACC,EAASC,IAAW,CACzCX,EAAM,KAAK,CACT,GAAAS,EACA,OAAAE,EACA,QAAAD,CAAA,CACD,EACDH,EAAA,CACF,CAAC,EAMH,MAAO,IAAY,CACjBP,EAAM,OAAS,CACjB,EAKA,OAAQ,IACFI,IAAgB,GAAKJ,EAAM,SAAW,EACjC,QAAQ,QAAA,GAGZK,IACHA,EAAc,IAAI,QAAeK,GAAY,CAC3CJ,EAAcI,CAChB,CAAC,GAGIL,GAMT,IAAI,SAAkB,CACpB,OAAOD,CACT,EAKA,IAAI,MAAe,CACjB,OAAOJ,EAAM,MACf,CAAA,CAEJ"}
+{"version":3,"file":"queue.cjs","names":[],"sources":["../../src/async/queue.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { Scheduler } from './scheduler';\n\n/**\n * Creates a promise queue that processes promises sequentially with optional concurrency limit.\n *\n * @example\n * ```ts\n * const requestQueue = queue({ concurrency: 2 });\n *\n * requestQueue.add(() => fetch('/api/1'));\n * requestQueue.add(() => fetch('/api/2'));\n * requestQueue.add(() => fetch('/api/3'));\n *\n * await requestQueue.onIdle(); // Wait for all tasks to complete\n * ```\n *\n * @param options - Queue configuration\n * @param options.concurrency - Maximum number of concurrent promises (default: 1)\n * @returns Queue instance with add, onIdle, and clear methods\n */\nexport function queue(options: { concurrency?: number } = {}) {\n  const { concurrency = 1 } = options;\n\n  assert(concurrency >= 1, 'Concurrency must be at least 1', {\n    args: { concurrency },\n    type: RangeError,\n  });\n\n  let activeCount = 0;\n  let idlePromise: Promise<void> | null = null;\n  let idleResolve: (() => void) | null = null;\n\n  const tasks: Array<{\n    fn: () => Promise<unknown>;\n    reject: (error: unknown) => void;\n    resolve: (value: unknown) => void;\n  }> = [];\n\n  let flushQueued = false;\n\n  const scheduleNext = (): void => {\n    if (flushQueued) return;\n\n    flushQueued = true;\n\n    const scheduler = new Scheduler();\n\n    void scheduler.postTask(\n      () => {\n        flushQueued = false;\n        next();\n      },\n      { priority: 'user-visible' },\n    );\n  };\n\n  const next = (): void => {\n    if (activeCount < concurrency && tasks.length > 0) {\n      const task = tasks.shift()!;\n\n      activeCount++;\n\n      task\n        .fn()\n        .then(task.resolve)\n        .catch(task.reject)\n        .finally(() => {\n          activeCount--;\n          scheduleNext();\n\n          if (activeCount === 0 && tasks.length === 0 && idleResolve) {\n            idleResolve();\n            idlePromise = null;\n            idleResolve = null;\n          }\n        });\n    }\n  };\n\n  return {\n    /**\n     * Adds a promise-returning function to the queue\n     */\n    add: <T>(fn: () => Promise<T>): Promise<T> => {\n      const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n      tasks.push({\n        fn: fn as () => Promise<unknown>,\n        reject,\n        resolve: resolve as (value: unknown) => void,\n      });\n      scheduleNext();\n\n      return promise;\n    },\n\n    /**\n     * Clears all pending tasks from the queue\n     */\n    clear: (): void => {\n      tasks.length = 0;\n    },\n\n    /**\n     * Returns a promise that resolves when the queue becomes idle\n     */\n    onIdle: (): Promise<void> => {\n      if (activeCount === 0 && tasks.length === 0) {\n        return Promise.resolve();\n      }\n\n      if (!idlePromise) {\n        const deferred = Promise.withResolvers<void>();\n\n        idlePromise = deferred.promise;\n        idleResolve = deferred.resolve;\n      }\n\n      return idlePromise;\n    },\n\n    /**\n     * Returns the number of currently active promises\n     */\n    get pending(): number {\n      return activeCount;\n    },\n\n    /**\n     * Returns the current size of the queue\n     */\n    get size(): number {\n      return tasks.length;\n    },\n  };\n}\n"],"mappings":"uEAqBA,SAAgB,EAAM,EAAoC,EAAE,CAAE,CAC5D,GAAM,CAAE,cAAc,GAAM,EAE5B,EAAA,OAAO,GAAe,EAAG,iCAAkC,CACzD,KAAM,CAAE,cAAa,CACrB,KAAM,WACP,CAAC,CAEF,IAAI,EAAc,EACd,EAAoC,KACpC,EAAmC,KAEjC,EAID,EAAE,CAEH,EAAc,GAEZ,MAA2B,CAC3B,IAEJ,EAAc,GAEI,IAAI,EAAA,WAAW,CAElB,aACP,CACJ,EAAc,GACd,GAAM,EAER,CAAE,SAAU,eAAgB,CAC7B,GAGG,MAAmB,CACvB,GAAI,EAAc,GAAe,EAAM,OAAS,EAAG,CACjD,IAAM,EAAO,EAAM,OAAO,CAE1B,IAEA,EACG,IAAI,CACJ,KAAK,EAAK,QAAQ,CAClB,MAAM,EAAK,OAAO,CAClB,YAAc,CACb,IACA,GAAc,CAEV,IAAgB,GAAK,EAAM,SAAW,GAAK,IAC7C,GAAa,CACb,EAAc,KACd,EAAc,OAEhB,GAIR,MAAO,CAIL,IAAS,GAAqC,CAC5C,GAAM,CAAE,UAAS,SAAQ,WAAY,QAAQ,eAAkB,CAS/D,OAPA,EAAM,KAAK,CACL,KACJ,SACS,UACV,CAAC,CACF,GAAc,CAEP,GAMT,UAAmB,CACjB,EAAM,OAAS,GAMjB,WAA6B,CAC3B,GAAI,IAAgB,GAAK,EAAM,SAAW,EACxC,OAAO,QAAQ,SAAS,CAG1B,GAAI,CAAC,EAAa,CAChB,IAAM,EAAW,QAAQ,eAAqB,CAE9C,EAAc,EAAS,QACvB,EAAc,EAAS,QAGzB,OAAO,GAMT,IAAI,SAAkB,CACpB,OAAO,GAMT,IAAI,MAAe,CACjB,OAAO,EAAM,QAEhB"}

package/dist/async/queue.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Creates a promise queue that processes promises sequentially with optional concurrency limit.
+ *
+ * @example
+ * ```ts
+ * const requestQueue = queue({ concurrency: 2 });
+ *
+ * requestQueue.add(() => fetch('/api/1'));
+ * requestQueue.add(() => fetch('/api/2'));
+ * requestQueue.add(() => fetch('/api/3'));
+ *
+ * await requestQueue.onIdle(); // Wait for all tasks to complete
+ * ```
+ *
+ * @param options - Queue configuration
+ * @param options.concurrency - Maximum number of concurrent promises (default: 1)
+ * @returns Queue instance with add, onIdle, and clear methods
+ */
+export declare function queue(options?: {
+    concurrency?: number;
+}): {
+    /**
+     * Adds a promise-returning function to the queue
+     */
+    add: <T>(fn: () => Promise<T>) => Promise<T>;
+    /**
+     * Clears all pending tasks from the queue
+     */
+    clear: () => void;
+    /**
+     * Returns a promise that resolves when the queue becomes idle
+     */
+    onIdle: () => Promise<void>;
+    /**
+     * Returns the number of currently active promises
+     */
+    readonly pending: number;
+    /**
+     * Returns the current size of the queue
+     */
+    readonly size: number;
+};
+//# sourceMappingURL=queue.d.ts.map

package/dist/async/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/async/queue.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO;IA4DxD;;OAEG;UACG,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC;IAa1C;;OAEG;iBACQ,IAAI;IAIf;;OAEG;kBACS,OAAO,CAAC,IAAI,CAAC;IAezB;;OAEG;sBACY,MAAM;IAIrB;;OAEG;mBACS,MAAM;EAIrB"}

package/dist/async/queue.js

@@ -1,57 +1,53 @@
-import { assert as a } from "../function/assert.js";
-function f(u = {}) {
-  const { concurrency: o = 1 } = u;
-  a(o >= 1, "Concurrency must be at least 1", {
-    args: { concurrency: o },
-    type: RangeError
-  });
-  let t = 0, r = null, l = null;
-  const e = [], s = () => {
-    if (t < o && e.length > 0) {
-      const n = e.shift();
-      t++, n.fn().then(n.resolve).catch(n.reject).finally(() => {
-        t--, s(), t === 0 && e.length === 0 && l && (l(), r = null, l = null);
-      });
-    }
-  };
-  return {
-    /**
-     * Adds a promise-returning function to the queue
-     */
-    add: (n) => new Promise((i, c) => {
-      e.push({
-        fn: n,
-        reject: c,
-        resolve: i
-      }), s();
-    }),
-    /**
-     * Clears all pending tasks from the queue
-     */
-    clear: () => {
-      e.length = 0;
-    },
-    /**
-     * Returns a promise that resolves when the queue becomes idle
-     */
-    onIdle: () => t === 0 && e.length === 0 ? Promise.resolve() : (r || (r = new Promise((n) => {
-      l = n;
-    })), r),
-    /**
-     * Returns the number of currently active promises
-     */
-    get pending() {
-      return t;
-    },
-    /**
-     * Returns the current size of the queue
-     */
-    get size() {
-      return e.length;
-    }
-  };
+import { assert as e } from "../function/assert.js";
+import { Scheduler as t } from "./scheduler.js";
+//#region src/async/queue.ts
+function n(n = {}) {
+	let { concurrency: r = 1 } = n;
+	e(r >= 1, "Concurrency must be at least 1", {
+		args: { concurrency: r },
+		type: RangeError
+	});
+	let i = 0, a = null, o = null, s = [], c = !1, l = () => {
+		c || (c = !0, new t().postTask(() => {
+			c = !1, u();
+		}, { priority: "user-visible" }));
+	}, u = () => {
+		if (i < r && s.length > 0) {
+			let e = s.shift();
+			i++, e.fn().then(e.resolve).catch(e.reject).finally(() => {
+				i--, l(), i === 0 && s.length === 0 && o && (o(), a = null, o = null);
+			});
+		}
+	};
+	return {
+		add: (e) => {
+			let { promise: t, reject: n, resolve: r } = Promise.withResolvers();
+			return s.push({
+				fn: e,
+				reject: n,
+				resolve: r
+			}), l(), t;
+		},
+		clear: () => {
+			s.length = 0;
+		},
+		onIdle: () => {
+			if (i === 0 && s.length === 0) return Promise.resolve();
+			if (!a) {
+				let e = Promise.withResolvers();
+				a = e.promise, o = e.resolve;
+			}
+			return a;
+		},
+		get pending() {
+			return i;
+		},
+		get size() {
+			return s.length;
+		}
+	};
 }
-export {
-  f as queue
-};
-//# sourceMappingURL=queue.js.map
+//#endregion
+export { n as queue };
+
+//# sourceMappingURL=queue.js.map

package/dist/async/queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"queue.js","sources":["../../src/async/queue.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a promise queue that processes promises sequentially with optional concurrency limit.\n *\n * @example\n * ```ts\n * const requestQueue = queue({ concurrency: 2 });\n *\n * requestQueue.add(() => fetch('/api/1'));\n * requestQueue.add(() => fetch('/api/2'));\n * requestQueue.add(() => fetch('/api/3'));\n *\n * await requestQueue.onIdle(); // Wait for all tasks to complete\n * ```\n *\n * @param options - Queue configuration\n * @param options.concurrency - Maximum number of concurrent promises (default: 1)\n * @returns Queue instance with add, onIdle, and clear methods\n */\nexport function queue(options: { concurrency?: number } = {}) {\n  const { concurrency = 1 } = options;\n\n  assert(concurrency >= 1, 'Concurrency must be at least 1', {\n    args: { concurrency },\n    type: RangeError,\n  });\n\n  let activeCount = 0;\n  let idlePromise: Promise<void> | null = null;\n  let idleResolve: (() => void) | null = null;\n\n  const queue: Array<{\n    fn: () => Promise<unknown>;\n    resolve: (value: unknown) => void;\n    reject: (error: unknown) => void;\n  }> = [];\n\n  const next = (): void => {\n    if (activeCount < concurrency && queue.length > 0) {\n      const task = queue.shift()!;\n      activeCount++;\n\n      task\n        .fn()\n        .then(task.resolve)\n        .catch(task.reject)\n        .finally(() => {\n          activeCount--;\n          next();\n\n          if (activeCount === 0 && queue.length === 0 && idleResolve) {\n            idleResolve();\n            idlePromise = null;\n            idleResolve = null;\n          }\n        });\n    }\n  };\n\n  return {\n    /**\n     * Adds a promise-returning function to the queue\n     */\n    add: <T>(fn: () => Promise<T>): Promise<T> => {\n      return new Promise<T>((resolve, reject) => {\n        queue.push({\n          fn: fn as () => Promise<unknown>,\n          reject,\n          resolve: resolve as (value: unknown) => void,\n        });\n        next();\n      });\n    },\n\n    /**\n     * Clears all pending tasks from the queue\n     */\n    clear: (): void => {\n      queue.length = 0;\n    },\n\n    /**\n     * Returns a promise that resolves when the queue becomes idle\n     */\n    onIdle: (): Promise<void> => {\n      if (activeCount === 0 && queue.length === 0) {\n        return Promise.resolve();\n      }\n\n      if (!idlePromise) {\n        idlePromise = new Promise<void>((resolve) => {\n          idleResolve = resolve;\n        });\n      }\n\n      return idlePromise;\n    },\n\n    /**\n     * Returns the number of currently active promises\n     */\n    get pending(): number {\n      return activeCount;\n    },\n\n    /**\n     * Returns the current size of the queue\n     */\n    get size(): number {\n      return queue.length;\n    },\n  };\n}\n"],"names":["queue","options","concurrency","assert","activeCount","idlePromise","idleResolve","next","task","fn","resolve","reject"],"mappings":";AAoBO,SAASA,EAAMC,IAAoC,IAAI;AAC5D,QAAM,EAAE,aAAAC,IAAc,EAAA,IAAMD;AAE5B,EAAAE,EAAOD,KAAe,GAAG,kCAAkC;AAAA,IACzD,MAAM,EAAE,aAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP;AAED,MAAIE,IAAc,GACdC,IAAoC,MACpCC,IAAmC;AAEvC,QAAMN,IAID,CAAA,GAECO,IAAO,MAAY;AACvB,QAAIH,IAAcF,KAAeF,EAAM,SAAS,GAAG;AACjD,YAAMQ,IAAOR,EAAM,MAAA;AACnB,MAAAI,KAEAI,EACG,GAAA,EACA,KAAKA,EAAK,OAAO,EACjB,MAAMA,EAAK,MAAM,EACjB,QAAQ,MAAM;AACb,QAAAJ,KACAG,EAAA,GAEIH,MAAgB,KAAKJ,EAAM,WAAW,KAAKM,MAC7CA,EAAA,GACAD,IAAc,MACdC,IAAc;AAAA,MAElB,CAAC;AAAA,IACL;AAAA,EACF;AAEA,SAAO;AAAA;AAAA;AAAA;AAAA,IAIL,KAAK,CAAIG,MACA,IAAI,QAAW,CAACC,GAASC,MAAW;AACzCX,MAAAA,EAAM,KAAK;AAAA,QACT,IAAAS;AAAA,QACA,QAAAE;AAAA,QACA,SAAAD;AAAA,MAAA,CACD,GACDH,EAAA;AAAA,IACF,CAAC;AAAA;AAAA;AAAA;AAAA,IAMH,OAAO,MAAY;AACjBP,MAAAA,EAAM,SAAS;AAAA,IACjB;AAAA;AAAA;AAAA;AAAA,IAKA,QAAQ,MACFI,MAAgB,KAAKJ,EAAM,WAAW,IACjC,QAAQ,QAAA,KAGZK,MACHA,IAAc,IAAI,QAAc,CAACK,MAAY;AAC3C,MAAAJ,IAAcI;AAAA,IAChB,CAAC,IAGIL;AAAA;AAAA;AAAA;AAAA,IAMT,IAAI,UAAkB;AACpB,aAAOD;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,IAAI,OAAe;AACjB,aAAOJ,EAAM;AAAA,IACf;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"queue.js","names":[],"sources":["../../src/async/queue.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { Scheduler } from './scheduler';\n\n/**\n * Creates a promise queue that processes promises sequentially with optional concurrency limit.\n *\n * @example\n * ```ts\n * const requestQueue = queue({ concurrency: 2 });\n *\n * requestQueue.add(() => fetch('/api/1'));\n * requestQueue.add(() => fetch('/api/2'));\n * requestQueue.add(() => fetch('/api/3'));\n *\n * await requestQueue.onIdle(); // Wait for all tasks to complete\n * ```\n *\n * @param options - Queue configuration\n * @param options.concurrency - Maximum number of concurrent promises (default: 1)\n * @returns Queue instance with add, onIdle, and clear methods\n */\nexport function queue(options: { concurrency?: number } = {}) {\n  const { concurrency = 1 } = options;\n\n  assert(concurrency >= 1, 'Concurrency must be at least 1', {\n    args: { concurrency },\n    type: RangeError,\n  });\n\n  let activeCount = 0;\n  let idlePromise: Promise<void> | null = null;\n  let idleResolve: (() => void) | null = null;\n\n  const tasks: Array<{\n    fn: () => Promise<unknown>;\n    reject: (error: unknown) => void;\n    resolve: (value: unknown) => void;\n  }> = [];\n\n  let flushQueued = false;\n\n  const scheduleNext = (): void => {\n    if (flushQueued) return;\n\n    flushQueued = true;\n\n    const scheduler = new Scheduler();\n\n    void scheduler.postTask(\n      () => {\n        flushQueued = false;\n        next();\n      },\n      { priority: 'user-visible' },\n    );\n  };\n\n  const next = (): void => {\n    if (activeCount < concurrency && tasks.length > 0) {\n      const task = tasks.shift()!;\n\n      activeCount++;\n\n      task\n        .fn()\n        .then(task.resolve)\n        .catch(task.reject)\n        .finally(() => {\n          activeCount--;\n          scheduleNext();\n\n          if (activeCount === 0 && tasks.length === 0 && idleResolve) {\n            idleResolve();\n            idlePromise = null;\n            idleResolve = null;\n          }\n        });\n    }\n  };\n\n  return {\n    /**\n     * Adds a promise-returning function to the queue\n     */\n    add: <T>(fn: () => Promise<T>): Promise<T> => {\n      const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n      tasks.push({\n        fn: fn as () => Promise<unknown>,\n        reject,\n        resolve: resolve as (value: unknown) => void,\n      });\n      scheduleNext();\n\n      return promise;\n    },\n\n    /**\n     * Clears all pending tasks from the queue\n     */\n    clear: (): void => {\n      tasks.length = 0;\n    },\n\n    /**\n     * Returns a promise that resolves when the queue becomes idle\n     */\n    onIdle: (): Promise<void> => {\n      if (activeCount === 0 && tasks.length === 0) {\n        return Promise.resolve();\n      }\n\n      if (!idlePromise) {\n        const deferred = Promise.withResolvers<void>();\n\n        idlePromise = deferred.promise;\n        idleResolve = deferred.resolve;\n      }\n\n      return idlePromise;\n    },\n\n    /**\n     * Returns the number of currently active promises\n     */\n    get pending(): number {\n      return activeCount;\n    },\n\n    /**\n     * Returns the current size of the queue\n     */\n    get size(): number {\n      return tasks.length;\n    },\n  };\n}\n"],"mappings":";;;AAqBA,SAAgB,EAAM,IAAoC,EAAE,EAAE;CAC5D,IAAM,EAAE,iBAAc,MAAM;AAE5B,GAAO,KAAe,GAAG,kCAAkC;EACzD,MAAM,EAAE,gBAAa;EACrB,MAAM;EACP,CAAC;CAEF,IAAI,IAAc,GACd,IAAoC,MACpC,IAAmC,MAEjC,IAID,EAAE,EAEH,IAAc,IAEZ,UAA2B;AAC3B,QAEJ,IAAc,IAEI,IAAI,GAAW,CAElB,eACP;AAEJ,GADA,IAAc,IACd,GAAM;KAER,EAAE,UAAU,gBAAgB,CAC7B;IAGG,UAAmB;AACvB,MAAI,IAAc,KAAe,EAAM,SAAS,GAAG;GACjD,IAAM,IAAO,EAAM,OAAO;AAI1B,GAFA,KAEA,EACG,IAAI,CACJ,KAAK,EAAK,QAAQ,CAClB,MAAM,EAAK,OAAO,CAClB,cAAc;AAIb,IAHA,KACA,GAAc,EAEV,MAAgB,KAAK,EAAM,WAAW,KAAK,MAC7C,GAAa,EACb,IAAc,MACd,IAAc;KAEhB;;;AAIR,QAAO;EAIL,MAAS,MAAqC;GAC5C,IAAM,EAAE,YAAS,WAAQ,eAAY,QAAQ,eAAkB;AAS/D,UAPA,EAAM,KAAK;IACL;IACJ;IACS;IACV,CAAC,EACF,GAAc,EAEP;;EAMT,aAAmB;AACjB,KAAM,SAAS;;EAMjB,cAA6B;AAC3B,OAAI,MAAgB,KAAK,EAAM,WAAW,EACxC,QAAO,QAAQ,SAAS;AAG1B,OAAI,CAAC,GAAa;IAChB,IAAM,IAAW,QAAQ,eAAqB;AAG9C,IADA,IAAc,EAAS,SACvB,IAAc,EAAS;;AAGzB,UAAO;;EAMT,IAAI,UAAkB;AACpB,UAAO;;EAMT,IAAI,OAAe;AACjB,UAAO,EAAM;;EAEhB"}

package/dist/async/race.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function o(e,r){const t=Array.isArray(e)?e:[e],a=new Promise(n=>setTimeout(n,r)),i=await Promise.race(t);return await a,i}exports.race=o;
-//# sourceMappingURL=race.cjs.map
+async function e(e,t){let n=new Promise(e=>setTimeout(e,t)),r=await e;return await n,r}exports.race=e;
+//# sourceMappingURL=race.cjs.map

package/dist/async/race.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"race.cjs","sources":["../../src/async/race.ts"],"sourcesContent":["/**\n * Race multiple promises but with a guaranteed minimum delay.\n * Useful for showing loading states for at least a minimum duration.\n *\n * @example\n * ```ts\n * // Show loading spinner for at least 500ms\n * const result = await race(\n *   fetchData(),\n *   500\n * );\n *\n * // With multiple promises\n * const result = await race(\n *   [fetch('/api/1'), fetch('/api/2')],\n *   1000\n * );\n * ```\n *\n * @param promises - Single promise or array of promises to race\n * @param minDelay - Minimum delay in milliseconds before resolving\n * @returns Promise that resolves with the first result after the minimum delay\n */\nexport async function race<T>(promises: Promise<T> | Promise<T>[], minDelay: number): Promise<T> {\n  const promiseArray = Array.isArray(promises) ? promises : [promises];\n  const minDelayPromise = new Promise<void>((resolve) => setTimeout(resolve, minDelay));\n\n  const result = await Promise.race(promiseArray);\n  await minDelayPromise;\n\n  return result;\n}\n"],"names":["race","promises","minDelay","promiseArray","minDelayPromise","resolve","result"],"mappings":"gFAuBA,eAAsBA,EAAQC,EAAqCC,EAA8B,CAC/F,MAAMC,EAAe,MAAM,QAAQF,CAAQ,EAAIA,EAAW,CAACA,CAAQ,EAC7DG,EAAkB,IAAI,QAAeC,GAAY,WAAWA,EAASH,CAAQ,CAAC,EAE9EI,EAAS,MAAM,QAAQ,KAAKH,CAAY,EAC9C,aAAMC,EAECE,CACT"}
+{"version":3,"file":"race.cjs","names":[],"sources":["../../src/async/race.ts"],"sourcesContent":["/**\n * Races a promise against a minimum delay, ensuring the result is not returned\n * before the minimum duration has elapsed. Useful for preventing loading flicker.\n *\n * @example\n * ```ts\n * // Show loading spinner for at least 500ms\n * const result = await race(fetchData(), 500);\n * ```\n *\n * @param promise - The promise to race\n * @param minDelay - Minimum delay in milliseconds before resolving\n * @returns Promise that resolves with the result after the minimum delay\n */\nexport async function race<T>(promise: Promise<T>, minDelay: number): Promise<T> {\n  const minDelayPromise = new Promise<void>((resolve) => setTimeout(resolve, minDelay));\n\n  const result = await promise;\n\n  await minDelayPromise;\n\n  return result;\n}\n"],"mappings":"AAcA,eAAsB,EAAQ,EAAqB,EAA8B,CAC/E,IAAM,EAAkB,IAAI,QAAe,GAAY,WAAW,EAAS,EAAS,CAAC,CAE/E,EAAS,MAAM,EAIrB,OAFA,MAAM,EAEC"}

package/dist/async/race.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Races a promise against a minimum delay, ensuring the result is not returned
+ * before the minimum duration has elapsed. Useful for preventing loading flicker.
+ *
+ * @example
+ * ```ts
+ * // Show loading spinner for at least 500ms
+ * const result = await race(fetchData(), 500);
+ * ```
+ *
+ * @param promise - The promise to race
+ * @param minDelay - Minimum delay in milliseconds before resolving
+ * @returns Promise that resolves with the result after the minimum delay
+ */
+export declare function race<T>(promise: Promise<T>, minDelay: number): Promise<T>;
+//# sourceMappingURL=race.d.ts.map

package/dist/async/race.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"race.d.ts","sourceRoot":"","sources":["../../src/async/race.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAQ/E"}

package/dist/async/race.js

@@ -1,8 +1,9 @@
-async function o(r, a) {
-  const e = Array.isArray(r) ? r : [r], t = new Promise((i) => setTimeout(i, a)), n = await Promise.race(e);
-  return await t, n;
+//#region src/async/race.ts
+async function e(e, t) {
+	let n = new Promise((e) => setTimeout(e, t)), r = await e;
+	return await n, r;
 }
-export {
-  o as race
-};
-//# sourceMappingURL=race.js.map
+//#endregion
+export { e as race };
+
+//# sourceMappingURL=race.js.map

package/dist/async/race.js.map

@@ -1 +1 @@
-{"version":3,"file":"race.js","sources":["../../src/async/race.ts"],"sourcesContent":["/**\n * Race multiple promises but with a guaranteed minimum delay.\n * Useful for showing loading states for at least a minimum duration.\n *\n * @example\n * ```ts\n * // Show loading spinner for at least 500ms\n * const result = await race(\n *   fetchData(),\n *   500\n * );\n *\n * // With multiple promises\n * const result = await race(\n *   [fetch('/api/1'), fetch('/api/2')],\n *   1000\n * );\n * ```\n *\n * @param promises - Single promise or array of promises to race\n * @param minDelay - Minimum delay in milliseconds before resolving\n * @returns Promise that resolves with the first result after the minimum delay\n */\nexport async function race<T>(promises: Promise<T> | Promise<T>[], minDelay: number): Promise<T> {\n  const promiseArray = Array.isArray(promises) ? promises : [promises];\n  const minDelayPromise = new Promise<void>((resolve) => setTimeout(resolve, minDelay));\n\n  const result = await Promise.race(promiseArray);\n  await minDelayPromise;\n\n  return result;\n}\n"],"names":["race","promises","minDelay","promiseArray","minDelayPromise","resolve","result"],"mappings":"AAuBA,eAAsBA,EAAQC,GAAqCC,GAA8B;AAC/F,QAAMC,IAAe,MAAM,QAAQF,CAAQ,IAAIA,IAAW,CAACA,CAAQ,GAC7DG,IAAkB,IAAI,QAAc,CAACC,MAAY,WAAWA,GAASH,CAAQ,CAAC,GAE9EI,IAAS,MAAM,QAAQ,KAAKH,CAAY;AAC9C,eAAMC,GAECE;AACT;"}
+{"version":3,"file":"race.js","names":[],"sources":["../../src/async/race.ts"],"sourcesContent":["/**\n * Races a promise against a minimum delay, ensuring the result is not returned\n * before the minimum duration has elapsed. Useful for preventing loading flicker.\n *\n * @example\n * ```ts\n * // Show loading spinner for at least 500ms\n * const result = await race(fetchData(), 500);\n * ```\n *\n * @param promise - The promise to race\n * @param minDelay - Minimum delay in milliseconds before resolving\n * @returns Promise that resolves with the result after the minimum delay\n */\nexport async function race<T>(promise: Promise<T>, minDelay: number): Promise<T> {\n  const minDelayPromise = new Promise<void>((resolve) => setTimeout(resolve, minDelay));\n\n  const result = await promise;\n\n  await minDelayPromise;\n\n  return result;\n}\n"],"mappings":";AAcA,eAAsB,EAAQ,GAAqB,GAA8B;CAC/E,IAAM,IAAkB,IAAI,SAAe,MAAY,WAAW,GAAS,EAAS,CAAC,EAE/E,IAAS,MAAM;AAIrB,QAFA,MAAM,GAEC"}

package/dist/async/retry.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../logit/dist/logit.cjs"),u=require("./sleep.cjs");async function c(i,{times:e=3,delay:y=250,backoff:o=1,signal:l}={}){let t=y;for(let r=1;r<=e;r++){if(l?.aborted)throw a.Logit.warn(`retry() -> Aborted after ${r-1} attempts`),new Error("Retry aborted");try{return await i()}catch(n){if(r===e)throw n;a.Logit.warn(`retry() -> ${n}, attempt ${r}/${e}, retrying in ${t}ms`),t>0&&await u.sleep(t),t=typeof o=="function"?o(r,t):t*o}}throw new Error("Retry failed unexpectedly")}exports.retry=c;
-//# sourceMappingURL=retry.cjs.map
+const e=require(`./sleep.cjs`);async function t(t,{backoff:n=1,delay:r=250,retryDelay:i,shouldRetry:a,signal:o,times:s=3}={}){let c=r;for(let r=1;r<=s;r++){if(o?.aborted)throw o.reason??new DOMException(`Retry aborted`,`AbortError`);try{return await t()}catch(t){if(r===s||a&&!a(t,r-1))throw t;let o=i?i(r-1):c;o>0&&await e.sleep(o),i||(c=typeof n==`function`?n(r,c):c*n)}}throw Error(`Retry failed unexpectedly`)}exports.retry=t;
+//# sourceMappingURL=retry.cjs.map