@mtkruto/browser 0.127.0 → 0.129.0

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

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

@@ -1,44 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deadline = deadline;
-const abortable_js_1 = require("./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);
- * ```
- */
-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 (0, abortable_js_1.abortable)(p, AbortSignal.any(signals));
-}

package/script/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/script/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/script/deps/jsr.io/@std/async/1.2.0/debounce.js

@@ -1,60 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debounce = debounce;
-/**
- * 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
-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/script/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/script/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"}