@vielzeug/toolkit 1.1.2 → 2.0.0

package/dist/async/queue.cjs.map

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

package/dist/async/queue.d.ts

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

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

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

package/dist/async/queue.js

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

package/dist/async/queue.js.map

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

package/dist/async/race.cjs

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

package/dist/async/race.cjs.map

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

package/dist/async/race.d.ts

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

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

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

package/dist/async/race.js

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

package/dist/async/race.js.map

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

package/dist/async/retry.cjs

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

package/dist/async/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","sources":["../../src/async/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":"oJAsBA,eAAsBA,EACpBC,EACA,CACE,MAAAC,EAAQ,EACR,MAAAC,EAAQ,IACR,QAAAC,EAAU,EACV,OAAAC,CACF,EAKI,GACQ,CACZ,IAAIC,EAAeH,EAEnB,QAASI,EAAU,EAAGA,GAAWL,EAAOK,IAAW,CACjD,GAAIF,GAAQ,QACVG,MAAAA,EAAAA,MAAM,KAAK,4BAA4BD,EAAU,CAAC,WAAW,EACvD,IAAI,MAAM,eAAe,EAGjC,GAAI,CACF,OAAO,MAAMN,EAAA,CACf,OAASQ,EAAK,CACZ,GAAIF,IAAYL,EAAO,MAAMO,EAE7BD,EAAAA,MAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,EACtFA,EAAe,GAAG,MAAMI,EAAAA,MAAMJ,CAAY,EAE9CA,EAAe,OAAOF,GAAY,WAAaA,EAAQG,EAASD,CAAY,EAAIA,EAAeF,CACjG,CACF,CAEA,MAAM,IAAI,MAAM,2BAA2B,CAC7C"}
+{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.\n * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.\n * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.\n * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    backoff = 1,\n    delay = 250,\n    retryDelay,\n    shouldRetry,\n    signal,\n    times = 3,\n  }: {\n    backoff?: number | ((attempt: number, currentDelay: number) => number);\n    delay?: number;\n    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */\n    retryDelay?: (attempt: number) => number;\n    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    signal?: AbortSignal;\n    times?: number;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) throw signal.reason ?? new DOMException('Retry aborted', 'AbortError');\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, attempt - 1)) throw err;\n\n      const ms = retryDelay ? retryDelay(attempt - 1) : currentDelay;\n\n      if (ms > 0) await sleep(ms);\n\n      if (!retryDelay) {\n        currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n      }\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"mappings":"+BAuBA,eAAsB,EACpB,EACA,CACE,UAAU,EACV,QAAQ,IACR,aACA,cACA,SACA,QAAQ,GAUN,EAAE,CACM,CACZ,IAAI,EAAe,EAEnB,IAAK,IAAI,EAAU,EAAG,GAAW,EAAO,IAAW,CACjD,GAAI,GAAQ,QAAS,MAAM,EAAO,QAAU,IAAI,aAAa,gBAAiB,aAAa,CAE3F,GAAI,CACF,OAAO,MAAM,GAAI,OACV,EAAK,CAGZ,GAFI,IAAY,GAEZ,GAAe,CAAC,EAAY,EAAK,EAAU,EAAE,CAAE,MAAM,EAEzD,IAAM,EAAK,EAAa,EAAW,EAAU,EAAE,CAAG,EAE9C,EAAK,GAAG,MAAM,EAAA,MAAM,EAAG,CAEtB,IACH,EAAe,OAAO,GAAY,WAAa,EAAQ,EAAS,EAAa,CAAG,EAAe,IAKrG,MAAU,MAAM,4BAA4B"}

package/dist/async/retry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.
+ *
+ * @example
+ * ```ts
+ * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })
+ *   .then(result => console.log(result))
+ *   .catch(error => console.error(error));
+ * ```
+ *
+ * @param fn - The asynchronous function to retry.
+ * @param options - (optional) Options for retrying the function.
+ * @param [options.times=3] - Total number of attempts (including the first).
+ * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.
+ * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.
+ * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.
+ * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.
+ * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.
+ *
+ * @returns The result of the asynchronous function.
+ */
+export declare function retry<T>(fn: () => Promise<T>, { backoff, delay, retryDelay, shouldRetry, signal, times, }?: {
+    backoff?: number | ((attempt: number, currentDelay: number) => number);
+    delay?: number;
+    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */
+    retryDelay?: (attempt: number) => number;
+    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    signal?: AbortSignal;
+    times?: number;
+}): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/async/retry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,EACE,OAAW,EACX,KAAW,EACX,UAAU,EACV,WAAW,EACX,MAAM,EACN,KAAS,GACV,GAAE;IACD,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mHAAmH;IACnH,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,gGAAgG;IAChG,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,GACL,OAAO,CAAC,CAAC,CAAC,CAwBZ"}

package/dist/async/retry.js

@@ -1,25 +1,20 @@
-import { Logit as n } from "../logit/dist/logit.js";
-import { sleep as w } from "./sleep.js";
-async function m(i, {
-  times: e = 3,
-  delay: y = 250,
-  backoff: o = 1,
-  signal: p
-} = {}) {
-  let r = y;
-  for (let t = 1; t <= e; t++) {
-    if (p?.aborted)
-      throw n.warn(`retry() -> Aborted after ${t - 1} attempts`), new Error("Retry aborted");
-    try {
-      return await i();
-    } catch (a) {
-      if (t === e) throw a;
-      n.warn(`retry() -> ${a}, attempt ${t}/${e}, retrying in ${r}ms`), r > 0 && await w(r), r = typeof o == "function" ? o(t, r) : r * o;
-    }
-  }
-  throw new Error("Retry failed unexpectedly");
+import { sleep as e } from "./sleep.js";
+//#region src/async/retry.ts
+async function t(t, { backoff: n = 1, delay: r = 250, retryDelay: i, shouldRetry: a, signal: o, times: s = 3 } = {}) {
+	let c = r;
+	for (let r = 1; r <= s; r++) {
+		if (o?.aborted) throw o.reason ?? new DOMException("Retry aborted", "AbortError");
+		try {
+			return await t();
+		} catch (t) {
+			if (r === s || a && !a(t, r - 1)) throw t;
+			let o = i ? i(r - 1) : c;
+			o > 0 && await e(o), i || (c = typeof n == "function" ? n(r, c) : c * n);
+		}
+	}
+	throw Error("Retry failed unexpectedly");
 }
-export {
-  m as retry
-};
-//# sourceMappingURL=retry.js.map
+//#endregion
+export { t as retry };
+
+//# sourceMappingURL=retry.js.map

package/dist/async/retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry.js","sources":["../../src/async/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":";;AAsBA,eAAsBA,EACpBC,GACA;AAAA,EACE,OAAAC,IAAQ;AAAA,EACR,OAAAC,IAAQ;AAAA,EACR,SAAAC,IAAU;AAAA,EACV,QAAAC;AACF,IAKI,IACQ;AACZ,MAAIC,IAAeH;AAEnB,WAASI,IAAU,GAAGA,KAAWL,GAAOK,KAAW;AACjD,QAAIF,GAAQ;AACVG,YAAAA,EAAM,KAAK,4BAA4BD,IAAU,CAAC,WAAW,GACvD,IAAI,MAAM,eAAe;AAGjC,QAAI;AACF,aAAO,MAAMN,EAAA;AAAA,IACf,SAASQ,GAAK;AACZ,UAAIF,MAAYL,EAAO,OAAMO;AAE7BD,MAAAA,EAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,GACtFA,IAAe,KAAG,MAAMI,EAAMJ,CAAY,GAE9CA,IAAe,OAAOF,KAAY,aAAaA,EAAQG,GAASD,CAAY,IAAIA,IAAeF;AAAA,IACjG;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;"}
+{"version":3,"file":"retry.js","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.\n * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.\n * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.\n * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    backoff = 1,\n    delay = 250,\n    retryDelay,\n    shouldRetry,\n    signal,\n    times = 3,\n  }: {\n    backoff?: number | ((attempt: number, currentDelay: number) => number);\n    delay?: number;\n    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */\n    retryDelay?: (attempt: number) => number;\n    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    signal?: AbortSignal;\n    times?: number;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) throw signal.reason ?? new DOMException('Retry aborted', 'AbortError');\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, attempt - 1)) throw err;\n\n      const ms = retryDelay ? retryDelay(attempt - 1) : currentDelay;\n\n      if (ms > 0) await sleep(ms);\n\n      if (!retryDelay) {\n        currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n      }\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"mappings":";;AAuBA,eAAsB,EACpB,GACA,EACE,aAAU,GACV,WAAQ,KACR,eACA,gBACA,WACA,WAAQ,MAUN,EAAE,EACM;CACZ,IAAI,IAAe;AAEnB,MAAK,IAAI,IAAU,GAAG,KAAW,GAAO,KAAW;AACjD,MAAI,GAAQ,QAAS,OAAM,EAAO,UAAU,IAAI,aAAa,iBAAiB,aAAa;AAE3F,MAAI;AACF,UAAO,MAAM,GAAI;WACV,GAAK;AAGZ,OAFI,MAAY,KAEZ,KAAe,CAAC,EAAY,GAAK,IAAU,EAAE,CAAE,OAAM;GAEzD,IAAM,IAAK,IAAa,EAAW,IAAU,EAAE,GAAG;AAIlD,GAFI,IAAK,KAAG,MAAM,EAAM,EAAG,EAEtB,MACH,IAAe,OAAO,KAAY,aAAa,EAAQ,GAAS,EAAa,GAAG,IAAe;;;AAKrG,OAAU,MAAM,4BAA4B"}

package/dist/async/scheduler.cjs

@@ -0,0 +1,2 @@
+function e(){return{postTask:(e,t)=>{let n=t?.delay??0,r=t?.signal;return new Promise((t,i)=>{if(r?.aborted){i(r.reason);return}let a=setTimeout(()=>{r?.removeEventListener(`abort`,o);try{t(e())}catch(e){i(e)}},n),o=()=>{clearTimeout(a),i(r.reason)};r?.addEventListener(`abort`,o,{once:!0})})}}}function t(){`scheduler`in globalThis||Object.defineProperty(globalThis,`scheduler`,{configurable:!0,value:e(),writable:!0})}var n=class{#e;constructor(){globalThis.scheduler===void 0&&t(),this.#e=globalThis.scheduler}postTask(e,t){return this.#e.postTask(e,t)}};exports.Scheduler=n,exports.polyfillScheduler=t;
+//# sourceMappingURL=scheduler.cjs.map

package/dist/async/scheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.cjs","names":["#scheduler"],"sources":["../../src/async/scheduler.ts"],"sourcesContent":["/**\n * Scheduler.postTask helper for environments with or without native support.\n *\n * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,\n * using the native API when available and installing a small fallback otherwise.\n *\n * `polyfillScheduler()` remains available when explicit installation is preferred.\n *\n * The polyfill provides:\n * - Delayed execution via the `delay` option\n * - AbortSignal support for cancellation\n * - Priority hint support (though priorities are not enforced in the polyfill)\n *\n * @example\n * ```ts\n * import { Scheduler } from '@vielzeug/toolkit';\n *\n * const scheduler = new Scheduler();\n * await scheduler.postTask(() => console.log('hello'), { delay: 100 });\n * ```\n */\n\nexport type TaskPriority = 'background' | 'user-blocking' | 'user-visible';\n\nexport type SchedulerLike = {\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T>;\n};\n\ntype SchedulerGlobal = { scheduler?: SchedulerLike };\n\nfunction createPolyfill(): SchedulerLike {\n  return {\n    postTask: <T>(\n      callback: () => T | PromiseLike<T>,\n      options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n    ) => {\n      const delay = options?.delay ?? 0;\n      const signal = options?.signal;\n\n      return new Promise<T>((resolve, reject) => {\n        if (signal?.aborted) {\n          reject(signal.reason);\n\n          return;\n        }\n\n        const id = setTimeout(() => {\n          signal?.removeEventListener('abort', onAbort);\n\n          try {\n            resolve(callback());\n          } catch (error) {\n            reject(error);\n          }\n        }, delay);\n\n        const onAbort = () => {\n          clearTimeout(id);\n          reject(signal!.reason);\n        };\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n      });\n    },\n  };\n}\n\n/**\n * Install the scheduler polyfill if not natively supported.\n *\n * Safe to call multiple times - it only installs if not already present.\n */\nexport function polyfillScheduler(): void {\n  if ('scheduler' in globalThis) {\n    return;\n  }\n\n  Object.defineProperty(globalThis, 'scheduler', {\n    configurable: true,\n    value: createPolyfill(),\n    writable: true,\n  });\n}\n\n/**\n * Lightweight scheduler wrapper.\n *\n * Creating an instance guarantees that a scheduler exists (native or polyfilled)\n * and exposes a stable postTask API.\n */\nexport class Scheduler implements SchedulerLike {\n  #scheduler: SchedulerLike;\n\n  constructor() {\n    const g = globalThis as unknown as SchedulerGlobal;\n\n    if (g.scheduler === undefined) {\n      polyfillScheduler();\n    }\n\n    this.#scheduler = (globalThis as unknown as SchedulerGlobal).scheduler!;\n  }\n\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T> {\n    return this.#scheduler.postTask(callback, options);\n  }\n}\n"],"mappings":"AAiCA,SAAS,GAAgC,CACvC,MAAO,CACL,UACE,EACA,IACG,CACH,IAAM,EAAQ,GAAS,OAAS,EAC1B,EAAS,GAAS,OAExB,OAAO,IAAI,SAAY,EAAS,IAAW,CACzC,GAAI,GAAQ,QAAS,CACnB,EAAO,EAAO,OAAO,CAErB,OAGF,IAAM,EAAK,eAAiB,CAC1B,GAAQ,oBAAoB,QAAS,EAAQ,CAE7C,GAAI,CACF,EAAQ,GAAU,CAAC,OACZ,EAAO,CACd,EAAO,EAAM,GAEd,EAAM,CAEH,MAAgB,CACpB,aAAa,EAAG,CAChB,EAAO,EAAQ,OAAO,EAGxB,GAAQ,iBAAiB,QAAS,EAAS,CAAE,KAAM,GAAM,CAAC,EAC1D,EAEL,CAQH,SAAgB,GAA0B,CACpC,cAAe,YAInB,OAAO,eAAe,WAAY,YAAa,CAC7C,aAAc,GACd,MAAO,GAAgB,CACvB,SAAU,GACX,CAAC,CASJ,IAAa,EAAb,KAAgD,CAC9C,GAEA,aAAc,CACF,WAEJ,YAAc,IAAA,IAClB,GAAmB,CAGrB,MAAA,EAAmB,WAA0C,UAG/D,SACE,EACA,EACY,CACZ,OAAO,MAAA,EAAgB,SAAS,EAAU,EAAQ"}

package/dist/async/scheduler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Scheduler.postTask helper for environments with or without native support.
+ *
+ * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,
+ * using the native API when available and installing a small fallback otherwise.
+ *
+ * `polyfillScheduler()` remains available when explicit installation is preferred.
+ *
+ * The polyfill provides:
+ * - Delayed execution via the `delay` option
+ * - AbortSignal support for cancellation
+ * - Priority hint support (though priorities are not enforced in the polyfill)
+ *
+ * @example
+ * ```ts
+ * import { Scheduler } from '@vielzeug/toolkit';
+ *
+ * const scheduler = new Scheduler();
+ * await scheduler.postTask(() => console.log('hello'), { delay: 100 });
+ * ```
+ */
+export type TaskPriority = 'background' | 'user-blocking' | 'user-visible';
+export type SchedulerLike = {
+    postTask<T>(callback: () => T | PromiseLike<T>, options?: {
+        delay?: number;
+        priority?: TaskPriority;
+        signal?: AbortSignal;
+    }): Promise<T>;
+};
+/**
+ * Install the scheduler polyfill if not natively supported.
+ *
+ * Safe to call multiple times - it only installs if not already present.
+ */
+export declare function polyfillScheduler(): void;
+/**
+ * Lightweight scheduler wrapper.
+ *
+ * Creating an instance guarantees that a scheduler exists (native or polyfilled)
+ * and exposes a stable postTask API.
+ */
+export declare class Scheduler implements SchedulerLike {
+    #private;
+    constructor();
+    postTask<T>(callback: () => T | PromiseLike<T>, options?: {
+        delay?: number;
+        priority?: TaskPriority;
+        signal?: AbortSignal;
+    }): Promise<T>;
+}
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/async/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,eAAe,GAAG,cAAc,CAAC;AAE3E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,CAAC,EACR,QAAQ,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1E,OAAO,CAAC,CAAC,CAAC,CAAC;CACf,CAAC;AAyCF;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAUxC;AAED;;;;;GAKG;AACH,qBAAa,SAAU,YAAW,aAAa;;;IAa7C,QAAQ,CAAC,CAAC,EACR,QAAQ,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1E,OAAO,CAAC,CAAC,CAAC;CAGd"}

package/dist/async/scheduler.js

@@ -0,0 +1,43 @@
+//#region src/async/scheduler.ts
+function e() {
+	return { postTask: (e, t) => {
+		let n = t?.delay ?? 0, r = t?.signal;
+		return new Promise((t, i) => {
+			if (r?.aborted) {
+				i(r.reason);
+				return;
+			}
+			let a = setTimeout(() => {
+				r?.removeEventListener("abort", o);
+				try {
+					t(e());
+				} catch (e) {
+					i(e);
+				}
+			}, n), o = () => {
+				clearTimeout(a), i(r.reason);
+			};
+			r?.addEventListener("abort", o, { once: !0 });
+		});
+	} };
+}
+function t() {
+	"scheduler" in globalThis || Object.defineProperty(globalThis, "scheduler", {
+		configurable: !0,
+		value: e(),
+		writable: !0
+	});
+}
+var n = class {
+	#e;
+	constructor() {
+		globalThis.scheduler === void 0 && t(), this.#e = globalThis.scheduler;
+	}
+	postTask(e, t) {
+		return this.#e.postTask(e, t);
+	}
+};
+//#endregion
+export { n as Scheduler, t as polyfillScheduler };
+
+//# sourceMappingURL=scheduler.js.map

package/dist/async/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","names":["#scheduler"],"sources":["../../src/async/scheduler.ts"],"sourcesContent":["/**\n * Scheduler.postTask helper for environments with or without native support.\n *\n * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,\n * using the native API when available and installing a small fallback otherwise.\n *\n * `polyfillScheduler()` remains available when explicit installation is preferred.\n *\n * The polyfill provides:\n * - Delayed execution via the `delay` option\n * - AbortSignal support for cancellation\n * - Priority hint support (though priorities are not enforced in the polyfill)\n *\n * @example\n * ```ts\n * import { Scheduler } from '@vielzeug/toolkit';\n *\n * const scheduler = new Scheduler();\n * await scheduler.postTask(() => console.log('hello'), { delay: 100 });\n * ```\n */\n\nexport type TaskPriority = 'background' | 'user-blocking' | 'user-visible';\n\nexport type SchedulerLike = {\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T>;\n};\n\ntype SchedulerGlobal = { scheduler?: SchedulerLike };\n\nfunction createPolyfill(): SchedulerLike {\n  return {\n    postTask: <T>(\n      callback: () => T | PromiseLike<T>,\n      options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n    ) => {\n      const delay = options?.delay ?? 0;\n      const signal = options?.signal;\n\n      return new Promise<T>((resolve, reject) => {\n        if (signal?.aborted) {\n          reject(signal.reason);\n\n          return;\n        }\n\n        const id = setTimeout(() => {\n          signal?.removeEventListener('abort', onAbort);\n\n          try {\n            resolve(callback());\n          } catch (error) {\n            reject(error);\n          }\n        }, delay);\n\n        const onAbort = () => {\n          clearTimeout(id);\n          reject(signal!.reason);\n        };\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n      });\n    },\n  };\n}\n\n/**\n * Install the scheduler polyfill if not natively supported.\n *\n * Safe to call multiple times - it only installs if not already present.\n */\nexport function polyfillScheduler(): void {\n  if ('scheduler' in globalThis) {\n    return;\n  }\n\n  Object.defineProperty(globalThis, 'scheduler', {\n    configurable: true,\n    value: createPolyfill(),\n    writable: true,\n  });\n}\n\n/**\n * Lightweight scheduler wrapper.\n *\n * Creating an instance guarantees that a scheduler exists (native or polyfilled)\n * and exposes a stable postTask API.\n */\nexport class Scheduler implements SchedulerLike {\n  #scheduler: SchedulerLike;\n\n  constructor() {\n    const g = globalThis as unknown as SchedulerGlobal;\n\n    if (g.scheduler === undefined) {\n      polyfillScheduler();\n    }\n\n    this.#scheduler = (globalThis as unknown as SchedulerGlobal).scheduler!;\n  }\n\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T> {\n    return this.#scheduler.postTask(callback, options);\n  }\n}\n"],"mappings":";AAiCA,SAAS,IAAgC;AACvC,QAAO,EACL,WACE,GACA,MACG;EACH,IAAM,IAAQ,GAAS,SAAS,GAC1B,IAAS,GAAS;AAExB,SAAO,IAAI,SAAY,GAAS,MAAW;AACzC,OAAI,GAAQ,SAAS;AACnB,MAAO,EAAO,OAAO;AAErB;;GAGF,IAAM,IAAK,iBAAiB;AAC1B,OAAQ,oBAAoB,SAAS,EAAQ;AAE7C,QAAI;AACF,OAAQ,GAAU,CAAC;aACZ,GAAO;AACd,OAAO,EAAM;;MAEd,EAAM,EAEH,UAAgB;AAEpB,IADA,aAAa,EAAG,EAChB,EAAO,EAAQ,OAAO;;AAGxB,MAAQ,iBAAiB,SAAS,GAAS,EAAE,MAAM,IAAM,CAAC;IAC1D;IAEL;;AAQH,SAAgB,IAA0B;AACpC,gBAAe,cAInB,OAAO,eAAe,YAAY,aAAa;EAC7C,cAAc;EACd,OAAO,GAAgB;EACvB,UAAU;EACX,CAAC;;AASJ,IAAa,IAAb,MAAgD;CAC9C;CAEA,cAAc;AAOZ,EANU,WAEJ,cAAc,KAAA,KAClB,GAAmB,EAGrB,MAAA,IAAmB,WAA0C;;CAG/D,SACE,GACA,GACY;AACZ,SAAO,MAAA,EAAgB,SAAS,GAAU,EAAQ"}

package/dist/async/sleep.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs");async function s(e){return n.assert(typeof e=="number"&&e>=0&&Number.isFinite(e),"Timeout must be a non-negative finite number",{args:{timeout:e},type:TypeError}),new Promise(r=>setTimeout(r,e))}exports.sleep=s;
-//# sourceMappingURL=sleep.cjs.map
+const e=require(`../function/assert.cjs`);async function t(t){return e.assert(typeof t==`number`&&t>=0&&Number.isFinite(t),`Timeout must be a non-negative finite number`,{args:{timeout:t},type:TypeError}),new Promise(e=>setTimeout(e,t))}exports.sleep=t;
+//# sourceMappingURL=sleep.cjs.map

package/dist/async/sleep.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.cjs","sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","assert","resolve"],"mappings":"0HAgBA,eAAsBA,EAAMC,EAAgC,CAC1DC,OAAAA,EAAAA,OACE,OAAOD,GAAY,UAAYA,GAAW,GAAK,OAAO,SAASA,CAAO,EACtE,+CACA,CAAE,KAAM,CAAE,QAAAA,CAAA,EAAW,KAAM,SAAA,CAAU,EAEhC,IAAI,QAASE,GAAY,WAAWA,EAASF,CAAO,CAAC,CAC9D"}
+{"version":3,"file":"sleep.cjs","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"mappings":"0CAgBA,eAAsB,EAAM,EAAgC,CAO1D,OANA,EAAA,OACE,OAAO,GAAY,UAAY,GAAW,GAAK,OAAO,SAAS,EAAQ,CACvE,+CACA,CAAE,KAAM,CAAE,UAAS,CAAE,KAAM,UAAW,CACvC,CAEM,IAAI,QAAS,GAAY,WAAW,EAAS,EAAQ,CAAC"}

package/dist/async/sleep.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a Promise that resolves after a specified amount of time.
+ *
+ * @example
+ * ```ts
+ * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second
+ * ```
+ *
+ * @param timeout - The number of milliseconds to wait before resolving the Promise.
+ *
+ * @returns A Promise that resolves after the specified time.
+ *
+ * @throws {TypeError} If timeout is not a non-negative number.
+ */
+export declare function sleep(timeout: number): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

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

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