@mtkruto/browser 0.128.0 → 0.129.0

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

@@ -1,39 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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
- */
-__exportStar(require("./abortable.js"), exports);
-__exportStar(require("./deadline.js"), exports);
-__exportStar(require("./debounce.js"), exports);
-__exportStar(require("./delay.js"), exports);
-__exportStar(require("./mux_async_iterator.js"), exports);
-__exportStar(require("./pool.js"), exports);
-__exportStar(require("./tee.js"), exports);
-__exportStar(require("./retry.js"), exports);

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

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

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

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetryError = void 0;
-exports.retry = retry;
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-const delay_js_1 = require("./delay.js");
-const _util_js_1 = require("./_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);
- * ```
- */
-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;
-    }
-}
-exports.RetryError = RetryError;
-/**
- * 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.
- */
-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 = (0, _util_js_1.exponentialBackoffWithJitter)(maxTimeout, minTimeout, attempt, multiplier, jitter);
-            await (0, delay_js_1.delay)(timeout, signal ? { signal } : undefined);
-        }
-        attempt++;
-    }
-}

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