@socketsecurity/lib 3.2.5 → 3.2.7

package/dist/external/streaming-iterables.js

@@ -3,4 +3,1059 @@
  * Bundled from streaming-iterables
  * This is a zero-dependency bundle created by esbuild.
  */
-"use strict";var Ae=Object.defineProperty;var o=(l,p)=>Ae(l,"name",{value:p,configurable:!0});var Ce=(l,p)=>()=>(p||l((p={exports:{}}).exports,p),p.exports);var Z=Ce((D,Y)=>{(function(l,p){typeof D=="object"&&typeof Y<"u"?p(D):typeof define=="function"&&define.amd?define(["exports"],p):(l=typeof globalThis<"u"?globalThis:l||self,p(l.streamingIterables={}))})(D,(function(l){"use strict";async function*p(e,t){let n=[];for await(let r of t)n.push(r),n.length===e&&(yield n,n=[]);n.length>0&&(yield n)}o(p,"_batch");function*$(e,t){let n=[];for(let r of t)n.push(r),n.length===e&&(yield n,n=[]);n.length>0&&(yield n)}o($,"_syncBatch");function P(e,t){return t===void 0?n=>P(e,n):t[Symbol.asyncIterator]?p(e,t):$(e,t)}o(P,"batch");let A=Symbol("TIMEOUT"),z=o(e=>{let t;return[new Promise(n=>{t=setTimeout(()=>n(A),e)}),()=>{clearTimeout(t)}]},"createTimer");async function*x(e,t,n){let r=n[Symbol.asyncIterator](),i,f=[],a,y,s=o(()=>{c(),[a,y]=z(t)},"startTimer"),c=o(()=>{y&&y(),a=void 0},"deleteTimer");for(i=r.next();;){let h=await(a?Promise.race([i,a]):i);if(h===A||h.done){if(f.length&&(yield f,f=[]),c(),h!==A)break;continue}if(i=r.next(),f.push(h.value),f.length===1&&s(),f.length===e){yield f,f=[],c();continue}}}o(x,"_batchWithTimeout");function L(e,t,n){return n===void 0?r=>L(e,t,r):n[Symbol.asyncIterator]&&t!==1/0?x(e,t,n):P(e,n)}o(L,"batchWithTimeout");function g(e){if(typeof e.next=="function")return e;if(typeof e[Symbol.iterator]=="function")return e[Symbol.iterator]();if(typeof e[Symbol.asyncIterator]=="function")return e[Symbol.asyncIterator]();throw new TypeError('"values" does not to conform to any of the iterator or iterable protocols')}o(g,"getIterator");function C(){let e,t;return{promise:new Promise((r,i)=>{t=r,e=i}),reject:e,resolve:t}}o(C,"defer");function ee(e,t){let n=g(t),r=[],i=[],f=!1,a=!1;function y(){for(;i.length>0&&r.length>0;){let u=i.shift(),{error:w,value:v}=r.shift();w?u.reject(w):u.resolve({done:!1,value:v})}for(;i.length>0&&a;){let{resolve:u}=i.shift();u({done:!0,value:void 0})}}o(y,"fulfillReadQueue");async function s(){if(!a&&!f&&!(r.length>=e)){f=!0;try{let{done:u,value:w}=await n.next();u?a=!0:r.push({value:w})}catch(u){a=!0,r.push({error:u})}y(),f=!1,s()}}o(s,"fillQueue");async function c(){if(r.length>0){let{error:w,value:v}=r.shift();if(w)throw w;return s(),{done:!1,value:v}}if(a)return{done:!0,value:void 0};let u=C();return i.push(u),s(),u.promise}o(c,"next");let h={next:c,[Symbol.asyncIterator]:()=>h};return h}o(ee,"_buffer");function*te(e,t){let n=[],r;try{for(let i of t)n.push(i),!(n.length<=e)&&(yield n.shift())}catch(i){r=i}for(let i of n)yield i;if(r)throw r}o(te,"syncBuffer");function _(e,t){return t===void 0?n=>_(e,n):e===0?t:t[Symbol.asyncIterator]?ee(e,t):te(e,t)}o(_,"buffer");async function ne(e){let t=[];for await(let n of e)t.push(n);return t}o(ne,"_collect");function re(e){return e[Symbol.asyncIterator]?ne(e):Array.from(e)}o(re,"collect");async function*oe(e){for await(let t of e)yield*t}o(oe,"_concat");function*ie(e){for(let t of e)yield*t}o(ie,"_syncConcat");function fe(...e){return e.find(n=>n[Symbol.asyncIterator]!==void 0)?oe(e):ie(e)}o(fe,"concat");async function ae(e){for await(let t of e);}o(ae,"_consume");function ue(e){if(e[Symbol.asyncIterator])return ae(e);for(let t of e);}o(ue,"consume");async function*le(e,t){let n=0;for await(let r of t){if(n<e){n++;continue}yield await r}}o(le,"_drop");function*se(e,t){let n=0;for(let r of t){if(n<e){n++;continue}yield r}}o(se,"_syncDrop");function F(e,t){return t===void 0?n=>F(e,n):t[Symbol.asyncIterator]?le(e,t):se(e,t)}o(F,"drop");async function*B(e,t){for await(let n of t)await e(n)&&(yield n)}o(B,"_filter");function I(e,t){return t===void 0?n=>B(e,n):B(e,t)}o(I,"filter");async function*T(e){for await(let t of e)t&&typeof t!="string"&&(t[Symbol.iterator]||t[Symbol.asyncIterator])?yield*T(t):yield t}o(T,"flatten");async function*R(e,t){for await(let n of t)yield await e(n)}o(R,"_map");function k(e,t){return t===void 0?n=>R(e,n):R(e,t)}o(k,"map");function j(e,t){return t===void 0?n=>j(e,n):I(n=>n!=null,T(k(e,t)))}o(j,"flatMap");function ce(e,t,n){let r=g(n),i=[],f=[],a=!1,y=!1,s=0,c=null;function h(){for(;f.length>0&&i.length>0;){let{resolve:m}=f.shift(),d=i.shift();m({done:!1,value:d})}for(;f.length>0&&s===0&&a;){let{resolve:m,reject:d}=f.shift();c?(d(c),c=null):m({done:!0,value:void 0})}}o(h,"fulfillReadQueue");async function u(){if(a){h();return}if(!y&&!(s+i.length>=e)){y=!0,s++;try{let{done:m,value:d}=await r.next();m?(a=!0,s--,h()):w(d)}catch(m){a=!0,s--,c=m,h()}y=!1,u()}}o(u,"fillQueue");async function w(m){try{let d=await t(m);if(d&&d[Symbol.asyncIterator])for await(let Pe of d)i.push(Pe);else i.push(d)}catch(d){a=!0,c=d}s--,h(),u()}o(w,"mapAndQueue");async function v(){if(i.length===0){let d=C();return f.push(d),u(),d.promise}let m=i.shift();return u(),{done:!1,value:m}}o(v,"next");let S={next:v,[Symbol.asyncIterator]:()=>S};return S}o(ce,"_flatTransform");function E(e,t,n){return t===void 0?(r,i)=>i?E(e,r,i):E(e,r):n===void 0?r=>E(e,t,r):I(r=>r!=null,T(ce(e,t,n)))}o(E,"flatTransform");async function de(e){return new Promise(t=>{e.once("readable",()=>{t()})})}o(de,"onceReadable");async function*ye(e){for(;;){let t=e.read();if(t!==null){yield t;continue}if(e._readableState.ended)break;await de(e)}}o(ye,"_fromStream");function he(e){return typeof e[Symbol.asyncIterator]=="function"?e:ye(e)}o(he,"fromStream");async function*me(...e){let t=new Set(e.map(g));for(;t.size>0;)for(let n of t){let r=await n.next();r.done?t.delete(n):yield r.value}}o(me,"merge");function N(e,...t){let n=e();for(let r of t)n=r(n);return n}o(N,"pipeline");async function*we(e,t,n){let r=null,i=o(s=>({value:t(s)}),"wrapFunc"),f=o(async function*(s){for await(let c of s){if(r)return;yield c}},"stopOnError"),a=N(()=>n,_(1),f,k(i),_(e-1)),y=g(a);for(;;){let{value:s,done:c}=await y.next();if(c)break;try{let h=await s.value;r||(yield h)}catch(h){r=h}}if(r)throw r}o(we,"_parallelMap");function Q(e,t,n){return t===void 0?(r,i)=>Q(e,r,i):n===void 0?r=>Q(e,t,r):e===1?k(t,n):we(e,t,n)}o(Q,"parallelMap");function b(e,t,n){return t===void 0?(r,i)=>i?b(e,r,i):b(e,r):n===void 0?r=>b(e,t,r):I(r=>r!=null,T(Q(e,t,n)))}o(b,"parallelFlatMap");async function*pe(...e){let t=e.map(g),n=new Set,r=new Map,i=null,f=null,a=null,y=o(u=>{i=u,f&&f(u)},"notifyError"),s=o(u=>{a&&a(u)},"notifyDone"),c=o(()=>new Promise((u,w)=>{if(i&&w(i),r.size>0)return u();a=u,f=w}),"waitForQueue"),h=o(u=>{let w=Promise.resolve(u.next()).then(async({done:v,value:S})=>{v||r.set(u,S),n.delete(w)});n.add(w),w.then(s,y)},"queueNext");for(let u of t)h(u);for(;;){if(n.size===0&&r.size===0)return;await c();for(let[u,w]of r)r.delete(u),yield w,h(u)}}o(pe,"parallelMerge");async function O(e,t,n){let r=t;for await(let i of n)r=await e(r,i);return r}o(O,"_reduce");function W(e,t,n){return t===void 0?(r,i)=>i?O(e,r,i):W(e,r):n===void 0?r=>W(e,t,r):O(e,t,n)}o(W,"reduce");async function*ve(e,t){let n=0;for await(let r of t)if(yield await r,n++,n>=e)break}o(ve,"_take");function*ge(e,t){let n=0;for(let r of t)if(yield r,n++,n>=e)break}o(ge,"_syncTake");function V(e,t){return t===void 0?n=>V(e,n):t[Symbol.asyncIterator]?ve(e,t):ge(e,t)}o(V,"take");async function*Se(e,t){let n=[];for await(let r of t)n.push(r),n.length>e&&n.shift();for(;n.length;)yield await n.shift()}o(Se,"_takeLast");function*Te(e,t){let n=[];for(let r of t)n.push(r),n.length>e&&n.shift();for(;n.length;)yield n.shift()}o(Te,"_syncTakeLast");function q(e,t){return t===void 0?n=>q(e,n):t[Symbol.asyncIterator]?Se(e,t):Te(e,t)}o(q,"takeLast");async function*U(e,t){for await(let n of t){if(!await e(n))return;yield n}}o(U,"_takeWhile");function _e(e,t){return t===void 0?n=>U(e,n):U(e,t)}o(_e,"takeWhile");async function*G(e,t){for await(let n of t)await e(n),yield n}o(G,"_asyncTap");function Ie(e,t){return t===void 0?n=>G(e,n):G(e,t)}o(Ie,"tap");let ke=o(e=>new Promise(t=>setTimeout(t,e)),"sleep");function H(e,t,n){if(!Number.isFinite(e))throw new TypeError("Expected `limit` to be a finite number");if(e<=0)throw new TypeError("Expected `limit` to be greater than 0");if(!Number.isFinite(t))throw new TypeError("Expected `interval` to be a finite number");return o((async function*(){let i=0,f;for await(let a of n){if(i<e){typeof f>"u"&&(f=Date.now()),i++,yield a;continue}let y=Date.now()-(f||0),s=t-y;s>0&&await ke(s),f=Date.now(),i=1,yield a}}),"__throttle")()}o(H,"_throttle");function Ee(e,t,n){return n===void 0?r=>H(e,t,r):H(e,t,n)}o(Ee,"throttle");function J(e,t){let n=e[0]+t[0],r=e[1]+t[1];if(r>=1e9){let i=r%1e9;n+=(r-i)/1e9,r=i}return[n,r]}o(J,"addTime");async function*Qe(e,t){let n=t[Symbol.asyncIterator](),r=[0,0];for(;;){let i=process.hrtime(),{value:f,done:a}=await n.next(),y=process.hrtime(i);if(r=J(r,y),e.progress&&e.progress(y,r),a)return e.total&&e.total(r),f;yield f}}o(Qe,"_asyncTime");function*be(e,t){let n=t[Symbol.iterator](),r=[0,0];for(;;){let i=process.hrtime(),{value:f,done:a}=n.next(),y=process.hrtime(i);if(r=J(r,y),e.progress&&e.progress(y,r),a)return e.total&&e.total(r),f;yield f}}o(be,"_syncTime");function K(e={},t){return t===void 0?n=>K(e,n):t[Symbol.asyncIterator]!==void 0?Qe(e,t):be(e,t)}o(K,"time");function Me(e,t,n){let r=g(n),i=[],f=[],a=!1,y=!1,s=0,c=null;function h(){for(;f.length>0&&i.length>0;){let{resolve:m}=f.shift(),d=i.shift();m({done:!1,value:d})}for(;f.length>0&&s===0&&a;){let{resolve:m,reject:d}=f.shift();c?(d(c),c=null):m({done:!0,value:void 0})}}o(h,"fulfillReadQueue");async function u(){if(a){h();return}if(!y&&!(s+i.length>=e)){y=!0,s++;try{let{done:m,value:d}=await r.next();m?(a=!0,s--,h()):w(d)}catch(m){a=!0,s--,c=m,h()}y=!1,u()}}o(u,"fillQueue");async function w(m){try{let d=await t(m);i.push(d)}catch(d){a=!0,c=d}s--,h(),u()}o(w,"mapAndQueue");async function v(){if(i.length===0){let d=C();return f.push(d),u(),d.promise}let m=i.shift();return u(),{done:!1,value:m}}o(v,"next");let S={next:v,[Symbol.asyncIterator]:()=>S};return S}o(Me,"_transform");function M(e,t,n){return t===void 0?(r,i)=>i?M(e,r,i):M(e,r):n===void 0?r=>M(e,t,r):Me(e,t,n)}o(M,"transform");async function X(e,t){let n=null,r=null,i=null,f=o(c=>{n=c,r&&r(c)},"notifyError"),a=o(()=>{i&&i()},"notifyDrain"),y=o(()=>{e.removeListener("error",f),e.removeListener("drain",a)},"cleanup");e.once("error",f);let s=o(()=>new Promise((c,h)=>{if(n)return h(n);e.once("drain",a),i=c,r=h}),"waitForDrain");for await(let c of t)if(e.write(c)===!1&&await s(),n)break;if(y(),n)throw n}o(X,"_writeToStream");function De(e,t){return t===void 0?n=>X(e,n):X(e,t)}o(De,"writeToStream"),l.batch=P,l.batchWithTimeout=L,l.buffer=_,l.collect=re,l.concat=fe,l.consume=ue,l.drop=F,l.filter=I,l.flatMap=j,l.flatTransform=E,l.flatten=T,l.fromStream=he,l.getIterator=g,l.map=k,l.merge=me,l.parallelFlatMap=b,l.parallelMap=Q,l.parallelMerge=pe,l.pipeline=N,l.reduce=W,l.take=V,l.takeLast=q,l.takeWhile=_e,l.tap=Ie,l.throttle=Ee,l.time=K,l.transform=M,l.writeToStream=De}))});var{parallelMap:We,transform:Le}=Z();module.exports={parallelMap:We,transform:Le};
+"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
+};