@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/external/streaming-iterables.js

@@ -1,1061 +1,844 @@
 "use strict";
 /**
  * Bundled from streaming-iterables
- * This is a zero-dependency bundle created by esbuild.
+ * This is a zero-dependency bundle created by rolldown.
  */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+'use strict';
 
-// node_modules/.pnpm/streaming-iterables@8.0.1/node_modules/streaming-iterables/dist/index.js
-var require_dist = __commonJS({
-  "node_modules/.pnpm/streaming-iterables@8.0.1/node_modules/streaming-iterables/dist/index.js"(exports2, module2) {
-    (function(global, factory) {
-      typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.streamingIterables = {}));
-    })(exports2, (function(exports3) {
-      "use strict";
-      async function* _batch(size, iterable) {
-        let dataBatch = [];
-        for await (const data of iterable) {
-          dataBatch.push(data);
-          if (dataBatch.length === size) {
-            yield dataBatch;
-            dataBatch = [];
-          }
-        }
-        if (dataBatch.length > 0) {
-          yield dataBatch;
-        }
-      }
-      __name(_batch, "_batch");
-      function* _syncBatch(size, iterable) {
-        let dataBatch = [];
-        for (const data of iterable) {
-          dataBatch.push(data);
-          if (dataBatch.length === size) {
-            yield dataBatch;
-            dataBatch = [];
-          }
-        }
-        if (dataBatch.length > 0) {
-          yield dataBatch;
-        }
-      }
-      __name(_syncBatch, "_syncBatch");
-      function batch(size, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => batch(size, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator]) {
-          return _batch(size, iterable);
-        }
-        return _syncBatch(size, iterable);
-      }
-      __name(batch, "batch");
-      const TIMEOUT = Symbol("TIMEOUT");
-      const createTimer = /* @__PURE__ */ __name((duration) => {
-        let timeoutId;
-        return [
-          new Promise((resolve) => {
-            timeoutId = setTimeout(() => resolve(TIMEOUT), duration);
-          }),
-          () => {
-            clearTimeout(timeoutId);
-          }
-        ];
-      }, "createTimer");
-      async function* _batchWithTimeout(size, timeout, iterable) {
-        const iterator = iterable[Symbol.asyncIterator]();
-        let pendingData;
-        let batchData = [];
-        let timer;
-        let clearTimer;
-        const startTimer = /* @__PURE__ */ __name(() => {
-          deleteTimer();
-          [timer, clearTimer] = createTimer(timeout);
-        }, "startTimer");
-        const deleteTimer = /* @__PURE__ */ __name(() => {
-          if (clearTimer) {
-            clearTimer();
-          }
-          timer = void 0;
-        }, "deleteTimer");
-        pendingData = iterator.next();
-        while (true) {
-          const res = await (timer ? Promise.race([pendingData, timer]) : pendingData);
-          if (res === TIMEOUT || res.done) {
-            if (batchData.length) {
-              yield batchData;
-              batchData = [];
-            }
-            deleteTimer();
-            if (res !== TIMEOUT) {
-              break;
-            }
-            continue;
-          }
-          pendingData = iterator.next();
-          batchData.push(res.value);
-          if (batchData.length === 1) {
-            startTimer();
-          }
-          if (batchData.length === size) {
-            yield batchData;
-            batchData = [];
-            deleteTimer();
-            continue;
-          }
-        }
-      }
-      __name(_batchWithTimeout, "_batchWithTimeout");
-      function batchWithTimeout(size, timeout, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => batchWithTimeout(size, timeout, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator] && timeout !== Infinity) {
-          return _batchWithTimeout(size, timeout, iterable);
-        }
-        return batch(size, iterable);
-      }
-      __name(batchWithTimeout, "batchWithTimeout");
-      function getIterator(iterable) {
-        if (typeof iterable.next === "function") {
-          return iterable;
-        }
-        if (typeof iterable[Symbol.iterator] === "function") {
-          return iterable[Symbol.iterator]();
-        }
-        if (typeof iterable[Symbol.asyncIterator] === "function") {
-          return iterable[Symbol.asyncIterator]();
-        }
-        throw new TypeError('"values" does not to conform to any of the iterator or iterable protocols');
-      }
-      __name(getIterator, "getIterator");
-      function defer() {
-        let reject;
-        let resolve;
-        const promise = new Promise((resolveFunc, rejectFunc) => {
-          resolve = resolveFunc;
-          reject = rejectFunc;
-        });
-        return {
-          promise,
-          reject,
-          resolve
-        };
-      }
-      __name(defer, "defer");
-      function _buffer(size, iterable) {
-        const iterator = getIterator(iterable);
-        const resultQueue = [];
-        const readQueue = [];
-        let reading = false;
-        let ended = false;
-        function fulfillReadQueue() {
-          while (readQueue.length > 0 && resultQueue.length > 0) {
-            const readDeferred = readQueue.shift();
-            const { error, value } = resultQueue.shift();
-            if (error) {
-              readDeferred.reject(error);
-            } else {
-              readDeferred.resolve({ done: false, value });
-            }
-          }
-          while (readQueue.length > 0 && ended) {
-            const { resolve } = readQueue.shift();
-            resolve({ done: true, value: void 0 });
-          }
-        }
-        __name(fulfillReadQueue, "fulfillReadQueue");
-        async function fillQueue() {
-          if (ended) {
-            return;
-          }
-          if (reading) {
-            return;
-          }
-          if (resultQueue.length >= size) {
-            return;
-          }
-          reading = true;
-          try {
-            const { done, value } = await iterator.next();
-            if (done) {
-              ended = true;
-            } else {
-              resultQueue.push({ value });
-            }
-          } catch (error) {
-            ended = true;
-            resultQueue.push({ error });
-          }
-          fulfillReadQueue();
-          reading = false;
-          fillQueue();
-        }
-        __name(fillQueue, "fillQueue");
-        async function next() {
-          if (resultQueue.length > 0) {
-            const { error, value } = resultQueue.shift();
-            if (error) {
-              throw error;
-            }
-            fillQueue();
-            return { done: false, value };
-          }
-          if (ended) {
-            return { done: true, value: void 0 };
-          }
-          const deferred = defer();
-          readQueue.push(deferred);
-          fillQueue();
-          return deferred.promise;
-        }
-        __name(next, "next");
-        const asyncIterableIterator = {
-          next,
-          [Symbol.asyncIterator]: () => asyncIterableIterator
-        };
-        return asyncIterableIterator;
-      }
-      __name(_buffer, "_buffer");
-      function* syncBuffer(size, iterable) {
-        const valueQueue = [];
-        let e;
-        try {
-          for (const value of iterable) {
-            valueQueue.push(value);
-            if (valueQueue.length <= size) {
-              continue;
-            }
-            yield valueQueue.shift();
-          }
-        } catch (error) {
-          e = error;
-        }
-        for (const value of valueQueue) {
-          yield value;
-        }
-        if (e) {
-          throw e;
-        }
-      }
-      __name(syncBuffer, "syncBuffer");
-      function buffer(size, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => buffer(size, curriedIterable);
-        }
-        if (size === 0) {
-          return iterable;
-        }
-        if (iterable[Symbol.asyncIterator]) {
-          return _buffer(size, iterable);
-        }
-        return syncBuffer(size, iterable);
-      }
-      __name(buffer, "buffer");
-      async function _collect(iterable) {
-        const values = [];
-        for await (const value of iterable) {
-          values.push(value);
-        }
-        return values;
-      }
-      __name(_collect, "_collect");
-      function collect(iterable) {
-        if (iterable[Symbol.asyncIterator]) {
-          return _collect(iterable);
-        }
-        return Array.from(iterable);
-      }
-      __name(collect, "collect");
-      async function* _concat(iterables) {
-        for await (const iterable of iterables) {
-          yield* iterable;
-        }
-      }
-      __name(_concat, "_concat");
-      function* _syncConcat(iterables) {
-        for (const iterable of iterables) {
-          yield* iterable;
-        }
-      }
-      __name(_syncConcat, "_syncConcat");
-      function concat(...iterables) {
-        const hasAnyAsync = iterables.find((itr) => itr[Symbol.asyncIterator] !== void 0);
-        if (hasAnyAsync) {
-          return _concat(iterables);
-        } else {
-          return _syncConcat(iterables);
-        }
-      }
-      __name(concat, "concat");
-      async function _consume(iterable) {
-        for await (const _val of iterable) {
-        }
-      }
-      __name(_consume, "_consume");
-      function consume(iterable) {
-        if (iterable[Symbol.asyncIterator]) {
-          return _consume(iterable);
-        }
-        for (const _val of iterable) {
-        }
-      }
-      __name(consume, "consume");
-      async function* _drop(count, iterable) {
-        let skipped = 0;
-        for await (const val of iterable) {
-          if (skipped < count) {
-            skipped++;
-            continue;
-          }
-          yield await val;
-        }
-      }
-      __name(_drop, "_drop");
-      function* _syncDrop(count, iterable) {
-        let skipped = 0;
-        for (const val of iterable) {
-          if (skipped < count) {
-            skipped++;
-            continue;
-          }
-          yield val;
-        }
-      }
-      __name(_syncDrop, "_syncDrop");
-      function drop(count, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => drop(count, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator]) {
-          return _drop(count, iterable);
-        }
-        return _syncDrop(count, iterable);
-      }
-      __name(drop, "drop");
-      async function* _filter(filterFunc, iterable) {
-        for await (const data of iterable) {
-          if (await filterFunc(data)) {
-            yield data;
-          }
-        }
-      }
-      __name(_filter, "_filter");
-      function filter(filterFunc, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _filter(filterFunc, curriedIterable);
-        }
-        return _filter(filterFunc, iterable);
-      }
-      __name(filter, "filter");
-      async function* flatten(iterable) {
-        for await (const maybeItr of iterable) {
-          if (maybeItr && typeof maybeItr !== "string" && (maybeItr[Symbol.iterator] || maybeItr[Symbol.asyncIterator])) {
-            yield* flatten(maybeItr);
-          } else {
-            yield maybeItr;
-          }
-        }
-      }
-      __name(flatten, "flatten");
-      async function* _map(func, iterable) {
-        for await (const val of iterable) {
-          yield await func(val);
-        }
-      }
-      __name(_map, "_map");
-      function map(func, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _map(func, curriedIterable);
-        }
-        return _map(func, iterable);
-      }
-      __name(map, "map");
-      function flatMap(func, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => flatMap(func, curriedIterable);
-        }
-        return filter((i) => i !== void 0 && i !== null, flatten(map(func, iterable)));
-      }
-      __name(flatMap, "flatMap");
-      function _flatTransform(concurrency, func, iterable) {
-        const iterator = getIterator(iterable);
-        const resultQueue = [];
-        const readQueue = [];
-        let ended = false;
-        let reading = false;
-        let inflightCount = 0;
-        let lastError = null;
-        function fulfillReadQueue() {
-          while (readQueue.length > 0 && resultQueue.length > 0) {
-            const { resolve } = readQueue.shift();
-            const value = resultQueue.shift();
-            resolve({ done: false, value });
-          }
-          while (readQueue.length > 0 && inflightCount === 0 && ended) {
-            const { resolve, reject } = readQueue.shift();
-            if (lastError) {
-              reject(lastError);
-              lastError = null;
-            } else {
-              resolve({ done: true, value: void 0 });
-            }
-          }
-        }
-        __name(fulfillReadQueue, "fulfillReadQueue");
-        async function fillQueue() {
-          if (ended) {
-            fulfillReadQueue();
-            return;
-          }
-          if (reading) {
-            return;
-          }
-          if (inflightCount + resultQueue.length >= concurrency) {
-            return;
-          }
-          reading = true;
-          inflightCount++;
-          try {
-            const { done, value } = await iterator.next();
-            if (done) {
-              ended = true;
-              inflightCount--;
-              fulfillReadQueue();
-            } else {
-              mapAndQueue(value);
-            }
-          } catch (error) {
-            ended = true;
-            inflightCount--;
-            lastError = error;
-            fulfillReadQueue();
-          }
-          reading = false;
-          fillQueue();
-        }
-        __name(fillQueue, "fillQueue");
-        async function mapAndQueue(itrValue) {
-          try {
-            const value = await func(itrValue);
-            if (value && value[Symbol.asyncIterator]) {
-              for await (const asyncVal of value) {
-                resultQueue.push(asyncVal);
-              }
-            } else {
-              resultQueue.push(value);
-            }
-          } catch (error) {
-            ended = true;
-            lastError = error;
-          }
-          inflightCount--;
-          fulfillReadQueue();
-          fillQueue();
-        }
-        __name(mapAndQueue, "mapAndQueue");
-        async function next() {
-          if (resultQueue.length === 0) {
-            const deferred = defer();
-            readQueue.push(deferred);
-            fillQueue();
-            return deferred.promise;
-          }
-          const value = resultQueue.shift();
-          fillQueue();
-          return { done: false, value };
-        }
-        __name(next, "next");
-        const asyncIterableIterator = {
-          next,
-          [Symbol.asyncIterator]: () => asyncIterableIterator
-        };
-        return asyncIterableIterator;
-      }
-      __name(_flatTransform, "_flatTransform");
-      function flatTransform(concurrency, func, iterable) {
-        if (func === void 0) {
-          return (curriedFunc, curriedIterable) => curriedIterable ? flatTransform(concurrency, curriedFunc, curriedIterable) : flatTransform(concurrency, curriedFunc);
-        }
-        if (iterable === void 0) {
-          return (curriedIterable) => flatTransform(concurrency, func, curriedIterable);
-        }
-        return filter((i) => i !== void 0 && i !== null, flatten(_flatTransform(concurrency, func, iterable)));
-      }
-      __name(flatTransform, "flatTransform");
-      async function onceReadable(stream) {
-        return new Promise((resolve) => {
-          stream.once("readable", () => {
-            resolve();
-          });
-        });
-      }
-      __name(onceReadable, "onceReadable");
-      async function* _fromStream(stream) {
-        while (true) {
-          const data = stream.read();
-          if (data !== null) {
-            yield data;
-            continue;
-          }
-          if (stream._readableState.ended) {
-            break;
-          }
-          await onceReadable(stream);
-        }
-      }
-      __name(_fromStream, "_fromStream");
-      function fromStream(stream) {
-        if (typeof stream[Symbol.asyncIterator] === "function") {
-          return stream;
-        }
-        return _fromStream(stream);
-      }
-      __name(fromStream, "fromStream");
-      async function* merge(...iterables) {
-        const sources = new Set(iterables.map(getIterator));
-        while (sources.size > 0) {
-          for (const iterator of sources) {
-            const nextVal = await iterator.next();
-            if (nextVal.done) {
-              sources.delete(iterator);
-            } else {
-              yield nextVal.value;
-            }
-          }
-        }
-      }
-      __name(merge, "merge");
-      function pipeline(firstFn, ...fns) {
-        let previousFn = firstFn();
-        for (const func of fns) {
-          previousFn = func(previousFn);
-        }
-        return previousFn;
-      }
-      __name(pipeline, "pipeline");
-      async function* _parallelMap(concurrency, func, iterable) {
-        let transformError = null;
-        const wrapFunc = /* @__PURE__ */ __name((value) => ({
-          value: func(value)
-        }), "wrapFunc");
-        const stopOnError = /* @__PURE__ */ __name(async function* (source) {
-          for await (const value of source) {
-            if (transformError) {
-              return;
-            }
-            yield value;
-          }
-        }, "stopOnError");
-        const output = pipeline(() => iterable, buffer(1), stopOnError, map(wrapFunc), buffer(concurrency - 1));
-        const itr = getIterator(output);
-        while (true) {
-          const { value, done } = await itr.next();
-          if (done) {
-            break;
-          }
-          try {
-            const val = await value.value;
-            if (!transformError) {
-              yield val;
-            }
-          } catch (error) {
-            transformError = error;
-          }
-        }
-        if (transformError) {
-          throw transformError;
-        }
-      }
-      __name(_parallelMap, "_parallelMap");
-      function parallelMap2(concurrency, func, iterable) {
-        if (func === void 0) {
-          return (curriedFunc, curriedIterable) => parallelMap2(concurrency, curriedFunc, curriedIterable);
-        }
-        if (iterable === void 0) {
-          return (curriedIterable) => parallelMap2(concurrency, func, curriedIterable);
-        }
-        if (concurrency === 1) {
-          return map(func, iterable);
-        }
-        return _parallelMap(concurrency, func, iterable);
-      }
-      __name(parallelMap2, "parallelMap");
-      function parallelFlatMap(concurrency, func, iterable) {
-        if (func === void 0) {
-          return (curriedFunc, curriedIterable) => curriedIterable ? parallelFlatMap(concurrency, curriedFunc, curriedIterable) : parallelFlatMap(concurrency, curriedFunc);
-        }
-        if (iterable === void 0) {
-          return (curriedIterable) => parallelFlatMap(concurrency, func, curriedIterable);
-        }
-        return filter((i) => i !== void 0 && i !== null, flatten(parallelMap2(concurrency, func, iterable)));
-      }
-      __name(parallelFlatMap, "parallelFlatMap");
-      async function* parallelMerge(...iterables) {
-        const inputs = iterables.map(getIterator);
-        const concurrentWork = /* @__PURE__ */ new Set();
-        const values = /* @__PURE__ */ new Map();
-        let lastError = null;
-        let errCb = null;
-        let valueCb = null;
-        const notifyError = /* @__PURE__ */ __name((err) => {
-          lastError = err;
-          if (errCb) {
-            errCb(err);
-          }
-        }, "notifyError");
-        const notifyDone = /* @__PURE__ */ __name((value) => {
-          if (valueCb) {
-            valueCb(value);
-          }
-        }, "notifyDone");
-        const waitForQueue = /* @__PURE__ */ __name(() => new Promise((resolve, reject) => {
-          if (lastError) {
-            reject(lastError);
-          }
-          if (values.size > 0) {
-            return resolve();
-          }
-          valueCb = resolve;
-          errCb = reject;
-        }), "waitForQueue");
-        const queueNext = /* @__PURE__ */ __name((input) => {
-          const nextVal = Promise.resolve(input.next()).then(async ({ done, value }) => {
-            if (!done) {
-              values.set(input, value);
-            }
-            concurrentWork.delete(nextVal);
-          });
-          concurrentWork.add(nextVal);
-          nextVal.then(notifyDone, notifyError);
-        }, "queueNext");
-        for (const input of inputs) {
-          queueNext(input);
-        }
-        while (true) {
-          if (concurrentWork.size === 0 && values.size === 0) {
-            return;
-          }
-          await waitForQueue();
-          for (const [input, value] of values) {
-            values.delete(input);
-            yield value;
-            queueNext(input);
-          }
-        }
-      }
-      __name(parallelMerge, "parallelMerge");
-      async function _reduce(func, start, iterable) {
-        let value = start;
-        for await (const nextItem of iterable) {
-          value = await func(value, nextItem);
-        }
-        return value;
-      }
-      __name(_reduce, "_reduce");
-      function reduce(func, start, iterable) {
-        if (start === void 0) {
-          return (curriedStart, curriedIterable) => curriedIterable ? _reduce(func, curriedStart, curriedIterable) : reduce(func, curriedStart);
-        }
-        if (iterable === void 0) {
-          return (curriedIterable) => reduce(func, start, curriedIterable);
-        }
-        return _reduce(func, start, iterable);
-      }
-      __name(reduce, "reduce");
-      async function* _take(count, iterable) {
-        let taken = 0;
-        for await (const val of iterable) {
-          yield await val;
-          taken++;
-          if (taken >= count) {
-            break;
-          }
-        }
-      }
-      __name(_take, "_take");
-      function* _syncTake(count, iterable) {
-        let taken = 0;
-        for (const val of iterable) {
-          yield val;
-          taken++;
-          if (taken >= count) {
-            break;
-          }
-        }
-      }
-      __name(_syncTake, "_syncTake");
-      function take(count, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => take(count, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator]) {
-          return _take(count, iterable);
-        }
-        return _syncTake(count, iterable);
-      }
-      __name(take, "take");
-      async function* _takeLast(count, iterable) {
-        const buffer2 = [];
-        for await (const res of iterable) {
-          buffer2.push(res);
-          if (buffer2.length > count) {
-            buffer2.shift();
-          }
-        }
-        while (buffer2.length) {
-          yield await buffer2.shift();
-        }
-      }
-      __name(_takeLast, "_takeLast");
-      function* _syncTakeLast(count, iterable) {
-        const buffer2 = [];
-        for (const res of iterable) {
-          buffer2.push(res);
-          if (buffer2.length > count) {
-            buffer2.shift();
-          }
-        }
-        while (buffer2.length) {
-          yield buffer2.shift();
-        }
-      }
-      __name(_syncTakeLast, "_syncTakeLast");
-      function takeLast(count, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => takeLast(count, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator]) {
-          return _takeLast(count, iterable);
-        }
-        return _syncTakeLast(count, iterable);
-      }
-      __name(takeLast, "takeLast");
-      async function* _takeWhile(predicate, iterable) {
-        for await (const data of iterable) {
-          if (!await predicate(data)) {
-            return;
-          }
-          yield data;
-        }
-      }
-      __name(_takeWhile, "_takeWhile");
-      function takeWhile(predicate, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _takeWhile(predicate, curriedIterable);
-        }
-        return _takeWhile(predicate, iterable);
-      }
-      __name(takeWhile, "takeWhile");
-      async function* _asyncTap(func, iterable) {
-        for await (const val of iterable) {
-          await func(val);
-          yield val;
-        }
-      }
-      __name(_asyncTap, "_asyncTap");
-      function tap(func, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _asyncTap(func, curriedIterable);
-        }
-        return _asyncTap(func, iterable);
-      }
-      __name(tap, "tap");
-      const sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
-      function _throttle(limit, interval, iterable) {
-        if (!Number.isFinite(limit)) {
-          throw new TypeError("Expected `limit` to be a finite number");
-        }
-        if (limit <= 0) {
-          throw new TypeError("Expected `limit` to be greater than 0");
-        }
-        if (!Number.isFinite(interval)) {
-          throw new TypeError("Expected `interval` to be a finite number");
-        }
-        return (/* @__PURE__ */ __name((async function* __throttle() {
-          let sent = 0;
-          let time2;
-          for await (const val of iterable) {
-            if (sent < limit) {
-              if (typeof time2 === "undefined") {
-                time2 = Date.now();
-              }
-              sent++;
-              yield val;
-              continue;
-            }
-            const elapsedMs = Date.now() - (time2 || 0);
-            const waitFor = interval - elapsedMs;
-            if (waitFor > 0) {
-              await sleep(waitFor);
-            }
-            time2 = Date.now();
-            sent = 1;
-            yield val;
-          }
-        }), "__throttle"))();
-      }
-      __name(_throttle, "_throttle");
-      function throttle(limit, interval, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _throttle(limit, interval, curriedIterable);
-        }
-        return _throttle(limit, interval, iterable);
-      }
-      __name(throttle, "throttle");
-      function addTime(a, b) {
-        let seconds = a[0] + b[0];
-        let nanoseconds = a[1] + b[1];
-        if (nanoseconds >= 1e9) {
-          const remainder = nanoseconds % 1e9;
-          seconds += (nanoseconds - remainder) / 1e9;
-          nanoseconds = remainder;
-        }
-        return [seconds, nanoseconds];
-      }
-      __name(addTime, "addTime");
-      async function* _asyncTime(config, iterable) {
-        const itr = iterable[Symbol.asyncIterator]();
-        let total = [0, 0];
-        while (true) {
-          const start = process.hrtime();
-          const { value, done } = await itr.next();
-          const delta = process.hrtime(start);
-          total = addTime(total, delta);
-          if (config.progress) {
-            config.progress(delta, total);
-          }
-          if (done) {
-            if (config.total) {
-              config.total(total);
-            }
-            return value;
-          }
-          yield value;
-        }
-      }
-      __name(_asyncTime, "_asyncTime");
-      function* _syncTime(config, iterable) {
-        const itr = iterable[Symbol.iterator]();
-        let total = [0, 0];
-        while (true) {
-          const start = process.hrtime();
-          const { value, done } = itr.next();
-          const delta = process.hrtime(start);
-          total = addTime(total, delta);
-          if (config.progress) {
-            config.progress(delta, total);
-          }
-          if (done) {
-            if (config.total) {
-              config.total(total);
-            }
-            return value;
-          }
-          yield value;
-        }
-      }
-      __name(_syncTime, "_syncTime");
-      function time(config = {}, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => time(config, curriedIterable);
-        }
-        if (iterable[Symbol.asyncIterator] !== void 0) {
-          return _asyncTime(config, iterable);
-        } else {
-          return _syncTime(config, iterable);
-        }
-      }
-      __name(time, "time");
-      function _transform(concurrency, func, iterable) {
-        const iterator = getIterator(iterable);
-        const resultQueue = [];
-        const readQueue = [];
-        let ended = false;
-        let reading = false;
-        let inflightCount = 0;
-        let lastError = null;
-        function fulfillReadQueue() {
-          while (readQueue.length > 0 && resultQueue.length > 0) {
-            const { resolve } = readQueue.shift();
-            const value = resultQueue.shift();
-            resolve({ done: false, value });
-          }
-          while (readQueue.length > 0 && inflightCount === 0 && ended) {
-            const { resolve, reject } = readQueue.shift();
-            if (lastError) {
-              reject(lastError);
-              lastError = null;
-            } else {
-              resolve({ done: true, value: void 0 });
-            }
-          }
-        }
-        __name(fulfillReadQueue, "fulfillReadQueue");
-        async function fillQueue() {
-          if (ended) {
-            fulfillReadQueue();
-            return;
-          }
-          if (reading) {
-            return;
-          }
-          if (inflightCount + resultQueue.length >= concurrency) {
-            return;
-          }
-          reading = true;
-          inflightCount++;
-          try {
-            const { done, value } = await iterator.next();
-            if (done) {
-              ended = true;
-              inflightCount--;
-              fulfillReadQueue();
-            } else {
-              mapAndQueue(value);
-            }
-          } catch (error) {
-            ended = true;
-            inflightCount--;
-            lastError = error;
-            fulfillReadQueue();
-          }
-          reading = false;
-          fillQueue();
-        }
-        __name(fillQueue, "fillQueue");
-        async function mapAndQueue(itrValue) {
-          try {
-            const value = await func(itrValue);
-            resultQueue.push(value);
-          } catch (error) {
-            ended = true;
-            lastError = error;
-          }
-          inflightCount--;
-          fulfillReadQueue();
-          fillQueue();
-        }
-        __name(mapAndQueue, "mapAndQueue");
-        async function next() {
-          if (resultQueue.length === 0) {
-            const deferred = defer();
-            readQueue.push(deferred);
-            fillQueue();
-            return deferred.promise;
-          }
-          const value = resultQueue.shift();
-          fillQueue();
-          return { done: false, value };
-        }
-        __name(next, "next");
-        const asyncIterableIterator = {
-          next,
-          [Symbol.asyncIterator]: () => asyncIterableIterator
-        };
-        return asyncIterableIterator;
-      }
-      __name(_transform, "_transform");
-      function transform2(concurrency, func, iterable) {
-        if (func === void 0) {
-          return (curriedFunc, curriedIterable) => curriedIterable ? transform2(concurrency, curriedFunc, curriedIterable) : transform2(concurrency, curriedFunc);
-        }
-        if (iterable === void 0) {
-          return (curriedIterable) => transform2(concurrency, func, curriedIterable);
-        }
-        return _transform(concurrency, func, iterable);
-      }
-      __name(transform2, "transform");
-      async function _writeToStream(stream, iterable) {
-        let lastError = null;
-        let errCb = null;
-        let drainCb = null;
-        const notifyError = /* @__PURE__ */ __name((err) => {
-          lastError = err;
-          if (errCb) {
-            errCb(err);
-          }
-        }, "notifyError");
-        const notifyDrain = /* @__PURE__ */ __name(() => {
-          if (drainCb) {
-            drainCb();
-          }
-        }, "notifyDrain");
-        const cleanup = /* @__PURE__ */ __name(() => {
-          stream.removeListener("error", notifyError);
-          stream.removeListener("drain", notifyDrain);
-        }, "cleanup");
-        stream.once("error", notifyError);
-        const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve, reject) => {
-          if (lastError) {
-            return reject(lastError);
-          }
-          stream.once("drain", notifyDrain);
-          drainCb = resolve;
-          errCb = reject;
-        }), "waitForDrain");
-        for await (const value of iterable) {
-          if (stream.write(value) === false) {
-            await waitForDrain();
-          }
-          if (lastError) {
-            break;
-          }
-        }
-        cleanup();
-        if (lastError) {
-          throw lastError;
-        }
-      }
-      __name(_writeToStream, "_writeToStream");
-      function writeToStream(stream, iterable) {
-        if (iterable === void 0) {
-          return (curriedIterable) => _writeToStream(stream, curriedIterable);
-        }
-        return _writeToStream(stream, iterable);
-      }
-      __name(writeToStream, "writeToStream");
-      exports3.batch = batch;
-      exports3.batchWithTimeout = batchWithTimeout;
-      exports3.buffer = buffer;
-      exports3.collect = collect;
-      exports3.concat = concat;
-      exports3.consume = consume;
-      exports3.drop = drop;
-      exports3.filter = filter;
-      exports3.flatMap = flatMap;
-      exports3.flatTransform = flatTransform;
-      exports3.flatten = flatten;
-      exports3.fromStream = fromStream;
-      exports3.getIterator = getIterator;
-      exports3.map = map;
-      exports3.merge = merge;
-      exports3.parallelFlatMap = parallelFlatMap;
-      exports3.parallelMap = parallelMap2;
-      exports3.parallelMerge = parallelMerge;
-      exports3.pipeline = pipeline;
-      exports3.reduce = reduce;
-      exports3.take = take;
-      exports3.takeLast = takeLast;
-      exports3.takeWhile = takeWhile;
-      exports3.tap = tap;
-      exports3.throttle = throttle;
-      exports3.time = time;
-      exports3.transform = transform2;
-      exports3.writeToStream = writeToStream;
-    }));
-  }
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
 });
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 
-// src/external/streaming-iterables.js
-var { parallelMap, transform } = require_dist();
+//#endregion
+
+//#region node_modules/.pnpm/streaming-iterables@8.0.1/node_modules/streaming-iterables/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.streamingIterables = {}));
+	})(exports, (function(exports$1) {
+		"use strict";
+		async function* _batch(size, iterable) {
+			let dataBatch = [];
+			for await (const data of iterable) {
+				dataBatch.push(data);
+				if (dataBatch.length === size) {
+					yield dataBatch;
+					dataBatch = [];
+				}
+			}
+			if (dataBatch.length > 0) yield dataBatch;
+		}
+		function* _syncBatch(size, iterable) {
+			let dataBatch = [];
+			for (const data of iterable) {
+				dataBatch.push(data);
+				if (dataBatch.length === size) {
+					yield dataBatch;
+					dataBatch = [];
+				}
+			}
+			if (dataBatch.length > 0) yield dataBatch;
+		}
+		function batch(size, iterable) {
+			if (iterable === void 0) return (curriedIterable) => batch(size, curriedIterable);
+			if (iterable[Symbol.asyncIterator]) return _batch(size, iterable);
+			return _syncBatch(size, iterable);
+		}
+		const TIMEOUT = Symbol("TIMEOUT");
+		const createTimer = (duration) => {
+			let timeoutId;
+			return [new Promise((resolve) => {
+				timeoutId = setTimeout(() => resolve(TIMEOUT), duration);
+			}), () => {
+				clearTimeout(timeoutId);
+			}];
+		};
+		async function* _batchWithTimeout(size, timeout, iterable) {
+			const iterator = iterable[Symbol.asyncIterator]();
+			let pendingData;
+			let batchData = [];
+			let timer;
+			let clearTimer;
+			const startTimer = () => {
+				deleteTimer();
+				[timer, clearTimer] = createTimer(timeout);
+			};
+			const deleteTimer = () => {
+				if (clearTimer) clearTimer();
+				timer = void 0;
+			};
+			pendingData = iterator.next();
+			while (true) {
+				const res = await (timer ? Promise.race([pendingData, timer]) : pendingData);
+				if (res === TIMEOUT || res.done) {
+					if (batchData.length) {
+						yield batchData;
+						batchData = [];
+					}
+					deleteTimer();
+					if (res !== TIMEOUT) break;
+					continue;
+				}
+				pendingData = iterator.next();
+				batchData.push(res.value);
+				if (batchData.length === 1) startTimer();
+				if (batchData.length === size) {
+					yield batchData;
+					batchData = [];
+					deleteTimer();
+					continue;
+				}
+			}
+		}
+		function batchWithTimeout(size, timeout, iterable) {
+			if (iterable === void 0) return (curriedIterable) => batchWithTimeout(size, timeout, curriedIterable);
+			if (iterable[Symbol.asyncIterator] && timeout !== Infinity) return _batchWithTimeout(size, timeout, iterable);
+			return batch(size, iterable);
+		}
+		function getIterator(iterable) {
+			if (typeof iterable.next === "function") return iterable;
+			if (typeof iterable[Symbol.iterator] === "function") return iterable[Symbol.iterator]();
+			if (typeof iterable[Symbol.asyncIterator] === "function") return iterable[Symbol.asyncIterator]();
+			throw new TypeError("\"values\" does not to conform to any of the iterator or iterable protocols");
+		}
+		function defer() {
+			let reject;
+			let resolve;
+			return {
+				promise: new Promise((resolveFunc, rejectFunc) => {
+					resolve = resolveFunc;
+					reject = rejectFunc;
+				}),
+				reject,
+				resolve
+			};
+		}
+		function _buffer(size, iterable) {
+			const iterator = getIterator(iterable);
+			const resultQueue = [];
+			const readQueue = [];
+			let reading = false;
+			let ended = false;
+			function fulfillReadQueue() {
+				while (readQueue.length > 0 && resultQueue.length > 0) {
+					const readDeferred = readQueue.shift();
+					const { error, value } = resultQueue.shift();
+					if (error) readDeferred.reject(error);
+					else readDeferred.resolve({
+						done: false,
+						value
+					});
+				}
+				while (readQueue.length > 0 && ended) {
+					const { resolve } = readQueue.shift();
+					resolve({
+						done: true,
+						value: void 0
+					});
+				}
+			}
+			async function fillQueue() {
+				if (ended) return;
+				if (reading) return;
+				if (resultQueue.length >= size) return;
+				reading = true;
+				try {
+					const { done, value } = await iterator.next();
+					if (done) ended = true;
+					else resultQueue.push({ value });
+				} catch (error) {
+					ended = true;
+					resultQueue.push({ error });
+				}
+				fulfillReadQueue();
+				reading = false;
+				fillQueue();
+			}
+			async function next() {
+				if (resultQueue.length > 0) {
+					const { error, value } = resultQueue.shift();
+					if (error) throw error;
+					fillQueue();
+					return {
+						done: false,
+						value
+					};
+				}
+				if (ended) return {
+					done: true,
+					value: void 0
+				};
+				const deferred = defer();
+				readQueue.push(deferred);
+				fillQueue();
+				return deferred.promise;
+			}
+			const asyncIterableIterator = {
+				next,
+				[Symbol.asyncIterator]: () => asyncIterableIterator
+			};
+			return asyncIterableIterator;
+		}
+		function* syncBuffer(size, iterable) {
+			const valueQueue = [];
+			let e;
+			try {
+				for (const value of iterable) {
+					valueQueue.push(value);
+					if (valueQueue.length <= size) continue;
+					yield valueQueue.shift();
+				}
+			} catch (error) {
+				e = error;
+			}
+			for (const value of valueQueue) yield value;
+			if (e) throw e;
+		}
+		function buffer(size, iterable) {
+			if (iterable === void 0) return (curriedIterable) => buffer(size, curriedIterable);
+			if (size === 0) return iterable;
+			if (iterable[Symbol.asyncIterator]) return _buffer(size, iterable);
+			return syncBuffer(size, iterable);
+		}
+		async function _collect(iterable) {
+			const values = [];
+			for await (const value of iterable) values.push(value);
+			return values;
+		}
+		function collect(iterable) {
+			if (iterable[Symbol.asyncIterator]) return _collect(iterable);
+			return Array.from(iterable);
+		}
+		async function* _concat(iterables) {
+			for await (const iterable of iterables) yield* iterable;
+		}
+		function* _syncConcat(iterables) {
+			for (const iterable of iterables) yield* iterable;
+		}
+		function concat(...iterables) {
+			if (iterables.find((itr) => itr[Symbol.asyncIterator] !== void 0)) return _concat(iterables);
+			else return _syncConcat(iterables);
+		}
+		async function _consume(iterable) {
+			for await (const _val of iterable);
+		}
+		function consume(iterable) {
+			if (iterable[Symbol.asyncIterator]) return _consume(iterable);
+			for (const _val of iterable);
+		}
+		async function* _drop(count, iterable) {
+			let skipped = 0;
+			for await (const val of iterable) {
+				if (skipped < count) {
+					skipped++;
+					continue;
+				}
+				yield await val;
+			}
+		}
+		function* _syncDrop(count, iterable) {
+			let skipped = 0;
+			for (const val of iterable) {
+				if (skipped < count) {
+					skipped++;
+					continue;
+				}
+				yield val;
+			}
+		}
+		function drop(count, iterable) {
+			if (iterable === void 0) return (curriedIterable) => drop(count, curriedIterable);
+			if (iterable[Symbol.asyncIterator]) return _drop(count, iterable);
+			return _syncDrop(count, iterable);
+		}
+		async function* _filter(filterFunc, iterable) {
+			for await (const data of iterable) if (await filterFunc(data)) yield data;
+		}
+		function filter(filterFunc, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _filter(filterFunc, curriedIterable);
+			return _filter(filterFunc, iterable);
+		}
+		/**
+		* Returns a new iterator by pulling every item out of `iterable` (and all its sub iterables) and yielding them depth-first. Checks for the iterable interfaces and iterates it if it exists. If the value is a string it is not iterated as that ends up in an infinite loop. Errors from the source `iterable` are raised immediately.
+		
+		*note*: Typescript doesn't have recursive types but you can nest iterables as deep as you like.
+		
+		```ts
+		import { flatten } from 'streaming-iterables'
+		
+		for await (const item of flatten([1, 2, [3, [4, 5], 6])) {
+		console.log(item)
+		}
+		// 1
+		// 2
+		// 3
+		// 4
+		// 5
+		// 6
+		```
+		*/
+		async function* flatten(iterable) {
+			for await (const maybeItr of iterable) if (maybeItr && typeof maybeItr !== "string" && (maybeItr[Symbol.iterator] || maybeItr[Symbol.asyncIterator])) yield* flatten(maybeItr);
+			else yield maybeItr;
+		}
+		async function* _map(func, iterable) {
+			for await (const val of iterable) yield await func(val);
+		}
+		function map(func, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _map(func, curriedIterable);
+			return _map(func, iterable);
+		}
+		function flatMap(func, iterable) {
+			if (iterable === void 0) return (curriedIterable) => flatMap(func, curriedIterable);
+			return filter((i) => i !== void 0 && i !== null, flatten(map(func, iterable)));
+		}
+		function _flatTransform(concurrency, func, iterable) {
+			const iterator = getIterator(iterable);
+			const resultQueue = [];
+			const readQueue = [];
+			let ended = false;
+			let reading = false;
+			let inflightCount = 0;
+			let lastError = null;
+			function fulfillReadQueue() {
+				while (readQueue.length > 0 && resultQueue.length > 0) {
+					const { resolve } = readQueue.shift();
+					resolve({
+						done: false,
+						value: resultQueue.shift()
+					});
+				}
+				while (readQueue.length > 0 && inflightCount === 0 && ended) {
+					const { resolve, reject } = readQueue.shift();
+					if (lastError) {
+						reject(lastError);
+						lastError = null;
+					} else resolve({
+						done: true,
+						value: void 0
+					});
+				}
+			}
+			async function fillQueue() {
+				if (ended) {
+					fulfillReadQueue();
+					return;
+				}
+				if (reading) return;
+				if (inflightCount + resultQueue.length >= concurrency) return;
+				reading = true;
+				inflightCount++;
+				try {
+					const { done, value } = await iterator.next();
+					if (done) {
+						ended = true;
+						inflightCount--;
+						fulfillReadQueue();
+					} else mapAndQueue(value);
+				} catch (error) {
+					ended = true;
+					inflightCount--;
+					lastError = error;
+					fulfillReadQueue();
+				}
+				reading = false;
+				fillQueue();
+			}
+			async function mapAndQueue(itrValue) {
+				try {
+					const value = await func(itrValue);
+					if (value && value[Symbol.asyncIterator]) for await (const asyncVal of value) resultQueue.push(asyncVal);
+					else resultQueue.push(value);
+				} catch (error) {
+					ended = true;
+					lastError = error;
+				}
+				inflightCount--;
+				fulfillReadQueue();
+				fillQueue();
+			}
+			async function next() {
+				if (resultQueue.length === 0) {
+					const deferred = defer();
+					readQueue.push(deferred);
+					fillQueue();
+					return deferred.promise;
+				}
+				const value = resultQueue.shift();
+				fillQueue();
+				return {
+					done: false,
+					value
+				};
+			}
+			const asyncIterableIterator = {
+				next,
+				[Symbol.asyncIterator]: () => asyncIterableIterator
+			};
+			return asyncIterableIterator;
+		}
+		function flatTransform(concurrency, func, iterable) {
+			if (func === void 0) return (curriedFunc, curriedIterable) => curriedIterable ? flatTransform(concurrency, curriedFunc, curriedIterable) : flatTransform(concurrency, curriedFunc);
+			if (iterable === void 0) return (curriedIterable) => flatTransform(concurrency, func, curriedIterable);
+			return filter((i) => i !== void 0 && i !== null, flatten(_flatTransform(concurrency, func, iterable)));
+		}
+		async function onceReadable(stream) {
+			return new Promise((resolve) => {
+				stream.once("readable", () => {
+					resolve();
+				});
+			});
+		}
+		async function* _fromStream(stream) {
+			while (true) {
+				const data = stream.read();
+				if (data !== null) {
+					yield data;
+					continue;
+				}
+				if (stream._readableState.ended) break;
+				await onceReadable(stream);
+			}
+		}
+		/**
+		* Wraps the stream in an async iterator or returns the stream if it already is an async iterator.
+		
+		*note*: Since Node 10, streams already async iterators. This function may be used to ensure compatibility with older versions of Node.
+		
+		```ts
+		import { fromStream } from 'streaming-iterables'
+		import { createReadStream } from 'fs'
+		
+		const pokeLog = fromStream(createReadStream('./pokedex-operating-system.log'))
+		
+		for await (const pokeData of pokeLog) {
+		console.log(pokeData) // Buffer(...)
+		}
+		```
+		* @deprecated This method is deprecated since, node 10 is out of LTS. It may be removed in an upcoming major release.
+		*/
+		function fromStream(stream) {
+			if (typeof stream[Symbol.asyncIterator] === "function") return stream;
+			return _fromStream(stream);
+		}
+		/**
+		* Combine multiple iterators into a single iterable. Reads one item off each iterable in order repeatedly until they are all exhausted. If you care less about order and want them faster see `parallelMerge()`.
+		*/
+		async function* merge(...iterables) {
+			const sources = new Set(iterables.map(getIterator));
+			while (sources.size > 0) for (const iterator of sources) {
+				const nextVal = await iterator.next();
+				if (nextVal.done) sources.delete(iterator);
+				else yield nextVal.value;
+			}
+		}
+		function pipeline(firstFn, ...fns) {
+			let previousFn = firstFn();
+			for (const func of fns) previousFn = func(previousFn);
+			return previousFn;
+		}
+		async function* _parallelMap(concurrency, func, iterable) {
+			let transformError = null;
+			const wrapFunc = (value) => ({ value: func(value) });
+			const stopOnError = async function* (source) {
+				for await (const value of source) {
+					if (transformError) return;
+					yield value;
+				}
+			};
+			const itr = getIterator(pipeline(() => iterable, buffer(1), stopOnError, map(wrapFunc), buffer(concurrency - 1)));
+			while (true) {
+				const { value, done } = await itr.next();
+				if (done) break;
+				try {
+					const val = await value.value;
+					if (!transformError) yield val;
+				} catch (error) {
+					transformError = error;
+				}
+			}
+			if (transformError) throw transformError;
+		}
+		function parallelMap(concurrency, func, iterable) {
+			if (func === void 0) return (curriedFunc, curriedIterable) => parallelMap(concurrency, curriedFunc, curriedIterable);
+			if (iterable === void 0) return (curriedIterable) => parallelMap(concurrency, func, curriedIterable);
+			if (concurrency === 1) return map(func, iterable);
+			return _parallelMap(concurrency, func, iterable);
+		}
+		function parallelFlatMap(concurrency, func, iterable) {
+			if (func === void 0) return (curriedFunc, curriedIterable) => curriedIterable ? parallelFlatMap(concurrency, curriedFunc, curriedIterable) : parallelFlatMap(concurrency, curriedFunc);
+			if (iterable === void 0) return (curriedIterable) => parallelFlatMap(concurrency, func, curriedIterable);
+			return filter((i) => i !== void 0 && i !== null, flatten(parallelMap(concurrency, func, iterable)));
+		}
+		/**
+		*Combine multiple iterators into a single iterable. Reads one item off of every iterable and yields them as they resolve. This is useful for pulling items out of a collection of iterables as soon as they're available. Errors `iterables` are raised immediately.
+		
+		```ts
+		import { parallelMerge } from 'streaming-iterables'
+		import { getPokemon, getTransformer } from 'iterable-pokedex'
+		
+		// pokemon are much faster to load btw
+		const heros = parallelMerge(getPokemon(), getTransformer())
+		for await (const hero of heros) {
+		console.log(hero)
+		}
+		// charmander
+		// bulbasaur
+		// megatron
+		// pikachu
+		// eevee
+		// bumblebee
+		// jazz
+		```
+		*/
+		async function* parallelMerge(...iterables) {
+			const inputs = iterables.map(getIterator);
+			const concurrentWork = /* @__PURE__ */ new Set();
+			const values = /* @__PURE__ */ new Map();
+			let lastError = null;
+			let errCb = null;
+			let valueCb = null;
+			const notifyError = (err) => {
+				lastError = err;
+				if (errCb) errCb(err);
+			};
+			const notifyDone = (value) => {
+				if (valueCb) valueCb(value);
+			};
+			const waitForQueue = () => new Promise((resolve, reject) => {
+				if (lastError) reject(lastError);
+				if (values.size > 0) return resolve();
+				valueCb = resolve;
+				errCb = reject;
+			});
+			const queueNext = (input) => {
+				const nextVal = Promise.resolve(input.next()).then(async ({ done, value }) => {
+					if (!done) values.set(input, value);
+					concurrentWork.delete(nextVal);
+				});
+				concurrentWork.add(nextVal);
+				nextVal.then(notifyDone, notifyError);
+			};
+			for (const input of inputs) queueNext(input);
+			while (true) {
+				if (concurrentWork.size === 0 && values.size === 0) return;
+				await waitForQueue();
+				for (const [input, value] of values) {
+					values.delete(input);
+					yield value;
+					queueNext(input);
+				}
+			}
+		}
+		async function _reduce(func, start, iterable) {
+			let value = start;
+			for await (const nextItem of iterable) value = await func(value, nextItem);
+			return value;
+		}
+		function reduce(func, start, iterable) {
+			if (start === void 0) return (curriedStart, curriedIterable) => curriedIterable ? _reduce(func, curriedStart, curriedIterable) : reduce(func, curriedStart);
+			if (iterable === void 0) return (curriedIterable) => reduce(func, start, curriedIterable);
+			return _reduce(func, start, iterable);
+		}
+		async function* _take(count, iterable) {
+			let taken = 0;
+			for await (const val of iterable) {
+				yield await val;
+				taken++;
+				if (taken >= count) break;
+			}
+		}
+		function* _syncTake(count, iterable) {
+			let taken = 0;
+			for (const val of iterable) {
+				yield val;
+				taken++;
+				if (taken >= count) break;
+			}
+		}
+		function take(count, iterable) {
+			if (iterable === void 0) return (curriedIterable) => take(count, curriedIterable);
+			if (iterable[Symbol.asyncIterator]) return _take(count, iterable);
+			return _syncTake(count, iterable);
+		}
+		async function* _takeLast(count, iterable) {
+			const buffer = [];
+			for await (const res of iterable) {
+				buffer.push(res);
+				if (buffer.length > count) buffer.shift();
+			}
+			while (buffer.length) yield await buffer.shift();
+		}
+		function* _syncTakeLast(count, iterable) {
+			const buffer = [];
+			for (const res of iterable) {
+				buffer.push(res);
+				if (buffer.length > count) buffer.shift();
+			}
+			while (buffer.length) yield buffer.shift();
+		}
+		function takeLast(count, iterable) {
+			if (iterable === void 0) return (curriedIterable) => takeLast(count, curriedIterable);
+			if (iterable[Symbol.asyncIterator]) return _takeLast(count, iterable);
+			return _syncTakeLast(count, iterable);
+		}
+		async function* _takeWhile(predicate, iterable) {
+			for await (const data of iterable) {
+				if (!await predicate(data)) return;
+				yield data;
+			}
+		}
+		function takeWhile(predicate, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _takeWhile(predicate, curriedIterable);
+			return _takeWhile(predicate, iterable);
+		}
+		async function* _asyncTap(func, iterable) {
+			for await (const val of iterable) {
+				await func(val);
+				yield val;
+			}
+		}
+		function tap(func, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _asyncTap(func, curriedIterable);
+			return _asyncTap(func, iterable);
+		}
+		const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+		function _throttle(limit, interval, iterable) {
+			if (!Number.isFinite(limit)) throw new TypeError("Expected `limit` to be a finite number");
+			if (limit <= 0) throw new TypeError("Expected `limit` to be greater than 0");
+			if (!Number.isFinite(interval)) throw new TypeError("Expected `interval` to be a finite number");
+			return (async function* __throttle() {
+				let sent = 0;
+				let time;
+				for await (const val of iterable) {
+					if (sent < limit) {
+						if (typeof time === "undefined") time = Date.now();
+						sent++;
+						yield val;
+						continue;
+					}
+					const waitFor = interval - (Date.now() - (time || 0));
+					if (waitFor > 0) await sleep(waitFor);
+					time = Date.now();
+					sent = 1;
+					yield val;
+				}
+			})();
+		}
+		function throttle(limit, interval, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _throttle(limit, interval, curriedIterable);
+			return _throttle(limit, interval, iterable);
+		}
+		function addTime(a, b) {
+			let seconds = a[0] + b[0];
+			let nanoseconds = a[1] + b[1];
+			if (nanoseconds >= 1e9) {
+				const remainder = nanoseconds % 1e9;
+				seconds += (nanoseconds - remainder) / 1e9;
+				nanoseconds = remainder;
+			}
+			return [seconds, nanoseconds];
+		}
+		async function* _asyncTime(config, iterable) {
+			const itr = iterable[Symbol.asyncIterator]();
+			let total = [0, 0];
+			while (true) {
+				const start = process.hrtime();
+				const { value, done } = await itr.next();
+				const delta = process.hrtime(start);
+				total = addTime(total, delta);
+				if (config.progress) config.progress(delta, total);
+				if (done) {
+					if (config.total) config.total(total);
+					return value;
+				}
+				yield value;
+			}
+		}
+		function* _syncTime(config, iterable) {
+			const itr = iterable[Symbol.iterator]();
+			let total = [0, 0];
+			while (true) {
+				const start = process.hrtime();
+				const { value, done } = itr.next();
+				const delta = process.hrtime(start);
+				total = addTime(total, delta);
+				if (config.progress) config.progress(delta, total);
+				if (done) {
+					if (config.total) config.total(total);
+					return value;
+				}
+				yield value;
+			}
+		}
+		function time(config = {}, iterable) {
+			if (iterable === void 0) return (curriedIterable) => time(config, curriedIterable);
+			if (iterable[Symbol.asyncIterator] !== void 0) return _asyncTime(config, iterable);
+			else return _syncTime(config, iterable);
+		}
+		function _transform(concurrency, func, iterable) {
+			const iterator = getIterator(iterable);
+			const resultQueue = [];
+			const readQueue = [];
+			let ended = false;
+			let reading = false;
+			let inflightCount = 0;
+			let lastError = null;
+			function fulfillReadQueue() {
+				while (readQueue.length > 0 && resultQueue.length > 0) {
+					const { resolve } = readQueue.shift();
+					resolve({
+						done: false,
+						value: resultQueue.shift()
+					});
+				}
+				while (readQueue.length > 0 && inflightCount === 0 && ended) {
+					const { resolve, reject } = readQueue.shift();
+					if (lastError) {
+						reject(lastError);
+						lastError = null;
+					} else resolve({
+						done: true,
+						value: void 0
+					});
+				}
+			}
+			async function fillQueue() {
+				if (ended) {
+					fulfillReadQueue();
+					return;
+				}
+				if (reading) return;
+				if (inflightCount + resultQueue.length >= concurrency) return;
+				reading = true;
+				inflightCount++;
+				try {
+					const { done, value } = await iterator.next();
+					if (done) {
+						ended = true;
+						inflightCount--;
+						fulfillReadQueue();
+					} else mapAndQueue(value);
+				} catch (error) {
+					ended = true;
+					inflightCount--;
+					lastError = error;
+					fulfillReadQueue();
+				}
+				reading = false;
+				fillQueue();
+			}
+			async function mapAndQueue(itrValue) {
+				try {
+					const value = await func(itrValue);
+					resultQueue.push(value);
+				} catch (error) {
+					ended = true;
+					lastError = error;
+				}
+				inflightCount--;
+				fulfillReadQueue();
+				fillQueue();
+			}
+			async function next() {
+				if (resultQueue.length === 0) {
+					const deferred = defer();
+					readQueue.push(deferred);
+					fillQueue();
+					return deferred.promise;
+				}
+				const value = resultQueue.shift();
+				fillQueue();
+				return {
+					done: false,
+					value
+				};
+			}
+			const asyncIterableIterator = {
+				next,
+				[Symbol.asyncIterator]: () => asyncIterableIterator
+			};
+			return asyncIterableIterator;
+		}
+		function transform(concurrency, func, iterable) {
+			if (func === void 0) return (curriedFunc, curriedIterable) => curriedIterable ? transform(concurrency, curriedFunc, curriedIterable) : transform(concurrency, curriedFunc);
+			if (iterable === void 0) return (curriedIterable) => transform(concurrency, func, curriedIterable);
+			return _transform(concurrency, func, iterable);
+		}
+		async function _writeToStream(stream, iterable) {
+			let lastError = null;
+			let errCb = null;
+			let drainCb = null;
+			const notifyError = (err) => {
+				lastError = err;
+				if (errCb) errCb(err);
+			};
+			const notifyDrain = () => {
+				if (drainCb) drainCb();
+			};
+			const cleanup = () => {
+				stream.removeListener("error", notifyError);
+				stream.removeListener("drain", notifyDrain);
+			};
+			stream.once("error", notifyError);
+			const waitForDrain = () => new Promise((resolve, reject) => {
+				if (lastError) return reject(lastError);
+				stream.once("drain", notifyDrain);
+				drainCb = resolve;
+				errCb = reject;
+			});
+			for await (const value of iterable) {
+				if (stream.write(value) === false) await waitForDrain();
+				if (lastError) break;
+			}
+			cleanup();
+			if (lastError) throw lastError;
+		}
+		function writeToStream(stream, iterable) {
+			if (iterable === void 0) return (curriedIterable) => _writeToStream(stream, curriedIterable);
+			return _writeToStream(stream, iterable);
+		}
+		exports$1.batch = batch;
+		exports$1.batchWithTimeout = batchWithTimeout;
+		exports$1.buffer = buffer;
+		exports$1.collect = collect;
+		exports$1.concat = concat;
+		exports$1.consume = consume;
+		exports$1.drop = drop;
+		exports$1.filter = filter;
+		exports$1.flatMap = flatMap;
+		exports$1.flatTransform = flatTransform;
+		exports$1.flatten = flatten;
+		exports$1.fromStream = fromStream;
+		exports$1.getIterator = getIterator;
+		exports$1.map = map;
+		exports$1.merge = merge;
+		exports$1.parallelFlatMap = parallelFlatMap;
+		exports$1.parallelMap = parallelMap;
+		exports$1.parallelMerge = parallelMerge;
+		exports$1.pipeline = pipeline;
+		exports$1.reduce = reduce;
+		exports$1.take = take;
+		exports$1.takeLast = takeLast;
+		exports$1.takeWhile = takeWhile;
+		exports$1.tap = tap;
+		exports$1.throttle = throttle;
+		exports$1.time = time;
+		exports$1.transform = transform;
+		exports$1.writeToStream = writeToStream;
+	}));
+}));
+
+//#endregion
+//#region src/external/streaming-iterables.js
+const { parallelMap, transform } = require_dist();
 module.exports = {
-  parallelMap,
-  transform
+	parallelMap,
+	transform
 };
+
+//#endregion