@mtkruto/node 0.63.3 → 0.63.4

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

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

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

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