elements-kit 0.0.12 → 0.0.14

package/dist/utilities/interval.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createInterval } from "./interval.mjs";
 //#region src/utilities/interval.test.ts
@@ -26,7 +26,7 @@ describe("createInterval", () => {
 		iv.stop();
 		vi.advanceTimersByTime(500);
 		globalExpect(cb).toHaveBeenCalledTimes(0);
-		globalExpect(iv.isRunning()).toBe(false);
+		globalExpect(iv.pending()).toBe(false);
 	});
 	it("start() resumes after stop", () => {
 		vi.useFakeTimers();
@@ -63,6 +63,35 @@ describe("createInterval", () => {
 		vi.advanceTimersByTime(500);
 		globalExpect(cb).toHaveBeenCalledTimes(0);
 	});
+	it("no-callback form updates timestamp on each tick", () => {
+		vi.useFakeTimers();
+		let iv;
+		effectScope(() => {
+			iv = createInterval(100);
+		});
+		const before = iv.timestamp();
+		vi.advanceTimersByTime(100);
+		globalExpect(iv.timestamp()).toBeGreaterThan(before);
+	});
+	it("dynamic delay form is called each tick", () => {
+		vi.useFakeTimers();
+		const cb = vi.fn();
+		const getDelay = vi.fn().mockReturnValue(100);
+		effectScope(() => {
+			createInterval(cb, getDelay);
+		});
+		vi.advanceTimersByTime(300);
+		globalExpect(cb).toHaveBeenCalledTimes(3);
+	});
+	it("stops when scope is disposed", () => {
+		vi.useFakeTimers();
+		const cb = vi.fn();
+		effectScope(() => {
+			createInterval(cb, 100);
+		})();
+		vi.advanceTimersByTime(500);
+		globalExpect(cb).toHaveBeenCalledTimes(0);
+	});
 });
 //#endregion
 export {};

package/dist/utilities/location.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/location.d.ts
 type LocationResult = {

package/dist/utilities/location.mjs

@@ -1,4 +1,4 @@
-import { a as computed, f as onCleanup, m as trigger, p as signal } from "../signals-DcgXhkU2.mjs";
+import { _ as signal, g as onCleanup, l as computed, v as trigger } from "../signals-BHmWX6ox.mjs";
 import { fromEvent } from "./event-driven.mjs";
 //#region src/utilities/location.ts
 const EVENTS = [

package/dist/utilities/long-press.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createLongPress } from "./long-press.mjs";
 //#region src/utilities/long-press.test.ts

package/dist/utilities/media-devices.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/media-devices.d.ts
 /**

package/dist/utilities/media-devices.mjs

@@ -1,4 +1,4 @@
-import { p as signal } from "../signals-DcgXhkU2.mjs";
+import { _ as signal } from "../signals-BHmWX6ox.mjs";
 import { on } from "./event-listener.mjs";
 //#region src/utilities/media-devices.ts
 /**

package/dist/utilities/media-devices.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createMediaDevices } from "./media-devices.mjs";
 //#region src/utilities/media-devices.test.ts

package/dist/utilities/media-player.d.mts

@@ -1,4 +1,4 @@
-import { r as Signal, t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { r as Signal, t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/media-player.d.ts
 type MediaPlayerResult<T extends HTMLMediaElement> = {

package/dist/utilities/media-player.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createMediaPlayer } from "./media-player.mjs";
 //#region src/utilities/media-player.test.ts

package/dist/utilities/media-query.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/media-query.d.ts
 declare const isBrowser: boolean;

package/dist/utilities/media-query.mjs

@@ -1,4 +1,4 @@
-import { p as signal } from "../signals-DcgXhkU2.mjs";
+import { _ as signal } from "../signals-BHmWX6ox.mjs";
 import { fromEvent, sync } from "./event-driven.mjs";
 //#region src/utilities/media-query.ts
 const isBrowser = typeof window !== "undefined";

package/dist/utilities/mutation-observer.mjs

@@ -1,4 +1,4 @@
-import { f as onCleanup } from "../signals-DcgXhkU2.mjs";
+import { g as onCleanup } from "../signals-BHmWX6ox.mjs";
 //#region src/utilities/mutation-observer.ts
 /**
 * Watches `target` for DOM mutations and calls `callback` with each batch of

package/dist/utilities/mutation-observer.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createMutationObserver } from "./mutation-observer.mjs";
 //#region src/utilities/mutation-observer.test.ts

package/dist/utilities/network.d.mts

@@ -0,0 +1,10 @@
+import { t as Computed } from "../index-DUshSQ_6.mjs";
+
+//#region src/utilities/network.d.ts
+/**
+ * Singleton `Computed<boolean>` — `true` when `navigator.onLine` is true.
+ * Reacts to `online` / `offline` window events.
+ */
+declare const online: Computed<boolean>;
+//#endregion
+export { online };

package/dist/utilities/network.mjs

@@ -0,0 +1,17 @@
+import { _ as signal } from "../signals-BHmWX6ox.mjs";
+import { on } from "./event-listener.mjs";
+//#region src/utilities/network.ts
+function createOnline() {
+	const value = signal(typeof navigator !== "undefined" ? navigator.onLine : true);
+	const update = () => value(navigator.onLine);
+	on(window, "online", update);
+	on(window, "offline", update);
+	return value;
+}
+/**
+* Singleton `Computed<boolean>` — `true` when `navigator.onLine` is true.
+* Reacts to `online` / `offline` window events.
+*/
+const online = createOnline();
+//#endregion
+export { online };

package/dist/utilities/network.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/utilities/network.test.mjs

@@ -0,0 +1,29 @@
+import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
+import { online } from "./network.mjs";
+//#region src/utilities/network.test.ts
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+describe("online", () => {
+	it("reflects navigator.onLine", () => {
+		globalExpect(online()).toBe(navigator.onLine);
+	});
+	it("becomes false on offline event", () => {
+		Object.defineProperty(navigator, "onLine", {
+			configurable: true,
+			get: () => false
+		});
+		window.dispatchEvent(new Event("offline"));
+		globalExpect(online()).toBe(false);
+	});
+	it("becomes true on online event", () => {
+		Object.defineProperty(navigator, "onLine", {
+			configurable: true,
+			get: () => true
+		});
+		window.dispatchEvent(new Event("online"));
+		globalExpect(online()).toBe(true);
+	});
+});
+//#endregion
+export {};

package/dist/utilities/on-click-outside.test.mjs

@@ -1,4 +1,4 @@
-import { s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { onClickOutside } from "./on-click-outside.mjs";
 //#region src/utilities/on-click-outside.test.ts

package/dist/utilities/orientation.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/orientation.d.ts
 type OrientationResult = {

package/dist/utilities/previous.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-Cvdhuy6Y.mjs";
+import { t as Computed } from "../index-DUshSQ_6.mjs";
 
 //#region src/utilities/previous.d.ts
 /**

package/dist/utilities/previous.mjs

@@ -1,4 +1,4 @@
-import { o as effect, p as signal } from "../signals-DcgXhkU2.mjs";
+import { _ as signal, u as effect } from "../signals-BHmWX6ox.mjs";
 //#region src/utilities/previous.ts
 /**
 * Returns a `Computed` that always holds the *previous* value of `source`.

package/dist/utilities/previous.test.mjs

@@ -1,4 +1,4 @@
-import { p as signal, s as effectScope } from "../signals-DcgXhkU2.mjs";
+import { _ as signal, d as effectScope } from "../signals-BHmWX6ox.mjs";
 import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
 import { createPrevious } from "./previous.mjs";
 //#region src/utilities/previous.test.ts

package/dist/utilities/promise.d.mts

@@ -0,0 +1,56 @@
+import { t as Computed } from "../index-DUshSQ_6.mjs";
+
+//#region src/utilities/promise.d.ts
+/**
+ * A `Promise` subclass that exposes its state as reactive signals.
+ *
+ * Prefer the {@link promise} factory for most use cases — it returns a
+ * `ComputedPromise` that is both awaitable and callable as a signal.
+ * Use `ReactivePromise` directly when you need the lower-level class —
+ * for example, to wrap a promise and expose `.state`, `.value`, `.reason`,
+ * and `.result` without the `Computed` callable interface.
+ *
+ * @example
+ * ```ts
+ * const rp = ReactivePromise.from(fetch("/api/data"));
+ *
+ * effect(() => {
+ *   if (rp.state === "fulfilled") console.log(rp.value);
+ * });
+ * ```
+ */
+declare class ReactivePromise<T, E = unknown> extends Promise<T> {
+  #private;
+  get state(): "pending" | "fulfilled" | "rejected";
+  get value(): T | undefined;
+  get reason(): E | undefined;
+  get result(): T | E | undefined;
+  constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
+  static from<T, E = unknown>(p: Promise<T>): ReactivePromise<T, E>;
+}
+type ComputedPromise<T, E = unknown> = ReactivePromise<T, E> & Computed<T | E | undefined>;
+type Executor<T, E = unknown> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void;
+/**
+ * Wraps a promise, executor, or `ReactivePromise` into a `ComputedPromise` —
+ * an object that is both awaitable like a regular Promise and reactive like a
+ * `Computed` signal.
+ *
+ * **Awaitable:** `await promise(fetch(...))` resolves to the fulfilled value,
+ * or rejects with the rejection reason, just like a native Promise.
+ *
+ * **Reactive:** calling the returned value as a function (`cp()`) reads the
+ * current result inside an `effect` or `computed`, tracking it as a dependency.
+ * Equivalent to `.result` — returns `undefined` while pending, the fulfilled
+ * value when resolved, or the rejection reason when rejected.
+ *
+ * Reactive state is also accessible via:
+ * - `.state` — `"pending" | "fulfilled" | "rejected"`
+ * - `.value` — the resolved value (or `undefined` while pending)
+ * - `.reason` — the rejection reason (or `undefined` while pending/fulfilled)
+ * - `.result` — `T | E | undefined`; the resolved value, rejection reason, or `undefined` while pending
+ */
+declare function promise<T, E = unknown>(p: ReactivePromise<T>): ComputedPromise<T, E>;
+declare function promise<T, E = unknown>(p: Promise<T>): ComputedPromise<T, E>;
+declare function promise<T, E = unknown>(executor: Executor<T, E>): ComputedPromise<T, E>;
+//#endregion
+export { ComputedPromise, ReactivePromise, promise };

package/dist/utilities/promise.mjs

@@ -0,0 +1,101 @@
+import { _ as signal, c as batch, l as computed } from "../signals-BHmWX6ox.mjs";
+//#region src/utilities/promise.ts
+/**
+* A `Promise` subclass that exposes its state as reactive signals.
+*
+* Prefer the {@link promise} factory for most use cases — it returns a
+* `ComputedPromise` that is both awaitable and callable as a signal.
+* Use `ReactivePromise` directly when you need the lower-level class —
+* for example, to wrap a promise and expose `.state`, `.value`, `.reason`,
+* and `.result` without the `Computed` callable interface.
+*
+* @example
+* ```ts
+* const rp = ReactivePromise.from(fetch("/api/data"));
+*
+* effect(() => {
+*   if (rp.state === "fulfilled") console.log(rp.value);
+* });
+* ```
+*/
+var ReactivePromise = class ReactivePromise extends Promise {
+	#state = signal("pending");
+	#value = signal(void 0);
+	#reason = signal(void 0);
+	#result = computed(() => {
+		const state = this.#state();
+		if (state === "fulfilled") return this.#value();
+		if (state === "rejected") return this.#reason();
+	});
+	get state() {
+		return this.#state();
+	}
+	get value() {
+		return this.#value();
+	}
+	get reason() {
+		return this.#reason();
+	}
+	get result() {
+		return this.#result();
+	}
+	constructor(executor) {
+		super((res, rej) => {
+			executor(async (value) => {
+				const resolved = await value;
+				batch(() => {
+					this.#state("fulfilled");
+					this.#value(resolved);
+				});
+				res(value);
+			}, async (_reason) => {
+				const reason = await _reason;
+				batch(() => {
+					this.#state("rejected");
+					this.#reason(reason);
+				});
+				rej(reason);
+			});
+		});
+	}
+	static from(p) {
+		return new ReactivePromise((resolve, reject) => {
+			p.then(resolve).catch(reject);
+		});
+	}
+};
+const PROMISE_KEYS = new Set([
+	"then",
+	"catch",
+	"finally",
+	"state",
+	"value",
+	"reason",
+	"result"
+]);
+function resolvePromise(from) {
+	if (from instanceof ReactivePromise) return from;
+	if (from instanceof Promise) return ReactivePromise.from(from);
+	return new ReactivePromise(from);
+}
+function promise(from) {
+	const p = resolvePromise(from);
+	const $value = computed(() => p.result);
+	return new Proxy($value, {
+		apply() {
+			return $value();
+		},
+		get(target, prop, receiver) {
+			if (PROMISE_KEYS.has(prop)) {
+				const val = p[prop];
+				return typeof val === "function" ? val.bind(p) : val;
+			}
+			return Reflect.get(target, prop, receiver);
+		},
+		getPrototypeOf() {
+			return ReactivePromise.prototype;
+		}
+	});
+}
+//#endregion
+export { ReactivePromise, promise };

package/dist/utilities/promise.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/utilities/promise.test.mjs

@@ -0,0 +1,156 @@
+import { u as effect } from "../signals-BHmWX6ox.mjs";
+import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-ANkhHvbr.mjs";
+import { ReactivePromise, promise } from "./promise.mjs";
+//#region src/utilities/promise.test.ts
+describe("ReactivePromise", () => {
+	it("starts in pending state", () => {
+		const rp = new ReactivePromise(() => {});
+		globalExpect(rp.state).toBe("pending");
+		globalExpect(rp.value).toBeUndefined();
+		globalExpect(rp.reason).toBeUndefined();
+		globalExpect(rp.result).toBeUndefined();
+	});
+	it("transitions to fulfilled", async () => {
+		const rp = new ReactivePromise((resolve) => resolve(42));
+		await rp;
+		globalExpect(rp.state).toBe("fulfilled");
+		globalExpect(rp.value).toBe(42);
+		globalExpect(rp.reason).toBeUndefined();
+		globalExpect(rp.result).toBe(42);
+	});
+	it("transitions to rejected", async () => {
+		const err = /* @__PURE__ */ new Error("fail");
+		const rp = new ReactivePromise((_, reject) => reject(err));
+		await rp.catch(() => {});
+		globalExpect(rp.state).toBe("rejected");
+		globalExpect(rp.reason).toBe(err);
+		globalExpect(rp.value).toBeUndefined();
+		globalExpect(rp.result).toBe(err);
+	});
+	it("unwraps a PromiseLike value", async () => {
+		const rp = new ReactivePromise((resolve) => resolve(Promise.resolve(99)));
+		await rp;
+		globalExpect(rp.value).toBe(99);
+	});
+	it("state and value update atomically — no inconsistent intermediate state", async () => {
+		const rp = new ReactivePromise((resolve) => resolve(7));
+		const snapshots = [];
+		const stop = effect(() => {
+			snapshots.push({
+				state: rp.state,
+				value: rp.value
+			});
+		});
+		await rp;
+		stop();
+		globalExpect(snapshots.find((s) => s.state === "fulfilled" && s.value === void 0)).toBeUndefined();
+		globalExpect(snapshots.at(-1)).toEqual({
+			state: "fulfilled",
+			value: 7
+		});
+	});
+	it("state and reason update atomically on rejection", async () => {
+		const err = /* @__PURE__ */ new Error("oops");
+		const rp = new ReactivePromise((_, reject) => reject(err));
+		const snapshots = [];
+		const stop = effect(() => {
+			snapshots.push({
+				state: rp.state,
+				reason: rp.reason
+			});
+		});
+		await rp.catch(() => {});
+		stop();
+		globalExpect(snapshots.find((s) => s.state === "rejected" && s.reason === void 0)).toBeUndefined();
+		globalExpect(snapshots.at(-1)).toEqual({
+			state: "rejected",
+			reason: err
+		});
+	});
+	it("ReactivePromise.from() wraps an existing Promise", async () => {
+		const rp = ReactivePromise.from(Promise.resolve("hello"));
+		await rp;
+		globalExpect(rp.state).toBe("fulfilled");
+		globalExpect(rp.value).toBe("hello");
+	});
+});
+describe("promise()", () => {
+	it("is instanceof ReactivePromise", () => {
+		globalExpect(promise(() => {}) instanceof ReactivePromise).toBe(true);
+	});
+	it("returns undefined while pending", () => {
+		const cp = promise(() => {});
+		globalExpect(cp()).toBeUndefined();
+		globalExpect(cp.state).toBe("pending");
+	});
+	it("returns the resolved value when fulfilled", async () => {
+		const cp = promise((resolve) => resolve(42));
+		await cp;
+		globalExpect(cp()).toBe(42);
+	});
+	it("returns the rejection reason when rejected", async () => {
+		const err = /* @__PURE__ */ new Error("fail");
+		const cp = promise((_, reject) => reject(err));
+		await cp.catch(() => {});
+		globalExpect(cp()).toBe(err);
+	});
+	it("wraps an existing Promise", async () => {
+		const cp = promise(Promise.resolve("hi"));
+		await cp;
+		globalExpect(cp()).toBe("hi");
+	});
+	it("passes through a ReactivePromise", async () => {
+		const cp = promise(new ReactivePromise((resolve) => resolve(5)));
+		await cp;
+		globalExpect(cp()).toBe(5);
+	});
+	it("is awaitable — resolves to the fulfilled value", async () => {
+		globalExpect(await promise((resolve) => resolve(100))).toBe(100);
+	});
+	it("is awaitable — rejects on failure", async () => {
+		const err = /* @__PURE__ */ new Error("bad");
+		const cp = promise((_, reject) => reject(err));
+		let caught;
+		await cp.catch((e) => {
+			caught = e;
+		});
+		globalExpect(caught).toBe(err);
+	});
+	it("delegates .then()", async () => {
+		globalExpect(await promise((resolve) => resolve(3)).then((v) => v * 2)).toBe(6);
+	});
+	it("delegates .catch()", async () => {
+		const err = /* @__PURE__ */ new Error("caught");
+		globalExpect(await promise((_, reject) => reject(err)).catch((e) => e)).toBe(err);
+	});
+	it("cp.catch handler runs on rejection", async () => {
+		const err = /* @__PURE__ */ new Error("caught");
+		const cp = promise((_, reject) => reject(err));
+		const caught = [];
+		await cp.catch((e) => caught.push(e));
+		globalExpect(caught).toEqual([err]);
+	});
+	it("is reactive — effect reruns on fulfillment", async () => {
+		const cp = promise((resolve) => resolve(1));
+		const values = [];
+		const stop = effect(() => {
+			values.push(cp.value);
+		});
+		await cp;
+		stop();
+		globalExpect(values).toEqual([void 0, 1]);
+	});
+	it("is reactive — effect reruns on rejection", async () => {
+		const err = /* @__PURE__ */ new Error("x");
+		const cp = promise((_, reject) => reject(err));
+		const results = [];
+		const stop = effect(() => {
+			results.push(cp());
+		});
+		await cp.catch(() => {});
+		stop();
+		globalExpect(results).toEqual([void 0, err]);
+	});
+});
+//#endregion
+export {};

package/dist/utilities/resize-observer.mjs

@@ -1,4 +1,4 @@
-import { f as onCleanup } from "../signals-DcgXhkU2.mjs";
+import { g as onCleanup } from "../signals-BHmWX6ox.mjs";
 //#region src/utilities/resize-observer.ts
 /**
 * Raw `ResizeObserver` wrapper with automatic cleanup.

package/dist/utilities/retry.d.mts

@@ -0,0 +1,10 @@
+//#region src/utilities/retry.d.ts
+type RetryDelay = number | ((attempt: number) => number);
+/**
+ * Wraps `fn` to retry up to `attempts` times on failure.
+ * Delay (if provided) is inserted between failures only — not after the last.
+ * Each attempt runs in an effect scope so `onCleanup` inside `fn` fires before each retry.
+ */
+declare function retry<T>(fn: () => Promise<T>, attempts: number, delay?: RetryDelay): () => Promise<T>;
+//#endregion
+export { retry };

package/dist/utilities/retry.mjs

@@ -0,0 +1,32 @@
+import { u as effect, y as untracked } from "../signals-BHmWX6ox.mjs";
+//#region src/utilities/retry.ts
+/**
+* Wraps `fn` to retry up to `attempts` times on failure.
+* Delay (if provided) is inserted between failures only — not after the last.
+* Each attempt runs in an effect scope so `onCleanup` inside `fn` fires before each retry.
+*/
+function retry(fn, attempts, delay) {
+	return async () => {
+		let last;
+		for (let i = 0; i < attempts; i++) {
+			let stop = () => {};
+			try {
+				const result = await new Promise((res, rej) => {
+					stop = effect(() => untracked(() => fn().then(res, rej)));
+				});
+				stop();
+				return result;
+			} catch (err) {
+				stop();
+				last = err;
+				if (i < attempts - 1 && delay !== void 0) {
+					const ms = typeof delay === "function" ? delay(i) : delay;
+					await new Promise((r) => setTimeout(r, ms));
+				}
+			}
+		}
+		throw last;
+	};
+}
+//#endregion
+export { retry };

package/dist/utilities/retry.test.d.mts

@@ -0,0 +1 @@
+export { };