@vielzeug/arsenal 1.1.2 → 2.0.0

package/dist/async/attempt.cjs

@@ -1,2 +1,2 @@
-function e(e){return e.ok===!0}function t(e){return e.ok===!1}function n(e){try{let t=e();return typeof t?.then==`function`?t.then(e=>({ok:!0,value:e}),e=>({error:e,ok:!1})):{ok:!0,value:t}}catch(e){return{error:e,ok:!1}}}exports.attempt=n,exports.isFail=t,exports.isOk=e;
+function e(e){return e.ok===!0}function t(e){return e.ok===!1}async function n(e){try{return{ok:!0,value:await e()}}catch(e){return{error:e,ok:!1}}}exports.attempt=n,exports.isFail=t,exports.isOk=e;
 //# sourceMappingURL=attempt.cjs.map

package/dist/async/attempt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.cjs","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["export type AttemptResult<T> =\n  | { ok: true; value: T }\n  // eslint-disable-next-line perfectionist/sort-object-types\n  | { ok: false; error: unknown };\n\n/**\n * Narrows an `AttemptResult` to the success branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isOk(result)) console.log(result.value);\n * ```\n */\n\nexport function isOk<T>(result: AttemptResult<T>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Narrows an `AttemptResult` to the failure branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isFail(result)) console.error(result.error);\n * ```\n */\n// eslint-disable-next-line perfectionist/sort-object-types\nexport function isFail<T>(result: AttemptResult<T>): result is { ok: false; error: unknown } {\n  return result.ok === false;\n}\n\n/**\n * Executes a function — sync or async — and returns an `AttemptResult` (or\n * `Promise<AttemptResult>` for async factories). Never throws.\n *\n * TypeScript infers the return type from the factory:\n * - sync factory → `AttemptResult<T>`\n * - async factory → `Promise<AttemptResult<T>>`\n *\n * @example\n * ```ts\n * // Sync\n * const parsed = attempt(() => JSON.parse(rawJson));\n * if (parsed.ok) console.log(parsed.value);\n * else console.error(parsed.error);\n *\n * // Async\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (result.ok) console.log(result.value);\n * else console.error(result.error);\n *\n * // Combined with retry()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n */\nexport function attempt<T>(fn: () => Promise<T>): Promise<AttemptResult<T>>;\nexport function attempt<T>(fn: () => T): AttemptResult<T>;\nexport function attempt<T>(fn: () => T | Promise<T>): AttemptResult<T> | Promise<AttemptResult<T>> {\n  try {\n    const result = fn();\n\n    if (typeof (result as PromiseLike<T>)?.then === 'function') {\n      return (result as Promise<T>).then(\n        (value) => ({ ok: true as const, value }),\n        (error) => ({ error, ok: false as const }),\n      );\n    }\n\n    return { ok: true, value: result as T };\n  } catch (error) {\n    return { error, ok: false };\n  }\n}\n"],"mappings":"AAcA,SAAgB,EAAQ,EAA4D,CAClF,OAAO,EAAO,KAAO,EACvB,CAWA,SAAgB,EAAU,EAAmE,CAC3F,OAAO,EAAO,KAAO,EACvB,CA4BA,SAAgB,EAAW,EAAwE,CACjG,GAAI,CACF,IAAM,EAAS,EAAG,EASlB,OAPI,OAAQ,GAA2B,MAAS,WACtC,EAAsB,KAC3B,IAAW,CAAE,GAAI,GAAe,OAAM,GACtC,IAAW,CAAE,QAAO,GAAI,EAAe,EAC1C,EAGK,CAAE,GAAI,GAAM,MAAO,CAAY,CACxC,OAAS,EAAO,CACd,MAAO,CAAE,QAAO,GAAI,EAAM,CAC5B,CACF"}
+{"version":3,"file":"attempt.cjs","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["export type AttemptResult<T> =\n  | { ok: true; value: T }\n  // eslint-disable-next-line perfectionist/sort-object-types\n  | { ok: false; error: unknown };\n\n/**\n * Narrows an `AttemptResult` to the success branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isOk(result)) console.log(result.value);\n * ```\n */\n\nexport function isOk<T>(result: AttemptResult<T>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Narrows an `AttemptResult` to the failure branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isFail(result)) console.error(result.error);\n * ```\n */\n// eslint-disable-next-line perfectionist/sort-object-types\nexport function isFail<T>(result: AttemptResult<T>): result is { ok: false; error: unknown } {\n  return result.ok === false;\n}\n\n/**\n * Executes a function — sync or async — and resolves to an `AttemptResult`.\n * Never throws.\n *\n * @example\n * ```ts\n * // Sync\n * const parsed = attempt(() => JSON.parse(rawJson));\n * if (parsed.ok) console.log(parsed.value);\n * else console.error(parsed.error);\n *\n * // Async\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (result.ok) console.log(result.value);\n * else console.error(result.error);\n *\n * // Combined with retry()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n */\nexport async function attempt<T>(fn: () => T | Promise<T>): Promise<AttemptResult<T>> {\n  try {\n    return { ok: true, value: await fn() };\n  } catch (error) {\n    return { error, ok: false };\n  }\n}\n"],"mappings":"AAcA,SAAgB,EAAQ,EAA4D,CAClF,OAAO,EAAO,KAAO,EACvB,CAWA,SAAgB,EAAU,EAAmE,CAC3F,OAAO,EAAO,KAAO,EACvB,CAsBA,eAAsB,EAAW,EAAqD,CACpF,GAAI,CACF,MAAO,CAAE,GAAI,GAAM,MAAO,MAAM,EAAG,CAAE,CACvC,OAAS,EAAO,CACd,MAAO,CAAE,QAAO,GAAI,EAAM,CAC5B,CACF"}

package/dist/async/attempt.d.ts

@@ -30,12 +30,8 @@ export declare function isFail<T>(result: AttemptResult<T>): result is {
     error: unknown;
 };
 /**
- * Executes a function — sync or async — and returns an `AttemptResult` (or
- * `Promise<AttemptResult>` for async factories). Never throws.
- *
- * TypeScript infers the return type from the factory:
- * - sync factory → `AttemptResult<T>`
- * - async factory → `Promise<AttemptResult<T>>`
+ * Executes a function — sync or async — and resolves to an `AttemptResult`.
+ * Never throws.
  *
  * @example
  * ```ts
@@ -53,6 +49,5 @@ export declare function isFail<T>(result: AttemptResult<T>): result is {
  * const result = await attempt(() => retry(fn, { times: 3 }));
  * ```
  */
-export declare function attempt<T>(fn: () => Promise<T>): Promise<AttemptResult<T>>;
-export declare function attempt<T>(fn: () => T): AttemptResult<T>;
+export declare function attempt<T>(fn: () => T | Promise<T>): Promise<AttemptResult<T>>;
 //# sourceMappingURL=attempt.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/async/attempt.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CAAC,CAAC,IACvB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAEtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAElC;;;;;;;GAOG;AAEH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAElF;AAED;;;;;;;GAOG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAE3F;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5E,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/async/attempt.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CAAC,CAAC,IACvB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAEtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAElC;;;;;;;GAOG;AAEH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAElF;AAED;;;;;;;GAOG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAE3F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAMpF"}

package/dist/async/attempt.js

@@ -5,18 +5,11 @@ function e(e) {
 function t(e) {
 	return e.ok === !1;
 }
-function n(e) {
+async function n(e) {
 	try {
-		let t = e();
-		return typeof t?.then == "function" ? t.then((e) => ({
-			ok: !0,
-			value: e
-		}), (e) => ({
-			error: e,
-			ok: !1
-		})) : {
+		return {
 			ok: !0,
-			value: t
+			value: await e()
 		};
 	} catch (e) {
 		return {

package/dist/async/attempt.js.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.js","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["export type AttemptResult<T> =\n  | { ok: true; value: T }\n  // eslint-disable-next-line perfectionist/sort-object-types\n  | { ok: false; error: unknown };\n\n/**\n * Narrows an `AttemptResult` to the success branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isOk(result)) console.log(result.value);\n * ```\n */\n\nexport function isOk<T>(result: AttemptResult<T>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Narrows an `AttemptResult` to the failure branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isFail(result)) console.error(result.error);\n * ```\n */\n// eslint-disable-next-line perfectionist/sort-object-types\nexport function isFail<T>(result: AttemptResult<T>): result is { ok: false; error: unknown } {\n  return result.ok === false;\n}\n\n/**\n * Executes a function — sync or async — and returns an `AttemptResult` (or\n * `Promise<AttemptResult>` for async factories). Never throws.\n *\n * TypeScript infers the return type from the factory:\n * - sync factory → `AttemptResult<T>`\n * - async factory → `Promise<AttemptResult<T>>`\n *\n * @example\n * ```ts\n * // Sync\n * const parsed = attempt(() => JSON.parse(rawJson));\n * if (parsed.ok) console.log(parsed.value);\n * else console.error(parsed.error);\n *\n * // Async\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (result.ok) console.log(result.value);\n * else console.error(result.error);\n *\n * // Combined with retry()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n */\nexport function attempt<T>(fn: () => Promise<T>): Promise<AttemptResult<T>>;\nexport function attempt<T>(fn: () => T): AttemptResult<T>;\nexport function attempt<T>(fn: () => T | Promise<T>): AttemptResult<T> | Promise<AttemptResult<T>> {\n  try {\n    const result = fn();\n\n    if (typeof (result as PromiseLike<T>)?.then === 'function') {\n      return (result as Promise<T>).then(\n        (value) => ({ ok: true as const, value }),\n        (error) => ({ error, ok: false as const }),\n      );\n    }\n\n    return { ok: true, value: result as T };\n  } catch (error) {\n    return { error, ok: false };\n  }\n}\n"],"mappings":";AAcA,SAAgB,EAAQ,GAA4D;CAClF,OAAO,EAAO,OAAO;AACvB;AAWA,SAAgB,EAAU,GAAmE;CAC3F,OAAO,EAAO,OAAO;AACvB;AA4BA,SAAgB,EAAW,GAAwE;CACjG,IAAI;EACF,IAAM,IAAS,EAAG;EASlB,OAPI,OAAQ,GAA2B,QAAS,aACtC,EAAsB,MAC3B,OAAW;GAAE,IAAI;GAAe;EAAM,KACtC,OAAW;GAAE;GAAO,IAAI;EAAe,EAC1C,IAGK;GAAE,IAAI;GAAM,OAAO;EAAY;CACxC,SAAS,GAAO;EACd,OAAO;GAAE;GAAO,IAAI;EAAM;CAC5B;AACF"}
+{"version":3,"file":"attempt.js","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["export type AttemptResult<T> =\n  | { ok: true; value: T }\n  // eslint-disable-next-line perfectionist/sort-object-types\n  | { ok: false; error: unknown };\n\n/**\n * Narrows an `AttemptResult` to the success branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isOk(result)) console.log(result.value);\n * ```\n */\n\nexport function isOk<T>(result: AttemptResult<T>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Narrows an `AttemptResult` to the failure branch.\n * @example\n * ```ts\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (isFail(result)) console.error(result.error);\n * ```\n */\n// eslint-disable-next-line perfectionist/sort-object-types\nexport function isFail<T>(result: AttemptResult<T>): result is { ok: false; error: unknown } {\n  return result.ok === false;\n}\n\n/**\n * Executes a function — sync or async — and resolves to an `AttemptResult`.\n * Never throws.\n *\n * @example\n * ```ts\n * // Sync\n * const parsed = attempt(() => JSON.parse(rawJson));\n * if (parsed.ok) console.log(parsed.value);\n * else console.error(parsed.error);\n *\n * // Async\n * const result = await attempt(() => fetch('/api').then(r => r.json()));\n * if (result.ok) console.log(result.value);\n * else console.error(result.error);\n *\n * // Combined with retry()\n * const result = await attempt(() => retry(fn, { times: 3 }));\n * ```\n */\nexport async function attempt<T>(fn: () => T | Promise<T>): Promise<AttemptResult<T>> {\n  try {\n    return { ok: true, value: await fn() };\n  } catch (error) {\n    return { error, ok: false };\n  }\n}\n"],"mappings":";AAcA,SAAgB,EAAQ,GAA4D;CAClF,OAAO,EAAO,OAAO;AACvB;AAWA,SAAgB,EAAU,GAAmE;CAC3F,OAAO,EAAO,OAAO;AACvB;AAsBA,eAAsB,EAAW,GAAqD;CACpF,IAAI;EACF,OAAO;GAAE,IAAI;GAAM,OAAO,MAAM,EAAG;EAAE;CACvC,SAAS,GAAO;EACd,OAAO;GAAE;GAAO,IAAI;EAAM;CAC5B;AACF"}

package/dist/async/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./abortError.cjs"),t=require("./attempt.cjs"),n=require("./backoff.cjs"),r=require("./parallel.cjs"),i=require("./sleep.cjs"),a=require("./retry.cjs"),o=require("./taskPool.cjs"),s=require("./waitFor.cjs");exports.abortError=e.abortError,exports.attempt=t.attempt,exports.backoff=n.backoff,exports.isFail=t.isFail,exports.isOk=t.isOk,exports.parallel=r.parallel,exports.retry=a.retry,exports.sleep=i.sleep,exports.taskPool=o.taskPool,exports.waitFor=s.waitFor;

package/dist/async/index.d.ts

@@ -2,8 +2,8 @@ export * from './abortError';
 export * from './attempt';
 export * from './backoff';
 export * from './parallel';
-export * from './queue';
 export * from './retry';
 export * from './sleep';
+export * from './taskPool';
 export * from './waitFor';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/async/index.js

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

package/dist/async/parallel.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs"),t=require("./abortError.cjs");async function n(n,r,i={}){let{abortOnError:a=!1,limit:o=1/0,signal:s}=i;if(o<1)throw new e.ArsenalValidationError(`parallel: limit must be at least 1, got ${o}`);if(s?.aborted)throw t.abortError(s);if(n.length===0)return[];let c=Array(n.length),l=0,u=a?new AbortController:void 0,d=async()=>{for(;;){if(s?.aborted)throw t.abortError(s);if(u?.signal.aborted||l>=n.length)return;let e=l++;try{c[e]=await r(n[e],e,n)}catch(e){throw u?.abort(),e}}},f=Math.min(o,n.length),p=Array.from({length:f},()=>d());return await Promise.all(p),c}exports.parallel=n;
+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;
 //# 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 { ArsenalValidationError } from '../errors';\nimport { 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 {ArsenalValidationError} 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 ArsenalValidationError(`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":"+DAuCA,eAAsB,EACpB,EACA,EACA,EAA4E,CAAC,EAC/D,CACd,GAAM,CAAE,eAAe,GAAO,QAAQ,IAAU,UAAW,EAE3D,GAAI,EAAQ,EACV,MAAM,IAAI,EAAA,uBAAuB,2CAA2C,GAAO,EAGrF,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,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"}

package/dist/async/parallel.d.ts

@@ -31,7 +31,7 @@
  *   callback throws, instead of letting them keep running to completion unobserved. Default
  *   preserves the existing best-effort-completion behavior.
  * @returns Promise resolving to an ordered array of results
- * @throws {ArsenalValidationError} If limit is less than 1
+ * @throws {RangeError} If limit is less than 1
  * @throws {DOMException} If aborted via signal
  */
 export declare function parallel<T, R>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<R> | R, options?: {

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

@@ -1 +1 @@
-{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/async/parallel.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EACzE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GAC7E,OAAO,CAAC,CAAC,EAAE,CAAC,CAkDd"}
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/async/parallel.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EACzE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GAC7E,OAAO,CAAC,CAAC,EAAE,CAAC,CAkDd"}

package/dist/async/parallel.js

@@ -1,26 +1,25 @@
-import { ArsenalValidationError as e } from "../errors.js";
-import { abortError as t } from "./abortError.js";
+import { abortError as e } from "./abortError.js";
 //#region src/async/parallel.ts
-async function n(n, r, i = {}) {
-	let { abortOnError: a = !1, limit: o = Infinity, signal: s } = i;
-	if (o < 1) throw new e(`parallel: limit must be at least 1, got ${o}`);
-	if (s?.aborted) throw t(s);
-	if (n.length === 0) return [];
-	let c = Array(n.length), l = 0, u = a ? new AbortController() : void 0, d = async () => {
+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 (s?.aborted) throw t(s);
-			if (u?.signal.aborted || l >= n.length) return;
-			let e = l++;
+			if (o?.aborted) throw e(o);
+			if (l?.signal.aborted || c >= t.length) return;
+			let r = c++;
 			try {
-				c[e] = await r(n[e], e, n);
+				s[r] = await n(t[r], r, t);
 			} catch (e) {
-				throw u?.abort(), e;
+				throw l?.abort(), e;
 			}
 		}
-	}, f = Math.min(o, n.length), p = Array.from({ length: f }, () => d());
-	return await Promise.all(p), c;
+	}, d = Math.min(a, t.length), f = Array.from({ length: d }, () => u());
+	return await Promise.all(f), s;
 }
 //#endregion
-export { n as parallel };
+export { t as 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 { ArsenalValidationError } from '../errors';\nimport { 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 {ArsenalValidationError} 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 ArsenalValidationError(`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":";;;AAuCA,eAAsB,EACpB,GACA,GACA,IAA4E,CAAC,GAC/D;CACd,IAAM,EAAE,kBAAe,IAAO,WAAQ,UAAU,cAAW;CAE3D,IAAI,IAAQ,GACV,MAAM,IAAI,EAAuB,2CAA2C,GAAO;CAGrF,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":";;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"}

package/dist/async/retry.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs"),t=require("./abortError.cjs"),n=require("./sleep.cjs");function r(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 i(i,{delay:a=250,onError:o,shouldRetry:s,signal:c,timeout:l,times:u=3}={}){if(!Number.isInteger(u)||u<1)throw new e.ArsenalValidationError(`retry: times must be a positive integer, got ${u}`);for(let e=1;e<=u;e++){if(c?.aborted)throw t.abortError(c);let d=r(l,c);try{return await i(d)}catch(t){if(e===u||s&&!s(t,e-1))throw o?.(t),t;let r=typeof a==`function`?a(e-1):a;r>0&&await n.sleep(r,c)}}}exports.retry=i;
+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;
 //# 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 { ArsenalValidationError } from '../errors';\nimport { 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 {ArsenalValidationError} 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 ArsenalValidationError(`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":"wFAaA,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,MAAM,IAAI,EAAA,uBAAuB,gDAAgD,GAAO,EAG1F,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  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"}

package/dist/async/retry.d.ts

@@ -39,7 +39,7 @@ export type RetryOptions = {
  * @param [options.onError] - Called with the last error before rethrowing — both on final attempt exhaustion
  *   and when `shouldRetry` returns `false` to abort early.
  * @returns The resolved value.
- * @throws {ArsenalValidationError} If `times` is not a positive integer.
+ * @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>;

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

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/async/retry.ts"],"names":[],"mappings":"AAIA,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,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"}

package/dist/async/retry.js

@@ -1,26 +1,25 @@
-import { ArsenalValidationError as e } from "../errors.js";
-import { abortError as t } from "./abortError.js";
-import { sleep as n } from "./sleep.js";
+import { abortError as e } from "./abortError.js";
+import { sleep as t } from "./sleep.js";
 //#region src/async/retry.ts
-function r(e, t) {
+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 i(i, { delay: a = 250, onError: o, shouldRetry: s, signal: c, timeout: l, times: u = 3 } = {}) {
-	if (!Number.isInteger(u) || u < 1) throw new e(`retry: times must be a positive integer, got ${u}`);
-	for (let e = 1; e <= u; e++) {
-		if (c?.aborted) throw t(c);
-		let d = r(l, c);
+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 i(d);
-		} catch (t) {
-			if (e === u || s && !s(t, e - 1)) throw o?.(t), t;
-			let r = typeof a == "function" ? a(e - 1) : a;
-			r > 0 && await n(r, c);
+			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 { i as retry };
+export { r as 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 { ArsenalValidationError } from '../errors';\nimport { 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 {ArsenalValidationError} 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 ArsenalValidationError(`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":";;;;AAaA,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,MAAM,IAAI,EAAuB,gDAAgD,GAAO;CAG1F,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  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"}

package/dist/async/taskPool.cjs

@@ -0,0 +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;
+//# sourceMappingURL=taskPool.cjs.map

package/dist/async/taskPool.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskPool.cjs","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  dispose(reason?: unknown): void;\n  idle(): Promise<void>;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  readonly active: number;\n  readonly disposed: boolean;\n  readonly disposalSignal: AbortSignal;\n  readonly pending: number;\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"}

package/dist/async/taskPool.d.ts

@@ -0,0 +1,14 @@
+export interface TaskPool {
+    dispose(reason?: unknown): void;
+    idle(): Promise<void>;
+    run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    readonly active: number;
+    readonly disposed: boolean;
+    readonly disposalSignal: AbortSignal;
+    readonly pending: number;
+    [Symbol.dispose](): void;
+}
+export declare function taskPool({ concurrency }?: {
+    concurrency?: number;
+}): TaskPool;
+//# sourceMappingURL=taskPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taskPool.d.ts","sourceRoot":"","sources":["../../src/async/taskPool.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAQD,wBAAgB,QAAQ,CAAC,EAAE,WAAe,EAAE,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,QAAQ,CAsFrF"}

package/dist/async/taskPool.js

@@ -0,0 +1,51 @@
+//#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 };
+
+//# sourceMappingURL=taskPool.js.map

package/dist/async/taskPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskPool.js","names":[],"sources":["../../src/async/taskPool.ts"],"sourcesContent":["export interface TaskPool {\n  dispose(reason?: unknown): void;\n  idle(): Promise<void>;\n  run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  readonly active: number;\n  readonly disposed: boolean;\n  readonly disposalSignal: AbortSignal;\n  readonly pending: number;\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"}

package/dist/cache/cache.cjs

@@ -0,0 +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)),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 u(),r.size}}}exports.cache=e;
+//# sourceMappingURL=cache.cjs.map

package/dist/cache/cache.cjs.map

@@ -0,0 +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  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    get: read,\n    getOrLoad,\n    set,\n    get size() {\n      trim();\n\n      return entries.size;\n    },\n  };\n}\n"],"mappings":"AAoBA,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,IAAK,EACL,WA/CiB,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,EAiBE,MACA,IAAI,MAAO,CAGT,OAFA,EAAK,EAEE,EAAQ,IACjB,CACF,CACF"}

package/dist/cache/cache.d.ts

@@ -0,0 +1,17 @@
+export type CacheOptions = {
+    capacity?: number;
+    now?: () => number;
+    ttlMs?: number;
+};
+export interface Cache<K, T> {
+    clear(): void;
+    delete(key: K): boolean;
+    get(key: K): T | undefined;
+    getOrLoad(key: K, load: () => Promise<T>): Promise<T>;
+    set(key: K, value: T, options?: {
+        ttlMs?: number;
+    }): void;
+    readonly size: number;
+}
+export declare function cache<K, T>({ capacity, now, ttlMs }?: CacheOptions): Cache<K, T>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache/cache.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAOF,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACxB,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAC3B,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAmB,EAAE,GAAc,EAAE,KAAK,EAAE,GAAE,YAAiB,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAsH1G"}

package/dist/cache/cache.js

@@ -0,0 +1,59 @@
+//#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)),
+		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 u(), r.size;
+		}
+	};
+}
+//#endregion
+export { e as cache };
+
+//# sourceMappingURL=cache.js.map

package/dist/cache/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","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  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    get: read,\n    getOrLoad,\n    set,\n    get size() {\n      trim();\n\n      return entries.size;\n    },\n  };\n}\n"],"mappings":";AAoBA,SAAgB,EAAY,EAAE,cAAW,UAAU,SAAM,KAAK,KAAK,aAAwB,CAAC,GAAgB;CAC1G,IAAI,MAAa,aAAa,CAAC,OAAO,UAAU,CAAQ,KAAK,IAAW,IACtE,MAAU,WAAW,+DAA+D,GAAU;CAGhG,IAAM,oBAAU,IAAI,IAAiB,GAC/B,oBAAU,IAAI,IAAmB,GACjC,oBAAY,IAAI,IAAe,GACjC,IAAa,GAEX,KAAmB,MAAmB;EAC1C,IAAM,KAAY,EAAU,IAAI,CAAG,KAAK,KAAK;EAI7C,OAFA,EAAU,IAAI,GAAK,CAAQ,GAEpB;CACT,GAEM,KAAa,MAAqD;EAClE,UAAa,KAAA,KAAa,MAAa,UAE3C;OAAI,CAAC,OAAO,SAAS,CAAQ,KAAK,IAAW,GAC3C,MAAU,WAAW,sEAAsE,GAAU;GAGvG,OAAO,EAAI,IAAI;EAHwF;CAIzG,GAEM,KAAQ,MAA0B;EACtC,IAAM,IAAQ,EAAQ,IAAI,CAAG;EAExB,OAEL;OAAI,EAAM,cAAc,KAAA,KAAa,EAAM,aAAa,EAAI,GAAG;IAC7D,EAAQ,OAAO,CAAG;IAElB;GACF;GAEA,OAAO,EAAM;EAFb;CAGF,GAEM,UAAmB;EACvB,KAAK,IAAM,CAAC,GAAK,MAAU,GACzB,AAAI,EAAM,cAAc,KAAA,KAAa,EAAM,aAAa,EAAI,KAAG,EAAQ,OAAO,CAAG;EAGnF,OAAO,EAAQ,OAAO,IAAU;GAC9B,IAAM,IAAS,EAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;GAErC,IAAI,MAAW,KAAA,GAAW;GAE1B,EAAQ,OAAO,CAAM;EACvB;CACF,GAEM,KAAO,GAAQ,GAAU,IAA8B,CAAC,MAAY;EAIxE,AAHA,EAAgB,CAAG,GACnB,EAAQ,OAAO,CAAG,GAClB,EAAQ,IAAI,GAAK;GAAE,WAAW,EAAU,EAAQ,SAAS,CAAK;GAAG;EAAM,CAAC,GACxE,EAAK;CACP;CAmCA,OAAO;EACL,aAAa;GAIX,AAHA,KACA,EAAQ,MAAM,GACd,EAAQ,MAAM,GACd,EAAU,MAAM;EAClB;EACA,SAAS,OACP,EAAQ,OAAO,CAAG,GAClB,EAAgB,CAAG,GAEZ,EAAQ,OAAO,CAAG;EAE3B,KAAK;EACL,YA/CiB,GAAQ,MAAuC;GAChE,IAAM,IAAS,EAAK,CAAG;GAEvB,IAAI,MAAW,KAAA,KAAa,EAAQ,IAAI,CAAG,GAAG,OAAO,QAAQ,QAAQ,CAAW;GAEhF,IAAM,IAAW,EAAQ,IAAI,CAAG;GAEhC,IAAI,GAAU,OAAO;GAErB,IAAM,IAAqB,GACrB,IAAmB,EAAgB,CAAG,GACtC,IAAS,EAAK,CAAC,CAAC,MACnB,OACK,EAAQ,IAAI,CAAG,MAAM,KAAQ,EAAQ,OAAO,CAAG,GAE/C,MAAe,KAAsB,EAAU,IAAI,CAAG,MAAM,KAC9D,EAAI,GAAK,CAAK,GAGT,KAER,MAAmB;IAGlB,MAFI,EAAQ,IAAI,CAAG,MAAM,KAAQ,EAAQ,OAAO,CAAG,GAE7C;GACR,CACF;GAIA,OAFA,EAAQ,IAAI,GAAK,CAAM,GAEhB;EACT;EAiBE;EACA,IAAI,OAAO;GAGT,OAFA,EAAK,GAEE,EAAQ;EACjB;CACF;AACF"}

package/dist/cache/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./cache.cjs"),t=require("./memo.cjs");exports.cache=e.cache,exports.memo=t.memo;

package/dist/cache/index.d.ts

@@ -1,3 +1,3 @@
+export * from './cache';
 export * from './memo';
-export * from './stash';
 //# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,3 @@
+import { cache as e } from "./cache.js";
+import { memo as t } from "./memo.js";
+export { e as cache, t as memo };