@mtkruto/node 0.63.2 → 0.63.4

package/script/deps/jsr.io/@std/async/1.0.12/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/deadline.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;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,CAIZ"}

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

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright 2018-2025 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.
+ * @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 = [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.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/script/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/script/deps/jsr.io/@std/async/1.0.12/debounce.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright 2018-2025 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.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/script/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/script/deps/jsr.io/@std/async/1.0.12/delay.js

@@ -0,0 +1,91 @@
+"use strict";
+// Copyright 2018-2025 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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+/** Options for {@linkcode delay}. */
+const dntShim = __importStar(require("../../../../../_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 });
+ * // ...
+ * ```
+ */
+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/script/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/script/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/script/deps/jsr.io/@std/async/1.0.12/mod.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright 2018-2025 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 | 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
+ */
+__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.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/script/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/script/deps/jsr.io/@std/async/1.0.12/mux_async_iterator.js

@@ -0,0 +1,174 @@
+"use strict";
+// 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;
+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 {
+    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();
+    }
+}
+exports.MuxAsyncIterator = MuxAsyncIterator;

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