@vielzeug/arsenal 3.0.0 → 26.10.1

package/dist/async/backoff.cjs

@@ -1,2 +1,2 @@
-function e(e,t=3e4){return Math.min(1e3*2**Math.max(0,Number.isNaN(e)?0:Math.floor(e)),t)}exports.backoff=e;
+function backoff(e,t=3e4){return Math.min(1e3*2**Math.max(0,Number.isNaN(e)?0:Math.floor(e)),t)}exports.backoff=backoff;
 //# sourceMappingURL=backoff.cjs.map

package/dist/async/backoff.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.cjs","names":[],"sources":["../../src/async/backoff.ts"],"sourcesContent":["/**\n * Computes an exponential backoff delay cap for a given zero-based attempt number.\n * Returns `min(1000 × 2ⁿ, maxMs)` — the cap before optional jitter is applied.\n *\n * Multiply the result by `Math.random()` for full-jitter backoff.\n *\n * @example\n * ```ts\n * // Deterministic (sourcerer-style):\n * const delay = backoff(attempt); // 1s, 2s, 4s, … capped at 30s\n *\n * // Full-jitter (courier-style):\n * const delay = Math.random() * backoff(attempt);\n * ```\n *\n * @param attempt - Zero-based attempt index (0 = first retry wait).\n * @param maxMs   - Maximum cap in milliseconds. Defaults to 30 000.\n */\nexport function backoff(attempt: number, maxMs = 30_000): number {\n  const n = Math.max(0, Number.isNaN(attempt) ? 0 : Math.floor(attempt));\n\n  return Math.min(1000 * 2 ** n, maxMs);\n}\n"],"mappings":"AAkBA,SAAgB,EAAQ,EAAiB,EAAQ,IAAgB,CAG/D,OAAO,KAAK,IAAI,IAAO,GAFb,KAAK,IAAI,EAAG,OAAO,MAAM,CAAO,EAAI,EAAI,KAAK,MAAM,CAAO,CAExC,EAAG,CAAK,CACtC"}
+{"version":3,"file":"backoff.cjs","names":[],"sources":["../../src/async/backoff.ts"],"sourcesContent":["/**\n * Computes an exponential backoff delay cap for a given zero-based attempt number.\n * Returns `min(1000 × 2ⁿ, maxMs)`: the cap before optional jitter is applied.\n *\n * Multiply the result by `Math.random()` for full-jitter backoff.\n *\n * @example\n * ```ts\n * // Deterministic (sourcerer-style):\n * const delay = backoff(attempt); // 1s, 2s, 4s, … capped at 30s\n *\n * // Full-jitter (courier-style):\n * const delay = Math.random() * backoff(attempt);\n * ```\n *\n * @param attempt - Zero-based attempt index (0 = first retry wait).\n * @param maxMs   - Maximum cap in milliseconds. Defaults to 30 000.\n */\nexport function backoff(attempt: number, maxMs = 30_000): number {\n  const n = Math.max(0, Number.isNaN(attempt) ? 0 : Math.floor(attempt));\n\n  return Math.min(1000 * 2 ** n, maxMs);\n}\n"],"mappings":"AAkBA,SAAgB,QAAQ,EAAiB,EAAQ,IAAgB,CAG/D,OAAO,KAAK,IAAI,IAAO,GAFb,KAAK,IAAI,EAAG,OAAO,MAAM,CAAO,EAAI,EAAI,KAAK,MAAM,CAAO,CAExC,EAAG,CAAK,CACtC"}

package/dist/async/backoff.d.ts

@@ -1,6 +1,6 @@
 /**
  * Computes an exponential backoff delay cap for a given zero-based attempt number.
- * Returns `min(1000 × 2ⁿ, maxMs)` — the cap before optional jitter is applied.
+ * Returns `min(1000 × 2ⁿ, maxMs)`: the cap before optional jitter is applied.
  *
  * Multiply the result by `Math.random()` for full-jitter backoff.
  *

package/dist/async/backoff.js

@@ -1,8 +1,2 @@
-//#region src/async/backoff.ts
-function e(e, t = 3e4) {
-	return Math.min(1e3 * 2 ** Math.max(0, Number.isNaN(e) ? 0 : Math.floor(e)), t);
-}
-//#endregion
-export { e as backoff };
-
+function backoff(e,t=3e4){return Math.min(1e3*2**Math.max(0,Number.isNaN(e)?0:Math.floor(e)),t)}export{backoff};
 //# sourceMappingURL=backoff.js.map

package/dist/async/backoff.js.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.js","names":[],"sources":["../../src/async/backoff.ts"],"sourcesContent":["/**\n * Computes an exponential backoff delay cap for a given zero-based attempt number.\n * Returns `min(1000 × 2ⁿ, maxMs)` — the cap before optional jitter is applied.\n *\n * Multiply the result by `Math.random()` for full-jitter backoff.\n *\n * @example\n * ```ts\n * // Deterministic (sourcerer-style):\n * const delay = backoff(attempt); // 1s, 2s, 4s, … capped at 30s\n *\n * // Full-jitter (courier-style):\n * const delay = Math.random() * backoff(attempt);\n * ```\n *\n * @param attempt - Zero-based attempt index (0 = first retry wait).\n * @param maxMs   - Maximum cap in milliseconds. Defaults to 30 000.\n */\nexport function backoff(attempt: number, maxMs = 30_000): number {\n  const n = Math.max(0, Number.isNaN(attempt) ? 0 : Math.floor(attempt));\n\n  return Math.min(1000 * 2 ** n, maxMs);\n}\n"],"mappings":";AAkBA,SAAgB,EAAQ,GAAiB,IAAQ,KAAgB;CAG/D,OAAO,KAAK,IAAI,MAAO,KAFb,KAAK,IAAI,GAAG,OAAO,MAAM,CAAO,IAAI,IAAI,KAAK,MAAM,CAAO,CAExC,GAAG,CAAK;AACtC"}
+{"version":3,"file":"backoff.js","names":[],"sources":["../../src/async/backoff.ts"],"sourcesContent":["/**\n * Computes an exponential backoff delay cap for a given zero-based attempt number.\n * Returns `min(1000 × 2ⁿ, maxMs)`: the cap before optional jitter is applied.\n *\n * Multiply the result by `Math.random()` for full-jitter backoff.\n *\n * @example\n * ```ts\n * // Deterministic (sourcerer-style):\n * const delay = backoff(attempt); // 1s, 2s, 4s, … capped at 30s\n *\n * // Full-jitter (courier-style):\n * const delay = Math.random() * backoff(attempt);\n * ```\n *\n * @param attempt - Zero-based attempt index (0 = first retry wait).\n * @param maxMs   - Maximum cap in milliseconds. Defaults to 30 000.\n */\nexport function backoff(attempt: number, maxMs = 30_000): number {\n  const n = Math.max(0, Number.isNaN(attempt) ? 0 : Math.floor(attempt));\n\n  return Math.min(1000 * 2 ** n, maxMs);\n}\n"],"mappings":"AAkBA,SAAgB,QAAQ,EAAiB,EAAQ,IAAgB,CAG/D,OAAO,KAAK,IAAI,IAAO,GAFb,KAAK,IAAI,EAAG,OAAO,MAAM,CAAO,EAAI,EAAI,KAAK,MAAM,CAAO,CAExC,EAAG,CAAK,CACtC"}

package/dist/async/index.js

@@ -1,10 +1 @@
-import { abortError as e } from "./abortError.js";
-import { abortable as t } from "./abortable.js";
-import { attempt as n, isFail as r, isOk as i } from "./attempt.js";
-import { backoff as a } from "./backoff.js";
-import { parallel as o } from "./parallel.js";
-import { sleep as s } from "./sleep.js";
-import { retry as c } from "./retry.js";
-import { taskPool as l } from "./taskPool.js";
-import { waitFor as u } from "./waitFor.js";
-export { e as abortError, t as abortable, n as attempt, a as backoff, r as isFail, i as isOk, o as parallel, c as retry, s as sleep, l as taskPool, u as waitFor };
+import{abortError as e}from"./abortError.js";import{abortable as t}from"./abortable.js";import{attempt as n,isFail as r,isOk as i}from"./attempt.js";import{backoff as a}from"./backoff.js";import{parallel as o}from"./parallel.js";import{sleep as s}from"./sleep.js";import{retry as c}from"./retry.js";import{taskPool as l}from"./taskPool.js";import{waitFor as u}from"./waitFor.js";export{e as abortError,t as abortable,n as attempt,a as backoff,r as isFail,i as isOk,o as parallel,c as retry,s as sleep,l as taskPool,u as waitFor};

package/dist/async/parallel.cjs

@@ -1,2 +1,2 @@
-const e=require("./abortError.cjs");async function t(t,n,r={}){let{abortOnError:i=!1,limit:a=1/0,signal:o}=r;if(a<1)throw RangeError(`parallel: limit must be at least 1, got ${a}`);if(o?.aborted)throw e.abortError(o);if(t.length===0)return[];let s=Array(t.length),c=0,l=i?new AbortController:void 0,u=async()=>{for(;;){if(o?.aborted)throw e.abortError(o);if(l?.signal.aborted||c>=t.length)return;let r=c++;try{s[r]=await n(t[r],r,t)}catch(e){throw l?.abort(),e}}},d=Math.min(a,t.length),f=Array.from({length:d},()=>u());return await Promise.all(f),s}exports.parallel=t;
+const e=require("./abortError.cjs");async function parallel(t,n,r={}){let{abortOnError:i=!1,limit:a=1/0,signal:o}=r;if(a<1)throw RangeError(`parallel: limit must be at least 1, got ${a}`);if(o?.aborted)throw e.abortError(o);if(t.length===0)return[];let s=Array(t.length),c=0,l=i?new AbortController:void 0,worker=async()=>{for(;;){if(o?.aborted)throw e.abortError(o);if(l?.signal.aborted||c>=t.length)return;let r=c++;try{s[r]=await n(t[r],r,t)}catch(e){throw l?.abort(),e}}},u=Math.min(a,t.length),d=Array.from({length:u},()=>worker());return await Promise.all(d),s}exports.parallel=parallel;
 //# sourceMappingURL=parallel.cjs.map

package/dist/async/parallel.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.cjs","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\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([1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * }, { limit: 3 });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(items, async (item) => {\n *   return processItem(item);\n * }, { limit: 2, signal: controller.signal });\n *\n * // Stop other workers as soon as one item fails\n * await parallel(items, riskyOperation, { abortOnError: true, limit: 3 });\n * ```\n *\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param options - Optional options for concurrency and cancellation\n * @param [options.limit=Infinity] - Maximum number of concurrent operations. Defaults to unbounded.\n * @param [options.signal] - Optional AbortSignal to cancel processing\n * @param [options.abortOnError=false] - When `true`, stops other in-flight workers as soon as any\n *   callback throws, instead of letting them keep running to completion unobserved. Default\n *   preserves the existing best-effort-completion behavior.\n * @returns Promise resolving to an ordered array of results\n * @throws {RangeError} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  array: readonly T[],\n  callback: (item: T, index: number, array: readonly T[]) => Promise<R> | R,\n  options: { abortOnError?: boolean; limit?: number; signal?: AbortSignal } = {},\n): Promise<R[]> {\n  const { abortOnError = false, limit = Infinity, signal } = options;\n\n  if (limit < 1) {\n    throw new RangeError(`parallel: limit must be at least 1, got ${limit}`);\n  }\n\n  if (signal?.aborted) {\n    throw abortError(signal);\n  }\n\n  if (array.length === 0) {\n    return [];\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  const failFastController = abortOnError ? new AbortController() : undefined;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      if (signal?.aborted) {\n        throw abortError(signal);\n      }\n\n      if (failFastController?.signal.aborted) {\n        return;\n      }\n\n      if (currentIndex >= array.length) {\n        return;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index]!, index, array);\n      } catch (err) {\n        failFastController?.abort();\n        throw err;\n      }\n    }\n  };\n\n  const workerCount = Math.min(limit, array.length);\n  const workers = Array.from({ length: workerCount }, () => worker());\n\n  await Promise.all(workers);\n\n  return results;\n}\n"],"mappings":"oCAsCA,eAAsB,EACpB,EACA,EACA,EAA4E,CAAC,EAC/D,CACd,GAAM,CAAE,eAAe,GAAO,QAAQ,IAAU,UAAW,EAE3D,GAAI,EAAQ,EACV,MAAU,WAAW,2CAA2C,GAAO,EAGzE,GAAI,GAAQ,QACV,MAAM,EAAA,WAAW,CAAM,EAGzB,GAAI,EAAM,SAAW,EACnB,MAAO,CAAC,EAGV,IAAM,EAAmB,MAAM,EAAM,MAAM,EACvC,EAAe,EACb,EAAqB,EAAe,IAAI,gBAAoB,IAAA,GAE5D,EAAS,SAA2B,CACxC,OAAa,CACX,GAAI,GAAQ,QACV,MAAM,EAAA,WAAW,CAAM,EAOzB,GAJI,GAAoB,OAAO,SAI3B,GAAgB,EAAM,OACxB,OAGF,IAAM,EAAQ,IAEd,GAAI,CACF,EAAQ,GAAS,MAAM,EAAS,EAAM,GAAS,EAAO,CAAK,CAC7D,OAAS,EAAK,CAEZ,MADA,GAAoB,MAAM,EACpB,CACR,CACF,CACF,EAEM,EAAc,KAAK,IAAI,EAAO,EAAM,MAAM,EAC1C,EAAU,MAAM,KAAK,CAAE,OAAQ,CAAY,MAAS,EAAO,CAAC,EAIlE,OAFA,MAAM,QAAQ,IAAI,CAAO,EAElB,CACT"}
+{"version":3,"file":"parallel.cjs","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\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([1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * }, { limit: 3 });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(items, async (item) => {\n *   return processItem(item);\n * }, { limit: 2, signal: controller.signal });\n *\n * // Stop other workers as soon as one item fails\n * await parallel(items, riskyOperation, { abortOnError: true, limit: 3 });\n * ```\n *\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param options - Optional options for concurrency and cancellation\n * @param [options.limit=Infinity] - Maximum number of concurrent operations. Defaults to unbounded.\n * @param [options.signal] - Optional AbortSignal to cancel processing\n * @param [options.abortOnError=false] - When `true`, stops other in-flight workers as soon as any\n *   callback throws, instead of letting them keep running to completion unobserved. Default\n *   preserves the existing best-effort-completion behavior.\n * @returns Promise resolving to an ordered array of results\n * @throws {RangeError} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  array: readonly T[],\n  callback: (item: T, index: number, array: readonly T[]) => Promise<R> | R,\n  options: { abortOnError?: boolean; limit?: number; signal?: AbortSignal } = {},\n): Promise<R[]> {\n  const { abortOnError = false, limit = Infinity, signal } = options;\n\n  if (limit < 1) {\n    throw new RangeError(`parallel: limit must be at least 1, got ${limit}`);\n  }\n\n  if (signal?.aborted) {\n    throw abortError(signal);\n  }\n\n  if (array.length === 0) {\n    return [];\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  const failFastController = abortOnError ? new AbortController() : undefined;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      if (signal?.aborted) {\n        throw abortError(signal);\n      }\n\n      if (failFastController?.signal.aborted) {\n        return;\n      }\n\n      if (currentIndex >= array.length) {\n        return;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index]!, index, array);\n      } catch (err) {\n        failFastController?.abort();\n        throw err;\n      }\n    }\n  };\n\n  const workerCount = Math.min(limit, array.length);\n  const workers = Array.from({ length: workerCount }, () => worker());\n\n  await Promise.all(workers);\n\n  return results;\n}\n"],"mappings":"oCAsCA,eAAsB,SACpB,EACA,EACA,EAA4E,CAAC,EAC/D,CACd,GAAM,CAAE,eAAe,GAAO,QAAQ,IAAU,UAAW,EAE3D,GAAI,EAAQ,EACV,MAAU,WAAW,2CAA2C,GAAO,EAGzE,GAAI,GAAQ,QACV,MAAM,EAAA,WAAW,CAAM,EAGzB,GAAI,EAAM,SAAW,EACnB,MAAO,CAAC,EAGV,IAAM,EAAmB,MAAM,EAAM,MAAM,EACvC,EAAe,EACb,EAAqB,EAAe,IAAI,gBAAoB,IAAA,GAE5D,OAAS,SAA2B,CACxC,OAAa,CACX,GAAI,GAAQ,QACV,MAAM,EAAA,WAAW,CAAM,EAOzB,GAJI,GAAoB,OAAO,SAI3B,GAAgB,EAAM,OACxB,OAGF,IAAM,EAAQ,IAEd,GAAI,CACF,EAAQ,GAAS,MAAM,EAAS,EAAM,GAAS,EAAO,CAAK,CAC7D,OAAS,EAAK,CAEZ,MADA,GAAoB,MAAM,EACpB,CACR,CACF,CACF,EAEM,EAAc,KAAK,IAAI,EAAO,EAAM,MAAM,EAC1C,EAAU,MAAM,KAAK,CAAE,OAAQ,CAAY,MAAS,OAAO,CAAC,EAIlE,OAFA,MAAM,QAAQ,IAAI,CAAO,EAElB,CACT"}

package/dist/async/parallel.js

@@ -1,25 +1,2 @@
-import { abortError as e } from "./abortError.js";
-//#region src/async/parallel.ts
-async function t(t, n, r = {}) {
-	let { abortOnError: i = !1, limit: a = Infinity, signal: o } = r;
-	if (a < 1) throw RangeError(`parallel: limit must be at least 1, got ${a}`);
-	if (o?.aborted) throw e(o);
-	if (t.length === 0) return [];
-	let s = Array(t.length), c = 0, l = i ? new AbortController() : void 0, u = async () => {
-		for (;;) {
-			if (o?.aborted) throw e(o);
-			if (l?.signal.aborted || c >= t.length) return;
-			let r = c++;
-			try {
-				s[r] = await n(t[r], r, t);
-			} catch (e) {
-				throw l?.abort(), e;
-			}
-		}
-	}, d = Math.min(a, t.length), f = Array.from({ length: d }, () => u());
-	return await Promise.all(f), s;
-}
-//#endregion
-export { t as parallel };
-
+import{abortError as e}from"./abortError.js";async function parallel(t,n,r={}){let{abortOnError:i=!1,limit:a=1/0,signal:o}=r;if(a<1)throw RangeError(`parallel: limit must be at least 1, got ${a}`);if(o?.aborted)throw e(o);if(t.length===0)return[];let s=Array(t.length),c=0,l=i?new AbortController:void 0,worker=async()=>{for(;;){if(o?.aborted)throw e(o);if(l?.signal.aborted||c>=t.length)return;let r=c++;try{s[r]=await n(t[r],r,t)}catch(e){throw l?.abort(),e}}},u=Math.min(a,t.length),d=Array.from({length:u},()=>worker());return await Promise.all(d),s}export{parallel};
 //# sourceMappingURL=parallel.js.map

package/dist/async/parallel.js.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.js","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\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([1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * }, { limit: 3 });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(items, async (item) => {\n *   return processItem(item);\n * }, { limit: 2, signal: controller.signal });\n *\n * // Stop other workers as soon as one item fails\n * await parallel(items, riskyOperation, { abortOnError: true, limit: 3 });\n * ```\n *\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param options - Optional options for concurrency and cancellation\n * @param [options.limit=Infinity] - Maximum number of concurrent operations. Defaults to unbounded.\n * @param [options.signal] - Optional AbortSignal to cancel processing\n * @param [options.abortOnError=false] - When `true`, stops other in-flight workers as soon as any\n *   callback throws, instead of letting them keep running to completion unobserved. Default\n *   preserves the existing best-effort-completion behavior.\n * @returns Promise resolving to an ordered array of results\n * @throws {RangeError} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  array: readonly T[],\n  callback: (item: T, index: number, array: readonly T[]) => Promise<R> | R,\n  options: { abortOnError?: boolean; limit?: number; signal?: AbortSignal } = {},\n): Promise<R[]> {\n  const { abortOnError = false, limit = Infinity, signal } = options;\n\n  if (limit < 1) {\n    throw new RangeError(`parallel: limit must be at least 1, got ${limit}`);\n  }\n\n  if (signal?.aborted) {\n    throw abortError(signal);\n  }\n\n  if (array.length === 0) {\n    return [];\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  const failFastController = abortOnError ? new AbortController() : undefined;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      if (signal?.aborted) {\n        throw abortError(signal);\n      }\n\n      if (failFastController?.signal.aborted) {\n        return;\n      }\n\n      if (currentIndex >= array.length) {\n        return;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index]!, index, array);\n      } catch (err) {\n        failFastController?.abort();\n        throw err;\n      }\n    }\n  };\n\n  const workerCount = Math.min(limit, array.length);\n  const workers = Array.from({ length: workerCount }, () => worker());\n\n  await Promise.all(workers);\n\n  return results;\n}\n"],"mappings":";;AAsCA,eAAsB,EACpB,GACA,GACA,IAA4E,CAAC,GAC/D;CACd,IAAM,EAAE,kBAAe,IAAO,WAAQ,UAAU,cAAW;CAE3D,IAAI,IAAQ,GACV,MAAU,WAAW,2CAA2C,GAAO;CAGzE,IAAI,GAAQ,SACV,MAAM,EAAW,CAAM;CAGzB,IAAI,EAAM,WAAW,GACnB,OAAO,CAAC;CAGV,IAAM,IAAmB,MAAM,EAAM,MAAM,GACvC,IAAe,GACb,IAAqB,IAAe,IAAI,gBAAgB,IAAI,KAAA,GAE5D,IAAS,YAA2B;EACxC,SAAa;GACX,IAAI,GAAQ,SACV,MAAM,EAAW,CAAM;GAOzB,IAJI,GAAoB,OAAO,WAI3B,KAAgB,EAAM,QACxB;GAGF,IAAM,IAAQ;GAEd,IAAI;IACF,EAAQ,KAAS,MAAM,EAAS,EAAM,IAAS,GAAO,CAAK;GAC7D,SAAS,GAAK;IAEZ,MADA,GAAoB,MAAM,GACpB;GACR;EACF;CACF,GAEM,IAAc,KAAK,IAAI,GAAO,EAAM,MAAM,GAC1C,IAAU,MAAM,KAAK,EAAE,QAAQ,EAAY,SAAS,EAAO,CAAC;CAIlE,OAFA,MAAM,QAAQ,IAAI,CAAO,GAElB;AACT"}
+{"version":3,"file":"parallel.js","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\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([1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * }, { limit: 3 });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(items, async (item) => {\n *   return processItem(item);\n * }, { limit: 2, signal: controller.signal });\n *\n * // Stop other workers as soon as one item fails\n * await parallel(items, riskyOperation, { abortOnError: true, limit: 3 });\n * ```\n *\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param options - Optional options for concurrency and cancellation\n * @param [options.limit=Infinity] - Maximum number of concurrent operations. Defaults to unbounded.\n * @param [options.signal] - Optional AbortSignal to cancel processing\n * @param [options.abortOnError=false] - When `true`, stops other in-flight workers as soon as any\n *   callback throws, instead of letting them keep running to completion unobserved. Default\n *   preserves the existing best-effort-completion behavior.\n * @returns Promise resolving to an ordered array of results\n * @throws {RangeError} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  array: readonly T[],\n  callback: (item: T, index: number, array: readonly T[]) => Promise<R> | R,\n  options: { abortOnError?: boolean; limit?: number; signal?: AbortSignal } = {},\n): Promise<R[]> {\n  const { abortOnError = false, limit = Infinity, signal } = options;\n\n  if (limit < 1) {\n    throw new RangeError(`parallel: limit must be at least 1, got ${limit}`);\n  }\n\n  if (signal?.aborted) {\n    throw abortError(signal);\n  }\n\n  if (array.length === 0) {\n    return [];\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  const failFastController = abortOnError ? new AbortController() : undefined;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      if (signal?.aborted) {\n        throw abortError(signal);\n      }\n\n      if (failFastController?.signal.aborted) {\n        return;\n      }\n\n      if (currentIndex >= array.length) {\n        return;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index]!, index, array);\n      } catch (err) {\n        failFastController?.abort();\n        throw err;\n      }\n    }\n  };\n\n  const workerCount = Math.min(limit, array.length);\n  const workers = Array.from({ length: workerCount }, () => worker());\n\n  await Promise.all(workers);\n\n  return results;\n}\n"],"mappings":"6CAsCA,eAAsB,SACpB,EACA,EACA,EAA4E,CAAC,EAC/D,CACd,GAAM,CAAE,eAAe,GAAO,QAAQ,IAAU,UAAW,EAE3D,GAAI,EAAQ,EACV,MAAU,WAAW,2CAA2C,GAAO,EAGzE,GAAI,GAAQ,QACV,MAAM,EAAW,CAAM,EAGzB,GAAI,EAAM,SAAW,EACnB,MAAO,CAAC,EAGV,IAAM,EAAmB,MAAM,EAAM,MAAM,EACvC,EAAe,EACb,EAAqB,EAAe,IAAI,gBAAoB,IAAA,GAE5D,OAAS,SAA2B,CACxC,OAAa,CACX,GAAI,GAAQ,QACV,MAAM,EAAW,CAAM,EAOzB,GAJI,GAAoB,OAAO,SAI3B,GAAgB,EAAM,OACxB,OAGF,IAAM,EAAQ,IAEd,GAAI,CACF,EAAQ,GAAS,MAAM,EAAS,EAAM,GAAS,EAAO,CAAK,CAC7D,OAAS,EAAK,CAEZ,MADA,GAAoB,MAAM,EACpB,CACR,CACF,CACF,EAEM,EAAc,KAAK,IAAI,EAAO,EAAM,MAAM,EAC1C,EAAU,MAAM,KAAK,CAAE,OAAQ,CAAY,MAAS,OAAO,CAAC,EAIlE,OAFA,MAAM,QAAQ,IAAI,CAAO,EAElB,CACT"}

package/dist/async/retry.cjs

@@ -1,2 +1,2 @@
-const e=require("./abortError.cjs"),t=require("./sleep.cjs");function n(e,t){let n=[e===void 0?void 0:AbortSignal.timeout(e),t].filter(e=>e!=null);if(n.length!==0)return n.length===1?n[0]:AbortSignal.any(n)}async function r(r,{delay:i=250,onError:a,shouldRetry:o,signal:s,timeout:c,times:l=3}={}){if(!Number.isInteger(l)||l<1)throw RangeError(`retry: times must be a positive integer, got ${l}`);for(let u=1;u<=l;u++){if(s?.aborted)throw e.abortError(s);let d=n(c,s);try{return await r(d)}catch(e){if(u===l||o&&!o(e,u-1))throw a?.(e),e;let n=typeof i==`function`?i(u-1):i;n>0&&await t.sleep(n,s)}}}exports.retry=r;
+const e=require("./abortError.cjs"),t=require("./sleep.cjs");function buildSignal(e,t){let n=[e===void 0?void 0:AbortSignal.timeout(e),t].filter(e=>e!=null);if(n.length!==0)return n.length===1?n[0]:AbortSignal.any(n)}async function retry(n,{delay:r=250,shouldRetry:i,signal:a,timeout:o,times:s=3}={}){if(!Number.isInteger(s)||s<1)throw RangeError(`retry: times must be a positive integer, got ${s}`);for(let c=1;c<=s;c++){if(a?.aborted)throw e.abortError(a);let l=buildSignal(o,a);try{return await n(l)}catch(e){if(c===s||i&&!i(e,c-1))throw e;let n=typeof r==`function`?r(c-1):r;n>0&&await t.sleep(n,a)}}}exports.retry=retry;
 //# sourceMappingURL=retry.cjs.map

package/dist/async/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { abortError } from './abortError';\nimport { sleep } from './sleep';\n\nexport type RetryOptions = {\n  delay?: number | ((attempt: number) => number);\n  onError?: (error: unknown) => void;\n  shouldRetry?: (error: unknown, attempt: number) => boolean;\n  signal?: AbortSignal;\n  timeout?: number;\n  times?: number;\n};\n\nfunction buildSignal(timeout: number | undefined, signal: AbortSignal | undefined): AbortSignal | undefined {\n  const parts = [timeout !== undefined ? AbortSignal.timeout(timeout) : undefined, signal].filter(\n    (s): s is AbortSignal => s != null,\n  );\n\n  if (parts.length === 0) return undefined;\n\n  if (parts.length === 1) return parts[0];\n\n  return AbortSignal.any(parts);\n}\n\n/**\n * Retries an async function with optional per-attempt timeout, delay strategy, and abort support.\n * The function receives a merged AbortSignal from the per-attempt timeout and any external signal.\n * On total failure, throws the last error (use `attempt()` to get an `AttemptResult` without throwing).\n *\n * @example\n * ```ts\n * // Basic retry\n * const data = await retry(() => fetch('/api').then(r => r.json()), { times: 3 });\n *\n * // With per-attempt timeout and cancellation\n * const data = await retry(\n *   async (signal) => fetch('/api', { signal }).then(r => r.json()),\n *   { times: 3, timeout: 5000 },\n * );\n *\n * // As AttemptResult (never throws) — combine with attempt()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n *\n * @param fn - Async function to retry. Receives a merged AbortSignal when timeout or signal is set.\n * @param options - Retry configuration.\n * @param [options.times=3] - Total attempts including the first.\n * @param [options.delay=250] - Delay between retries in ms, or a function of (attemptIndex).\n * @param [options.timeout] - Per-attempt timeout in milliseconds.\n * @param [options.signal] - External AbortSignal to cancel all retries.\n * @param [options.shouldRetry] - Predicate called after each non-final failure.\n *   Receives the error and the number of failures so far (0-indexed: `0` on the first failure,\n *   `1` on the second, etc.). Return `false` to abort immediately. **Not called on the final attempt**\n *   (use `onError` to observe the final error unconditionally).\n * @param [options.onError] - Called with the last error before rethrowing — both on final attempt exhaustion\n *   and when `shouldRetry` returns `false` to abort early.\n * @returns The resolved value.\n * @throws {RangeError} If `times` is not a positive integer.\n * @throws The last error if all attempts fail.\n */\nexport async function retry<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  { delay = 250, onError, shouldRetry, signal, timeout, times = 3 }: RetryOptions = {},\n): Promise<T> {\n  if (!Number.isInteger(times) || times < 1) {\n    throw new RangeError(`retry: times must be a positive integer, got ${times}`);\n  }\n\n  for (let tryCount = 1; tryCount <= times; tryCount++) {\n    if (signal?.aborted) throw abortError(signal);\n\n    const callSignal = buildSignal(timeout, signal);\n\n    try {\n      return await fn(callSignal);\n    } catch (err) {\n      if (tryCount === times) {\n        onError?.(err);\n        throw err;\n      }\n\n      if (shouldRetry && !shouldRetry(err, tryCount - 1)) {\n        onError?.(err);\n        throw err;\n      }\n\n      const ms = typeof delay === 'function' ? delay(tryCount - 1) : delay;\n\n      if (ms > 0) await sleep(ms, signal);\n    }\n  }\n\n  /* unreachable — the loop always returns or throws before exhausting all attempts */\n  return undefined as never;\n}\n"],"mappings":"6DAYA,SAAS,EAAY,EAA6B,EAA0D,CAC1G,IAAM,EAAQ,CAAC,IAAY,IAAA,GAA2C,IAAA,GAA/B,YAAY,QAAQ,CAAO,EAAe,CAAM,CAAC,CAAC,OACtF,GAAwB,GAAK,IAChC,EAEI,KAAM,SAAW,EAIrB,OAFI,EAAM,SAAW,EAAU,EAAM,GAE9B,YAAY,IAAI,CAAK,CAC9B,CAsCA,eAAsB,EACpB,EACA,CAAE,QAAQ,IAAK,UAAS,cAAa,SAAQ,UAAS,QAAQ,GAAoB,CAAC,EACvE,CACZ,GAAI,CAAC,OAAO,UAAU,CAAK,GAAK,EAAQ,EACtC,MAAU,WAAW,gDAAgD,GAAO,EAG9E,IAAK,IAAI,EAAW,EAAG,GAAY,EAAO,IAAY,CACpD,GAAI,GAAQ,QAAS,MAAM,EAAA,WAAW,CAAM,EAE5C,IAAM,EAAa,EAAY,EAAS,CAAM,EAE9C,GAAI,CACF,OAAO,MAAM,EAAG,CAAU,CAC5B,OAAS,EAAK,CAMZ,GALI,IAAa,GAKb,GAAe,CAAC,EAAY,EAAK,EAAW,CAAC,EAE/C,MADA,IAAU,CAAG,EACP,EAGR,IAAM,EAAK,OAAO,GAAU,WAAa,EAAM,EAAW,CAAC,EAAI,EAE3D,EAAK,GAAG,MAAM,EAAA,MAAM,EAAI,CAAM,CACpC,CACF,CAIF"}
+{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { abortError } from './abortError';\nimport { sleep } from './sleep';\n\nexport type RetryOptions = {\n  delay?: number | ((attempt: number) => number);\n  shouldRetry?: (error: unknown, attempt: number) => boolean;\n  signal?: AbortSignal;\n  timeout?: number;\n  times?: number;\n};\n\nfunction buildSignal(timeout: number | undefined, signal: AbortSignal | undefined): AbortSignal | undefined {\n  const parts = [timeout !== undefined ? AbortSignal.timeout(timeout) : undefined, signal].filter(\n    (s): s is AbortSignal => s != null,\n  );\n\n  if (parts.length === 0) return undefined;\n\n  if (parts.length === 1) return parts[0];\n\n  return AbortSignal.any(parts);\n}\n\n/**\n * Retries an async function with optional per-attempt timeout, delay strategy, and abort support.\n * The function receives a merged AbortSignal from the per-attempt timeout and any external signal.\n * On total failure, throws the last error (use `attempt()` to get an `AttemptResult` without throwing).\n *\n * @example\n * ```ts\n * // Basic retry\n * const data = await retry(() => fetch('/api').then(r => r.json()), { times: 3 });\n *\n * // With per-attempt timeout and cancellation\n * const data = await retry(\n *   async (signal) => fetch('/api', { signal }).then(r => r.json()),\n *   { times: 3, timeout: 5000 },\n * );\n *\n * // As AttemptResult (never throws): combine with attempt()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n *\n * @param fn - Async function to retry. Receives a merged AbortSignal when timeout or signal is set.\n * @param options - Retry configuration.\n * @param [options.times=3] - Total attempts including the first.\n * @param [options.delay=250] - Delay between retries in ms, or a function of (attemptIndex).\n * @param [options.timeout] - Per-attempt timeout in milliseconds.\n * @param [options.signal] - External AbortSignal to cancel all retries.\n * @param [options.shouldRetry] - Predicate called after each non-final failure.\n *   Receives the error and the number of failures so far (0-indexed: `0` on the first failure,\n *   `1` on the second, etc.). Return `false` to abort immediately. Not called on the final\n *   attempt, because there is no retry left to decide about; observe the thrown error with\n *   `attempt()` or `try/catch` instead.\n * @returns The resolved value.\n * @throws {RangeError} If `times` is not a positive integer.\n * @throws The last error if all attempts fail.\n */\nexport async function retry<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  { delay = 250, shouldRetry, signal, timeout, times = 3 }: RetryOptions = {},\n): Promise<T> {\n  if (!Number.isInteger(times) || times < 1) {\n    throw new RangeError(`retry: times must be a positive integer, got ${times}`);\n  }\n\n  for (let tryCount = 1; tryCount <= times; tryCount++) {\n    if (signal?.aborted) throw abortError(signal);\n\n    const callSignal = buildSignal(timeout, signal);\n\n    try {\n      return await fn(callSignal);\n    } catch (err) {\n      if (tryCount === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, tryCount - 1)) throw err;\n\n      const ms = typeof delay === 'function' ? delay(tryCount - 1) : delay;\n\n      if (ms > 0) await sleep(ms, signal);\n    }\n  }\n\n  /* unreachable: the loop always returns or throws before exhausting all attempts */\n  return undefined as never;\n}\n"],"mappings":"6DAWA,SAAS,YAAY,EAA6B,EAA0D,CAC1G,IAAM,EAAQ,CAAC,IAAY,IAAA,GAA2C,IAAA,GAA/B,YAAY,QAAQ,CAAO,EAAe,CAAM,CAAC,CAAC,OACtF,GAAwB,GAAK,IAChC,EAEI,KAAM,SAAW,EAIrB,OAFI,EAAM,SAAW,EAAU,EAAM,GAE9B,YAAY,IAAI,CAAK,CAC9B,CAqCA,eAAsB,MACpB,EACA,CAAE,QAAQ,IAAK,cAAa,SAAQ,UAAS,QAAQ,GAAoB,CAAC,EAC9D,CACZ,GAAI,CAAC,OAAO,UAAU,CAAK,GAAK,EAAQ,EACtC,MAAU,WAAW,gDAAgD,GAAO,EAG9E,IAAK,IAAI,EAAW,EAAG,GAAY,EAAO,IAAY,CACpD,GAAI,GAAQ,QAAS,MAAM,EAAA,WAAW,CAAM,EAE5C,IAAM,EAAa,YAAY,EAAS,CAAM,EAE9C,GAAI,CACF,OAAO,MAAM,EAAG,CAAU,CAC5B,OAAS,EAAK,CAGZ,GAFI,IAAa,GAEb,GAAe,CAAC,EAAY,EAAK,EAAW,CAAC,EAAG,MAAM,EAE1D,IAAM,EAAK,OAAO,GAAU,WAAa,EAAM,EAAW,CAAC,EAAI,EAE3D,EAAK,GAAG,MAAM,EAAA,MAAM,EAAI,CAAM,CACpC,CACF,CAIF"}

package/dist/async/retry.d.ts

@@ -1,6 +1,5 @@
 export type RetryOptions = {
     delay?: number | ((attempt: number) => number);
-    onError?: (error: unknown) => void;
     shouldRetry?: (error: unknown, attempt: number) => boolean;
     signal?: AbortSignal;
     timeout?: number;
@@ -22,7 +21,7 @@ export type RetryOptions = {
  *   { times: 3, timeout: 5000 },
  * );
  *
- * // As AttemptResult (never throws) — combine with attempt()
+ * // As AttemptResult (never throws): combine with attempt()
  * const result = await attempt(() => retry(fn, { times: 3 }));
  * ```
  *
@@ -34,13 +33,12 @@ export type RetryOptions = {
  * @param [options.signal] - External AbortSignal to cancel all retries.
  * @param [options.shouldRetry] - Predicate called after each non-final failure.
  *   Receives the error and the number of failures so far (0-indexed: `0` on the first failure,
- *   `1` on the second, etc.). Return `false` to abort immediately. **Not called on the final attempt**
- *   (use `onError` to observe the final error unconditionally).
- * @param [options.onError] - Called with the last error before rethrowing — both on final attempt exhaustion
- *   and when `shouldRetry` returns `false` to abort early.
+ *   `1` on the second, etc.). Return `false` to abort immediately. Not called on the final
+ *   attempt, because there is no retry left to decide about; observe the thrown error with
+ *   `attempt()` or `try/catch` instead.
  * @returns The resolved value.
  * @throws {RangeError} If `times` is not a positive integer.
  * @throws The last error if all attempts fail.
  */
-export declare function retry<T>(fn: (signal?: AbortSignal) => Promise<T>, { delay, onError, shouldRetry, signal, timeout, times }?: RetryOptions): Promise<T>;
+export declare function retry<T>(fn: (signal?: AbortSignal) => Promise<T>, { delay, shouldRetry, signal, timeout, times }?: RetryOptions): Promise<T>;
 //# sourceMappingURL=retry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/async/retry.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACxC,EAAE,KAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,KAAS,EAAE,GAAE,YAAiB,GACnF,OAAO,CAAC,CAAC,CAAC,CA+BZ"}
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/async/retry.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAC/C,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACxC,EAAE,KAAW,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,KAAS,EAAE,GAAE,YAAiB,GAC1E,OAAO,CAAC,CAAC,CAAC,CAyBZ"}

package/dist/async/retry.js

@@ -1,25 +1,2 @@
-import { abortError as e } from "./abortError.js";
-import { sleep as t } from "./sleep.js";
-//#region src/async/retry.ts
-function n(e, t) {
-	let n = [e === void 0 ? void 0 : AbortSignal.timeout(e), t].filter((e) => e != null);
-	if (n.length !== 0) return n.length === 1 ? n[0] : AbortSignal.any(n);
-}
-async function r(r, { delay: i = 250, onError: a, shouldRetry: o, signal: s, timeout: c, times: l = 3 } = {}) {
-	if (!Number.isInteger(l) || l < 1) throw RangeError(`retry: times must be a positive integer, got ${l}`);
-	for (let u = 1; u <= l; u++) {
-		if (s?.aborted) throw e(s);
-		let d = n(c, s);
-		try {
-			return await r(d);
-		} catch (e) {
-			if (u === l || o && !o(e, u - 1)) throw a?.(e), e;
-			let n = typeof i == "function" ? i(u - 1) : i;
-			n > 0 && await t(n, s);
-		}
-	}
-}
-//#endregion
-export { r as retry };
-
+import{abortError as e}from"./abortError.js";import{sleep as t}from"./sleep.js";function buildSignal(e,t){let n=[e===void 0?void 0:AbortSignal.timeout(e),t].filter(e=>e!=null);if(n.length!==0)return n.length===1?n[0]:AbortSignal.any(n)}async function retry(n,{delay:r=250,shouldRetry:i,signal:a,timeout:o,times:s=3}={}){if(!Number.isInteger(s)||s<1)throw RangeError(`retry: times must be a positive integer, got ${s}`);for(let c=1;c<=s;c++){if(a?.aborted)throw e(a);let l=buildSignal(o,a);try{return await n(l)}catch(e){if(c===s||i&&!i(e,c-1))throw e;let n=typeof r==`function`?r(c-1):r;n>0&&await t(n,a)}}}export{retry};
 //# sourceMappingURL=retry.js.map

package/dist/async/retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry.js","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { abortError } from './abortError';\nimport { sleep } from './sleep';\n\nexport type RetryOptions = {\n  delay?: number | ((attempt: number) => number);\n  onError?: (error: unknown) => void;\n  shouldRetry?: (error: unknown, attempt: number) => boolean;\n  signal?: AbortSignal;\n  timeout?: number;\n  times?: number;\n};\n\nfunction buildSignal(timeout: number | undefined, signal: AbortSignal | undefined): AbortSignal | undefined {\n  const parts = [timeout !== undefined ? AbortSignal.timeout(timeout) : undefined, signal].filter(\n    (s): s is AbortSignal => s != null,\n  );\n\n  if (parts.length === 0) return undefined;\n\n  if (parts.length === 1) return parts[0];\n\n  return AbortSignal.any(parts);\n}\n\n/**\n * Retries an async function with optional per-attempt timeout, delay strategy, and abort support.\n * The function receives a merged AbortSignal from the per-attempt timeout and any external signal.\n * On total failure, throws the last error (use `attempt()` to get an `AttemptResult` without throwing).\n *\n * @example\n * ```ts\n * // Basic retry\n * const data = await retry(() => fetch('/api').then(r => r.json()), { times: 3 });\n *\n * // With per-attempt timeout and cancellation\n * const data = await retry(\n *   async (signal) => fetch('/api', { signal }).then(r => r.json()),\n *   { times: 3, timeout: 5000 },\n * );\n *\n * // As AttemptResult (never throws) — combine with attempt()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n *\n * @param fn - Async function to retry. Receives a merged AbortSignal when timeout or signal is set.\n * @param options - Retry configuration.\n * @param [options.times=3] - Total attempts including the first.\n * @param [options.delay=250] - Delay between retries in ms, or a function of (attemptIndex).\n * @param [options.timeout] - Per-attempt timeout in milliseconds.\n * @param [options.signal] - External AbortSignal to cancel all retries.\n * @param [options.shouldRetry] - Predicate called after each non-final failure.\n *   Receives the error and the number of failures so far (0-indexed: `0` on the first failure,\n *   `1` on the second, etc.). Return `false` to abort immediately. **Not called on the final attempt**\n *   (use `onError` to observe the final error unconditionally).\n * @param [options.onError] - Called with the last error before rethrowing — both on final attempt exhaustion\n *   and when `shouldRetry` returns `false` to abort early.\n * @returns The resolved value.\n * @throws {RangeError} If `times` is not a positive integer.\n * @throws The last error if all attempts fail.\n */\nexport async function retry<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  { delay = 250, onError, shouldRetry, signal, timeout, times = 3 }: RetryOptions = {},\n): Promise<T> {\n  if (!Number.isInteger(times) || times < 1) {\n    throw new RangeError(`retry: times must be a positive integer, got ${times}`);\n  }\n\n  for (let tryCount = 1; tryCount <= times; tryCount++) {\n    if (signal?.aborted) throw abortError(signal);\n\n    const callSignal = buildSignal(timeout, signal);\n\n    try {\n      return await fn(callSignal);\n    } catch (err) {\n      if (tryCount === times) {\n        onError?.(err);\n        throw err;\n      }\n\n      if (shouldRetry && !shouldRetry(err, tryCount - 1)) {\n        onError?.(err);\n        throw err;\n      }\n\n      const ms = typeof delay === 'function' ? delay(tryCount - 1) : delay;\n\n      if (ms > 0) await sleep(ms, signal);\n    }\n  }\n\n  /* unreachable — the loop always returns or throws before exhausting all attempts */\n  return undefined as never;\n}\n"],"mappings":";;;AAYA,SAAS,EAAY,GAA6B,GAA0D;CAC1G,IAAM,IAAQ,CAAC,MAAY,KAAA,IAA2C,KAAA,IAA/B,YAAY,QAAQ,CAAO,GAAe,CAAM,CAAC,CAAC,QACtF,MAAwB,KAAK,IAChC;CAEI,MAAM,WAAW,GAIrB,OAFI,EAAM,WAAW,IAAU,EAAM,KAE9B,YAAY,IAAI,CAAK;AAC9B;AAsCA,eAAsB,EACpB,GACA,EAAE,WAAQ,KAAK,YAAS,gBAAa,WAAQ,YAAS,WAAQ,MAAoB,CAAC,GACvE;CACZ,IAAI,CAAC,OAAO,UAAU,CAAK,KAAK,IAAQ,GACtC,MAAU,WAAW,gDAAgD,GAAO;CAG9E,KAAK,IAAI,IAAW,GAAG,KAAY,GAAO,KAAY;EACpD,IAAI,GAAQ,SAAS,MAAM,EAAW,CAAM;EAE5C,IAAM,IAAa,EAAY,GAAS,CAAM;EAE9C,IAAI;GACF,OAAO,MAAM,EAAG,CAAU;EAC5B,SAAS,GAAK;GAMZ,IALI,MAAa,KAKb,KAAe,CAAC,EAAY,GAAK,IAAW,CAAC,GAE/C,MADA,IAAU,CAAG,GACP;GAGR,IAAM,IAAK,OAAO,KAAU,aAAa,EAAM,IAAW,CAAC,IAAI;GAE/D,AAAI,IAAK,KAAG,MAAM,EAAM,GAAI,CAAM;EACpC;CACF;AAIF"}
+{"version":3,"file":"retry.js","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { abortError } from './abortError';\nimport { sleep } from './sleep';\n\nexport type RetryOptions = {\n  delay?: number | ((attempt: number) => number);\n  shouldRetry?: (error: unknown, attempt: number) => boolean;\n  signal?: AbortSignal;\n  timeout?: number;\n  times?: number;\n};\n\nfunction buildSignal(timeout: number | undefined, signal: AbortSignal | undefined): AbortSignal | undefined {\n  const parts = [timeout !== undefined ? AbortSignal.timeout(timeout) : undefined, signal].filter(\n    (s): s is AbortSignal => s != null,\n  );\n\n  if (parts.length === 0) return undefined;\n\n  if (parts.length === 1) return parts[0];\n\n  return AbortSignal.any(parts);\n}\n\n/**\n * Retries an async function with optional per-attempt timeout, delay strategy, and abort support.\n * The function receives a merged AbortSignal from the per-attempt timeout and any external signal.\n * On total failure, throws the last error (use `attempt()` to get an `AttemptResult` without throwing).\n *\n * @example\n * ```ts\n * // Basic retry\n * const data = await retry(() => fetch('/api').then(r => r.json()), { times: 3 });\n *\n * // With per-attempt timeout and cancellation\n * const data = await retry(\n *   async (signal) => fetch('/api', { signal }).then(r => r.json()),\n *   { times: 3, timeout: 5000 },\n * );\n *\n * // As AttemptResult (never throws): combine with attempt()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n *\n * @param fn - Async function to retry. Receives a merged AbortSignal when timeout or signal is set.\n * @param options - Retry configuration.\n * @param [options.times=3] - Total attempts including the first.\n * @param [options.delay=250] - Delay between retries in ms, or a function of (attemptIndex).\n * @param [options.timeout] - Per-attempt timeout in milliseconds.\n * @param [options.signal] - External AbortSignal to cancel all retries.\n * @param [options.shouldRetry] - Predicate called after each non-final failure.\n *   Receives the error and the number of failures so far (0-indexed: `0` on the first failure,\n *   `1` on the second, etc.). Return `false` to abort immediately. Not called on the final\n *   attempt, because there is no retry left to decide about; observe the thrown error with\n *   `attempt()` or `try/catch` instead.\n * @returns The resolved value.\n * @throws {RangeError} If `times` is not a positive integer.\n * @throws The last error if all attempts fail.\n */\nexport async function retry<T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  { delay = 250, shouldRetry, signal, timeout, times = 3 }: RetryOptions = {},\n): Promise<T> {\n  if (!Number.isInteger(times) || times < 1) {\n    throw new RangeError(`retry: times must be a positive integer, got ${times}`);\n  }\n\n  for (let tryCount = 1; tryCount <= times; tryCount++) {\n    if (signal?.aborted) throw abortError(signal);\n\n    const callSignal = buildSignal(timeout, signal);\n\n    try {\n      return await fn(callSignal);\n    } catch (err) {\n      if (tryCount === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, tryCount - 1)) throw err;\n\n      const ms = typeof delay === 'function' ? delay(tryCount - 1) : delay;\n\n      if (ms > 0) await sleep(ms, signal);\n    }\n  }\n\n  /* unreachable: the loop always returns or throws before exhausting all attempts */\n  return undefined as never;\n}\n"],"mappings":"gFAWA,SAAS,YAAY,EAA6B,EAA0D,CAC1G,IAAM,EAAQ,CAAC,IAAY,IAAA,GAA2C,IAAA,GAA/B,YAAY,QAAQ,CAAO,EAAe,CAAM,CAAC,CAAC,OACtF,GAAwB,GAAK,IAChC,EAEI,KAAM,SAAW,EAIrB,OAFI,EAAM,SAAW,EAAU,EAAM,GAE9B,YAAY,IAAI,CAAK,CAC9B,CAqCA,eAAsB,MACpB,EACA,CAAE,QAAQ,IAAK,cAAa,SAAQ,UAAS,QAAQ,GAAoB,CAAC,EAC9D,CACZ,GAAI,CAAC,OAAO,UAAU,CAAK,GAAK,EAAQ,EACtC,MAAU,WAAW,gDAAgD,GAAO,EAG9E,IAAK,IAAI,EAAW,EAAG,GAAY,EAAO,IAAY,CACpD,GAAI,GAAQ,QAAS,MAAM,EAAW,CAAM,EAE5C,IAAM,EAAa,YAAY,EAAS,CAAM,EAE9C,GAAI,CACF,OAAO,MAAM,EAAG,CAAU,CAC5B,OAAS,EAAK,CAGZ,GAFI,IAAa,GAEb,GAAe,CAAC,EAAY,EAAK,EAAW,CAAC,EAAG,MAAM,EAE1D,IAAM,EAAK,OAAO,GAAU,WAAa,EAAM,EAAW,CAAC,EAAI,EAE3D,EAAK,GAAG,MAAM,EAAM,EAAI,CAAM,CACpC,CACF,CAIF"}

package/dist/async/sleep.cjs

@@ -1,2 +1,2 @@
-const e=require("./abortError.cjs");async function t(t,n){return n?n.aborted?Promise.reject(e.abortError(n)):new Promise((r,i)=>{let a=setTimeout(()=>{n.removeEventListener(`abort`,o),r()},t),o=()=>{clearTimeout(a),n.removeEventListener(`abort`,o),i(e.abortError(n))};n.addEventListener(`abort`,o)}):new Promise(e=>setTimeout(e,t))}exports.sleep=t;
+const e=require("./abortError.cjs");async function sleep(t,n){return n?n.aborted?Promise.reject(e.abortError(n)):new Promise((r,i)=>{let a=setTimeout(()=>{n.removeEventListener(`abort`,onAbort),r()},t),onAbort=()=>{clearTimeout(a),n.removeEventListener(`abort`,onAbort),i(e.abortError(n))};n.addEventListener(`abort`,onAbort)}):new Promise(e=>setTimeout(e,t))}exports.sleep=sleep;
 //# sourceMappingURL=sleep.cjs.map

package/dist/async/sleep.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.cjs","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n * If an `AbortSignal` is provided and fires before the delay elapses, the promise rejects with\n * the signal's reason (or a generic `DOMException('Aborted', 'AbortError')`).\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs after 1 second\n *\n * // With abort support\n * const controller = new AbortController();\n * await sleep(5000, controller.signal); // rejects immediately when aborted\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n * @param signal  - Optional AbortSignal to cancel the sleep early.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number, signal?: AbortSignal): Promise<void> {\n  if (!signal) {\n    return new Promise((resolve) => setTimeout(resolve, timeout));\n  }\n\n  if (signal.aborted) {\n    return Promise.reject(abortError(signal));\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const id = setTimeout(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    }, timeout);\n\n    const onAbort = () => {\n      clearTimeout(id);\n      signal.removeEventListener('abort', onAbort);\n      reject(abortError(signal));\n    };\n\n    signal.addEventListener('abort', onAbort);\n  });\n}\n"],"mappings":"oCAqBA,eAAsB,EAAM,EAAiB,EAAqC,CAShF,OARK,EAID,EAAO,QACF,QAAQ,OAAO,EAAA,WAAW,CAAM,CAAC,EAGnC,IAAI,SAAe,EAAS,IAAW,CAC5C,IAAM,EAAK,eAAiB,CAC1B,EAAO,oBAAoB,QAAS,CAAO,EAC3C,EAAQ,CACV,EAAG,CAAO,EAEJ,MAAgB,CACpB,aAAa,CAAE,EACf,EAAO,oBAAoB,QAAS,CAAO,EAC3C,EAAO,EAAA,WAAW,CAAM,CAAC,CAC3B,EAEA,EAAO,iBAAiB,QAAS,CAAO,CAC1C,CAAC,EApBQ,IAAI,QAAS,GAAY,WAAW,EAAS,CAAO,CAAC,CAqBhE"}
+{"version":3,"file":"sleep.cjs","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n * If an `AbortSignal` is provided and fires before the delay elapses, the promise rejects with\n * the signal's reason (or a generic `DOMException('Aborted', 'AbortError')`).\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs after 1 second\n *\n * // With abort support\n * const controller = new AbortController();\n * await sleep(5000, controller.signal); // rejects immediately when aborted\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n * @param signal  - Optional AbortSignal to cancel the sleep early.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number, signal?: AbortSignal): Promise<void> {\n  if (!signal) {\n    return new Promise((resolve) => setTimeout(resolve, timeout));\n  }\n\n  if (signal.aborted) {\n    return Promise.reject(abortError(signal));\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const id = setTimeout(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    }, timeout);\n\n    const onAbort = () => {\n      clearTimeout(id);\n      signal.removeEventListener('abort', onAbort);\n      reject(abortError(signal));\n    };\n\n    signal.addEventListener('abort', onAbort);\n  });\n}\n"],"mappings":"oCAqBA,eAAsB,MAAM,EAAiB,EAAqC,CAShF,OARK,EAID,EAAO,QACF,QAAQ,OAAO,EAAA,WAAW,CAAM,CAAC,EAGnC,IAAI,SAAe,EAAS,IAAW,CAC5C,IAAM,EAAK,eAAiB,CAC1B,EAAO,oBAAoB,QAAS,OAAO,EAC3C,EAAQ,CACV,EAAG,CAAO,EAEJ,YAAgB,CACpB,aAAa,CAAE,EACf,EAAO,oBAAoB,QAAS,OAAO,EAC3C,EAAO,EAAA,WAAW,CAAM,CAAC,CAC3B,EAEA,EAAO,iBAAiB,QAAS,OAAO,CAC1C,CAAC,EApBQ,IAAI,QAAS,GAAY,WAAW,EAAS,CAAO,CAAC,CAqBhE"}

package/dist/async/sleep.js

@@ -1,16 +1,2 @@
-import { abortError as e } from "./abortError.js";
-//#region src/async/sleep.ts
-async function t(t, n) {
-	return n ? n.aborted ? Promise.reject(e(n)) : new Promise((r, i) => {
-		let a = setTimeout(() => {
-			n.removeEventListener("abort", o), r();
-		}, t), o = () => {
-			clearTimeout(a), n.removeEventListener("abort", o), i(e(n));
-		};
-		n.addEventListener("abort", o);
-	}) : new Promise((e) => setTimeout(e, t));
-}
-//#endregion
-export { t as sleep };
-
+import{abortError as e}from"./abortError.js";async function sleep(t,n){return n?n.aborted?Promise.reject(e(n)):new Promise((r,i)=>{let a=setTimeout(()=>{n.removeEventListener(`abort`,onAbort),r()},t),onAbort=()=>{clearTimeout(a),n.removeEventListener(`abort`,onAbort),i(e(n))};n.addEventListener(`abort`,onAbort)}):new Promise(e=>setTimeout(e,t))}export{sleep};
 //# sourceMappingURL=sleep.js.map

package/dist/async/sleep.js.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.js","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n * If an `AbortSignal` is provided and fires before the delay elapses, the promise rejects with\n * the signal's reason (or a generic `DOMException('Aborted', 'AbortError')`).\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs after 1 second\n *\n * // With abort support\n * const controller = new AbortController();\n * await sleep(5000, controller.signal); // rejects immediately when aborted\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n * @param signal  - Optional AbortSignal to cancel the sleep early.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number, signal?: AbortSignal): Promise<void> {\n  if (!signal) {\n    return new Promise((resolve) => setTimeout(resolve, timeout));\n  }\n\n  if (signal.aborted) {\n    return Promise.reject(abortError(signal));\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const id = setTimeout(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    }, timeout);\n\n    const onAbort = () => {\n      clearTimeout(id);\n      signal.removeEventListener('abort', onAbort);\n      reject(abortError(signal));\n    };\n\n    signal.addEventListener('abort', onAbort);\n  });\n}\n"],"mappings":";;AAqBA,eAAsB,EAAM,GAAiB,GAAqC;CAShF,OARK,IAID,EAAO,UACF,QAAQ,OAAO,EAAW,CAAM,CAAC,IAGnC,IAAI,SAAe,GAAS,MAAW;EAC5C,IAAM,IAAK,iBAAiB;GAE1B,AADA,EAAO,oBAAoB,SAAS,CAAO,GAC3C,EAAQ;EACV,GAAG,CAAO,GAEJ,UAAgB;GAGpB,AAFA,aAAa,CAAE,GACf,EAAO,oBAAoB,SAAS,CAAO,GAC3C,EAAO,EAAW,CAAM,CAAC;EAC3B;EAEA,EAAO,iBAAiB,SAAS,CAAO;CAC1C,CAAC,IApBQ,IAAI,SAAS,MAAY,WAAW,GAAS,CAAO,CAAC;AAqBhE"}
+{"version":3,"file":"sleep.js","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { abortError } from './abortError';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n * If an `AbortSignal` is provided and fires before the delay elapses, the promise rejects with\n * the signal's reason (or a generic `DOMException('Aborted', 'AbortError')`).\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs after 1 second\n *\n * // With abort support\n * const controller = new AbortController();\n * await sleep(5000, controller.signal); // rejects immediately when aborted\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n * @param signal  - Optional AbortSignal to cancel the sleep early.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number, signal?: AbortSignal): Promise<void> {\n  if (!signal) {\n    return new Promise((resolve) => setTimeout(resolve, timeout));\n  }\n\n  if (signal.aborted) {\n    return Promise.reject(abortError(signal));\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const id = setTimeout(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    }, timeout);\n\n    const onAbort = () => {\n      clearTimeout(id);\n      signal.removeEventListener('abort', onAbort);\n      reject(abortError(signal));\n    };\n\n    signal.addEventListener('abort', onAbort);\n  });\n}\n"],"mappings":"6CAqBA,eAAsB,MAAM,EAAiB,EAAqC,CAShF,OARK,EAID,EAAO,QACF,QAAQ,OAAO,EAAW,CAAM,CAAC,EAGnC,IAAI,SAAe,EAAS,IAAW,CAC5C,IAAM,EAAK,eAAiB,CAC1B,EAAO,oBAAoB,QAAS,OAAO,EAC3C,EAAQ,CACV,EAAG,CAAO,EAEJ,YAAgB,CACpB,aAAa,CAAE,EACf,EAAO,oBAAoB,QAAS,OAAO,EAC3C,EAAO,EAAW,CAAM,CAAC,CAC3B,EAEA,EAAO,iBAAiB,QAAS,OAAO,CAC1C,CAAC,EApBQ,IAAI,QAAS,GAAY,WAAW,EAAS,CAAO,CAAC,CAqBhE"}

package/dist/async/taskPool.cjs

@@ -1,2 +1,2 @@
-function e({concurrency:e=1}={}){if(!Number.isInteger(e)||e<1)throw RangeError(`taskPool: concurrency must be a positive integer`);let t=new AbortController,n=[],r=0,i=!1,a,o=()=>{r===0&&n.length===0&&(a?.resolve(),a=void 0)},s=()=>{for(;r<e&&n.length>0;){let e=n.shift();r++,Promise.resolve().then(()=>e.run(t.signal)).then(e.resolve,e.reject).finally(()=>{r--,s(),o()})}};return{get active(){return r},get disposalSignal(){return t.signal},dispose:(e=new DOMException(`Task pool disposed`,`AbortError`))=>{if(!i){i=!0,t.abort(e);for(let t of n.splice(0))t.reject(e);o()}},get disposed(){return i},idle:()=>r===0&&n.length===0?Promise.resolve():(a??=Promise.withResolvers(),a.promise),get pending(){return n.length},run:e=>{let r=Promise.withResolvers();return i?(r.reject(t.signal.reason),r.promise):(n.push({reject:r.reject,resolve:r.resolve,run:e}),s(),r.promise)},[Symbol.dispose](){this.dispose()}}}exports.taskPool=e;
+function taskPool({concurrency:e=1}={}){if(!Number.isInteger(e)||e<1)throw RangeError(`taskPool: concurrency must be a positive integer`);let t=new AbortController,n=[],r=0,i=!1,a,resolveIdle=()=>{r===0&&n.length===0&&(a?.resolve(),a=void 0)},start=()=>{for(;r<e&&n.length>0;){let e=n.shift();r++,Promise.resolve().then(()=>e.run(t.signal)).then(e.resolve,e.reject).finally(()=>{r--,start(),resolveIdle()})}};return{get active(){return r},get disposalSignal(){return t.signal},dispose:(e=new DOMException(`Task pool disposed`,`AbortError`))=>{if(!i){i=!0,t.abort(e);for(let t of n.splice(0))t.reject(e);resolveIdle()}},get disposed(){return i},idle:()=>r===0&&n.length===0?Promise.resolve():(a??=Promise.withResolvers(),a.promise),get pending(){return n.length},run:e=>{let r=Promise.withResolvers();return i?(r.reject(t.signal.reason),r.promise):(n.push({reject:r.reject,resolve:r.resolve,run:e}),start(),r.promise)},[Symbol.dispose](){this.dispose()}}}exports.taskPool=taskPool;
 //# sourceMappingURL=taskPool.cjs.map

package/dist/async/taskPool.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"taskPool.cjs","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  readonly active: number;\n  readonly disposalSignal: AbortSignal;\n  dispose(reason?: unknown): void;\n  readonly disposed: boolean;\n  idle(): Promise<void>;\n  readonly pending: number;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  [Symbol.dispose](): void;\n}\n\ntype PendingTask = {\n  reject: (reason?: unknown) => void;\n  resolve: (value: unknown) => void;\n  run: (signal: AbortSignal) => Promise<unknown>;\n};\n\nexport function taskPool({ concurrency = 1 }: { concurrency?: number } = {}): TaskPool {\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new RangeError('taskPool: concurrency must be a positive integer');\n  }\n\n  const controller = new AbortController();\n  const pending: PendingTask[] = [];\n  let active = 0;\n  let disposed = false;\n  let idleDeferred: ReturnType<typeof Promise.withResolvers<void>> | undefined;\n\n  const resolveIdle = (): void => {\n    if (active === 0 && pending.length === 0) {\n      idleDeferred?.resolve();\n      idleDeferred = undefined;\n    }\n  };\n\n  const start = (): void => {\n    while (active < concurrency && pending.length > 0) {\n      const next = pending.shift()!;\n\n      active++;\n      void Promise.resolve()\n        .then(() => next.run(controller.signal))\n        .then(next.resolve, next.reject)\n        .finally(() => {\n          active--;\n          start();\n          resolveIdle();\n        });\n    }\n  };\n\n  return {\n    get active(): number {\n      return active;\n    },\n    get disposalSignal(): AbortSignal {\n      return controller.signal;\n    },\n    dispose: (reason: unknown = new DOMException('Task pool disposed', 'AbortError')): void => {\n      if (disposed) return;\n\n      disposed = true;\n      controller.abort(reason);\n\n      for (const task of pending.splice(0)) task.reject(reason);\n\n      resolveIdle();\n    },\n    get disposed(): boolean {\n      return disposed;\n    },\n    idle: (): Promise<void> => {\n      if (active === 0 && pending.length === 0) return Promise.resolve();\n\n      idleDeferred ??= Promise.withResolvers<void>();\n\n      return idleDeferred.promise;\n    },\n    get pending(): number {\n      return pending.length;\n    },\n    run: <T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> => {\n      const deferred = Promise.withResolvers<T>();\n\n      if (disposed) {\n        deferred.reject(controller.signal.reason);\n\n        return deferred.promise;\n      }\n\n      pending.push({\n        reject: deferred.reject,\n        resolve: deferred.resolve as (value: unknown) => void,\n        run: task as (signal: AbortSignal) => Promise<unknown>,\n      });\n      start();\n\n      return deferred.promise;\n    },\n    [Symbol.dispose](): void {\n      this.dispose();\n    },\n  };\n}\n"],"mappings":"AAiBA,SAAgB,EAAS,CAAE,cAAc,GAAgC,CAAC,EAAa,CACrF,GAAI,CAAC,OAAO,UAAU,CAAW,GAAK,EAAc,EAClD,MAAU,WAAW,kDAAkD,EAGzE,IAAM,EAAa,IAAI,gBACjB,EAAyB,CAAC,EAC5B,EAAS,EACT,EAAW,GACX,EAEE,MAA0B,CAC1B,IAAW,GAAK,EAAQ,SAAW,IACrC,GAAc,QAAQ,EACtB,EAAe,IAAA,GAEnB,EAEM,MAAoB,CACxB,KAAO,EAAS,GAAe,EAAQ,OAAS,GAAG,CACjD,IAAM,EAAO,EAAQ,MAAM,EAE3B,IACA,QAAa,QAAQ,CAAC,CACnB,SAAW,EAAK,IAAI,EAAW,MAAM,CAAC,CAAC,CACvC,KAAK,EAAK,QAAS,EAAK,MAAM,CAAC,CAC/B,YAAc,CACb,IACA,EAAM,EACN,EAAY,CACd,CAAC,CACL,CACF,EAEA,MAAO,CACL,IAAI,QAAiB,CACnB,OAAO,CACT,EACA,IAAI,gBAA8B,CAChC,OAAO,EAAW,MACpB,EACA,SAAU,EAAkB,IAAI,aAAa,qBAAsB,YAAY,IAAY,CACrF,MAGJ,CADA,EAAW,GACX,EAAW,MAAM,CAAM,EAEvB,IAAK,IAAM,KAAQ,EAAQ,OAAO,CAAC,EAAG,EAAK,OAAO,CAAM,EAExD,EAAY,CAJW,CAKzB,EACA,IAAI,UAAoB,CACtB,OAAO,CACT,EACA,SACM,IAAW,GAAK,EAAQ,SAAW,EAAU,QAAQ,QAAQ,GAEjE,IAAiB,QAAQ,cAAoB,EAEtC,EAAa,SAEtB,IAAI,SAAkB,CACpB,OAAO,EAAQ,MACjB,EACA,IAAS,GAA0D,CACjE,IAAM,EAAW,QAAQ,cAAiB,EAe1C,OAbI,GACF,EAAS,OAAO,EAAW,OAAO,MAAM,EAEjC,EAAS,UAGlB,EAAQ,KAAK,CACX,OAAQ,EAAS,OACjB,QAAS,EAAS,QAClB,IAAK,CACP,CAAC,EACD,EAAM,EAEC,EAAS,QAClB,EACA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,CACF,CACF"}
+{"version":3,"file":"taskPool.cjs","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  readonly active: number;\n  readonly disposalSignal: AbortSignal;\n  dispose(reason?: unknown): void;\n  readonly disposed: boolean;\n  idle(): Promise<void>;\n  readonly pending: number;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  [Symbol.dispose](): void;\n}\n\ntype PendingTask = {\n  reject: (reason?: unknown) => void;\n  resolve: (value: unknown) => void;\n  run: (signal: AbortSignal) => Promise<unknown>;\n};\n\nexport function taskPool({ concurrency = 1 }: { concurrency?: number } = {}): TaskPool {\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new RangeError('taskPool: concurrency must be a positive integer');\n  }\n\n  const controller = new AbortController();\n  const pending: PendingTask[] = [];\n  let active = 0;\n  let disposed = false;\n  let idleDeferred: ReturnType<typeof Promise.withResolvers<void>> | undefined;\n\n  const resolveIdle = (): void => {\n    if (active === 0 && pending.length === 0) {\n      idleDeferred?.resolve();\n      idleDeferred = undefined;\n    }\n  };\n\n  const start = (): void => {\n    while (active < concurrency && pending.length > 0) {\n      const next = pending.shift()!;\n\n      active++;\n      void Promise.resolve()\n        .then(() => next.run(controller.signal))\n        .then(next.resolve, next.reject)\n        .finally(() => {\n          active--;\n          start();\n          resolveIdle();\n        });\n    }\n  };\n\n  return {\n    get active(): number {\n      return active;\n    },\n    get disposalSignal(): AbortSignal {\n      return controller.signal;\n    },\n    dispose: (reason: unknown = new DOMException('Task pool disposed', 'AbortError')): void => {\n      if (disposed) return;\n\n      disposed = true;\n      controller.abort(reason);\n\n      for (const task of pending.splice(0)) task.reject(reason);\n\n      resolveIdle();\n    },\n    get disposed(): boolean {\n      return disposed;\n    },\n    idle: (): Promise<void> => {\n      if (active === 0 && pending.length === 0) return Promise.resolve();\n\n      idleDeferred ??= Promise.withResolvers<void>();\n\n      return idleDeferred.promise;\n    },\n    get pending(): number {\n      return pending.length;\n    },\n    run: <T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> => {\n      const deferred = Promise.withResolvers<T>();\n\n      if (disposed) {\n        deferred.reject(controller.signal.reason);\n\n        return deferred.promise;\n      }\n\n      pending.push({\n        reject: deferred.reject,\n        resolve: deferred.resolve as (value: unknown) => void,\n        run: task as (signal: AbortSignal) => Promise<unknown>,\n      });\n      start();\n\n      return deferred.promise;\n    },\n    [Symbol.dispose](): void {\n      this.dispose();\n    },\n  };\n}\n"],"mappings":"AAiBA,SAAgB,SAAS,CAAE,cAAc,GAAgC,CAAC,EAAa,CACrF,GAAI,CAAC,OAAO,UAAU,CAAW,GAAK,EAAc,EAClD,MAAU,WAAW,kDAAkD,EAGzE,IAAM,EAAa,IAAI,gBACjB,EAAyB,CAAC,EAC5B,EAAS,EACT,EAAW,GACX,EAEE,gBAA0B,CAC1B,IAAW,GAAK,EAAQ,SAAW,IACrC,GAAc,QAAQ,EACtB,EAAe,IAAA,GAEnB,EAEM,UAAoB,CACxB,KAAO,EAAS,GAAe,EAAQ,OAAS,GAAG,CACjD,IAAM,EAAO,EAAQ,MAAM,EAE3B,IACA,QAAa,QAAQ,CAAC,CACnB,SAAW,EAAK,IAAI,EAAW,MAAM,CAAC,CAAC,CACvC,KAAK,EAAK,QAAS,EAAK,MAAM,CAAC,CAC/B,YAAc,CACb,IACA,MAAM,EACN,YAAY,CACd,CAAC,CACL,CACF,EAEA,MAAO,CACL,IAAI,QAAiB,CACnB,OAAO,CACT,EACA,IAAI,gBAA8B,CAChC,OAAO,EAAW,MACpB,EACA,SAAU,EAAkB,IAAI,aAAa,qBAAsB,YAAY,IAAY,CACrF,MAGJ,CADA,EAAW,GACX,EAAW,MAAM,CAAM,EAEvB,IAAK,IAAM,KAAQ,EAAQ,OAAO,CAAC,EAAG,EAAK,OAAO,CAAM,EAExD,YAAY,CAJW,CAKzB,EACA,IAAI,UAAoB,CACtB,OAAO,CACT,EACA,SACM,IAAW,GAAK,EAAQ,SAAW,EAAU,QAAQ,QAAQ,GAEjE,IAAiB,QAAQ,cAAoB,EAEtC,EAAa,SAEtB,IAAI,SAAkB,CACpB,OAAO,EAAQ,MACjB,EACA,IAAS,GAA0D,CACjE,IAAM,EAAW,QAAQ,cAAiB,EAe1C,OAbI,GACF,EAAS,OAAO,EAAW,OAAO,MAAM,EAEjC,EAAS,UAGlB,EAAQ,KAAK,CACX,OAAQ,EAAS,OACjB,QAAS,EAAS,QAClB,IAAK,CACP,CAAC,EACD,MAAM,EAEC,EAAS,QAClB,EACA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,CACF,CACF"}

package/dist/async/taskPool.js

@@ -1,51 +1,2 @@
-//#region src/async/taskPool.ts
-function e({ concurrency: e = 1 } = {}) {
-	if (!Number.isInteger(e) || e < 1) throw RangeError("taskPool: concurrency must be a positive integer");
-	let t = new AbortController(), n = [], r = 0, i = !1, a, o = () => {
-		r === 0 && n.length === 0 && (a?.resolve(), a = void 0);
-	}, s = () => {
-		for (; r < e && n.length > 0;) {
-			let e = n.shift();
-			r++, Promise.resolve().then(() => e.run(t.signal)).then(e.resolve, e.reject).finally(() => {
-				r--, s(), o();
-			});
-		}
-	};
-	return {
-		get active() {
-			return r;
-		},
-		get disposalSignal() {
-			return t.signal;
-		},
-		dispose: (e = new DOMException("Task pool disposed", "AbortError")) => {
-			if (!i) {
-				i = !0, t.abort(e);
-				for (let t of n.splice(0)) t.reject(e);
-				o();
-			}
-		},
-		get disposed() {
-			return i;
-		},
-		idle: () => r === 0 && n.length === 0 ? Promise.resolve() : (a ??= Promise.withResolvers(), a.promise),
-		get pending() {
-			return n.length;
-		},
-		run: (e) => {
-			let r = Promise.withResolvers();
-			return i ? (r.reject(t.signal.reason), r.promise) : (n.push({
-				reject: r.reject,
-				resolve: r.resolve,
-				run: e
-			}), s(), r.promise);
-		},
-		[Symbol.dispose]() {
-			this.dispose();
-		}
-	};
-}
-//#endregion
-export { e as taskPool };
-
+function taskPool({concurrency:e=1}={}){if(!Number.isInteger(e)||e<1)throw RangeError(`taskPool: concurrency must be a positive integer`);let t=new AbortController,n=[],r=0,i=!1,a,resolveIdle=()=>{r===0&&n.length===0&&(a?.resolve(),a=void 0)},start=()=>{for(;r<e&&n.length>0;){let e=n.shift();r++,Promise.resolve().then(()=>e.run(t.signal)).then(e.resolve,e.reject).finally(()=>{r--,start(),resolveIdle()})}};return{get active(){return r},get disposalSignal(){return t.signal},dispose:(e=new DOMException(`Task pool disposed`,`AbortError`))=>{if(!i){i=!0,t.abort(e);for(let t of n.splice(0))t.reject(e);resolveIdle()}},get disposed(){return i},idle:()=>r===0&&n.length===0?Promise.resolve():(a??=Promise.withResolvers(),a.promise),get pending(){return n.length},run:e=>{let r=Promise.withResolvers();return i?(r.reject(t.signal.reason),r.promise):(n.push({reject:r.reject,resolve:r.resolve,run:e}),start(),r.promise)},[Symbol.dispose](){this.dispose()}}}export{taskPool};
 //# sourceMappingURL=taskPool.js.map

package/dist/async/taskPool.js.map

@@ -1 +1 @@
-{"version":3,"file":"taskPool.js","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  readonly active: number;\n  readonly disposalSignal: AbortSignal;\n  dispose(reason?: unknown): void;\n  readonly disposed: boolean;\n  idle(): Promise<void>;\n  readonly pending: number;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  [Symbol.dispose](): void;\n}\n\ntype PendingTask = {\n  reject: (reason?: unknown) => void;\n  resolve: (value: unknown) => void;\n  run: (signal: AbortSignal) => Promise<unknown>;\n};\n\nexport function taskPool({ concurrency = 1 }: { concurrency?: number } = {}): TaskPool {\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new RangeError('taskPool: concurrency must be a positive integer');\n  }\n\n  const controller = new AbortController();\n  const pending: PendingTask[] = [];\n  let active = 0;\n  let disposed = false;\n  let idleDeferred: ReturnType<typeof Promise.withResolvers<void>> | undefined;\n\n  const resolveIdle = (): void => {\n    if (active === 0 && pending.length === 0) {\n      idleDeferred?.resolve();\n      idleDeferred = undefined;\n    }\n  };\n\n  const start = (): void => {\n    while (active < concurrency && pending.length > 0) {\n      const next = pending.shift()!;\n\n      active++;\n      void Promise.resolve()\n        .then(() => next.run(controller.signal))\n        .then(next.resolve, next.reject)\n        .finally(() => {\n          active--;\n          start();\n          resolveIdle();\n        });\n    }\n  };\n\n  return {\n    get active(): number {\n      return active;\n    },\n    get disposalSignal(): AbortSignal {\n      return controller.signal;\n    },\n    dispose: (reason: unknown = new DOMException('Task pool disposed', 'AbortError')): void => {\n      if (disposed) return;\n\n      disposed = true;\n      controller.abort(reason);\n\n      for (const task of pending.splice(0)) task.reject(reason);\n\n      resolveIdle();\n    },\n    get disposed(): boolean {\n      return disposed;\n    },\n    idle: (): Promise<void> => {\n      if (active === 0 && pending.length === 0) return Promise.resolve();\n\n      idleDeferred ??= Promise.withResolvers<void>();\n\n      return idleDeferred.promise;\n    },\n    get pending(): number {\n      return pending.length;\n    },\n    run: <T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> => {\n      const deferred = Promise.withResolvers<T>();\n\n      if (disposed) {\n        deferred.reject(controller.signal.reason);\n\n        return deferred.promise;\n      }\n\n      pending.push({\n        reject: deferred.reject,\n        resolve: deferred.resolve as (value: unknown) => void,\n        run: task as (signal: AbortSignal) => Promise<unknown>,\n      });\n      start();\n\n      return deferred.promise;\n    },\n    [Symbol.dispose](): void {\n      this.dispose();\n    },\n  };\n}\n"],"mappings":";AAiBA,SAAgB,EAAS,EAAE,iBAAc,MAAgC,CAAC,GAAa;CACrF,IAAI,CAAC,OAAO,UAAU,CAAW,KAAK,IAAc,GAClD,MAAU,WAAW,kDAAkD;CAGzE,IAAM,IAAa,IAAI,gBAAgB,GACjC,IAAyB,CAAC,GAC5B,IAAS,GACT,IAAW,IACX,GAEE,UAA0B;EAC9B,AAAI,MAAW,KAAK,EAAQ,WAAW,MACrC,GAAc,QAAQ,GACtB,IAAe,KAAA;CAEnB,GAEM,UAAoB;EACxB,OAAO,IAAS,KAAe,EAAQ,SAAS,IAAG;GACjD,IAAM,IAAO,EAAQ,MAAM;GAG3B,AADA,KACA,QAAa,QAAQ,CAAC,CACnB,WAAW,EAAK,IAAI,EAAW,MAAM,CAAC,CAAC,CACvC,KAAK,EAAK,SAAS,EAAK,MAAM,CAAC,CAC/B,cAAc;IAGb,AAFA,KACA,EAAM,GACN,EAAY;GACd,CAAC;EACL;CACF;CAEA,OAAO;EACL,IAAI,SAAiB;GACnB,OAAO;EACT;EACA,IAAI,iBAA8B;GAChC,OAAO,EAAW;EACpB;EACA,UAAU,IAAkB,IAAI,aAAa,sBAAsB,YAAY,MAAY;GACrF,QAGJ;IADA,IAAW,IACX,EAAW,MAAM,CAAM;IAEvB,KAAK,IAAM,KAAQ,EAAQ,OAAO,CAAC,GAAG,EAAK,OAAO,CAAM;IAExD,EAAY;GAJW;EAKzB;EACA,IAAI,WAAoB;GACtB,OAAO;EACT;EACA,YACM,MAAW,KAAK,EAAQ,WAAW,IAAU,QAAQ,QAAQ,KAEjE,MAAiB,QAAQ,cAAoB,GAEtC,EAAa;EAEtB,IAAI,UAAkB;GACpB,OAAO,EAAQ;EACjB;EACA,MAAS,MAA0D;GACjE,IAAM,IAAW,QAAQ,cAAiB;GAe1C,OAbI,KACF,EAAS,OAAO,EAAW,OAAO,MAAM,GAEjC,EAAS,YAGlB,EAAQ,KAAK;IACX,QAAQ,EAAS;IACjB,SAAS,EAAS;IAClB,KAAK;GACP,CAAC,GACD,EAAM,GAEC,EAAS;EAClB;EACA,CAAC,OAAO,WAAiB;GACvB,KAAK,QAAQ;EACf;CACF;AACF"}
+{"version":3,"file":"taskPool.js","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  readonly active: number;\n  readonly disposalSignal: AbortSignal;\n  dispose(reason?: unknown): void;\n  readonly disposed: boolean;\n  idle(): Promise<void>;\n  readonly pending: number;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  [Symbol.dispose](): void;\n}\n\ntype PendingTask = {\n  reject: (reason?: unknown) => void;\n  resolve: (value: unknown) => void;\n  run: (signal: AbortSignal) => Promise<unknown>;\n};\n\nexport function taskPool({ concurrency = 1 }: { concurrency?: number } = {}): TaskPool {\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new RangeError('taskPool: concurrency must be a positive integer');\n  }\n\n  const controller = new AbortController();\n  const pending: PendingTask[] = [];\n  let active = 0;\n  let disposed = false;\n  let idleDeferred: ReturnType<typeof Promise.withResolvers<void>> | undefined;\n\n  const resolveIdle = (): void => {\n    if (active === 0 && pending.length === 0) {\n      idleDeferred?.resolve();\n      idleDeferred = undefined;\n    }\n  };\n\n  const start = (): void => {\n    while (active < concurrency && pending.length > 0) {\n      const next = pending.shift()!;\n\n      active++;\n      void Promise.resolve()\n        .then(() => next.run(controller.signal))\n        .then(next.resolve, next.reject)\n        .finally(() => {\n          active--;\n          start();\n          resolveIdle();\n        });\n    }\n  };\n\n  return {\n    get active(): number {\n      return active;\n    },\n    get disposalSignal(): AbortSignal {\n      return controller.signal;\n    },\n    dispose: (reason: unknown = new DOMException('Task pool disposed', 'AbortError')): void => {\n      if (disposed) return;\n\n      disposed = true;\n      controller.abort(reason);\n\n      for (const task of pending.splice(0)) task.reject(reason);\n\n      resolveIdle();\n    },\n    get disposed(): boolean {\n      return disposed;\n    },\n    idle: (): Promise<void> => {\n      if (active === 0 && pending.length === 0) return Promise.resolve();\n\n      idleDeferred ??= Promise.withResolvers<void>();\n\n      return idleDeferred.promise;\n    },\n    get pending(): number {\n      return pending.length;\n    },\n    run: <T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> => {\n      const deferred = Promise.withResolvers<T>();\n\n      if (disposed) {\n        deferred.reject(controller.signal.reason);\n\n        return deferred.promise;\n      }\n\n      pending.push({\n        reject: deferred.reject,\n        resolve: deferred.resolve as (value: unknown) => void,\n        run: task as (signal: AbortSignal) => Promise<unknown>,\n      });\n      start();\n\n      return deferred.promise;\n    },\n    [Symbol.dispose](): void {\n      this.dispose();\n    },\n  };\n}\n"],"mappings":"AAiBA,SAAgB,SAAS,CAAE,cAAc,GAAgC,CAAC,EAAa,CACrF,GAAI,CAAC,OAAO,UAAU,CAAW,GAAK,EAAc,EAClD,MAAU,WAAW,kDAAkD,EAGzE,IAAM,EAAa,IAAI,gBACjB,EAAyB,CAAC,EAC5B,EAAS,EACT,EAAW,GACX,EAEE,gBAA0B,CAC1B,IAAW,GAAK,EAAQ,SAAW,IACrC,GAAc,QAAQ,EACtB,EAAe,IAAA,GAEnB,EAEM,UAAoB,CACxB,KAAO,EAAS,GAAe,EAAQ,OAAS,GAAG,CACjD,IAAM,EAAO,EAAQ,MAAM,EAE3B,IACA,QAAa,QAAQ,CAAC,CACnB,SAAW,EAAK,IAAI,EAAW,MAAM,CAAC,CAAC,CACvC,KAAK,EAAK,QAAS,EAAK,MAAM,CAAC,CAC/B,YAAc,CACb,IACA,MAAM,EACN,YAAY,CACd,CAAC,CACL,CACF,EAEA,MAAO,CACL,IAAI,QAAiB,CACnB,OAAO,CACT,EACA,IAAI,gBAA8B,CAChC,OAAO,EAAW,MACpB,EACA,SAAU,EAAkB,IAAI,aAAa,qBAAsB,YAAY,IAAY,CACrF,MAGJ,CADA,EAAW,GACX,EAAW,MAAM,CAAM,EAEvB,IAAK,IAAM,KAAQ,EAAQ,OAAO,CAAC,EAAG,EAAK,OAAO,CAAM,EAExD,YAAY,CAJW,CAKzB,EACA,IAAI,UAAoB,CACtB,OAAO,CACT,EACA,SACM,IAAW,GAAK,EAAQ,SAAW,EAAU,QAAQ,QAAQ,GAEjE,IAAiB,QAAQ,cAAoB,EAEtC,EAAa,SAEtB,IAAI,SAAkB,CACpB,OAAO,EAAQ,MACjB,EACA,IAAS,GAA0D,CACjE,IAAM,EAAW,QAAQ,cAAiB,EAe1C,OAbI,GACF,EAAS,OAAO,EAAW,OAAO,MAAM,EAEjC,EAAS,UAGlB,EAAQ,KAAK,CACX,OAAQ,EAAS,OACjB,QAAS,EAAS,QAClB,IAAK,CACP,CAAC,EACD,MAAM,EAEC,EAAS,QAClB,EACA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,CACF,CACF"}

package/dist/async/waitFor.cjs

@@ -1,2 +1,2 @@
-const e=require("./sleep.cjs");async function t(t,{interval:n=100,signal:r,timeout:i=5e3}={}){let a=AbortSignal.timeout(i),o=r?AbortSignal.any([r,a]):a;for(o.throwIfAborted();;){if(o.throwIfAborted(),await t(o))return;await e.sleep(n,o)}}exports.waitFor=t;
+const e=require("./sleep.cjs");async function waitFor(t,{interval:n=100,signal:r,timeout:i=5e3}={}){let a=AbortSignal.timeout(i),o=r?AbortSignal.any([r,a]):a;for(o.throwIfAborted();;){if(o.throwIfAborted(),await t(o))return;await e.sleep(n,o)}}exports.waitFor=waitFor;
 //# sourceMappingURL=waitFor.cjs.map

package/dist/async/waitFor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"waitFor.cjs","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["import { sleep } from './sleep';\n\nexport type WaitForOptions = {\n  interval?: number;\n  signal?: AbortSignal;\n  timeout?: number;\n};\n\n/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready with cancellation support\n * await waitFor(\n *   async (signal) => {\n *     const res = await fetch('/api/health', { signal });\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 },\n * );\n * ```\n *\n * @param condition - Polling function that receives the merged AbortSignal and returns true when the condition is met\n * @param options - Configuration options\n * @param [options.timeout=5000] - Maximum time to wait in ms\n * @param [options.interval=100] - Polling interval in ms\n * @param [options.signal] - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws Rejects with the abort reason when timed out or cancelled\n */\nexport async function waitFor(\n  condition: (signal: AbortSignal) => boolean | Promise<boolean>,\n  { interval = 100, signal, timeout: ms = 5000 }: WaitForOptions = {},\n): Promise<void> {\n  const deadline = AbortSignal.timeout(ms);\n  const merged = signal ? AbortSignal.any([signal, deadline]) : deadline;\n\n  merged.throwIfAborted();\n\n  while (true) {\n    merged.throwIfAborted();\n\n    if (await condition(merged)) return;\n\n    await sleep(interval, merged);\n  }\n}\n"],"mappings":"+BAmCA,eAAsB,EACpB,EACA,CAAE,WAAW,IAAK,SAAQ,QAAS,EAAK,KAAyB,CAAC,EACnD,CACf,IAAM,EAAW,YAAY,QAAQ,CAAE,EACjC,EAAS,EAAS,YAAY,IAAI,CAAC,EAAQ,CAAQ,CAAC,EAAI,EAI9D,IAFA,EAAO,eAAe,IAET,CAGX,GAFA,EAAO,eAAe,EAElB,MAAM,EAAU,CAAM,EAAG,OAE7B,MAAM,EAAA,MAAM,EAAU,CAAM,CAC9B,CACF"}
+{"version":3,"file":"waitFor.cjs","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["import { sleep } from './sleep';\n\nexport type WaitForOptions = {\n  interval?: number;\n  signal?: AbortSignal;\n  timeout?: number;\n};\n\n/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready with cancellation support\n * await waitFor(\n *   async (signal) => {\n *     const res = await fetch('/api/health', { signal });\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 },\n * );\n * ```\n *\n * @param condition - Polling function that receives the merged AbortSignal and returns true when the condition is met\n * @param options - Configuration options\n * @param [options.timeout=5000] - Maximum time to wait in ms\n * @param [options.interval=100] - Polling interval in ms\n * @param [options.signal] - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws Rejects with the abort reason when timed out or cancelled\n */\nexport async function waitFor(\n  condition: (signal: AbortSignal) => boolean | Promise<boolean>,\n  { interval = 100, signal, timeout: ms = 5000 }: WaitForOptions = {},\n): Promise<void> {\n  const deadline = AbortSignal.timeout(ms);\n  const merged = signal ? AbortSignal.any([signal, deadline]) : deadline;\n\n  merged.throwIfAborted();\n\n  while (true) {\n    merged.throwIfAborted();\n\n    if (await condition(merged)) return;\n\n    await sleep(interval, merged);\n  }\n}\n"],"mappings":"+BAmCA,eAAsB,QACpB,EACA,CAAE,WAAW,IAAK,SAAQ,QAAS,EAAK,KAAyB,CAAC,EACnD,CACf,IAAM,EAAW,YAAY,QAAQ,CAAE,EACjC,EAAS,EAAS,YAAY,IAAI,CAAC,EAAQ,CAAQ,CAAC,EAAI,EAI9D,IAFA,EAAO,eAAe,IAET,CAGX,GAFA,EAAO,eAAe,EAElB,MAAM,EAAU,CAAM,EAAG,OAE7B,MAAM,EAAA,MAAM,EAAU,CAAM,CAC9B,CACF"}

package/dist/async/waitFor.js

@@ -1,13 +1,2 @@
-import { sleep as e } from "./sleep.js";
-//#region src/async/waitFor.ts
-async function t(t, { interval: n = 100, signal: r, timeout: i = 5e3 } = {}) {
-	let a = AbortSignal.timeout(i), o = r ? AbortSignal.any([r, a]) : a;
-	for (o.throwIfAborted();;) {
-		if (o.throwIfAborted(), await t(o)) return;
-		await e(n, o);
-	}
-}
-//#endregion
-export { t as waitFor };
-
+import{sleep as e}from"./sleep.js";async function waitFor(t,{interval:n=100,signal:r,timeout:i=5e3}={}){let a=AbortSignal.timeout(i),o=r?AbortSignal.any([r,a]):a;for(o.throwIfAborted();;){if(o.throwIfAborted(),await t(o))return;await e(n,o)}}export{waitFor};
 //# sourceMappingURL=waitFor.js.map

package/dist/async/waitFor.js.map

@@ -1 +1 @@
-{"version":3,"file":"waitFor.js","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["import { sleep } from './sleep';\n\nexport type WaitForOptions = {\n  interval?: number;\n  signal?: AbortSignal;\n  timeout?: number;\n};\n\n/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready with cancellation support\n * await waitFor(\n *   async (signal) => {\n *     const res = await fetch('/api/health', { signal });\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 },\n * );\n * ```\n *\n * @param condition - Polling function that receives the merged AbortSignal and returns true when the condition is met\n * @param options - Configuration options\n * @param [options.timeout=5000] - Maximum time to wait in ms\n * @param [options.interval=100] - Polling interval in ms\n * @param [options.signal] - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws Rejects with the abort reason when timed out or cancelled\n */\nexport async function waitFor(\n  condition: (signal: AbortSignal) => boolean | Promise<boolean>,\n  { interval = 100, signal, timeout: ms = 5000 }: WaitForOptions = {},\n): Promise<void> {\n  const deadline = AbortSignal.timeout(ms);\n  const merged = signal ? AbortSignal.any([signal, deadline]) : deadline;\n\n  merged.throwIfAborted();\n\n  while (true) {\n    merged.throwIfAborted();\n\n    if (await condition(merged)) return;\n\n    await sleep(interval, merged);\n  }\n}\n"],"mappings":";;AAmCA,eAAsB,EACpB,GACA,EAAE,cAAW,KAAK,WAAQ,SAAS,IAAK,QAAyB,CAAC,GACnD;CACf,IAAM,IAAW,YAAY,QAAQ,CAAE,GACjC,IAAS,IAAS,YAAY,IAAI,CAAC,GAAQ,CAAQ,CAAC,IAAI;CAI9D,KAFA,EAAO,eAAe,KAET;EAGX,IAFA,EAAO,eAAe,GAElB,MAAM,EAAU,CAAM,GAAG;EAE7B,MAAM,EAAM,GAAU,CAAM;CAC9B;AACF"}
+{"version":3,"file":"waitFor.js","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["import { sleep } from './sleep';\n\nexport type WaitForOptions = {\n  interval?: number;\n  signal?: AbortSignal;\n  timeout?: number;\n};\n\n/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready with cancellation support\n * await waitFor(\n *   async (signal) => {\n *     const res = await fetch('/api/health', { signal });\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 },\n * );\n * ```\n *\n * @param condition - Polling function that receives the merged AbortSignal and returns true when the condition is met\n * @param options - Configuration options\n * @param [options.timeout=5000] - Maximum time to wait in ms\n * @param [options.interval=100] - Polling interval in ms\n * @param [options.signal] - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws Rejects with the abort reason when timed out or cancelled\n */\nexport async function waitFor(\n  condition: (signal: AbortSignal) => boolean | Promise<boolean>,\n  { interval = 100, signal, timeout: ms = 5000 }: WaitForOptions = {},\n): Promise<void> {\n  const deadline = AbortSignal.timeout(ms);\n  const merged = signal ? AbortSignal.any([signal, deadline]) : deadline;\n\n  merged.throwIfAborted();\n\n  while (true) {\n    merged.throwIfAborted();\n\n    if (await condition(merged)) return;\n\n    await sleep(interval, merged);\n  }\n}\n"],"mappings":"mCAmCA,eAAsB,QACpB,EACA,CAAE,WAAW,IAAK,SAAQ,QAAS,EAAK,KAAyB,CAAC,EACnD,CACf,IAAM,EAAW,YAAY,QAAQ,CAAE,EACjC,EAAS,EAAS,YAAY,IAAI,CAAC,EAAQ,CAAQ,CAAC,EAAI,EAI9D,IAFA,EAAO,eAAe,IAET,CAGX,GAFA,EAAO,eAAe,EAElB,MAAM,EAAU,CAAM,EAAG,OAE7B,MAAM,EAAM,EAAU,CAAM,CAC9B,CACF"}

package/dist/cache/cache.cjs

@@ -1,2 +1,2 @@
-function e({capacity:e=1/0,now:t=Date.now,ttlMs:n}={}){if(e!==1/0&&(!Number.isInteger(e)||e<1))throw RangeError(`cache: capacity must be a positive integer or Infinity, got ${e}`);let r=new Map,i=new Map,a=new Map,o=0,s=e=>{let t=(a.get(e)??0)+1;return a.set(e,t),t},c=e=>{if(e!==void 0&&e!==1/0){if(!Number.isFinite(e)||e<0)throw RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${e}`);return t()+e}},l=e=>{let n=r.get(e);if(n){if(n.expiresAt!==void 0&&n.expiresAt<=t()){r.delete(e);return}return n.value}},u=()=>{for(let[e,n]of r)n.expiresAt!==void 0&&n.expiresAt<=t()&&r.delete(e);for(;r.size>e;){let e=r.keys().next().value;if(e===void 0)return;r.delete(e)}},d=(e,t,i={})=>{s(e),r.delete(e),r.set(e,{expiresAt:c(i.ttlMs??n),value:t}),u()};return{clear:()=>{o++,r.clear(),i.clear(),a.clear()},delete:e=>(i.delete(e),s(e),r.delete(e)),entries:()=>(u(),[...r].map(([e,t])=>[e,t.value])),get:l,getOrLoad:(e,t)=>{let n=l(e);if(n!==void 0||r.has(e))return Promise.resolve(n);let c=i.get(e);if(c)return c;let u=o,f=s(e),p=t().then(t=>(i.get(e)===p&&i.delete(e),o===u&&a.get(e)===f&&d(e,t),t),t=>{throw i.get(e)===p&&i.delete(e),t});return i.set(e,p),p},set:d,get size(){return r.size}}}exports.cache=e;
+function cache({capacity:e=1/0,now:t=Date.now,ttlMs:n}={}){if(e!==1/0&&(!Number.isInteger(e)||e<1))throw RangeError(`cache: capacity must be a positive integer or Infinity, got ${e}`);let r=new Map,i=new Map,a=new Map,o=0,advanceRevision=e=>{let t=(a.get(e)??0)+1;return a.set(e,t),t},expiresAt=e=>{if(e!==void 0&&e!==1/0){if(!Number.isFinite(e)||e<0)throw RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${e}`);return t()+e}},read=e=>{let n=r.get(e);if(n){if(n.expiresAt!==void 0&&n.expiresAt<=t()){r.delete(e);return}return n.value}},trim=()=>{for(let[e,n]of r)n.expiresAt!==void 0&&n.expiresAt<=t()&&r.delete(e);for(;r.size>e;){let e=r.keys().next().value;if(e===void 0)return;r.delete(e)}},set=(e,t,i={})=>{advanceRevision(e),r.delete(e),r.set(e,{expiresAt:expiresAt(i.ttlMs??n),value:t}),trim()},getOrLoad=(e,t)=>{let n=read(e);if(n!==void 0||r.has(e))return Promise.resolve(n);let s=i.get(e);if(s)return s;let c=o,l=advanceRevision(e),u=t().then(t=>(i.get(e)===u&&i.delete(e),o===c&&a.get(e)===l&&set(e,t),t),t=>{throw i.get(e)===u&&i.delete(e),t});return i.set(e,u),u};return{clear:()=>{o++,r.clear(),i.clear(),a.clear()},delete:e=>(i.delete(e),advanceRevision(e),r.delete(e)),entries:()=>(trim(),[...r].map(([e,t])=>[e,t.value])),get:read,getOrLoad,set,get size(){return r.size}}}exports.cache=cache;
 //# sourceMappingURL=cache.cjs.map

package/dist/cache/cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache.cjs","names":[],"sources":["../../src/cache/cache.ts"],"sourcesContent":["export type CacheOptions = {\n  capacity?: number;\n  now?: () => number;\n  ttlMs?: number;\n};\n\ntype Entry<T> = {\n  expiresAt: number | undefined;\n  value: T;\n};\n\nexport interface Cache<K, T> {\n  clear(): void;\n  delete(key: K): boolean;\n  entries(): ReadonlyArray<readonly [K, T]>;\n  get(key: K): T | undefined;\n  getOrLoad(key: K, load: () => Promise<T>): Promise<T>;\n  set(key: K, value: T, options?: { ttlMs?: number }): void;\n  readonly size: number;\n}\n\nexport function cache<K, T>({ capacity = Infinity, now = Date.now, ttlMs }: CacheOptions = {}): Cache<K, T> {\n  if (capacity !== Infinity && (!Number.isInteger(capacity) || capacity < 1)) {\n    throw new RangeError(`cache: capacity must be a positive integer or Infinity, got ${capacity}`);\n  }\n\n  const entries = new Map<K, Entry<T>>();\n  const pending = new Map<K, Promise<T>>();\n  const revisions = new Map<K, number>();\n  let generation = 0;\n\n  const advanceRevision = (key: K): number => {\n    const revision = (revisions.get(key) ?? 0) + 1;\n\n    revisions.set(key, revision);\n\n    return revision;\n  };\n\n  const expiresAt = (duration: number | undefined): number | undefined => {\n    if (duration === undefined || duration === Infinity) return undefined;\n\n    if (!Number.isFinite(duration) || duration < 0) {\n      throw new RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${duration}`);\n    }\n\n    return now() + duration;\n  };\n\n  const read = (key: K): T | undefined => {\n    const entry = entries.get(key);\n\n    if (!entry) return undefined;\n\n    if (entry.expiresAt !== undefined && entry.expiresAt <= now()) {\n      entries.delete(key);\n\n      return undefined;\n    }\n\n    return entry.value;\n  };\n\n  const trim = (): void => {\n    for (const [key, entry] of entries) {\n      if (entry.expiresAt !== undefined && entry.expiresAt <= now()) entries.delete(key);\n    }\n\n    while (entries.size > capacity) {\n      const oldest = entries.keys().next().value;\n\n      if (oldest === undefined) return;\n\n      entries.delete(oldest);\n    }\n  };\n\n  const set = (key: K, value: T, options: { ttlMs?: number } = {}): void => {\n    advanceRevision(key);\n    entries.delete(key);\n    entries.set(key, { expiresAt: expiresAt(options.ttlMs ?? ttlMs), value });\n    trim();\n  };\n\n  const getOrLoad = (key: K, load: () => Promise<T>): Promise<T> => {\n    const cached = read(key);\n\n    if (cached !== undefined || entries.has(key)) return Promise.resolve(cached as T);\n\n    const existing = pending.get(key);\n\n    if (existing) return existing;\n\n    const capturedGeneration = generation;\n    const capturedRevision = advanceRevision(key);\n    const result = load().then(\n      (value) => {\n        if (pending.get(key) === result) pending.delete(key);\n\n        if (generation === capturedGeneration && revisions.get(key) === capturedRevision) {\n          set(key, value);\n        }\n\n        return value;\n      },\n      (error: unknown) => {\n        if (pending.get(key) === result) pending.delete(key);\n\n        throw error;\n      },\n    );\n\n    pending.set(key, result);\n\n    return result;\n  };\n\n  return {\n    clear: () => {\n      generation++;\n      entries.clear();\n      pending.clear();\n      revisions.clear();\n    },\n    delete: (key) => {\n      pending.delete(key);\n      advanceRevision(key);\n\n      return entries.delete(key);\n    },\n    entries: () => {\n      trim();\n      return [...entries].map(([key, entry]) => [key, entry.value] as const);\n    },\n    get: read,\n    getOrLoad,\n    set,\n    get size() {\n      return entries.size;\n    },\n  };\n}\n"],"mappings":"AAqBA,SAAgB,EAAY,CAAE,WAAW,IAAU,MAAM,KAAK,IAAK,SAAwB,CAAC,EAAgB,CAC1G,GAAI,IAAa,MAAa,CAAC,OAAO,UAAU,CAAQ,GAAK,EAAW,GACtE,MAAU,WAAW,+DAA+D,GAAU,EAGhG,IAAM,EAAU,IAAI,IACd,EAAU,IAAI,IACd,EAAY,IAAI,IAClB,EAAa,EAEX,EAAmB,GAAmB,CAC1C,IAAM,GAAY,EAAU,IAAI,CAAG,GAAK,GAAK,EAI7C,OAFA,EAAU,IAAI,EAAK,CAAQ,EAEpB,CACT,EAEM,EAAa,GAAqD,CAClE,OAAa,IAAA,IAAa,IAAa,IAE3C,IAAI,CAAC,OAAO,SAAS,CAAQ,GAAK,EAAW,EAC3C,MAAU,WAAW,sEAAsE,GAAU,EAGvG,OAAO,EAAI,EAAI,CAHwF,CAIzG,EAEM,EAAQ,GAA0B,CACtC,IAAM,EAAQ,EAAQ,IAAI,CAAG,EAExB,KAEL,IAAI,EAAM,YAAc,IAAA,IAAa,EAAM,WAAa,EAAI,EAAG,CAC7D,EAAQ,OAAO,CAAG,EAElB,MACF,CAEA,OAAO,EAAM,KAFb,CAGF,EAEM,MAAmB,CACvB,IAAK,GAAM,CAAC,EAAK,KAAU,EACrB,EAAM,YAAc,IAAA,IAAa,EAAM,WAAa,EAAI,GAAG,EAAQ,OAAO,CAAG,EAGnF,KAAO,EAAQ,KAAO,GAAU,CAC9B,IAAM,EAAS,EAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,MAErC,GAAI,IAAW,IAAA,GAAW,OAE1B,EAAQ,OAAO,CAAM,CACvB,CACF,EAEM,GAAO,EAAQ,EAAU,EAA8B,CAAC,IAAY,CACxE,EAAgB,CAAG,EACnB,EAAQ,OAAO,CAAG,EAClB,EAAQ,IAAI,EAAK,CAAE,UAAW,EAAU,EAAQ,OAAS,CAAK,EAAG,OAAM,CAAC,EACxE,EAAK,CACP,EAmCA,MAAO,CACL,UAAa,CACX,IACA,EAAQ,MAAM,EACd,EAAQ,MAAM,EACd,EAAU,MAAM,CAClB,EACA,OAAS,IACP,EAAQ,OAAO,CAAG,EAClB,EAAgB,CAAG,EAEZ,EAAQ,OAAO,CAAG,GAE3B,aACE,EAAK,EACE,CAAC,GAAG,CAAO,CAAC,CAAC,KAAK,CAAC,EAAK,KAAW,CAAC,EAAK,EAAM,KAAK,CAAU,GAEvE,IAAK,EACL,WAnDiB,EAAQ,IAAuC,CAChE,IAAM,EAAS,EAAK,CAAG,EAEvB,GAAI,IAAW,IAAA,IAAa,EAAQ,IAAI,CAAG,EAAG,OAAO,QAAQ,QAAQ,CAAW,EAEhF,IAAM,EAAW,EAAQ,IAAI,CAAG,EAEhC,GAAI,EAAU,OAAO,EAErB,IAAM,EAAqB,EACrB,EAAmB,EAAgB,CAAG,EACtC,EAAS,EAAK,CAAC,CAAC,KACnB,IACK,EAAQ,IAAI,CAAG,IAAM,GAAQ,EAAQ,OAAO,CAAG,EAE/C,IAAe,GAAsB,EAAU,IAAI,CAAG,IAAM,GAC9D,EAAI,EAAK,CAAK,EAGT,GAER,GAAmB,CAGlB,MAFI,EAAQ,IAAI,CAAG,IAAM,GAAQ,EAAQ,OAAO,CAAG,EAE7C,CACR,CACF,EAIA,OAFA,EAAQ,IAAI,EAAK,CAAM,EAEhB,CACT,EAqBE,MACA,IAAI,MAAO,CACT,OAAO,EAAQ,IACjB,CACF,CACF"}
+{"version":3,"file":"cache.cjs","names":[],"sources":["../../src/cache/cache.ts"],"sourcesContent":["export type CacheOptions = {\n  capacity?: number;\n  now?: () => number;\n  ttlMs?: number;\n};\n\ntype Entry<T> = {\n  expiresAt: number | undefined;\n  value: T;\n};\n\nexport interface Cache<K, T> {\n  clear(): void;\n  delete(key: K): boolean;\n  entries(): ReadonlyArray<readonly [K, T]>;\n  get(key: K): T | undefined;\n  getOrLoad(key: K, load: () => Promise<T>): Promise<T>;\n  set(key: K, value: T, options?: { ttlMs?: number }): void;\n  readonly size: number;\n}\n\nexport function cache<K, T>({ capacity = Infinity, now = Date.now, ttlMs }: CacheOptions = {}): Cache<K, T> {\n  if (capacity !== Infinity && (!Number.isInteger(capacity) || capacity < 1)) {\n    throw new RangeError(`cache: capacity must be a positive integer or Infinity, got ${capacity}`);\n  }\n\n  const entries = new Map<K, Entry<T>>();\n  const pending = new Map<K, Promise<T>>();\n  const revisions = new Map<K, number>();\n  let generation = 0;\n\n  const advanceRevision = (key: K): number => {\n    const revision = (revisions.get(key) ?? 0) + 1;\n\n    revisions.set(key, revision);\n\n    return revision;\n  };\n\n  const expiresAt = (duration: number | undefined): number | undefined => {\n    if (duration === undefined || duration === Infinity) return undefined;\n\n    if (!Number.isFinite(duration) || duration < 0) {\n      throw new RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${duration}`);\n    }\n\n    return now() + duration;\n  };\n\n  const read = (key: K): T | undefined => {\n    const entry = entries.get(key);\n\n    if (!entry) return undefined;\n\n    if (entry.expiresAt !== undefined && entry.expiresAt <= now()) {\n      entries.delete(key);\n\n      return undefined;\n    }\n\n    return entry.value;\n  };\n\n  const trim = (): void => {\n    for (const [key, entry] of entries) {\n      if (entry.expiresAt !== undefined && entry.expiresAt <= now()) entries.delete(key);\n    }\n\n    while (entries.size > capacity) {\n      const oldest = entries.keys().next().value;\n\n      if (oldest === undefined) return;\n\n      entries.delete(oldest);\n    }\n  };\n\n  const set = (key: K, value: T, options: { ttlMs?: number } = {}): void => {\n    advanceRevision(key);\n    entries.delete(key);\n    entries.set(key, { expiresAt: expiresAt(options.ttlMs ?? ttlMs), value });\n    trim();\n  };\n\n  const getOrLoad = (key: K, load: () => Promise<T>): Promise<T> => {\n    const cached = read(key);\n\n    if (cached !== undefined || entries.has(key)) return Promise.resolve(cached as T);\n\n    const existing = pending.get(key);\n\n    if (existing) return existing;\n\n    const capturedGeneration = generation;\n    const capturedRevision = advanceRevision(key);\n    const result = load().then(\n      (value) => {\n        if (pending.get(key) === result) pending.delete(key);\n\n        if (generation === capturedGeneration && revisions.get(key) === capturedRevision) {\n          set(key, value);\n        }\n\n        return value;\n      },\n      (error: unknown) => {\n        if (pending.get(key) === result) pending.delete(key);\n\n        throw error;\n      },\n    );\n\n    pending.set(key, result);\n\n    return result;\n  };\n\n  return {\n    clear: () => {\n      generation++;\n      entries.clear();\n      pending.clear();\n      revisions.clear();\n    },\n    delete: (key) => {\n      pending.delete(key);\n      advanceRevision(key);\n\n      return entries.delete(key);\n    },\n    entries: () => {\n      trim();\n      return [...entries].map(([key, entry]) => [key, entry.value] as const);\n    },\n    get: read,\n    getOrLoad,\n    set,\n    get size() {\n      return entries.size;\n    },\n  };\n}\n"],"mappings":"AAqBA,SAAgB,MAAY,CAAE,WAAW,IAAU,MAAM,KAAK,IAAK,SAAwB,CAAC,EAAgB,CAC1G,GAAI,IAAa,MAAa,CAAC,OAAO,UAAU,CAAQ,GAAK,EAAW,GACtE,MAAU,WAAW,+DAA+D,GAAU,EAGhG,IAAM,EAAU,IAAI,IACd,EAAU,IAAI,IACd,EAAY,IAAI,IAClB,EAAa,EAEX,gBAAmB,GAAmB,CAC1C,IAAM,GAAY,EAAU,IAAI,CAAG,GAAK,GAAK,EAI7C,OAFA,EAAU,IAAI,EAAK,CAAQ,EAEpB,CACT,EAEM,UAAa,GAAqD,CAClE,OAAa,IAAA,IAAa,IAAa,IAE3C,IAAI,CAAC,OAAO,SAAS,CAAQ,GAAK,EAAW,EAC3C,MAAU,WAAW,sEAAsE,GAAU,EAGvG,OAAO,EAAI,EAAI,CAHwF,CAIzG,EAEM,KAAQ,GAA0B,CACtC,IAAM,EAAQ,EAAQ,IAAI,CAAG,EAExB,KAEL,IAAI,EAAM,YAAc,IAAA,IAAa,EAAM,WAAa,EAAI,EAAG,CAC7D,EAAQ,OAAO,CAAG,EAElB,MACF,CAEA,OAAO,EAAM,KAFb,CAGF,EAEM,SAAmB,CACvB,IAAK,GAAM,CAAC,EAAK,KAAU,EACrB,EAAM,YAAc,IAAA,IAAa,EAAM,WAAa,EAAI,GAAG,EAAQ,OAAO,CAAG,EAGnF,KAAO,EAAQ,KAAO,GAAU,CAC9B,IAAM,EAAS,EAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,MAErC,GAAI,IAAW,IAAA,GAAW,OAE1B,EAAQ,OAAO,CAAM,CACvB,CACF,EAEM,KAAO,EAAQ,EAAU,EAA8B,CAAC,IAAY,CACxE,gBAAgB,CAAG,EACnB,EAAQ,OAAO,CAAG,EAClB,EAAQ,IAAI,EAAK,CAAE,UAAW,UAAU,EAAQ,OAAS,CAAK,EAAG,OAAM,CAAC,EACxE,KAAK,CACP,EAEM,WAAa,EAAQ,IAAuC,CAChE,IAAM,EAAS,KAAK,CAAG,EAEvB,GAAI,IAAW,IAAA,IAAa,EAAQ,IAAI,CAAG,EAAG,OAAO,QAAQ,QAAQ,CAAW,EAEhF,IAAM,EAAW,EAAQ,IAAI,CAAG,EAEhC,GAAI,EAAU,OAAO,EAErB,IAAM,EAAqB,EACrB,EAAmB,gBAAgB,CAAG,EACtC,EAAS,EAAK,CAAC,CAAC,KACnB,IACK,EAAQ,IAAI,CAAG,IAAM,GAAQ,EAAQ,OAAO,CAAG,EAE/C,IAAe,GAAsB,EAAU,IAAI,CAAG,IAAM,GAC9D,IAAI,EAAK,CAAK,EAGT,GAER,GAAmB,CAGlB,MAFI,EAAQ,IAAI,CAAG,IAAM,GAAQ,EAAQ,OAAO,CAAG,EAE7C,CACR,CACF,EAIA,OAFA,EAAQ,IAAI,EAAK,CAAM,EAEhB,CACT,EAEA,MAAO,CACL,UAAa,CACX,IACA,EAAQ,MAAM,EACd,EAAQ,MAAM,EACd,EAAU,MAAM,CAClB,EACA,OAAS,IACP,EAAQ,OAAO,CAAG,EAClB,gBAAgB,CAAG,EAEZ,EAAQ,OAAO,CAAG,GAE3B,aACE,KAAK,EACE,CAAC,GAAG,CAAO,CAAC,CAAC,KAAK,CAAC,EAAK,KAAW,CAAC,EAAK,EAAM,KAAK,CAAU,GAEvE,IAAK,KACL,UACA,IACA,IAAI,MAAO,CACT,OAAO,EAAQ,IACjB,CACF,CACF"}

package/dist/cache/cache.js

@@ -1,60 +1,2 @@
-//#region src/cache/cache.ts
-function e({ capacity: e = Infinity, now: t = Date.now, ttlMs: n } = {}) {
-	if (e !== Infinity && (!Number.isInteger(e) || e < 1)) throw RangeError(`cache: capacity must be a positive integer or Infinity, got ${e}`);
-	let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = 0, s = (e) => {
-		let t = (a.get(e) ?? 0) + 1;
-		return a.set(e, t), t;
-	}, c = (e) => {
-		if (e !== void 0 && e !== Infinity) {
-			if (!Number.isFinite(e) || e < 0) throw RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${e}`);
-			return t() + e;
-		}
-	}, l = (e) => {
-		let n = r.get(e);
-		if (n) {
-			if (n.expiresAt !== void 0 && n.expiresAt <= t()) {
-				r.delete(e);
-				return;
-			}
-			return n.value;
-		}
-	}, u = () => {
-		for (let [e, n] of r) n.expiresAt !== void 0 && n.expiresAt <= t() && r.delete(e);
-		for (; r.size > e;) {
-			let e = r.keys().next().value;
-			if (e === void 0) return;
-			r.delete(e);
-		}
-	}, d = (e, t, i = {}) => {
-		s(e), r.delete(e), r.set(e, {
-			expiresAt: c(i.ttlMs ?? n),
-			value: t
-		}), u();
-	};
-	return {
-		clear: () => {
-			o++, r.clear(), i.clear(), a.clear();
-		},
-		delete: (e) => (i.delete(e), s(e), r.delete(e)),
-		entries: () => (u(), [...r].map(([e, t]) => [e, t.value])),
-		get: l,
-		getOrLoad: (e, t) => {
-			let n = l(e);
-			if (n !== void 0 || r.has(e)) return Promise.resolve(n);
-			let c = i.get(e);
-			if (c) return c;
-			let u = o, f = s(e), p = t().then((t) => (i.get(e) === p && i.delete(e), o === u && a.get(e) === f && d(e, t), t), (t) => {
-				throw i.get(e) === p && i.delete(e), t;
-			});
-			return i.set(e, p), p;
-		},
-		set: d,
-		get size() {
-			return r.size;
-		}
-	};
-}
-//#endregion
-export { e as cache };
-
+function cache({capacity:e=1/0,now:t=Date.now,ttlMs:n}={}){if(e!==1/0&&(!Number.isInteger(e)||e<1))throw RangeError(`cache: capacity must be a positive integer or Infinity, got ${e}`);let r=new Map,i=new Map,a=new Map,o=0,advanceRevision=e=>{let t=(a.get(e)??0)+1;return a.set(e,t),t},expiresAt=e=>{if(e!==void 0&&e!==1/0){if(!Number.isFinite(e)||e<0)throw RangeError(`cache: ttlMs must be a non-negative finite number or Infinity, got ${e}`);return t()+e}},read=e=>{let n=r.get(e);if(n){if(n.expiresAt!==void 0&&n.expiresAt<=t()){r.delete(e);return}return n.value}},trim=()=>{for(let[e,n]of r)n.expiresAt!==void 0&&n.expiresAt<=t()&&r.delete(e);for(;r.size>e;){let e=r.keys().next().value;if(e===void 0)return;r.delete(e)}},set=(e,t,i={})=>{advanceRevision(e),r.delete(e),r.set(e,{expiresAt:expiresAt(i.ttlMs??n),value:t}),trim()},getOrLoad=(e,t)=>{let n=read(e);if(n!==void 0||r.has(e))return Promise.resolve(n);let s=i.get(e);if(s)return s;let c=o,l=advanceRevision(e),u=t().then(t=>(i.get(e)===u&&i.delete(e),o===c&&a.get(e)===l&&set(e,t),t),t=>{throw i.get(e)===u&&i.delete(e),t});return i.set(e,u),u};return{clear:()=>{o++,r.clear(),i.clear(),a.clear()},delete:e=>(i.delete(e),advanceRevision(e),r.delete(e)),entries:()=>(trim(),[...r].map(([e,t])=>[e,t.value])),get:read,getOrLoad,set,get size(){return r.size}}}export{cache};
 //# sourceMappingURL=cache.js.map