@vielzeug/toolkit 1.1.2 → 2.0.0

package/dist/async/attempt.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../logit/dist/logit.cjs"),c=require("./predict.cjs"),u=require("./retry.cjs");async function s(t,{silent:e=!1,retries:r=0,timeout:i=7e3,identifier:a=t.name||"anonymous function"}={}){try{return await u.retry(()=>c.predict(()=>t(),{timeout:i}),{times:r+1})}catch(o){e||n.Logit.error(`attempt(${a}) -> all attempts failed`,{cause:o});return}}exports.attempt=s;
-//# sourceMappingURL=attempt.cjs.map
+const e=require(`./predict.cjs`),t=require(`./retry.cjs`);async function n(n,{onError:r,timeout:i=7e3,times:a=3}={}){try{return{ok:!0,value:await t.retry(()=>e.predict(()=>n(),{timeout:i}),{times:a})}}catch(e){return r?.(e),{error:e,ok:!1}}}exports.attempt=n;
+//# sourceMappingURL=attempt.cjs.map

package/dist/async/attempt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.cjs","sources":["../../src/async/attempt.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport type { Fn } from '../types';\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  identifier?: string;\n  retries?: number;\n  silent?: boolean;\n  timeout?: number;\n};\n\n/**\n * Attempts to execute a function with advanced error handling and retry logic.\n *\n * @example\n * ```ts\n * const unreliableFunction = async () => {\n *   if (Math.random() < 0.7) throw new Error ('Random failure');\n *   return 'Success!';\n * };\n *\n * await attempt(\n *   unreliableFunction,\n *   { retries: 3, silent: false, timeout: 5000 }); // Success! (or undefined if all attempts failed)\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options for the attempt.\n * @param [options.identifier] - Custom identifier for logging purposes.\n * @param [options.retries=0] - Number of retry attempts if the function fails.\n * @param [options.silent=false] - If true, suppresses error logging.\n * @param [options.timeout=7000] - Timeout in milliseconds for function execution.\n *\n * @returns The result of the function or undefined if it failed.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { silent = false, retries = 0, timeout = 7000, identifier = fn.name || 'anonymous function' }: AttemptOptions = {},\n): Promise<R | undefined> {\n  try {\n    return await retry(() => predict<R>(() => fn(), { timeout }), { times: retries + 1 });\n  } catch (err) {\n    if (!silent) {\n      Logit.error(`attempt(${identifier}) -> all attempts failed`, { cause: err });\n    }\n    return undefined;\n  }\n}\n"],"names":["attempt","fn","silent","retries","timeout","identifier","retry","predict","err","Logit"],"mappings":"+KAoCA,eAAsBA,EACpBC,EACA,CAAE,OAAAC,EAAS,GAAO,QAAAC,EAAU,EAAG,QAAAC,EAAU,IAAM,WAAAC,EAAaJ,EAAG,MAAQ,oBAAA,EAAyC,CAAA,EACxF,CACxB,GAAI,CACF,OAAO,MAAMK,EAAAA,MAAM,IAAMC,EAAAA,QAAW,IAAMN,EAAA,EAAM,CAAE,QAAAG,CAAA,CAAS,EAAG,CAAE,MAAOD,EAAU,EAAG,CACtF,OAASK,EAAK,CACPN,GACHO,QAAM,MAAM,WAAWJ,CAAU,2BAA4B,CAAE,MAAOG,EAAK,EAE7E,MACF,CACF"}
+{"version":3,"file":"attempt.cjs","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  onError?: (err: unknown) => void;\n  timeout?: number;\n  times?: number;\n};\n\nexport type AttemptResult<R> = { ok: true; value: R } | { error: unknown; ok: false };\n\n/**\n * Attempts to execute a function with retry logic and an optional timeout.\n * Returns a discriminated union so callers can handle success and failure\n * explicitly without relying on `undefined`.\n *\n * @example\n * ```ts\n * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });\n *\n * if (result.ok) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.onError] - Called with the error when all attempts fail.\n * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.\n *\n * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { onError, timeout = 7000, times = 3 }: AttemptOptions = {},\n): Promise<AttemptResult<R>> {\n  try {\n    const value = await retry(() => predict<R>(() => fn(), { timeout }), { times });\n\n    return { ok: true, value };\n  } catch (err) {\n    onError?.(err);\n\n    return { error: err, ok: false };\n  }\n}\n"],"mappings":"0DAqCA,eAAsB,EACpB,EACA,CAAE,UAAS,UAAU,IAAM,QAAQ,GAAsB,EAAE,CAChC,CAC3B,GAAI,CAGF,MAAO,CAAE,GAAI,GAAM,MAFL,MAAM,EAAA,UAAY,EAAA,YAAiB,GAAI,CAAE,CAAE,UAAS,CAAC,CAAE,CAAE,QAAO,CAAC,CAErD,OACnB,EAAK,CAGZ,OAFA,IAAU,EAAI,CAEP,CAAE,MAAO,EAAK,GAAI,GAAO"}

package/dist/async/attempt.d.ts

@@ -0,0 +1,40 @@
+import type { Fn } from '../types';
+type AttemptOptions = {
+    onError?: (err: unknown) => void;
+    timeout?: number;
+    times?: number;
+};
+export type AttemptResult<R> = {
+    ok: true;
+    value: R;
+} | {
+    error: unknown;
+    ok: false;
+};
+/**
+ * Attempts to execute a function with retry logic and an optional timeout.
+ * Returns a discriminated union so callers can handle success and failure
+ * explicitly without relying on `undefined`.
+ *
+ * @example
+ * ```ts
+ * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });
+ *
+ * if (result.ok) {
+ *   console.log(result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * @param fn - The function to be executed.
+ * @param [options] - Configuration options.
+ * @param [options.times=3] - Total number of attempts (including the first).
+ * @param [options.onError] - Called with the error when all attempts fail.
+ * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.
+ *
+ * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.
+ */
+export declare function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(fn: T, { onError, timeout, times }?: AttemptOptions): Promise<AttemptResult<R>>;
+export {};
+//# sourceMappingURL=attempt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/async/attempt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC,KAAK,cAAc,GAAG;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EACpE,EAAE,EAAE,CAAC,EACL,EAAE,OAAO,EAAE,OAAc,EAAE,KAAS,EAAE,GAAE,cAAmB,GAC1D,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAU3B"}

package/dist/async/attempt.js

@@ -1,15 +1,20 @@
-import { Logit as m } from "../logit/dist/logit.js";
-import { predict as n } from "./predict.js";
-import { retry as p } from "./retry.js";
-async function u(t, { silent: r = !1, retries: e = 0, timeout: a = 7e3, identifier: o = t.name || "anonymous function" } = {}) {
-  try {
-    return await p(() => n(() => t(), { timeout: a }), { times: e + 1 });
-  } catch (i) {
-    r || m.error(`attempt(${o}) -> all attempts failed`, { cause: i });
-    return;
-  }
+import { predict as e } from "./predict.js";
+import { retry as t } from "./retry.js";
+//#region src/async/attempt.ts
+async function n(n, { onError: r, timeout: i = 7e3, times: a = 3 } = {}) {
+	try {
+		return {
+			ok: !0,
+			value: await t(() => e(() => n(), { timeout: i }), { times: a })
+		};
+	} catch (e) {
+		return r?.(e), {
+			error: e,
+			ok: !1
+		};
+	}
 }
-export {
-  u as attempt
-};
-//# sourceMappingURL=attempt.js.map
+//#endregion
+export { n as attempt };
+
+//# sourceMappingURL=attempt.js.map

package/dist/async/attempt.js.map

@@ -1 +1 @@
-{"version":3,"file":"attempt.js","sources":["../../src/async/attempt.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport type { Fn } from '../types';\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  identifier?: string;\n  retries?: number;\n  silent?: boolean;\n  timeout?: number;\n};\n\n/**\n * Attempts to execute a function with advanced error handling and retry logic.\n *\n * @example\n * ```ts\n * const unreliableFunction = async () => {\n *   if (Math.random() < 0.7) throw new Error ('Random failure');\n *   return 'Success!';\n * };\n *\n * await attempt(\n *   unreliableFunction,\n *   { retries: 3, silent: false, timeout: 5000 }); // Success! (or undefined if all attempts failed)\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options for the attempt.\n * @param [options.identifier] - Custom identifier for logging purposes.\n * @param [options.retries=0] - Number of retry attempts if the function fails.\n * @param [options.silent=false] - If true, suppresses error logging.\n * @param [options.timeout=7000] - Timeout in milliseconds for function execution.\n *\n * @returns The result of the function or undefined if it failed.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { silent = false, retries = 0, timeout = 7000, identifier = fn.name || 'anonymous function' }: AttemptOptions = {},\n): Promise<R | undefined> {\n  try {\n    return await retry(() => predict<R>(() => fn(), { timeout }), { times: retries + 1 });\n  } catch (err) {\n    if (!silent) {\n      Logit.error(`attempt(${identifier}) -> all attempts failed`, { cause: err });\n    }\n    return undefined;\n  }\n}\n"],"names":["attempt","fn","silent","retries","timeout","identifier","retry","predict","err","Logit"],"mappings":";;;AAoCA,eAAsBA,EACpBC,GACA,EAAE,QAAAC,IAAS,IAAO,SAAAC,IAAU,GAAG,SAAAC,IAAU,KAAM,YAAAC,IAAaJ,EAAG,QAAQ,qBAAA,IAAyC,CAAA,GACxF;AACxB,MAAI;AACF,WAAO,MAAMK,EAAM,MAAMC,EAAW,MAAMN,EAAA,GAAM,EAAE,SAAAG,EAAA,CAAS,GAAG,EAAE,OAAOD,IAAU,GAAG;AAAA,EACtF,SAASK,GAAK;AACZ,IAAKN,KACHO,EAAM,MAAM,WAAWJ,CAAU,4BAA4B,EAAE,OAAOG,GAAK;AAE7E;AAAA,EACF;AACF;"}
+{"version":3,"file":"attempt.js","names":[],"sources":["../../src/async/attempt.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  onError?: (err: unknown) => void;\n  timeout?: number;\n  times?: number;\n};\n\nexport type AttemptResult<R> = { ok: true; value: R } | { error: unknown; ok: false };\n\n/**\n * Attempts to execute a function with retry logic and an optional timeout.\n * Returns a discriminated union so callers can handle success and failure\n * explicitly without relying on `undefined`.\n *\n * @example\n * ```ts\n * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });\n *\n * if (result.ok) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.onError] - Called with the error when all attempts fail.\n * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.\n *\n * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { onError, timeout = 7000, times = 3 }: AttemptOptions = {},\n): Promise<AttemptResult<R>> {\n  try {\n    const value = await retry(() => predict<R>(() => fn(), { timeout }), { times });\n\n    return { ok: true, value };\n  } catch (err) {\n    onError?.(err);\n\n    return { error: err, ok: false };\n  }\n}\n"],"mappings":";;;AAqCA,eAAsB,EACpB,GACA,EAAE,YAAS,aAAU,KAAM,WAAQ,MAAsB,EAAE,EAChC;AAC3B,KAAI;AAGF,SAAO;GAAE,IAAI;GAAM,OAFL,MAAM,QAAY,QAAiB,GAAI,EAAE,EAAE,YAAS,CAAC,EAAE,EAAE,UAAO,CAAC;GAErD;UACnB,GAAK;AAGZ,SAFA,IAAU,EAAI,EAEP;GAAE,OAAO;GAAK,IAAI;GAAO"}

package/dist/async/defer.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function i(){let e,r;return{promise:new Promise((t,o)=>{e=t,r=o}),reject:r,resolve:e}}exports.defer=i;
-//# sourceMappingURL=defer.cjs.map
+function e(){let{promise:e,reject:t,resolve:n}=Promise.withResolvers();return{promise:e,reject:t,resolve:n}}exports.defer=e;
+//# sourceMappingURL=defer.cjs.map

package/dist/async/defer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defer.cjs","sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: unknown) => void;\n} {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason?: unknown) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, reject, resolve };\n}\n"],"names":["defer","resolve","reject","res","rej"],"mappings":"gFAiBO,SAASA,GAId,CACA,IAAIC,EACAC,EAOJ,MAAO,CAAE,QALO,IAAI,QAAW,CAACC,EAAKC,IAAQ,CAC3CH,EAAUE,EACVD,EAASE,CACX,CAAC,EAEiB,OAAAF,EAAQ,QAAAD,CAAA,CAC5B"}
+{"version":3,"file":"defer.cjs","names":[],"sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  reject: (reason?: unknown) => void;\n  resolve: (value: T | PromiseLike<T>) => void;\n} {\n  const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n  return { promise, reject, resolve };\n}\n"],"mappings":"AAiBA,SAAgB,GAId,CACA,GAAM,CAAE,UAAS,SAAQ,WAAY,QAAQ,eAAkB,CAE/D,MAAO,CAAE,UAAS,SAAQ,UAAS"}

package/dist/async/defer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a deferred promise with resolve and reject methods exposed.
+ * Useful for creating promises that are resolved/rejected externally.
+ *
+ * @example
+ * ```ts
+ * const deferred = defer<string>();
+ *
+ * setTimeout(() => {
+ *   deferred.resolve('Done!');
+ * }, 1000);
+ *
+ * const result = await deferred.promise; // 'Done!'
+ * ```
+ *
+ * @returns Object with promise and resolve/reject methods
+ */
+export declare function defer<T = void>(): {
+    promise: Promise<T>;
+    reject: (reason?: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};
+//# sourceMappingURL=defer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defer.d.ts","sourceRoot":"","sources":["../../src/async/defer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,IAAI,KAAK;IACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CAC9C,CAIA"}

package/dist/async/defer.js

@@ -1,10 +1,13 @@
-function s() {
-  let e, r;
-  return { promise: new Promise((o, t) => {
-    e = o, r = t;
-  }), reject: r, resolve: e };
+//#region src/async/defer.ts
+function e() {
+	let { promise: e, reject: t, resolve: n } = Promise.withResolvers();
+	return {
+		promise: e,
+		reject: t,
+		resolve: n
+	};
 }
-export {
-  s as defer
-};
-//# sourceMappingURL=defer.js.map
+//#endregion
+export { e as defer };
+
+//# sourceMappingURL=defer.js.map

package/dist/async/defer.js.map

@@ -1 +1 @@
-{"version":3,"file":"defer.js","sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: unknown) => void;\n} {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason?: unknown) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, reject, resolve };\n}\n"],"names":["defer","resolve","reject","res","rej"],"mappings":"AAiBO,SAASA,IAId;AACA,MAAIC,GACAC;AAOJ,SAAO,EAAE,SALO,IAAI,QAAW,CAACC,GAAKC,MAAQ;AAC3C,IAAAH,IAAUE,GACVD,IAASE;AAAA,EACX,CAAC,GAEiB,QAAAF,GAAQ,SAAAD,EAAA;AAC5B;"}
+{"version":3,"file":"defer.js","names":[],"sources":["../../src/async/defer.ts"],"sourcesContent":["/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  reject: (reason?: unknown) => void;\n  resolve: (value: T | PromiseLike<T>) => void;\n} {\n  const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n  return { promise, reject, resolve };\n}\n"],"mappings":";AAiBA,SAAgB,IAId;CACA,IAAM,EAAE,YAAS,WAAQ,eAAY,QAAQ,eAAkB;AAE/D,QAAO;EAAE;EAAS;EAAQ;EAAS"}

package/dist/async/index.d.ts

@@ -0,0 +1,12 @@
+export * from './attempt';
+export * from './defer';
+export * from './parallel';
+export * from './pool';
+export * from './predict';
+export * from './queue';
+export * from './race';
+export * from './retry';
+export * from './scheduler';
+export * from './sleep';
+export * from './waitFor';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/async/parallel.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function f(n,r,a,l){if(n<1)throw new Error("Limit must be at least 1");if(l?.aborted)throw new DOMException("Aborted","AbortError");const s=new Array(r.length);let c=0,t=!1,o;const u=()=>l?.aborted?(t=!0,o=new DOMException("Aborted","AbortError"),!0):!1,w=async()=>{for(;c<r.length&&!t&&!u();){const e=c++;try{s[e]=await a(r[e],e,r)}catch(h){t=!0,o=h;break}}},i=[],b=Math.min(n,r.length);for(let e=0;e<b;e++)i.push(w());if(await Promise.all(i),t)throw o;return s}exports.parallel=f;
-//# sourceMappingURL=parallel.cjs.map
+async function e(e,t,n,r){if(e<1)throw Error(`Limit must be at least 1`);if(r?.aborted)throw new DOMException(`Aborted`,`AbortError`);let i=Array(t.length),a=0,o=!1,s,c=async()=>{for(;a<t.length&&!o;){if(r?.aborted){o=!0,s=new DOMException(`Aborted`,`AbortError`);break}let e=a++;try{i[e]=await n(t[e],e,t)}catch(e){o=!0,s=e;break}}},l=[],u=Math.min(e,t.length);for(let e=0;e<u;e++)l.push(c());if(await Promise.all(l),o)throw s;return i}exports.parallel=e;
+//# sourceMappingURL=parallel.cjs.map

package/dist/async/parallel.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.cjs","sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  // Check for abort\n  const checkAbort = () => {\n    if (signal?.aborted) {\n      hasError = true;\n      error = new DOMException('Aborted', 'AbortError');\n      return true;\n    }\n    return false;\n  };\n\n  // Worker function that processes items from the queue\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (checkAbort()) {\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"names":["parallel","limit","array","callback","signal","results","currentIndex","hasError","error","checkAbort","worker","index","err","workers","workerCount","i"],"mappings":"gFA6BA,eAAsBA,EACpBC,EACAC,EACAC,EACAC,EACc,CACd,GAAIH,EAAQ,EACV,MAAM,IAAI,MAAM,0BAA0B,EAG5C,GAAIG,GAAQ,QACV,MAAM,IAAI,aAAa,UAAW,YAAY,EAGhD,MAAMC,EAAe,IAAI,MAAMH,EAAM,MAAM,EAC3C,IAAII,EAAe,EACfC,EAAW,GACXC,EAGJ,MAAMC,EAAa,IACbL,GAAQ,SACVG,EAAW,GACXC,EAAQ,IAAI,aAAa,UAAW,YAAY,EACzC,IAEF,GAIHE,EAAS,SAA2B,CACxC,KAAOJ,EAAeJ,EAAM,QAAU,CAACK,GACjC,CAAAE,KAD2C,CAK/C,MAAME,EAAQL,IAEd,GAAI,CACFD,EAAQM,CAAK,EAAI,MAAMR,EAASD,EAAMS,CAAK,EAAGA,EAAOT,CAAK,CAC5D,OAASU,EAAK,CACZL,EAAW,GACXC,EAAQI,EACR,KACF,CACF,CACF,EAGMC,EAA2B,CAAA,EAC3BC,EAAc,KAAK,IAAIb,EAAOC,EAAM,MAAM,EAEhD,QAASa,EAAI,EAAGA,EAAID,EAAaC,IAC/BF,EAAQ,KAAKH,GAAQ,EAOvB,GAHA,MAAM,QAAQ,IAAIG,CAAO,EAGrBN,EACF,MAAMC,EAGR,OAAOH,CACT"}
+{"version":3,"file":"parallel.cjs","names":[],"sources":["../../src/async/parallel.ts"],"sourcesContent":["/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (signal?.aborted) {\n        hasError = true;\n        error = new DOMException('Aborted', 'AbortError');\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n"],"mappings":"AA6BA,eAAsB,EACpB,EACA,EACA,EACA,EACc,CACd,GAAI,EAAQ,EACV,MAAU,MAAM,2BAA2B,CAG7C,GAAI,GAAQ,QACV,MAAM,IAAI,aAAa,UAAW,aAAa,CAGjD,IAAM,EAAmB,MAAM,EAAM,OAAO,CACxC,EAAe,EACf,EAAW,GACX,EAEE,EAAS,SAA2B,CACxC,KAAO,EAAe,EAAM,QAAU,CAAC,GAAU,CAC/C,GAAI,GAAQ,QAAS,CACnB,EAAW,GACX,EAAQ,IAAI,aAAa,UAAW,aAAa,CACjD,MAGF,IAAM,EAAQ,IAEd,GAAI,CACF,EAAQ,GAAS,MAAM,EAAS,EAAM,GAAQ,EAAO,EAAM,OACpD,EAAK,CACZ,EAAW,GACX,EAAQ,EACR,SAMA,EAA2B,EAAE,CAC7B,EAAc,KAAK,IAAI,EAAO,EAAM,OAAO,CAEjD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAa,IAC/B,EAAQ,KAAK,GAAQ,CAAC,CAOxB,GAHA,MAAM,QAAQ,IAAI,EAAQ,CAGtB,EACF,MAAM,EAGR,OAAO"}

package/dist/async/parallel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Processes an array with an async callback with controlled parallelism.
+ * Similar to Promise.all, but limits how many items are processed concurrently.
+ * Returns an ordered array of results.
+ *
+ * @example
+ * ```ts
+ * // Process 3 items at a time
+ * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {
+ *   await delay(100);
+ *   return n * 2;
+ * });
+ * // [2, 4, 6, 8, 10]
+ *
+ * // With abort signal
+ * const controller = new AbortController();
+ * const results = await parallel(2, items, async (item) => {
+ *   return processItem(item);
+ * }, controller.signal);
+ * ```
+ *
+ * @param limit - Maximum number of concurrent operations (must be >= 1)
+ * @param array - Array of items to process
+ * @param callback - Async function to process each item
+ * @param signal - Optional AbortSignal to cancel processing
+ * @returns Promise resolving to an ordered array of results
+ * @throws {Error} If limit is less than 1
+ * @throws {DOMException} If aborted via signal
+ */
+export declare function parallel<T, R>(limit: number, array: T[], callback: (item: T, index: number, array: T[]) => Promise<R>, signal?: AbortSignal): Promise<R[]>;
+//# sourceMappingURL=parallel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/async/parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5D,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,EAAE,CAAC,CAmDd"}

package/dist/async/parallel.js

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

package/dist/async/parallel.js.map

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

package/dist/async/pool.cjs

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

package/dist/async/pool.cjs.map

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

package/dist/async/pool.d.ts

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

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

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

package/dist/async/pool.js

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

package/dist/async/pool.js.map

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

package/dist/async/predict.cjs

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

package/dist/async/predict.cjs.map

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

package/dist/async/predict.d.ts

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

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

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

package/dist/async/predict.js

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

package/dist/async/predict.js.map

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

package/dist/async/queue.cjs

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