@mtkruto/node 0.63.3 → 0.63.6

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

@@ -0,0 +1,38 @@
+// Copyright 2018-2025 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.
+ * @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 = [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.0.12/debounce.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.0.12/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/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.0.12/debounce.js

@@ -0,0 +1,57 @@
+// Copyright 2018-2025 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.0.12/delay.d.ts

@@ -0,0 +1,42 @@
+export interface DelayOptions {
+    /** Signal used to abort the delay. */
+    signal?: AbortSignal;
+    /** Indicates whether the process should continue to run as long as the timer exists.
+     *
+     * @default {true}
+     */
+    persistent?: boolean;
+}
+/**
+ * Resolve a {@linkcode Promise} after a given amount of milliseconds.
+ *
+ * @throws {DOMException} If the optional signal is aborted before the delay
+ * duration, and `signal.reason` is undefined.
+ * @param ms Duration in milliseconds for how long the delay should last.
+ * @param options Additional options.
+ *
+ * @example Basic usage
+ * ```ts no-assert
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * const delayedPromise = delay(100);
+ * const result = await delayedPromise;
+ * // ...
+ * ```
+ *
+ * @example Disable persistence
+ *
+ * Setting `persistent` to `false` will allow the process to continue to run as
+ * long as the timer exists.
+ *
+ * ```ts no-assert ignore
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * await delay(100, { persistent: false });
+ * // ...
+ * ```
+ */
+export declare function delay(ms: number, options?: DelayOptions): Promise<void>;
+//# sourceMappingURL=delay.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.12/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/delay.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E"}

package/esm/deps/jsr.io/@std/async/1.0.12/delay.js

@@ -0,0 +1,65 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/** Options for {@linkcode delay}. */
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * Resolve a {@linkcode Promise} after a given amount of milliseconds.
+ *
+ * @throws {DOMException} If the optional signal is aborted before the delay
+ * duration, and `signal.reason` is undefined.
+ * @param ms Duration in milliseconds for how long the delay should last.
+ * @param options Additional options.
+ *
+ * @example Basic usage
+ * ```ts no-assert
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * const delayedPromise = delay(100);
+ * const result = await delayedPromise;
+ * // ...
+ * ```
+ *
+ * @example Disable persistence
+ *
+ * Setting `persistent` to `false` will allow the process to continue to run as
+ * long as the timer exists.
+ *
+ * ```ts no-assert ignore
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * await delay(100, { persistent: false });
+ * // ...
+ * ```
+ */
+export function delay(ms, options = {}) {
+    const { signal, persistent = true } = options;
+    if (signal?.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(i);
+            reject(signal?.reason);
+        };
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const i = setTimeout(done, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (persistent === false) {
+            try {
+                // @ts-ignore For browser compatibility
+                dntShim.Deno.unrefTimer(i);
+            }
+            catch (error) {
+                if (!(error instanceof ReferenceError)) {
+                    throw error;
+                }
+                // deno-lint-ignore no-console
+                console.error("`persistent` option is only available in Deno");
+            }
+        }
+    });
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Provide helpers with asynchronous tasks like {@linkcode delay | delays},
+ * {@linkcode debounce | debouncing}, {@linkcode retry | retrying}, or
+ * {@linkcode pooledMap | pooling}.
+ *
+ * ```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.0.12/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/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.0.12/mod.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Provide helpers with asynchronous tasks like {@linkcode delay | delays},
+ * {@linkcode debounce | debouncing}, {@linkcode retry | retrying}, or
+ * {@linkcode pooledMap | pooling}.
+ *
+ * ```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.0.12/mux_async_iterator.d.ts

@@ -0,0 +1,111 @@
+/**
+ * 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.0.12/mux_async_iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mux_async_iterator.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/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.0.12/mux_async_iterator.js

@@ -0,0 +1,170 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _MuxAsyncIterator_instances, _MuxAsyncIterator_iteratorCount, _MuxAsyncIterator_yields, _MuxAsyncIterator_throws, _MuxAsyncIterator_signal, _MuxAsyncIterator_callIteratorNext;
+/**
+ * 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 {
+    constructor() {
+        _MuxAsyncIterator_instances.add(this);
+        _MuxAsyncIterator_iteratorCount.set(this, 0);
+        _MuxAsyncIterator_yields.set(this, []);
+        // deno-lint-ignore no-explicit-any
+        _MuxAsyncIterator_throws.set(this, []);
+        _MuxAsyncIterator_signal.set(this, 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) {
+        var _a;
+        __classPrivateFieldSet(this, _MuxAsyncIterator_iteratorCount, (_a = __classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f"), ++_a), "f");
+        __classPrivateFieldGet(this, _MuxAsyncIterator_instances, "m", _MuxAsyncIterator_callIteratorNext).call(this, iterable[Symbol.asyncIterator]());
+    }
+    /**
+     * 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 (__classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f") > 0) {
+            // Sleep until any of the wrapped iterators yields.
+            await __classPrivateFieldGet(this, _MuxAsyncIterator_signal, "f").promise;
+            // Note that while we're looping over `yields`, new items may be added.
+            for (const { iterator, value } of __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f")) {
+                yield value;
+                __classPrivateFieldGet(this, _MuxAsyncIterator_instances, "m", _MuxAsyncIterator_callIteratorNext).call(this, iterator);
+            }
+            if (__classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f").length) {
+                for (const e of __classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f")) {
+                    throw e;
+                }
+            }
+            // Clear the `yields` list and reset the `signal` promise.
+            __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f").length = 0;
+            __classPrivateFieldSet(this, _MuxAsyncIterator_signal, Promise.withResolvers(), "f");
+        }
+    }
+    /**
+     * 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]);
+     * ```
+     */
+    [(_MuxAsyncIterator_iteratorCount = new WeakMap(), _MuxAsyncIterator_yields = new WeakMap(), _MuxAsyncIterator_throws = new WeakMap(), _MuxAsyncIterator_signal = new WeakMap(), _MuxAsyncIterator_instances = new WeakSet(), _MuxAsyncIterator_callIteratorNext = async function _MuxAsyncIterator_callIteratorNext(iterator) {
+        var _a;
+        try {
+            const { value, done } = await iterator.next();
+            if (done) {
+                __classPrivateFieldSet(this, _MuxAsyncIterator_iteratorCount, (_a = __classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f"), --_a), "f");
+            }
+            else {
+                __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f").push({ iterator, value });
+            }
+        }
+        catch (e) {
+            __classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f").push(e);
+        }
+        __classPrivateFieldGet(this, _MuxAsyncIterator_signal, "f").resolve();
+    }, Symbol.asyncIterator)]() {
+        return this.iterate();
+    }
+}

package/esm/deps/jsr.io/@std/async/1.0.12/pool.d.ts

@@ -0,0 +1,33 @@
+/**
+ * pooledMap transforms values from an (async) iterable into another async
+ * iterable. The transforms are done concurrently, with a max concurrency
+ * defined by the poolLimit.
+ *
+ * If an error is thrown from `iterableFn`, no new transformations will begin.
+ * All currently executing transformations are allowed to finish and still
+ * yielded on success. After that, the rejections among them are gathered and
+ * thrown by the iterator in an `AggregateError`.
+ *
+ * @example Usage
+ * ```ts
+ * import { pooledMap } from "@std/async/pool";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const results = pooledMap(
+ *   2,
+ *   [1, 2, 3],
+ *   (i) => new Promise((r) => setTimeout(() => r(i), 1000)),
+ * );
+ *
+ * assertEquals(await Array.fromAsync(results), [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T the input type.
+ * @typeParam R the output type.
+ * @param poolLimit The maximum count of items being processed concurrently.
+ * @param array The input array for mapping.
+ * @param iteratorFn The function to call for every item of the array.
+ * @returns The async iterator with the transformed values.
+ */
+export declare function pooledMap<T, R>(poolLimit: number, array: Iterable<T> | AsyncIterable<T>, iteratorFn: (data: T) => Promise<R>): AsyncIterableIterator<R>;
+//# sourceMappingURL=pool.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.12/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/pool.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACrC,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,qBAAqB,CAAC,CAAC,CAAC,CAqE1B"}