@mtkruto/browser 0.128.0 → 0.129.0

package/esm/deps/jsr.io/@std/async/1.2.0/deadline.d.ts

@@ -1,37 +0,0 @@
-/** Options for {@linkcode deadline}. */
-export interface DeadlineOptions {
-    /** Signal used to abort the deadline. */
-    signal?: AbortSignal;
-}
-/**
- * Create a promise which will be rejected with {@linkcode DOMException} when
- * a given delay is exceeded.
- *
- * Note: Prefer to use {@linkcode AbortSignal.timeout} instead for the APIs
- * that accept {@linkcode AbortSignal}.
- *
- * @throws {DOMException & { name: "TimeoutError" }} If the provided duration
- * runs out before resolving.
- * @throws {DOMException & { name: "AbortError" }} If the optional signal is
- * aborted with the default `reason` before resolving or timing out.
- * @throws {AbortSignal["reason"]} If the optional signal is aborted with a
- * custom `reason` before resolving or timing out.
- * @typeParam T The type of the provided and returned promise.
- * @param p The promise to make rejectable.
- * @param ms Duration in milliseconds for when the promise should time out. If
- * greater than `Number.MAX_SAFE_INTEGER`, the deadline will never expire.
- * @param options Additional options.
- * @returns A promise that will reject if the provided duration runs out before resolving.
- *
- * @example Usage
- * ```ts ignore
- * import { deadline } from "@std/async/deadline";
- * import { delay } from "@std/async/delay";
- *
- * const delayedPromise = delay(1_000);
- * // Below throws `DOMException` after 10 ms
- * const result = await deadline(delayedPromise, 10);
- * ```
- */
-export declare function deadline<T>(p: Promise<T>, ms: number, options?: DeadlineOptions): Promise<T>;
-//# sourceMappingURL=deadline.d.ts.map

package/esm/deps/jsr.io/@std/async/1.2.0/deadline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/deadline.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,CAAC,CAKZ"}

package/esm/deps/jsr.io/@std/async/1.2.0/deadline.js

@@ -1,41 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { abortable } from "./abortable.js";
-/**
- * Create a promise which will be rejected with {@linkcode DOMException} when
- * a given delay is exceeded.
- *
- * Note: Prefer to use {@linkcode AbortSignal.timeout} instead for the APIs
- * that accept {@linkcode AbortSignal}.
- *
- * @throws {DOMException & { name: "TimeoutError" }} If the provided duration
- * runs out before resolving.
- * @throws {DOMException & { name: "AbortError" }} If the optional signal is
- * aborted with the default `reason` before resolving or timing out.
- * @throws {AbortSignal["reason"]} If the optional signal is aborted with a
- * custom `reason` before resolving or timing out.
- * @typeParam T The type of the provided and returned promise.
- * @param p The promise to make rejectable.
- * @param ms Duration in milliseconds for when the promise should time out. If
- * greater than `Number.MAX_SAFE_INTEGER`, the deadline will never expire.
- * @param options Additional options.
- * @returns A promise that will reject if the provided duration runs out before resolving.
- *
- * @example Usage
- * ```ts ignore
- * import { deadline } from "@std/async/deadline";
- * import { delay } from "@std/async/delay";
- *
- * const delayedPromise = delay(1_000);
- * // Below throws `DOMException` after 10 ms
- * const result = await deadline(delayedPromise, 10);
- * ```
- */
-export async function deadline(p, ms, options = {}) {
-    const signals = [];
-    if (ms < Number.MAX_SAFE_INTEGER)
-        signals.push(AbortSignal.timeout(ms));
-    if (options.signal)
-        signals.push(options.signal);
-    return await abortable(p, AbortSignal.any(signals));
-}

package/esm/deps/jsr.io/@std/async/1.2.0/debounce.d.ts

@@ -1,44 +0,0 @@
-/**
- * A debounced function that will be delayed by a given `wait`
- * time in milliseconds. If the method is called again before
- * the timeout expires, the previous call will be aborted.
- */
-export interface DebouncedFunction<T extends Array<unknown>> {
-    (...args: T): void;
-    /** Clears the debounce timeout and omits calling the debounced function. */
-    clear(): void;
-    /** Clears the debounce timeout and calls the debounced function immediately. */
-    flush(): void;
-    /** Returns a boolean whether a debounce call is pending or not. */
-    readonly pending: boolean;
-}
-/**
- * Creates a debounced function that delays the given `func`
- * by a given `wait` time in milliseconds. If the method is called
- * again before the timeout expires, the previous call will be
- * aborted.
- *
- * @example Usage
- * ```ts ignore
- * import { debounce } from "@std/async/debounce";
- *
- * const log = debounce(
- *   (event: Deno.FsEvent) =>
- *     console.log("[%s] %s", event.kind, event.paths[0]),
- *   200,
- * );
- *
- * for await (const event of Deno.watchFs("./")) {
- *   log(event);
- * }
- * // wait 200ms ...
- * // output: Function debounced after 200ms with baz
- * ```
- *
- * @typeParam T The arguments of the provided function.
- * @param fn The function to debounce.
- * @param wait The time in milliseconds to delay the function.
- * @returns The debounced function.
- */
-export declare function debounce<T extends Array<any>>(fn: (this: DebouncedFunction<T>, ...args: T) => void, wait: number): DebouncedFunction<T>;
-//# sourceMappingURL=debounce.d.ts.map

package/esm/deps/jsr.io/@std/async/1.2.0/debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/debounce.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC;IACzD,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAC;IACd,gFAAgF;IAChF,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAC3C,EAAE,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EACpD,IAAI,EAAE,MAAM,GACX,iBAAiB,CAAC,CAAC,CAAC,CA8BtB"}

package/esm/deps/jsr.io/@std/async/1.2.0/debounce.js

@@ -1,57 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Creates a debounced function that delays the given `func`
- * by a given `wait` time in milliseconds. If the method is called
- * again before the timeout expires, the previous call will be
- * aborted.
- *
- * @example Usage
- * ```ts ignore
- * import { debounce } from "@std/async/debounce";
- *
- * const log = debounce(
- *   (event: Deno.FsEvent) =>
- *     console.log("[%s] %s", event.kind, event.paths[0]),
- *   200,
- * );
- *
- * for await (const event of Deno.watchFs("./")) {
- *   log(event);
- * }
- * // wait 200ms ...
- * // output: Function debounced after 200ms with baz
- * ```
- *
- * @typeParam T The arguments of the provided function.
- * @param fn The function to debounce.
- * @param wait The time in milliseconds to delay the function.
- * @returns The debounced function.
- */
-// deno-lint-ignore no-explicit-any
-export function debounce(fn, wait) {
-    let timeout = null;
-    let flush = null;
-    const debounced = ((...args) => {
-        debounced.clear();
-        flush = () => {
-            debounced.clear();
-            fn.call(debounced, ...args);
-        };
-        timeout = Number(setTimeout(flush, wait));
-    });
-    debounced.clear = () => {
-        if (typeof timeout === "number") {
-            clearTimeout(timeout);
-            timeout = null;
-            flush = null;
-        }
-    };
-    debounced.flush = () => {
-        flush?.();
-    };
-    Object.defineProperty(debounced, "pending", {
-        get: () => typeof timeout === "number",
-    });
-    return debounced;
-}

package/esm/deps/jsr.io/@std/async/1.2.0/mod.d.ts

@@ -1,22 +0,0 @@
-/**
- * Provide helpers with asynchronous tasks, like {@linkcode delay},
- * {@linkcode debounce}, {@linkcode retry}, or
- * {@linkcode pooledMap}.
- *
- * ```ts no-assert
- * import { delay } from "@std/async/delay";
- *
- * await delay(100); // waits for 100 milliseconds
- * ```
- *
- * @module
- */
-export * from "./abortable.js";
-export * from "./deadline.js";
-export * from "./debounce.js";
-export * from "./delay.js";
-export * from "./mux_async_iterator.js";
-export * from "./pool.js";
-export * from "./tee.js";
-export * from "./retry.js";
-//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/async/1.2.0/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/esm/deps/jsr.io/@std/async/1.2.0/mod.js

@@ -1,23 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Provide helpers with asynchronous tasks, like {@linkcode delay},
- * {@linkcode debounce}, {@linkcode retry}, or
- * {@linkcode pooledMap}.
- *
- * ```ts no-assert
- * import { delay } from "@std/async/delay";
- *
- * await delay(100); // waits for 100 milliseconds
- * ```
- *
- * @module
- */
-export * from "./abortable.js";
-export * from "./deadline.js";
-export * from "./debounce.js";
-export * from "./delay.js";
-export * from "./mux_async_iterator.js";
-export * from "./pool.js";
-export * from "./tee.js";
-export * from "./retry.js";

package/esm/deps/jsr.io/@std/async/1.2.0/mux_async_iterator.d.ts

@@ -1,111 +0,0 @@
-/**
- * Multiplexes multiple async iterators into a single stream. It currently
- * makes an assumption that the final result (the value returned and not
- * yielded from the iterator) does not matter; if there is any result, it is
- * discarded.
- *
- * @example Usage
- * ```ts
- * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
- * import { assertEquals } from "@std/assert";
- *
- * async function* gen123(): AsyncIterableIterator<number> {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * async function* gen456(): AsyncIterableIterator<number> {
- *   yield 4;
- *   yield 5;
- *   yield 6;
- * }
- *
- * const mux = new MuxAsyncIterator<number>();
- * mux.add(gen123());
- * mux.add(gen456());
- *
- * const result = await Array.fromAsync(mux);
- *
- * assertEquals(result, [1, 4, 2, 5, 3, 6]);
- * ```
- *
- * @typeParam T The type of the provided async iterables and generated async iterable.
- */
-export declare class MuxAsyncIterator<T> implements AsyncIterable<T> {
-    #private;
-    /**
-     * Add an async iterable to the stream.
-     *
-     * @param iterable The async iterable to add.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux.iterate());
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    add(iterable: AsyncIterable<T>): void;
-    /**
-     * Returns an async iterator of the stream.
-     * @returns the async iterator for all the added async iterables.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux.iterate());
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    iterate(): AsyncIterableIterator<T>;
-    /**
-     * Implements an async iterator for the stream.
-     * @returns the async iterator for all the added async iterables.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux);
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-//# sourceMappingURL=mux_async_iterator.d.ts.map

package/esm/deps/jsr.io/@std/async/1.2.0/mux_async_iterator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mux_async_iterator.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/mux_async_iterator.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,gBAAgB,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;;IAO1D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC;IAqB9B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,OAAO,IAAI,qBAAqB,CAAC,CAAC,CAAC;IAsB1C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAG3C"}

package/esm/deps/jsr.io/@std/async/1.2.0/mux_async_iterator.js

@@ -1,154 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Multiplexes multiple async iterators into a single stream. It currently
- * makes an assumption that the final result (the value returned and not
- * yielded from the iterator) does not matter; if there is any result, it is
- * discarded.
- *
- * @example Usage
- * ```ts
- * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
- * import { assertEquals } from "@std/assert";
- *
- * async function* gen123(): AsyncIterableIterator<number> {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * async function* gen456(): AsyncIterableIterator<number> {
- *   yield 4;
- *   yield 5;
- *   yield 6;
- * }
- *
- * const mux = new MuxAsyncIterator<number>();
- * mux.add(gen123());
- * mux.add(gen456());
- *
- * const result = await Array.fromAsync(mux);
- *
- * assertEquals(result, [1, 4, 2, 5, 3, 6]);
- * ```
- *
- * @typeParam T The type of the provided async iterables and generated async iterable.
- */
-export class MuxAsyncIterator {
-    #iteratorCount = 0;
-    #yields = [];
-    // deno-lint-ignore no-explicit-any
-    #throws = [];
-    #signal = Promise.withResolvers();
-    /**
-     * Add an async iterable to the stream.
-     *
-     * @param iterable The async iterable to add.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux.iterate());
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    add(iterable) {
-        ++this.#iteratorCount;
-        this.#callIteratorNext(iterable[Symbol.asyncIterator]());
-    }
-    async #callIteratorNext(iterator) {
-        try {
-            const { value, done } = await iterator.next();
-            if (done) {
-                --this.#iteratorCount;
-            }
-            else {
-                this.#yields.push({ iterator, value });
-            }
-        }
-        catch (e) {
-            this.#throws.push(e);
-        }
-        this.#signal.resolve();
-    }
-    /**
-     * Returns an async iterator of the stream.
-     * @returns the async iterator for all the added async iterables.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux.iterate());
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    async *iterate() {
-        while (this.#iteratorCount > 0) {
-            // Sleep until any of the wrapped iterators yields.
-            await this.#signal.promise;
-            // Note that while we're looping over `yields`, new items may be added.
-            for (const { iterator, value } of this.#yields) {
-                yield value;
-                this.#callIteratorNext(iterator);
-            }
-            if (this.#throws.length) {
-                for (const e of this.#throws) {
-                    throw e;
-                }
-            }
-            // Clear the `yields` list and reset the `signal` promise.
-            this.#yields.length = 0;
-            this.#signal = Promise.withResolvers();
-        }
-    }
-    /**
-     * Implements an async iterator for the stream.
-     * @returns the async iterator for all the added async iterables.
-     *
-     * @example Usage
-     * ```ts
-     * import { MuxAsyncIterator } from "@std/async/mux-async-iterator";
-     * import { assertEquals } from "@std/assert";
-     *
-     * async function* gen123(): AsyncIterableIterator<number> {
-     *   yield 1;
-     *   yield 2;
-     *   yield 3;
-     * }
-     *
-     * const mux = new MuxAsyncIterator<number>();
-     * mux.add(gen123());
-     *
-     * const result = await Array.fromAsync(mux);
-     *
-     * assertEquals(result, [1, 2, 3]);
-     * ```
-     */
-    [Symbol.asyncIterator]() {
-        return this.iterate();
-    }
-}

package/esm/deps/jsr.io/@std/async/1.2.0/retry.d.ts

@@ -1,155 +0,0 @@
-/**
- * Error thrown in {@linkcode retry} once the maximum number of failed attempts
- * has been reached.
- *
- * @example Usage
- * ```ts no-assert ignore
- * import { RetryError } from "@std/async/retry";
- *
- * throw new RetryError({ foo: "bar" }, 3);
- * ```
- */
-export declare class RetryError extends Error {
-    /**
-     * Constructs a new {@linkcode RetryError} instance.
-     *
-     * @param cause the cause for this error.
-     * @param attempts the number of retry attempts made.
-     */
-    constructor(cause: unknown, attempts: number);
-}
-/** Options for {@linkcode retry}. */
-export interface RetryOptions {
-    /**
-     * How much to backoff after each retry.
-     *
-     * @default {2}
-     */
-    multiplier?: number;
-    /**
-     * The maximum milliseconds between attempts.
-     *
-     * @default {60000}
-     */
-    maxTimeout?: number;
-    /**
-     * The maximum amount of attempts until failure.
-     *
-     * @default {5}
-     */
-    maxAttempts?: number;
-    /**
-     * The initial and minimum amount of milliseconds between attempts.
-     *
-     * @default {1000}
-     */
-    minTimeout?: number;
-    /**
-     * Amount of jitter to introduce to the time between attempts. This is `1`
-     * for full jitter by default.
-     *
-     * @default {1}
-     */
-    jitter?: number;
-    /**
-     * Callback to determine if an error or other thrown value is retriable.
-     *
-     * @default {() => true}
-     *
-     * @param err The thrown error or other value.
-     * @returns `true` if the error is retriable, `false` otherwise.
-     */
-    isRetriable?: (err: unknown) => boolean;
-    /**
-     * An AbortSignal to cancel the retry operation.
-     *
-     * If the signal is aborted, the retry will stop and reject with the signal's
-     * reason. The signal is checked before each attempt and during the delay
-     * between attempts.
-     *
-     * @default {undefined}
-     */
-    signal?: AbortSignal;
-}
-/**
- * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
- * Retries as long as the given function throws. If the attempts are exhausted,
- * throws a {@linkcode RetryError} with `cause` set to the inner exception.
- *
- * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
- * How long the actual delay is, depends on `jitter`.
- *
- * When `jitter` is the default value of `1`, waits between two attempts for a
- * randomized amount between 0 and the backoff time. With the default options
- * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
- * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
- *
- * When `jitter` is `0`, waits the full backoff time.
- *
- * @example Example configuration 1
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- * const req = async () => {
- *  // some function that throws sometimes
- * };
- *
- * // Below resolves to the first non-error result of `req`
- * const retryPromise = await retry(req, {
- *  multiplier: 2,
- *  maxTimeout: 60000,
- *  maxAttempts: 5,
- *  minTimeout: 100,
- *  jitter: 1,
- * });
- * ```
- *
- * @example Example configuration 2
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- * const req = async () => {
- *  // some function that throws sometimes
- * };
- *
- * // Make sure we wait at least 1 minute, but at most 2 minutes
- * const retryPromise = await retry(req, {
- *  multiplier: 2.34,
- *  maxTimeout: 80000,
- *  maxAttempts: 7,
- *  minTimeout: 1000,
- *  jitter: 0.5,
- * });
- * ```
- *
- * @example Only retry on specific error types
- * ```ts no-assert
- * import { retry } from "@std/async/retry";
- *
- * class HttpError extends Error {
- *   status: number;
- *   constructor(status: number) {
- *     super(`HTTP ${status}`);
- *     this.status = status;
- *   }
- * }
- *
- * const req = async () => {
- *   // some function that throws HttpError
- * };
- *
- * // Only retry on 429 (rate limit) or 5xx (server) errors
- * const retryPromise = await retry(req, {
- *   isRetriable: (err) =>
- *     err instanceof HttpError && (err.status === 429 || err.status >= 500),
- * });
- * ```
- *
- * @typeParam T The return type of the function to retry and returned promise.
- * @param fn The function to retry.
- * @param options Additional options.
- * @returns The promise that resolves with the value returned by the function to retry.
- * @throws {RetryError} If the function fails after `maxAttempts` attempts.
- * @throws If the `signal` is aborted, throws the signal's reason.
- * @throws If `isRetriable` returns `false` for an error, throws that error immediately.
- */
-export declare function retry<T>(fn: (() => Promise<T>) | (() => T), options?: RetryOptions): Promise<T>;
-//# sourceMappingURL=retry.d.ts.map

package/esm/deps/jsr.io/@std/async/1.2.0/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/retry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;;;;OAKG;gBACS,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;CAK7C;AAED,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,CAAC,CAAC,CAoEZ"}