@socketsecurity/lib/dist/external/streaming-iterables.js

Core utilities and infrastructure for Socket.dev security tools

"use strict";
/**
 * Bundled from streaming-iterables
 * This is a zero-dependency bundle created by esbuild.
 */
"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;
};

// 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;
    }));
  }
});

// src/external/streaming-iterables.js
var { parallelMap, transform } = require_dist();
module.exports = {
  parallelMap,
  transform
};