@seyuna/cli 1.0.0-canary.23 → 1.0.0-canary.25

package/esm/deps/jsr.io/@std/async/1.0.16/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.16/delay.d.ts

@@ -0,0 +1,43 @@
+/** Options for {@linkcode delay}. */
+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.16/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/delay.ts"],"names":[],"mappings":"AAGA,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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.16/delay.js

@@ -0,0 +1,78 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * 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 = setArbitraryLengthTimeout(done, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (persistent === false) {
+            try {
+                Deno.unrefTimer(+i);
+            }
+            catch (error) {
+                if (!(error instanceof ReferenceError)) {
+                    clearTimeout(+i);
+                    throw error;
+                }
+                // deno-lint-ignore no-console
+                console.error("`persistent` option is only available in Deno");
+            }
+        }
+    });
+}
+const I32_MAX = 2 ** 31 - 1;
+function setArbitraryLengthTimeout(callback, delay) {
+    // ensure non-negative integer (but > I32_MAX is OK, even if Infinity)
+    let currentDelay = delay = Math.trunc(Math.max(delay, 0) || 0);
+    const start = Date.now();
+    let timeoutId;
+    const queueTimeout = () => {
+        currentDelay = delay - (Date.now() - start);
+        timeoutId = currentDelay > I32_MAX
+            ? Number(setTimeout(queueTimeout, I32_MAX))
+            : Number(setTimeout(callback, currentDelay));
+    };
+    queueTimeout();
+    return { valueOf: () => timeoutId };
+}

package/esm/deps/jsr.io/@std/async/1.0.16/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.16/mod.d.ts.map

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

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

package/esm/deps/jsr.io/@std/async/1.0.16/pool.js

@@ -0,0 +1,99 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/** Error message emitted from the thrown error while mapping. */
+const ERROR_WHILE_MAPPING_MESSAGE = "Cannot complete the mapping as an error was thrown from an item";
+/**
+ * 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 function pooledMap(poolLimit, array, iteratorFn) {
+    // Create the async iterable that is returned from this function.
+    const res = new TransformStream({
+        async transform(p, controller) {
+            try {
+                const s = await p;
+                controller.enqueue(s);
+            }
+            catch (e) {
+                if (e instanceof AggregateError &&
+                    e.message === ERROR_WHILE_MAPPING_MESSAGE) {
+                    controller.error(e);
+                }
+            }
+        },
+    });
+    // Start processing items from the iterator
+    (async () => {
+        const writer = res.writable.getWriter();
+        const executing = [];
+        try {
+            for await (const item of array) {
+                const p = Promise.resolve().then(() => iteratorFn(item));
+                // Only write on success. If we `writer.write()` a rejected promise,
+                // that will end the iteration. We don't want that yet. Instead let it
+                // fail the race, taking us to the catch block where all currently
+                // executing jobs are allowed to finish and all rejections among them
+                // can be reported together.
+                writer.write(p);
+                const e = p.then(() => executing.splice(executing.indexOf(e), 1));
+                executing.push(e);
+                if (executing.length >= poolLimit) {
+                    await Promise.race(executing);
+                }
+            }
+            // Wait until all ongoing events have processed, then close the writer.
+            await Promise.all(executing);
+            writer.close();
+        }
+        catch {
+            const errors = [];
+            for (const result of await Promise.allSettled(executing)) {
+                if (result.status === "rejected") {
+                    errors.push(result.reason);
+                }
+            }
+            writer.write(Promise.reject(new AggregateError(errors, ERROR_WHILE_MAPPING_MESSAGE))).catch(() => { });
+        }
+    })();
+    // Feature test until browser coverage is adequate
+    return Symbol.asyncIterator in res.readable &&
+        typeof res.readable[Symbol.asyncIterator] === "function"
+        ? res.readable[Symbol.asyncIterator]()
+        : (async function* () {
+            const reader = res.readable.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                yield value;
+            }
+            reader.releaseLock();
+        })();
+}