@mtkruto/browser 0.128.0 → 0.130.0

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"}

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

@@ -1,147 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { delay } from "./delay.js";
-import { exponentialBackoffWithJitter } from "./_util.js";
-/**
- * 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 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, attempts) {
-        super(`Retrying exceeded the maxAttempts (${attempts}).`);
-        this.name = "RetryError";
-        this.cause = cause;
-    }
-}
-/**
- * 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 async function retry(fn, options) {
-    const { multiplier = 2, maxTimeout = 60000, maxAttempts = 5, minTimeout = 1000, jitter = 1, isRetriable = () => true, signal, } = options ?? {};
-    if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-        throw new RangeError(`Cannot retry as 'maxAttempts' must be a positive integer: current value is ${maxAttempts}`);
-    }
-    if (!Number.isFinite(multiplier) || multiplier < 1) {
-        throw new RangeError(`Cannot retry as 'multiplier' must be a finite number >= 1: current value is ${multiplier}`);
-    }
-    if (Number.isNaN(maxTimeout) || maxTimeout <= 0) {
-        throw new RangeError(`Cannot retry as 'maxTimeout' must be a positive number: current value is ${maxTimeout}`);
-    }
-    if (Number.isNaN(minTimeout) || minTimeout < 0) {
-        throw new RangeError(`Cannot retry as 'minTimeout' must be >= 0: current value is ${minTimeout}`);
-    }
-    if (minTimeout > maxTimeout) {
-        throw new RangeError(`Cannot retry as 'minTimeout' must be <= 'maxTimeout': current values 'minTimeout=${minTimeout}', 'maxTimeout=${maxTimeout}'`);
-    }
-    if (Number.isNaN(jitter) || jitter < 0 || jitter > 1) {
-        throw new RangeError(`Cannot retry as 'jitter' must be between 0 and 1: current value is ${jitter}`);
-    }
-    let attempt = 0;
-    while (true) {
-        signal?.throwIfAborted();
-        try {
-            return await fn();
-        }
-        catch (error) {
-            if (!isRetriable(error)) {
-                throw error;
-            }
-            if (attempt + 1 >= maxAttempts) {
-                throw new RetryError(error, maxAttempts);
-            }
-            const timeout = exponentialBackoffWithJitter(maxTimeout, minTimeout, attempt, multiplier, jitter);
-            await delay(timeout, signal ? { signal } : undefined);
-        }
-        attempt++;
-    }
-}

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

@@ -1,43 +0,0 @@
-/**
- * Utility for representing n-tuple. Used in {@linkcode tee}.
- *
- * @internal
- */
-export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;
-/**
- * Utility for representing n-tuple of. Used in {@linkcode Tuple}.
- *
- * @internal
- */
-export type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
-/**
- * Branches the given async iterable into the `n` branches.
- *
- * @example Usage
- * ```ts
- * import { tee } from "@std/async/tee";
- * import { assertEquals } from "@std/assert";
- *
- * const gen = async function* gen() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * };
- *
- * const [branch1, branch2] = tee(gen());
- *
- * const result1 = await Array.fromAsync(branch1);
- * assertEquals(result1, [1, 2, 3]);
- *
- * const result2 = await Array.fromAsync(branch2);
- * assertEquals(result2, [1, 2, 3]);
- * ```
- *
- * @typeParam T The type of the provided async iterable and the returned async iterables.
- * @typeParam N The amount of branches to tee into.
- * @param iterable The iterable to tee.
- * @param n The amount of branches to tee into.
- * @returns The tuple where each element is an async iterable.
- */
-export declare function tee<T, N extends number = 2>(iterable: AsyncIterable<T>, n?: N): Tuple<AsyncIterable<T>, N>;
-//# sourceMappingURL=tee.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/tee.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAChD,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAC1C,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAC1D,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAuC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,GAAE,CAAU,GACZ,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAuB5B"}

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

@@ -1,79 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-class Queue {
-    #source;
-    #queue;
-    head;
-    done;
-    constructor(iterable) {
-        this.#source = iterable[Symbol.asyncIterator]();
-        this.#queue = {
-            value: undefined,
-            next: undefined,
-        };
-        this.head = this.#queue;
-        this.done = false;
-    }
-    async next() {
-        const result = await this.#source.next();
-        if (!result.done) {
-            const nextNode = {
-                value: result.value,
-                next: undefined,
-            };
-            this.#queue.next = nextNode;
-            this.#queue = nextNode;
-        }
-        else {
-            this.done = true;
-        }
-    }
-}
-/**
- * Branches the given async iterable into the `n` branches.
- *
- * @example Usage
- * ```ts
- * import { tee } from "@std/async/tee";
- * import { assertEquals } from "@std/assert";
- *
- * const gen = async function* gen() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * };
- *
- * const [branch1, branch2] = tee(gen());
- *
- * const result1 = await Array.fromAsync(branch1);
- * assertEquals(result1, [1, 2, 3]);
- *
- * const result2 = await Array.fromAsync(branch2);
- * assertEquals(result2, [1, 2, 3]);
- * ```
- *
- * @typeParam T The type of the provided async iterable and the returned async iterables.
- * @typeParam N The amount of branches to tee into.
- * @param iterable The iterable to tee.
- * @param n The amount of branches to tee into.
- * @returns The tuple where each element is an async iterable.
- */
-export function tee(iterable, n = 2) {
-    const queue = new Queue(iterable);
-    async function* generator() {
-        let buffer = queue.head;
-        while (true) {
-            if (buffer.next) {
-                buffer = buffer.next;
-                yield buffer.value;
-            }
-            else if (queue.done) {
-                return;
-            }
-            else {
-                await queue.next();
-            }
-        }
-    }
-    return Array.from({ length: n }).map(() => generator());
-}

package/script/deps/jsr.io/@std/async/1.2.0/_util.d.ts

@@ -1,2 +0,0 @@
-export declare function exponentialBackoffWithJitter(cap: number, base: number, attempt: number, multiplier: number, jitter: number): number;
-//# sourceMappingURL=_util.d.ts.map

package/script/deps/jsr.io/@std/async/1.2.0/_util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/_util.ts"],"names":[],"mappings":"AAGA,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,UAIf"}

package/script/deps/jsr.io/@std/async/1.2.0/_util.js

@@ -1,9 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exponentialBackoffWithJitter = exponentialBackoffWithJitter;
-function exponentialBackoffWithJitter(cap, base, attempt, multiplier, jitter) {
-    const exp = Math.min(cap, base * multiplier ** attempt);
-    return (1 - jitter * Math.random()) * exp;
-}

package/script/deps/jsr.io/@std/async/1.2.0/abortable.d.ts

@@ -1,107 +0,0 @@
-/**
- * Make a {@linkcode Promise} abortable with the given signal.
- *
- * @throws {DOMException} If the signal is already aborted and `signal.reason`
- * is undefined. Otherwise, throws `signal.reason`.
- * @typeParam T The type of the provided and returned promise.
- * @param p The promise to make abortable.
- * @param signal The signal to abort the promise with.
- * @returns A promise that can be aborted.
- *
- * @example Error-handling a timeout
- * ```ts ignore
- * import { abortable, delay } from "@std/async";
- * import { assertRejects, assertEquals } from "@std/assert";
- *
- * const promise = delay(1_000);
- *
- * // Rejects with `DOMException` after 100 ms
- * await assertRejects(
- *   () => abortable(promise, AbortSignal.timeout(100)),
- *   DOMException,
- *   "Signal timed out."
- * );
- * ```
- *
- * @example Error-handling an abort
- * ```ts ignore
- * import { abortable, delay } from "@std/async";
- * import { assertRejects, assertEquals } from "@std/assert";
- *
- * const promise = delay(1_000);
- * const controller = new AbortController();
- * controller.abort(new Error("This is my reason"));
- *
- * // Rejects with `DOMException` immediately
- * await assertRejects(
- *   () => abortable(promise, controller.signal),
- *   Error,
- *   "This is my reason"
- * );
- * ```
- */
-export declare function abortable<T>(p: Promise<T>, signal: AbortSignal): Promise<T>;
-/**
- * Make an {@linkcode AsyncIterable} abortable with the given signal.
- *
- * @throws {DOMException} If the signal is already aborted and `signal.reason`
- * is undefined. Otherwise, throws `signal.reason`.
- * @typeParam T The type of the provided and returned async iterable.
- * @param p The async iterable to make abortable.
- * @param signal The signal to abort the promise with.
- * @returns An async iterable that can be aborted.
- *
- * @example Error-handling a timeout
- * ```ts
- * import { abortable, delay } from "@std/async";
- * import { assertRejects, assertEquals } from "@std/assert";
- *
- * const asyncIter = async function* () {
- *   yield "Hello";
- *   await delay(1_000);
- *   yield "World";
- * };
- *
- * const items: string[] = [];
- * // Below throws `DOMException` after 100 ms and items become `["Hello"]`
- * await assertRejects(
- *   async () => {
- *     for await (const item of abortable(asyncIter(), AbortSignal.timeout(100))) {
- *       items.push(item);
- *     }
- *   },
- *   DOMException,
- *   "Signal timed out."
- * );
- * assertEquals(items, ["Hello"]);
- * ```
- *
- * @example Error-handling an abort
- * ```ts
- * import { abortable, delay } from "@std/async";
- * import { assertRejects, assertEquals } from "@std/assert";
- *
- * const asyncIter = async function* () {
- *   yield "Hello";
- *   await delay(1_000);
- *   yield "World";
- * };
- * const controller = new AbortController();
- * controller.abort(new Error("This is my reason"));
- *
- * const items: string[] = [];
- * // Below throws `DOMException` immediately
- * await assertRejects(
- *   async () => {
- *     for await (const item of abortable(asyncIter(), controller.signal)) {
- *       items.push(item);
- *     }
- *   },
- *   Error,
- *   "This is my reason"
- * );
- * assertEquals(items, []);
- * ```
- */
-export declare function abortable<T>(p: AsyncIterable<T>, signal: AbortSignal): AsyncGenerator<T>;
-//# sourceMappingURL=abortable.d.ts.map

package/script/deps/jsr.io/@std/async/1.2.0/abortable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/abortable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC"}

package/script/deps/jsr.io/@std/async/1.2.0/abortable.js

@@ -1,49 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.abortable = abortable;
-function abortable(p, signal) {
-    if (p instanceof Promise) {
-        return abortablePromise(p, signal);
-    }
-    else {
-        return abortableAsyncIterable(p, signal);
-    }
-}
-function abortablePromise(p, signal) {
-    const { promise, reject } = Promise.withResolvers();
-    const abort = () => reject(signal.reason);
-    if (signal.aborted)
-        abort();
-    signal.addEventListener("abort", abort, { once: true });
-    return Promise.race([promise, p]).finally(() => {
-        signal.removeEventListener("abort", abort);
-    });
-}
-async function* abortableAsyncIterable(p, signal) {
-    signal.throwIfAborted();
-    const { promise, reject } = Promise.withResolvers();
-    const abort = () => reject(signal.reason);
-    signal.addEventListener("abort", abort, { once: true });
-    const it = p[Symbol.asyncIterator]();
-    try {
-        while (true) {
-            const race = Promise.race([promise, it.next()]);
-            race.catch(() => {
-                signal.removeEventListener("abort", abort);
-            });
-            const { done, value } = await race;
-            if (done) {
-                signal.removeEventListener("abort", abort);
-                const result = await it.return?.(value);
-                return result?.value;
-            }
-            yield value;
-        }
-    }
-    catch (e) {
-        await it.return?.();
-        throw e;
-    }
-}

package/script/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/script/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"}