uneventful 0.0.2 → 0.0.4

package/dist/mod.mjs

@@ -1,2 +1,1772 @@
-let y=typeof queueMicrotask=="function"?queueMicrotask:(n=>t=>n.then(t))(Promise.resolve());function P(n,t){n("next",t)}function Q(n,t){n("throw",void 0,t)}function it(n){return n.bind(null,"next")}function st(n){return n.bind(null,"throw",void 0)}function V(){}function ut(n,t,e){return{op:n,val:t,err:e}}const H=Object.freeze(ut("cancel"));function vt(n){return ut("next",n)}function gt(n){return ut("throw",void 0,n)}function J(n){return n===H}function _(n){return n?n.op==="next":!1}function C(n){return n?n.op==="throw":!1}function L(n){return C(n)&&n.val===void 0}function Gt(n){return C(n)&&n.val===null}function W(n){return n.val=null,n.err}function yt(n){if(_(n))return n.val;n.op,U(V,t=>{throw t},n)}function U(n,t,e){C(e)?t(W(e)):J(e)?t(new wt("Job canceled")):n(e.val)}function mt(n,t){n.result()||U(n.return.bind(n),n.throw.bind(n),t)}class wt extends Error{}var p=k();function a(n){const t=p;return p=n,t}var B=[];function k(n,t){if(B&&B.length){const e=B.pop();return e.job=n,e.cell=t,e}return{job:n,cell:t}}function G(n){n.job=n.cell=null,B.push(n)}const z=new WeakMap,St=n=>{Promise.reject(n)},bt=k(),_t=new WeakMap;function kt(){return X(0,void 0,void 0)}function Yt(n){for(;n.v;)Z(n,n.n);n.u=void 0,Z(n,n)}function Xt(n,t){++n.v,X(t,n.n,n)}function Zt(n,t){++n.v,X(t,n,n.p)}function $t(n,t){return++n.v,te(n,X(t,n,n.p))}function Ft(n){return!n||n.v===0}function xt(n){return n?n.v:0}function jt(n){if(xt(n))return Z(n,n.p)}class Kt{constructor(){this.n=this,this.p=this,this.v=0,this.u=void 0}}var Y;function X(n,t,e){let r=Y;return r?(Y=r.n,r.n=t||r,r.p=e||r):(r=new Kt,t&&(r.n=t),e&&(r.p=e)),r.v=n,r.n.p=r,r.p.n=r,r}function Z(n,t){--n.v;var e=t.v,r=t.u;return t.n&&(t.n.p=t.p),t.p&&(t.p.n=t.n),t.u=t.v=t.p=void 0,t.n=Y,Y=t,r&&r(),e}function te(n,t){let e=t.u||(t.u=()=>{e&&(e===t.u&&Z(n,t),e=n=t=void 0)});return e}function w(n){return typeof n=="function"}function d(){const{job:n}=p;if(n)return n;throw new Error("No job is currently active")}function ee(n){return t=>{p.job.must(n.release(t))}}function Rt(n,t){for(;xt(t);)try{jt(t)(n)}catch(e){m.asyncThrow(e)}t&&Yt(t)}var x=new Set;class N{constructor(){this.end=()=>{const t=this._done||(this._done=H),e=this._cbs;if(!e&&!L(t))return;const r=x.size,i=a(bt);if(r||x.add(null),e&&e.u&&(e.u=Rt(t,e.u)),x.add(this),r){a(i);return}x.delete(null);for(const s of x)s._cbs&&(s._cbs=Rt(s._done,s._cbs)),x.delete(s),L(s._done)&&s.throw(W(s._done));a(i)},this._done=void 0,this._cbs=void 0}static create(t,e){const r=new N;return(t||e)&&(r.must((t||(t=d())).release(e||r.end)),_t.set(r,t)),r}do(t){return Xt(this._chain(),t),this}onError(t){return this.do(e=>{C(e)&&t(W(e))})}onValue(t){return this.do(e=>{_(e)&&t(e.val)})}onCancel(t){return this.do(e=>{J(e)&&t()})}result(){return this._done||p.cell?.recalcWhen(this,ee)||void 0}get[Symbol.toStringTag](){return"Job"}restart(){if(!this._done&&x.size){const t=x;x=new Set,this.end(),x=t}else this._end(H);return this._done=void 0,$.delete(this),this}_end(t){if(this._done)throw new Error("Job already ended");return this!==m&&(this._done=t),this.end(),this}throw(t){return this._done?((_t.get(this)||m).asyncThrow(t),this):this._end(gt(t))}return(t){return this._end(vt(t))}then(t,e){return F(this).then(t,e)}catch(t){return F(this).catch(t)}finally(t){return F(this).finally(t)}*[Symbol.iterator](){return this._done?yt(this._done):yield t=>{this.do(e=>U(it(t),st(t),e))}}start(t,e){if(!t)return E(this);let r,i;if(w(e))r=e.bind(t);else if(w(t))r=t;else{if(t instanceof N)return t;i=t}const s=E(this);try{if(r&&(i=s.run(r,s)),i!=null)if(i instanceof N)i!==s&&i.do(u=>mt(s,u));else{if(w(i.then))return i.then(u=>{s.result()||s.return(u)},u=>{s.result()||s.throw(u)}),s;if(w(i[Symbol.iterator])&&typeof i!="string")s.run(ne,i,s);else throw new TypeError("Invalid value/return for start()")}return s}catch(u){throw s.end(),u}}connect(t,e,r){return this.start(i=>void t(e,i,r))}run(t,...e){const r=a(k(this));try{return t.apply(null,e)}finally{G(a(r))}}bind(t){const e=this;return function(){const r=a(k(e));try{return t.apply(this,arguments)}finally{G(a(r))}}}must(t){return w(t)&&Zt(this._chain(),t),this}release(t){if(this===m)return V;let e=this._chain();return(!this._done||e.u)&&(e=e.u||(e.u=kt())),$t(e,t)}asyncThrow(t){try{(z.get(this)||this.throw).call(this,t)}catch(e){this===m?z.set(this,St):z.delete(this);const r=z.get(this)||this.throw;r.call(this,t),r.call(this,e)}return this}asyncCatch(t){return w(t)?z.set(this,t):t===null&&z.delete(this),this}_chain(){return this===m&&this.end(),this._done&&Ft(this._cbs)&&y(this.end),this._cbs||(this._cbs=kt())}}const $=new WeakMap;function F(n=d()){return $.has(n)||$.set(n,new Promise((t,e)=>{const r=U.bind(null,t,e);n.result()?r(n.result()):n.do(r)})),$.get(n)}const E=N.create,m=E();m.end=()=>{throw new Error("Can't do that with the detached job")},m.asyncCatch(St);function ne(n,t){let e=n[Symbol.iterator](),r=!0,i=k(t),s=0,u=i.job.release(()=>{t=void 0,++s,o("return",void 0)});y(()=>{r=!1,o("next",void 0)});function o(c,l){if(!e)return;if(r)return y(o.bind(null,c,l));const T=a(i);try{r=!0;try{for(;;){++s;const{done:f,value:b}=e[c](l);if(f){t&&t.return(b),t=void 0;break}else if(w(b)){let g=!1,O=!1,Ht=s;if(b((rt,Lt,Bt)=>{g||(g=!0,c=rt,l=rt==="next"?Lt:Bt,O&&Ht===s&&o(rt,l))}),O=!0,!g)return}else{c="throw",l=new TypeError("Jobs must yield functions (or yield* Yielding<T>s)");continue}}}catch(f){e=t=void 0,i.job.throw(f)}e=void 0,u?.(),u=void 0}finally{a(T),r=!1}}}function*Tt(n){return yield t=>Promise.resolve(n).then(it(t),st(t))}function*re(n){try{var t;yield e=>{t=setTimeout(()=>{t=void 0,P(e,void 0)},n)}}finally{t&&clearTimeout(t)}}class Ct{constructor(t,e){this.sched=t,this.reap=e,this._flags=0,this.q=new Set,this._run=()=>{this._flags&=-3,this.flush()},this.flush=()=>{if(this._flags&1)return;const{q:r}=this;if(r.size){this._flags|=1;try{this.reap(r)}finally{this._flags&=-2,!r.size||this._flags&2||this._sched()}}}}isRunning(){return!!(this._flags&1)}isEmpty(){return!this.q.size}add(t){this.q.size||this._flags&3||this._sched(),this.q.add(t)}delete(t){this.q.delete(t)}_sched(){this._flags|=2,this.sched(this._run)}}const Et=new Ct(y,n=>{for(const t of n)n.delete(t),t.doPull()});Et.flush;function q(n=se){const t=d();return e=>!t.result()&&n.isOpen()?(e&&n.onReady(e,t),n.isReady()):!1}const h="uneventful/is-stream";function Mt(n,t,e){return d().connect(n,t,e)}function I(n=p.job){return new ie(n)}class ie{constructor(t){this._job=t,this._callbacks=void 0,this._isReady=!0,this._isPulling=!1}isOpen(){return!this._job?.result()}isReady(){return this.isOpen()&&this._isReady}onReady(t,e){if(!this.isOpen())return this;const r=this._callbacks||(this._callbacks=new Map),i=e.release(()=>r.delete(t));return this.isReady()&&this&&!r.size&&Et.add(this),r.set(t,i),this}pause(){return this._isReady=!1,this}doPull(){if(this._isPulling)return;const{_callbacks:t}=this;if(t?.size){this._isPulling=!0;try{for(let[e,r]of t){if(!this.isReady())break;r(),t.delete(e),e()}}finally{this._isPulling=!1}}}resume(){this.isOpen()&&(this._isReady=!0,this.doPull())}}const se=I();function Pt(){for(var n=arguments[0],t=1;t<arguments.length;t++)n=arguments[t](n);return n}function ue(...n){return t=>Pt(t,...n)}function oe(...n){return t=>t(...n)}function le(n,t,e){return n.set(t,e),e}class ot extends Error{}class lt extends Error{}var v=1,A,ct;class j{constructor(t=y){this.rule=e=>R.mkRule(e,this.q),this.q=new Ct(t,e=>{if(!ct){ct=this;try{for(A of e)A.catchUp(),e.delete(A)}finally{ct=A=void 0}}}),this.flush=this.q.flush}static for(t=y){return this.cache.has(t)||this.cache.set(t,new this(t)),this.cache.get(t)}}j.cache=new WeakMap;const Vt=j.for(y),at=Vt.rule,ce=Vt.flush,ae=new WeakMap,Wt=new WeakMap,zt=[];function he(n){const t=n.lastChanged=n.latestSource=v;for(;n;n=zt.pop())for(let e=n.subscribers;e;e=e.nT){const r=e.tgt;r.latestSource>=t||r.latestSource===0||(r.latestSource=t,r.flags&1&&r.value.add(r),r.subscribers&&zt.push(r))}}var K;function fe(n,t){let e=K;e?(K=e.old,e.src=n,e.nS=void 0,e.pS=t.sources,e.tgt=t,e.nT=e.pT=void 0,e.ts=n.lastChanged,e.old=n.adding):e={src:n,nS:void 0,pS:t.sources,tgt:t,nT:void 0,pT:void 0,ts:n.lastChanged,old:n.adding},t.sources&&(t.sources.nS=e),t.sources=e,n.adding=e,t.latestSource===0||n.subscribe(e)}function qt(n){n.src.unsubscribe(n),n.nS&&(n.nS.pS=n.pS),n.pS&&(n.pS.nS=n.nS),n.src=n.tgt=n.nS=n.pS=n.nT=n.pT=void 0,n.old=K,K=n}const de={};class R{constructor(){this.value=void 0,this.validThrough=0,this.lastChanged=0,this.latestSource=v,this.flags=0,this.ctx=void 0,this.adding=void 0,this.sources=void 0,this.subscribers=void 0,this.compute=void 0}stream(t,e,r){let i=de;return(r?j.for(q(r)).rule:at)(()=>{const s=this.getValue();if(s!==i){const u=a(bt);try{t(i=s)}finally{a(u)}}}),h}getValue(){if(arguments.length)return this.stream.apply(this,arguments);this.catchUp();const t=p.cell;if(t){if(this.flags&32)throw new lt("Cached function dependency cycle");let e=this.adding;!e||e.tgt!==t?fe(this,t):e.ts===-1&&(e.ts=this.lastChanged,e.nS&&(e.nS.pS=e.pS,e.pS&&(e.pS.nS=e.nS),e.nS=void 0,e.pS=t.sources,t.sources.nS=e,t.sources=e))}if(this.flags&16)throw this.value;return this.value}setValue(t){const e=p.cell||A;if(e){if(e.flags&4)throw new ot("Side-effects not allowed in cached functions");if(this.adding&&this.adding.tgt===e)throw new lt("Can't update direct dependency");if(this.validThrough===v)throw new ot("Value already used")}else{if(t===this.value)return;this.validThrough===v&&++v}this.lastChanged===v||he(this),this.value=t}catchUp(){const{validThrough:t}=this;if(t!==v&&(this.validThrough=v,!(this.latestSource!==0&&this.latestSource<=t||!(this.flags&5))))if(this.sources)for(let e=this.sources;e;e=e.nS){const r=e.src;if(!(r.latestSource!==0&&r.latestSource<=t)){if(e.ts!==r.lastChanged)return this.doRecalc();if(r.catchUp(),r.lastChanged>t)return this.doRecalc()}}else return this.doRecalc()}doRecalc(){const t=a(this.ctx);for(let e=this.sources;e;e=e.nS)e.ts=-1,e.old=e.src.adding,e.src.adding=e,this.sources=e;this.flags|=32;try{if(this.flags&4){this.flags&=-17;try{const e=this.compute();(e!==this.value||!this.lastChanged)&&(this.value=e,this.lastChanged=v)}catch(e){this.flags|=16,this.value=e,this.lastChanged=v}}else{const{job:e}=this.ctx;e.restart();try{e.must(this.compute()),this.lastChanged=v}catch(r){throw this.disposeRule(),r}}}finally{this.flags&=-33,a(t);let e;for(let r=this.sources;r;){const i=r.pS;r.src.adding=r.old,r.old=void 0,r.ts===-1?qt(r):e=r,r=i}this.sources=e,this.flags&8&&this.disposeRule()}}disposeRule(){if(this.ctx.job.end(),this.flags|=8,this.value.delete(this),p!==this.ctx){for(let t=this.sources;t;){let e=t.nS;qt(t),t=e}this.sources=void 0}}subscribe(t){if(!this.subscribers){if(this.flags&4){this.latestSource=v;for(let e=this.sources;e;e=e.nS)e.src.subscribe(e)}this.flags&64&&this.compute()}this.subscribers!==t&&!t.pT&&(t.nT=this.subscribers,this.subscribers&&(this.subscribers.pT=t),this.subscribers=t)}unsubscribe(t){if(t.nT&&(t.nT.pT=t.pT),t.pT&&(t.pT.nT=t.nT),this.subscribers===t&&(this.subscribers=t.nT),!this.subscribers){if(this.flags&4){this.latestSource=0;for(let e=this.sources;e;e=e.nS)e.src.unsubscribe(e)}this.flags&64&&this.ctx.job?.restart()}}static mkValue(t){const e=new R;return e.value=t,e.lastChanged=v,e}static mkStream(t,e){const r=this.mkValue(e);r.flags|=64,r.ctx=k();const i=r.setValue.bind(r);return r.compute=()=>{var s;(s=r.ctx).job||(s.job=E().asyncCatch(o=>m.asyncThrow(o)).must(o=>{r.value=e,J(o)||(r.ctx.job=void 0)}));const u=a(r.ctx);try{t(i)}catch(o){m.asyncThrow(o),r.ctx.job.end(),r.ctx.job=void 0}finally{a(u)}},r.getValue.bind(r)}recalcWhen(t,e){let r=e?Wt.get(e)||le(Wt,e,new WeakMap):ae,i=r.get(t);if(!i){const s=e?e(t):t;let u=0;i=R.mkStream(o=>(s(()=>o(++u)),h),u),r.set(t,i)}i()}static mkCached(t){const e=new R;return e.compute=t,e.ctx=k(null,e),e.flags=4,e.latestSource=0,e.getValue.bind(e)}static mkRule(t,e){var r=d().release(u),i=new R,s=E();return i.value=e,i.compute=t.bind(null,u),i.ctx=k(s,i),i.flags=1,e.add(i),u;function u(){r(),i&&(i.disposeRule(),i=void 0)}}}class tt extends Function{get value(){return this()}valueOf(){return this()}toString(){return""+this()}toJSON(){return this()}peek(){return Jt(this)}readonly(){return this}withSet(t){const e=this;return et(function(){return e.apply(null,arguments)},t)}*"uneventful.until"(){return yield t=>{try{let e=this.peek();if(e)return P(t,e);at(r=>{try{(e=this())&&(r(),P(t,e))}catch(i){r(),Q(t,i)}})}catch(e){Q(t,e)}}}constructor(){super()}}class It extends tt{get value(){return this()}set value(t){this.set(t)}readonly(){const t=this;return et(function(){return t.apply(null,arguments)})}}function pe(n){const t=R.mkValue(n);return et(t.getValue.bind(t),t.setValue.bind(t))}function ve(n,t){return n instanceof tt?n:et(n.length?R.mkStream(n,t):R.mkCached(n))}function Jt(n,...t){if(!p.cell)return n(...t);const e=a(k(p.job));try{return n.apply(null,t)}finally{G(a(e))}}function ge(n,t){p.cell?.recalcWhen(n,t)}function et(n,t){return t&&(n.set=t),Object.setPrototypeOf(n,(t?It:tt).prototype)}function M(n){return d().must(n)}function S(n,t){return d().start(n,t)}function ye(){return!!p.job}const D=new WeakMap;function Ut(n=0,t=d()){let e=D.get(t);return e?clearTimeout(e):e===void 0&&!t.result()&&t.must(Ut.bind(null,0,t)),t.result()?D.delete(t):n?D.set(t,setTimeout(()=>{D.set(t,null),t.end()},n)):D.set(t,null),t}const ht=new WeakMap;function me(n=d()){let t=ht.get(n);if(!t){const e=new AbortController;t=e.signal,n.do(()=>{ht.set(n,null),e.abort()}),ht.set(n,t),n.result()&&e.abort()}return t}function we(n){const t=d(),e=E(t),{end:r}=e;return n||(n=i=>{e.must(i())}),e.asyncCatch(i=>t.asyncThrow(i)),function(){e.restart().must(t.release(r));const i=a(k(e));try{return n.apply(this,arguments)}catch(s){throw e.restart(),s}finally{G(a(i))}}}function Se(){const n=At();return n.source=Dt(n.source),n}function be(){return(n,t)=>(t?.return(),h)}function _e(n){return(t,e=S(),r)=>{const i=q(r),s=n[Symbol.asyncIterator]();return s.return&&M(()=>s.return()),i(u),h;function u(){s.next().then(({value:o,done:c})=>{c?e.return():i(()=>{t(o),i()?u():i(u)})},o=>e.throw(o))}}}function ke(n,t,e){return r=>{function i(s){r(s)}return n.addEventListener(t,i,e),M(()=>n.removeEventListener(t,i,e)),h}}function ft(n){return(t,e=S(),r)=>{const i=q(r),s=n[Symbol.iterator]();return s.return&&M(()=>s.return()),i(u),h;function u(){try{for(;;){const{value:o,done:c}=s.next();if(c)return e.return();if(t(o),!i())return i(u)}}catch(o){e.throw(o)}}}}function xe(n){return(t,e)=>{const r=d();return Promise.resolve(n).then(i=>void(r.result()||(t(i),e?.return())),i=>void(r.result()||e?.throw(i))),h}}function Re(n){return t=>{const e=d().must(()=>t=V);return y(()=>e.must(n(r=>{t(r)}))),h}}function Te(n){return(t,e)=>(M(()=>{t=V,e=void 0}),y(()=>{t(n),e?.return()}),h)}function Ce(n){return t=>{let e=0,r=setInterval(()=>t(e++),n);return M(()=>clearInterval(r)),h}}function Ee(n){return(t,e)=>n()(t,e)}function At(){let n,t,e;const r=i=>{n&&n(i)};return r.source=(i,s,u)=>(n=i,t=s,e=q(u),M(()=>n=t=e=void 0),h),r.end=()=>t?.return(),r.throw=i=>t?.throw(i),r.ready=i=>e(i),r}function Me(){return()=>h}function Dt(n){let t;const e=new Set,r=new Map,i=I(),s={isOpen(){return!t?.result()},isReady(){if(this.isOpen()){for(const[o]of r)if(!o.isReady())return i.pause(),!1;return!0}return i.pause(),!1},onReady(o,c){if(this.isOpen()){i.onReady(o,c);for(const[l]of r)l.isReady()||l.onReady(u,c)}return this}};function u(){s.isReady()&&i.resume()}return(o,c=S(),l)=>{const T=[o,c];return e.add(T),l&&r.set(l,1+(r.get(l)||0)),c.must(()=>{e.delete(T),l&&(r.set(l,r.get(l)-1),r.get(l)||r.delete(l)),e.size?s.isReady()&&!i.isReady()&&y(u):t?.end()}),e.size===1&&(t=m.connect(n,f=>{for(const[b,g]of e)try{b(f)}catch(O){g.throw(O)}},s).do(f=>{if(t=void 0,!J(f)){L(f)&&W(f);for(const[b,g]of e)C(f)?g.throw(f.err):g.return()}})),h}}function*Pe(n){let t=!1,e;const r={value:{item:void 0,next:u},done:!1},i=I(),s=d().connect(n,o=>{i.pause(),!(!e||s.result())&&(r.value.item=o,P(e,e=void 0))},i).do(o=>{C(o)&&W(o),e&&(y(u.bind(null,e)),e=void 0)});return i.pause(),yield u,{[Symbol.iterator](){return this},next(){if(!t)throw new Error("Must `yield next` in loop");return t=!1,r},return(){return s.end(),{value:void 0,done:!0}}};function u(o){if(e)throw new Error("Multiple `yield next` in loop");t=!0,s.result()?(r.value=void 0,r.done=!0,C(s.result())?Q(o,s.result().err):P(o,void 0)):(e=o,i.resume())}}function Ve(n){if(w(n["uneventful.until"]))return n["uneventful.until"]();if(w(n.then))return Tt(n);if(w(n))return S(t=>{Mt(n,e=>t.return(e)).onError(e=>t.throw(e)).onValue(()=>t.throw(new Error("Stream ended")))});throw new TypeError("until(): must be signal, source, or then-able")}function We(n){return dt(ft(n))}function dt(n){return(t,e=S(),r)=>{let i;const s=[],u=I();let o=e.connect(n,l=>{s.push(l),c(),u.pause()},u).do(l=>{o=void 0,s.length||i||!_(l)||e.return()});function c(){i||(i=e.connect(s.shift(),t,r).do(l=>{i=void 0,s.length?c():o?u.resume():!_(l)||e.return()}))}return h}}function ze(n){return t=>dt(nt(n)(t))}function qe(n){return t=>(e,r,i)=>{let s=0;return t(u=>n(u,s++)&&e(u),r,i)}}function nt(n){return t=>(e,r,i)=>{let s=0;return t(u=>e(n(u,s++)),r,i)}}function Ie(n){return pt(ft(n))}function pt(n){return(t,e=S(),r)=>{const i=new Set;let s=e.connect(n,u=>{const o=e.connect(u,t,r).do(c=>{i.delete(o),i.size||s||!_(c)||e.return()});i.add(o)}).do(u=>{s=void 0,i.size||!_(u)||e.return()});return h}}function Je(n){return t=>pt(nt(n)(t))}function Ue(n){return Nt((t,e)=>e<n)}function Ae(n){return t=>(e,r=S(),i)=>{let s=!1;const u=r.connect(n,()=>{s=!0,u.end()});return t(o=>s&&e(o),r,i)}}function Nt(n){return t=>(e,r,i)=>{let s=0,u=!1;return t(o=>(u||(u=!n(o,s++)))&&e(o),r,i)}}function De(n,t=V){const e=Math.abs(n);return r=>(i,s=S(),u)=>{const o=[],c=q(u);let l=!1,T=!1;const f=I();s.connect(r,g=>{if(o.push(g),!T&&c())return b();for(;o.length>e;)t(n<0?o.pop():o.shift());o.length===e&&(f.pause(),l=!0),o.length&&c(b)},f).do(g=>{_(g)&&s.return()});function b(){T=!0;try{for(;o.length;)if(i(o.shift()),l&&c()&&(l=!1,f.resume()),o.length&&!c())return c(b)}finally{T=!1}}return h}}function Ot(n){return(t,e=S(),r)=>{let i,s=e.connect(n,u=>{i?.end(),i=e.connect(u,t,r).do(o=>{i=void 0,s||!_(o)||e.return()})}).do(u=>{s=void 0,i||!_(u)||e.return()});return h}}function Ne(n){return t=>Ot(nt(n)(t))}function Oe(n){return Qt((t,e)=>e<n)}function Qe(n){return t=>(e,r=S(),i)=>(r.connect(n,()=>r.return()),t(e,r,i))}function Qt(n){return t=>(e,r,i)=>{let s=0;return t(u=>n(u,s++)?e(u):r?.return(),r,i)}}export{wt as CancelError,H as CancelResult,lt as CircularDependency,gt as ErrorResult,h as IsStream,j as RuleScheduler,tt as Signal,vt as ValueResult,It as Writable,ot as WriteConflict,me as abortSignal,q as backpressure,ve as cached,ue as compose,We as concat,dt as concatAll,ze as concatMap,Mt as connect,y as defer,m as detached,Pe as each,Se as emitter,be as empty,qe as filter,_e as fromAsyncIterable,ke as fromDomEvent,ft as fromIterable,xe as fromPromise,Re as fromSubscribe,Te as fromValue,U as fulfillPromise,d as getJob,yt as getResult,Ce as interval,oe as into,J as isCancel,C as isError,w as isFunction,Gt as isHandled,ye as isJobActive,L as isUnhandled,_ as isValue,Ee as lazy,E as makeJob,nt as map,W as markHandled,Ie as merge,pt as mergeAll,Je as mergeMap,At as mockSource,M as must,F as nativePromise,Me as never,Jt as noDeps,V as noop,Pt as pipe,mt as propagateResult,ge as recalcWhen,Q as reject,st as rejecter,P as resolve,it as resolver,we as restarting,at as rule,ce as runRules,Dt as share,Ue as skip,Ae as skipUntil,Nt as skipWhile,De as slack,re as sleep,S as start,Ot as switchAll,Ne as switchMap,Oe as take,Qe as takeUntil,Qt as takeWhile,I as throttle,Ut as timeout,Tt as to,Ve as until,pe as value};
+let defer = typeof queueMicrotask === "function" ? queueMicrotask : ((p) => (cb) => p.then(cb))(Promise.resolve());
+
+function resolve(request, val) {
+  request("next", val);
+}
+function reject(request, reason) {
+  request("throw", void 0, reason);
+}
+function resolver(request) {
+  return request.bind(null, "next");
+}
+function rejecter(request) {
+  return request.bind(null, "throw", void 0);
+}
+function noop() {
+}
+function mkResult(op, val, err) {
+  return { op, val, err };
+}
+const CancelResult = Object.freeze(mkResult("cancel"));
+function ValueResult(val) {
+  return mkResult("next", val);
+}
+function ErrorResult(err) {
+  return mkResult("throw", void 0, err);
+}
+function isCancel(res) {
+  return res === CancelResult;
+}
+function isValue(res) {
+  return res ? res.op === "next" : false;
+}
+function isError(res) {
+  return res ? res.op === "throw" : false;
+}
+function isUnhandled(res) {
+  return isError(res) && res.val === void 0;
+}
+function isHandled(res) {
+  return isError(res) && res.val === null;
+}
+function markHandled(res) {
+  res.val = null;
+  return res.err;
+}
+function getResult(res) {
+  if (isValue(res))
+    return res.val;
+  res.op;
+  fulfillPromise(noop, (e) => {
+    throw e;
+  }, res);
+}
+function fulfillPromise(resolve2, reject2, res) {
+  if (isError(res))
+    reject2(markHandled(res));
+  else if (isCancel(res))
+    reject2(new CancelError("Job canceled"));
+  else
+    resolve2(res.val);
+}
+function propagateResult(job, res) {
+  if (!job.result())
+    fulfillPromise(job.return.bind(job), job.throw.bind(job), res);
+}
+class CancelError extends Error {
+}
+
+var current = makeCtx();
+function swapCtx(future) {
+  const now = current;
+  current = future;
+  return now;
+}
+var freelist = [];
+function makeCtx(job, cell) {
+  if (freelist && freelist.length) {
+    const s = freelist.pop();
+    s.job = job;
+    s.cell = cell;
+    return s;
+  }
+  return { job, cell };
+}
+function freeCtx(s) {
+  s.job = s.cell = null;
+  freelist.push(s);
+}
+
+const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
+  Promise.reject(e);
+};
+const nullCtx = makeCtx();
+const owners = /* @__PURE__ */ new WeakMap();
+
+function chain() {
+  return link(0, void 0, void 0);
+}
+function recycle(c) {
+  while (c.v)
+    unlink(c, c.n);
+  c.u = void 0;
+  unlink(c, c);
+}
+function unshift(c, v) {
+  ++c.v;
+  link(v, c.n, c);
+}
+function push(c, v) {
+  ++c.v;
+  link(v, c, c.p);
+}
+function pushCB(c, v) {
+  ++c.v;
+  return unlinker(c, link(v, c, c.p));
+}
+function isEmpty(c) {
+  return !c || c.v === 0;
+}
+function qlen(c) {
+  return c ? c.v : 0;
+}
+function pop(c) {
+  if (qlen(c))
+    return unlink(c, c.p);
+}
+class Node {
+  constructor() {
+    /** The next node (or the start node if this is a chain head) */
+    this.n = this;
+    /** The previous node (or the end node if this is a chain head) */
+    this.p = this;
+    /** The value held by the node (or the chain length if this is a chain head) */
+    this.v = 0;
+    /** The most recently created undo callback for this node */
+    this.u = void 0;
+  }
+}
+var free;
+function link(v, n, p) {
+  let node = free;
+  if (node) {
+    free = node.n;
+    node.n = n || node;
+    node.p = p || node;
+  } else {
+    node = new Node();
+    if (n)
+      node.n = n;
+    if (p)
+      node.p = p;
+  }
+  node.v = v;
+  node.n.p = node;
+  node.p.n = node;
+  return node;
+}
+function unlink(c, node) {
+  --c.v;
+  var v = node.v, u = node.u;
+  node.n && (node.n.p = node.p);
+  node.p && (node.p.n = node.n);
+  node.u = node.v = node.p = void 0;
+  node.n = free;
+  free = node;
+  if (u)
+    u();
+  return v;
+}
+function unlinker(chain2, node) {
+  let u = node.u ||= () => {
+    if (u) {
+      if (u === node.u)
+        unlink(chain2, node);
+      u = chain2 = node = void 0;
+    }
+  };
+  return u;
+}
+
+function isFunction(f) {
+  return typeof f === "function";
+}
+function getJob() {
+  const { job } = current;
+  if (job)
+    return job;
+  throw new Error("No job is currently active");
+}
+function recalcJob(job) {
+  return (cb) => {
+    current.job.must(job.release(cb));
+  };
+}
+function runChain(res, cbs) {
+  while (qlen(cbs))
+    try {
+      pop(cbs)(res);
+    } catch (e) {
+      detached.asyncThrow(e);
+    }
+  cbs && recycle(cbs);
+  return void 0;
+}
+var inProcess = /* @__PURE__ */ new Set();
+class _Job {
+  constructor() {
+    this.end = () => {
+      const res = this._done ||= CancelResult, cbs = this._cbs;
+      if (!cbs && !isUnhandled(res))
+        return;
+      const ct = inProcess.size, old = swapCtx(nullCtx);
+      if (!ct)
+        inProcess.add(null);
+      if (cbs && cbs.u)
+        cbs.u = runChain(res, cbs.u);
+      inProcess.add(this);
+      if (ct) {
+        swapCtx(old);
+        return;
+      }
+      inProcess.delete(null);
+      for (const item of inProcess) {
+        if (item._cbs)
+          item._cbs = runChain(item._done, item._cbs);
+        inProcess.delete(item);
+        if (isUnhandled(item._done))
+          item.throw(markHandled(item._done));
+      }
+      swapCtx(old);
+    };
+    this._done = void 0;
+    // Chain whose .u stores a second chain for `release()` callbacks
+    this._cbs = void 0;
+  }
+  /** @internal */
+  static create(parent, stop) {
+    const job = new _Job();
+    if (parent || stop) {
+      job.must((parent ||= getJob()).release(stop || job.end));
+      owners.set(job, parent);
+    }
+    return job;
+  }
+  do(cleanup) {
+    unshift(this._chain(), cleanup);
+    return this;
+  }
+  onError(cb) {
+    return this.do((r) => {
+      if (isError(r))
+        cb(markHandled(r));
+    });
+  }
+  onValue(cb) {
+    return this.do((r) => {
+      if (isValue(r))
+        cb(r.val);
+    });
+  }
+  onCancel(cb) {
+    return this.do((r) => {
+      if (isCancel(r))
+        cb();
+    });
+  }
+  result() {
+    return this._done || current.cell?.recalcWhen(this, recalcJob) || void 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Job";
+  }
+  restart() {
+    if (!this._done && inProcess.size) {
+      const old = inProcess;
+      inProcess = /* @__PURE__ */ new Set();
+      this.end();
+      inProcess = old;
+    } else {
+      this._end(CancelResult);
+    }
+    this._done = void 0;
+    promises.delete(this);
+    return this;
+  }
+  _end(res) {
+    if (this._done)
+      throw new Error("Job already ended");
+    if (this !== detached)
+      this._done = res;
+    this.end();
+    return this;
+  }
+  throw(err) {
+    if (this._done) {
+      (owners.get(this) || detached).asyncThrow(err);
+      return this;
+    }
+    return this._end(ErrorResult(err));
+  }
+  return(val) {
+    return this._end(ValueResult(val));
+  }
+  then(onfulfilled, onrejected) {
+    return nativePromise(this).then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return nativePromise(this).catch(onrejected);
+  }
+  finally(onfinally) {
+    return nativePromise(this).finally(onfinally);
+  }
+  *[Symbol.iterator]() {
+    if (this._done) {
+      return getResult(this._done);
+    } else
+      return yield (req) => {
+        this.do((res) => fulfillPromise(resolver(req), rejecter(req), res));
+      };
+  }
+  start(fnOrCtx, fn) {
+    if (!fnOrCtx)
+      return makeJob(this);
+    let init, result;
+    if (isFunction(fn)) {
+      init = fn.bind(fnOrCtx);
+    } else if (isFunction(fnOrCtx)) {
+      init = fnOrCtx;
+    } else if (fnOrCtx instanceof _Job) {
+      return fnOrCtx;
+    } else {
+      result = fnOrCtx;
+    }
+    const job = makeJob(this);
+    try {
+      if (init)
+        result = job.run(init, job);
+      if (result != null) {
+        if (result instanceof _Job) {
+          if (result !== job)
+            result.do((res) => propagateResult(job, res));
+        } else if (isFunction(result.then)) {
+          result.then(
+            (v) => {
+              job.result() || job.return(v);
+            },
+            (e) => {
+              job.result() || job.throw(e);
+            }
+          );
+          return job;
+        } else if (isFunction(result[Symbol.iterator]) && typeof result !== "string") {
+          job.run(runGen, result, job);
+        } else if (isFunction(result)) {
+          job.must(result);
+        } else {
+          throw new TypeError("Invalid value/return for start()");
+        }
+      }
+      return job;
+    } catch (e) {
+      job.end();
+      throw e;
+    }
+  }
+  connect(src, sink, inlet) {
+    return this.start((job) => void src(sink, job, inlet));
+  }
+  run(fn, ...args) {
+    const old = swapCtx(makeCtx(this));
+    try {
+      return fn.apply(null, args);
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  }
+  bind(fn) {
+    const job = this;
+    return function() {
+      const old = swapCtx(makeCtx(job));
+      try {
+        return fn.apply(this, arguments);
+      } finally {
+        freeCtx(swapCtx(old));
+      }
+    };
+  }
+  must(cleanup) {
+    if (isFunction(cleanup))
+      push(this._chain(), cleanup);
+    return this;
+  }
+  release(cleanup) {
+    if (this === detached)
+      return noop;
+    let cbs = this._chain();
+    if (!this._done || cbs.u)
+      cbs = cbs.u ||= chain();
+    return pushCB(cbs, cleanup);
+  }
+  asyncThrow(err) {
+    try {
+      (catchers.get(this) || this.throw).call(this, err);
+    } catch (e) {
+      if (this === detached)
+        catchers.set(this, defaultCatch);
+      else
+        catchers.delete(this);
+      const catcher = catchers.get(this) || this.throw;
+      catcher.call(this, err);
+      catcher.call(this, e);
+    }
+    return this;
+  }
+  asyncCatch(handler) {
+    if (isFunction(handler))
+      catchers.set(this, handler);
+    else if (handler === null)
+      catchers.delete(this);
+    return this;
+  }
+  _chain() {
+    if (this === detached)
+      this.end();
+    if (this._done && isEmpty(this._cbs))
+      defer(this.end);
+    return this._cbs ||= chain();
+  }
+}
+const promises = /* @__PURE__ */ new WeakMap();
+function nativePromise(job = getJob()) {
+  if (!promises.has(job)) {
+    promises.set(job, new Promise((res, rej) => {
+      const toPromise = fulfillPromise.bind(null, res, rej);
+      if (job.result())
+        toPromise(job.result());
+      else
+        job.do(toPromise);
+    }));
+  }
+  return promises.get(job);
+}
+const makeJob = _Job.create;
+const detached = makeJob();
+detached.end = () => {
+  throw new Error("Can't do that with the detached job");
+};
+detached.asyncCatch(defaultCatch);
+function runGen(g, job) {
+  let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;
+  let done = ctx.job.release(() => {
+    job = void 0;
+    ++ct;
+    step("return", void 0);
+  });
+  defer(() => {
+    running = false;
+    step("next", void 0);
+  });
+  function step(method, arg) {
+    if (!it)
+      return;
+    if (running) {
+      return defer(step.bind(null, method, arg));
+    }
+    const old = swapCtx(ctx);
+    try {
+      running = true;
+      try {
+        for (; ; ) {
+          ++ct;
+          const { done: done2, value } = it[method](arg);
+          if (done2) {
+            job && job.return(value);
+            job = void 0;
+            break;
+          } else if (!isFunction(value)) {
+            method = "throw";
+            arg = new TypeError("Jobs must yield functions (or yield* Yielding<T>s)");
+            continue;
+          } else {
+            let called = false, returned = false, count = ct;
+            value((op, val, err) => {
+              if (called)
+                return;
+              else
+                called = true;
+              method = op;
+              arg = op === "next" ? val : err;
+              if (returned && count === ct)
+                step(op, arg);
+            });
+            returned = true;
+            if (!called)
+              return;
+          }
+        }
+      } catch (e) {
+        it = job = void 0;
+        ctx.job.throw(e);
+      }
+      it = void 0;
+      done?.();
+      done = void 0;
+    } finally {
+      swapCtx(old);
+      running = false;
+    }
+  }
+}
+
+function* to(p) {
+  return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
+}
+function* sleep(ms) {
+  try {
+    var id;
+    yield (r) => {
+      id = setTimeout(() => {
+        id = void 0;
+        resolve(r, void 0);
+      }, ms);
+    };
+  } finally {
+    if (id)
+      clearTimeout(id);
+  }
+}
+
+class RunQueue {
+  constructor(sched, reap) {
+    this.sched = sched;
+    this.reap = reap;
+    this._flags = 0 /* Unset */;
+    this.q = /* @__PURE__ */ new Set();
+    this._run = () => {
+      this._flags &= ~2 /* Scheduled */;
+      this.flush();
+    };
+    /** Run all pending items */
+    this.flush = () => {
+      if (this._flags & 1 /* Running */)
+        return;
+      const { q: queue } = this;
+      if (!queue.size)
+        return;
+      this._flags |= 1 /* Running */;
+      try {
+        this.reap(queue);
+      } finally {
+        this._flags &= ~1 /* Running */;
+        !queue.size || this._flags & 2 /* Scheduled */ || this._sched();
+      }
+    };
+  }
+  /** Is this queue currently running? */
+  isRunning() {
+    return !!(this._flags & 1 /* Running */);
+  }
+  /** Is this queue currently empty? */
+  isEmpty() {
+    return !this.q.size;
+  }
+  add(subject) {
+    this.q.size || this._flags & (1 /* Running */ | 2 /* Scheduled */) || this._sched();
+    this.q.add(subject);
+  }
+  delete(subject) {
+    this.q.delete(subject);
+  }
+  _sched() {
+    this._flags |= 2 /* Scheduled */;
+    this.sched(this._run);
+  }
+}
+var currentRule;
+var currentQueue;
+const ruleQueues = /* @__PURE__ */ new WeakMap();
+class RuleQueue extends RunQueue {
+  constructor(sched) {
+    super(sched, function(q) {
+      if (currentQueue)
+        return;
+      currentQueue = this;
+      try {
+        for (currentRule of q) {
+          currentRule.catchUp();
+          q.delete(currentRule);
+        }
+      } finally {
+        currentQueue = currentRule = void 0;
+      }
+    });
+  }
+}
+function ruleQueue(scheduleFn = defer) {
+  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, new RuleQueue(scheduleFn));
+  return ruleQueues.get(scheduleFn);
+}
+const defaultQ = /* @__PURE__ */ ruleQueue(defer);
+const pulls = new RunQueue(defer, (pulls2) => {
+  for (const conn of pulls2) {
+    pulls2.delete(conn);
+    conn.doPull();
+  }
+});
+pulls.flush;
+
+function backpressure(inlet = defaultInlet) {
+  const job = getJob();
+  return (cb) => {
+    if (!job.result() && inlet.isOpen()) {
+      if (cb)
+        inlet.onReady(cb, job);
+      return inlet.isReady();
+    }
+    return false;
+  };
+}
+const IsStream = "uneventful/is-stream";
+function connect(src, sink, inlet) {
+  return getJob().connect(src, sink, inlet);
+}
+function throttle(job = current.job) {
+  return new _Throttle(job);
+}
+class _Throttle {
+  /** @internal */
+  constructor(_job) {
+    this._job = _job;
+    /** @internal */
+    this._callbacks = void 0;
+    this._isReady = true;
+    this._isPulling = false;
+  }
+  isOpen() {
+    return !this._job?.result();
+  }
+  /** Is the conduit currently ready to receive data? */
+  isReady() {
+    return this.isOpen() && this._isReady;
+  }
+  onReady(cb, job) {
+    if (!this.isOpen())
+      return this;
+    const _callbacks = this._callbacks ||= /* @__PURE__ */ new Map();
+    const unlink = job.release(() => _callbacks.delete(cb));
+    if (this.isReady() && this && !_callbacks.size) {
+      pulls.add(this);
+    }
+    _callbacks.set(cb, unlink);
+    return this;
+  }
+  pause() {
+    this._isReady = false;
+    return this;
+  }
+  doPull() {
+    if (this._isPulling)
+      return;
+    const { _callbacks } = this;
+    if (!_callbacks?.size)
+      return;
+    this._isPulling = true;
+    try {
+      for (let [cb, unlink] of _callbacks) {
+        if (!this.isReady())
+          break;
+        unlink();
+        _callbacks.delete(cb);
+        cb();
+      }
+    } finally {
+      this._isPulling = false;
+    }
+  }
+  resume() {
+    if (this.isOpen()) {
+      this._isReady = true;
+      this.doPull();
+    }
+  }
+}
+const defaultInlet = throttle();
+function pipe() {
+  var v = arguments[0];
+  for (var i = 1; i < arguments.length; i++)
+    v = arguments[i](v);
+  return v;
+}
+function compose(...fns) {
+  return (val) => pipe(val, ...fns);
+}
+function into(...args) {
+  return (src) => src(...args);
+}
+
+function setMap(map, key, val) {
+  map.set(key, val);
+  return val;
+}
+function CallableObject(fn) {
+  return Object.setPrototypeOf(fn, new.target.prototype);
+}
+CallableObject.prototype = Function.prototype;
+
+class WriteConflict extends Error {
+}
+class CircularDependency extends Error {
+}
+var timestamp = 1;
+const fntrackers = /* @__PURE__ */ new WeakMap();
+const obtrackers = /* @__PURE__ */ new WeakMap();
+const dirtyStack = [];
+function markDependentsDirty(cell) {
+  const latestSource = cell.latestSource = timestamp;
+  for (; cell; cell = dirtyStack.pop()) {
+    for (let sub = cell.subscribers; sub; sub = sub.nT) {
+      const tgt = sub.tgt;
+      if (tgt.latestSource >= latestSource)
+        continue;
+      tgt.latestSource = latestSource;
+      if (tgt.flags & 1 /* Rule */)
+        tgt.value.q.add(tgt);
+      if (tgt.subscribers)
+        dirtyStack.push(tgt);
+    }
+  }
+}
+function returnValue() {
+  return this.value;
+}
+function throwValue() {
+  throw this.value;
+}
+const notCaughtUp = [];
+var freesubs;
+function mksub(source, target) {
+  let sub = freesubs;
+  if (sub) {
+    freesubs = sub.old;
+    sub.src = source;
+    sub.nS = void 0;
+    sub.pS = target.sources;
+    sub.tgt = target;
+    sub.nT = sub.pT = void 0;
+    sub.ts = source.lastChanged;
+    sub.old = source.adding;
+  } else
+    sub = {
+      src: source,
+      nS: void 0,
+      pS: target.sources,
+      tgt: target,
+      nT: void 0,
+      pT: void 0,
+      ts: source.lastChanged,
+      old: source.adding
+    };
+  if (target.sources)
+    target.sources.nS = sub;
+  target.sources = sub;
+  source.adding = sub;
+  if (target.subscribers || target.flags & 1 /* Rule */)
+    source.subscribe(sub);
+}
+function delsub(sub) {
+  sub.src.unsubscribe(sub);
+  if (sub.nS)
+    sub.nS.pS = sub.pS;
+  if (sub.pS)
+    sub.pS.nS = sub.nS;
+  sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = void 0;
+  sub.old = freesubs;
+  freesubs = sub;
+}
+const sentinel = {};
+class Cell {
+  constructor() {
+    this.value = void 0;
+    // the value, or, for a rule, the `{q, rm}` struct
+    this.validThrough = 0;
+    // timestamp of most recent validation or recalculation
+    this.lastChanged = 0;
+    // timestamp of last value change
+    this.latestSource = timestamp;
+    // max lastChanged of this cell or any ancestor source
+    this.flags = 0;
+    this.ctx = void 0;
+    /** The subscription being added during the current calculation - used for uniqueness */
+    this.adding = void 0;
+    /** Linked list of sources */
+    this.sources = void 0;
+    /** Linked list of targets */
+    this.subscribers = void 0;
+    /**
+     * The computation to be performed (if {@link Is.Calc} or {@link Is.Rule})
+     * or the setup/teardown for {@link Is.Stream}.
+     */
+    this.compute = returnValue;
+  }
+  stream(sink, _conn, inlet) {
+    let lastValue = sentinel;
+    Cell.mkRule(() => {
+      const val = this.getValue();
+      if (val !== lastValue) {
+        const old = swapCtx(nullCtx);
+        try {
+          sink(lastValue = val);
+        } finally {
+          swapCtx(old);
+        }
+      }
+    }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
+    return IsStream;
+  }
+  getValue() {
+    if (arguments.length)
+      return this.stream.apply(this, arguments);
+    this.catchUp();
+    const dep = current.cell;
+    if (dep && this.flags & 133 /* Variable */) {
+      if (this.flags & 32 /* Running */)
+        throw new CircularDependency("Cached function dependency cycle");
+      let s = this.adding;
+      if (!s || s.tgt !== dep) {
+        mksub(this, dep);
+      } else {
+        if (s.ts === -1) {
+          s.ts = this.lastChanged;
+          if (s.nS) {
+            s.nS.pS = s.pS;
+            if (s.pS)
+              s.pS.nS = s.nS;
+            s.nS = void 0;
+            s.pS = dep.sources;
+            dep.sources.nS = s;
+            dep.sources = s;
+          }
+        }
+      }
+    }
+    if (this.flags & 16 /* Error */)
+      throw this.value;
+    return this.value;
+  }
+  shouldWrite(changed) {
+    const cell = current.cell || currentRule;
+    if (cell) {
+      if (cell.flags & 4 /* Calc */)
+        throw new WriteConflict("Side-effects not allowed in cached functions");
+      if (this.adding && this.adding.tgt === cell)
+        throw new CircularDependency("Can't update direct dependency");
+      if (this.validThrough === timestamp || this.hasBeenRead())
+        throw new WriteConflict("Value already used");
+    } else if (changed) {
+      if (this.validThrough === timestamp || notCaughtUp.length) {
+        ++timestamp;
+        notCaughtUp.length = 0;
+      }
+    } else {
+      return false;
+    }
+    this.lastChanged === timestamp || markDependentsDirty(this);
+    if (this.sources)
+      this.sources.ts = 0;
+    return true;
+  }
+  setValue(val, isErr) {
+    if (this.shouldWrite(val !== this.value || isErr !== !!(this.flags & 16 /* Error */))) {
+      this.value = val;
+      this.lastChanged = timestamp;
+      this.flags = isErr ? this.flags | 16 /* Error */ : this.flags & ~16 /* Error */;
+    }
+    this.compute = isErr ? throwValue : returnValue;
+  }
+  setCalc(compute) {
+    if (this.shouldWrite(compute !== this.compute)) {
+      this.flags |= 4 /* Calc */;
+      this.compute = compute;
+      this.ctx ||= makeCtx(null, this);
+    }
+  }
+  hasBeenRead() {
+    if (notCaughtUp.length) {
+      for (const cell of notCaughtUp)
+        cell.catchUp();
+      notCaughtUp.length = 0;
+    }
+    return this.validThrough === timestamp;
+  }
+  catchUp() {
+    const { validThrough } = this;
+    if (validThrough === timestamp)
+      return;
+    this.validThrough = timestamp;
+    if (!(this.flags & 5 /* Computed */))
+      return;
+    if (this.sources) {
+      for (let sub = this.sources; sub; sub = sub.nS) {
+        const s = sub.src;
+        if (sub.ts !== s.lastChanged)
+          return this.doRecalc();
+        if (s.subscribers && s.latestSource <= validThrough)
+          continue;
+        s.catchUp();
+        if (s.lastChanged > validThrough) {
+          return this.doRecalc();
+        }
+      }
+      for (let sub = this.sources; sub; sub = sub.nS) {
+        if (sub.src.validThrough !== timestamp)
+          notCaughtUp.push(sub.src);
+      }
+    } else
+      return this.doRecalc();
+  }
+  doRecalc() {
+    const oldCtx = swapCtx(this.ctx);
+    for (let sub = this.sources; sub; sub = sub.nS) {
+      sub.ts = -1;
+      sub.old = sub.src.adding;
+      sub.src.adding = sub;
+      this.sources = sub;
+    }
+    this.flags |= 32 /* Running */;
+    try {
+      if (this.flags & 4 /* Calc */) {
+        try {
+          const future = this.compute();
+          if (future !== this.value || !this.lastChanged || this.flags & 16 /* Error */) {
+            this.value = future;
+            this.lastChanged = timestamp;
+          }
+          this.flags &= ~16 /* Error */;
+        } catch (e) {
+          this.flags |= 16 /* Error */;
+          this.value = e;
+          this.lastChanged = timestamp;
+        }
+      } else {
+        const { job } = this.ctx;
+        job.restart();
+        try {
+          job.must(this.compute());
+          this.lastChanged = timestamp;
+        } catch (e) {
+          this.disposeRule();
+          throw e;
+        }
+      }
+    } finally {
+      this.flags &= ~32 /* Running */;
+      swapCtx(oldCtx);
+      let head;
+      for (let sub = this.sources; sub; ) {
+        const pS = sub.pS;
+        sub.src.adding = sub.old;
+        sub.old = void 0;
+        if (sub.ts === -1)
+          delsub(sub);
+        else
+          head = sub;
+        sub = pS;
+      }
+      this.sources = head;
+      if (!head) {
+        this.flags &= ~4 /* Calc */;
+      }
+      if (this.flags & 8 /* Dead */)
+        this.disposeRule();
+    }
+  }
+  disposeRule() {
+    this.ctx.job.end();
+    this.flags |= 8 /* Dead */;
+    this.value.q.delete(this);
+    this.value.rm();
+    if (current !== this.ctx) {
+      for (let s = this.sources; s; ) {
+        let nS = s.nS;
+        delsub(s);
+        s = nS;
+      }
+      this.sources = void 0;
+    }
+  }
+  subscribe(sub) {
+    if (!this.subscribers) {
+      if (this.flags & 4 /* Calc */) {
+        for (let s = this.sources; s; s = s.nS)
+          s.src.subscribe(s);
+      }
+      if (this.flags & 64 /* Stream */)
+        this.compute(true);
+    }
+    if (this.subscribers !== sub && !sub.pT) {
+      sub.nT = this.subscribers;
+      if (this.subscribers)
+        this.subscribers.pT = sub;
+      this.subscribers = sub;
+    }
+  }
+  unsubscribe(sub) {
+    if (sub.nT)
+      sub.nT.pT = sub.pT;
+    if (sub.pT)
+      sub.pT.nT = sub.nT;
+    if (this.subscribers === sub)
+      this.subscribers = sub.nT;
+    if (!this.subscribers) {
+      if (this.flags & 4 /* Calc */) {
+        for (let s = this.sources; s; s = s.nS)
+          s.src.unsubscribe(s);
+      }
+      if (this.flags & 64 /* Stream */)
+        this.compute(false);
+    }
+  }
+  static mkValue(val) {
+    const cell = new Cell();
+    cell.flags = 128 /* Mutable */;
+    cell.value = val;
+    cell.lastChanged = timestamp;
+    return cell;
+  }
+  static mkStream(src, val) {
+    const cell = this.mkValue(val);
+    cell.flags |= 64 /* Stream */;
+    cell.ctx = makeCtx();
+    const write = (v) => {
+      cell.setValue(v, false);
+      cell.compute = compute;
+    };
+    let job;
+    const compute = cell.compute = (sub) => {
+      if (!sub) {
+        cell.value = val;
+        cell.flags &= ~16 /* Error */;
+        job?.end();
+        return;
+      }
+      if (job)
+        return;
+      job = cell.ctx.job = makeJob().do((r) => {
+        if (isError(r)) {
+          cell.setValue(markHandled(r), true);
+        } else if (isValue(r)) {
+          cell.setValue(val, false);
+        }
+        cell.compute = compute;
+        cell.ctx.job = job = void 0;
+      });
+      const old = swapCtx(cell.ctx);
+      try {
+        src(write, job);
+      } catch (e) {
+        job.end();
+        throw e;
+      } finally {
+        swapCtx(old);
+      }
+    };
+    return cell;
+  }
+  recalcWhen(fnOrKey, fn) {
+    let trackers = fn ? obtrackers.get(fn) || setMap(obtrackers, fn, /* @__PURE__ */ new WeakMap()) : fntrackers;
+    let signal = trackers.get(fnOrKey);
+    if (!signal) {
+      const src = fn ? fn(fnOrKey) : fnOrKey;
+      let ct = 0;
+      const c = Cell.mkStream((s) => (src(() => s(++ct)), IsStream), ct);
+      trackers.set(fnOrKey, signal = c.getValue.bind(c));
+    }
+    signal();
+  }
+  static mkCached(compute) {
+    const cell = new Cell();
+    cell.compute = compute;
+    cell.ctx = makeCtx(null, cell);
+    cell.flags = 4 /* Calc */;
+    return cell;
+  }
+  static mkRule(fn, q) {
+    var cell = new Cell(), job = makeJob();
+    const stop = cell.disposeRule.bind(cell);
+    cell.value = { q, rm: getJob().release(stop) };
+    cell.compute = fn.bind(null, stop);
+    cell.ctx = makeCtx(job, cell);
+    cell.flags = 1 /* Rule */;
+    q.add(cell);
+    return stop;
+  }
+}
+
+class RF extends CallableObject {
+  constructor(q) {
+    super((fn) => Cell.mkRule(fn, q));
+  }
+  stop() {
+    if (currentRule)
+      return currentRule.disposeRule();
+    throw new Error("No rule active");
+  }
+  if(condition, action) {
+    const cond = Cell.mkCached(() => !!condition());
+    return this(() => cond.getValue() ? action() : void 0);
+  }
+  get method() {
+    const self = this;
+    return (fn, _ctxOrName, desc) => {
+      if (desc)
+        return void (desc.value = this.method(desc.value));
+      return function(...args) {
+        return self(() => fn.apply(this, args));
+      };
+    };
+  }
+  factory(scheduleFn) {
+    return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));
+  }
+}
+const factories = /* @__PURE__ */ new WeakMap();
+const rule = RF.prototype.factory(defer);
+function runRules(scheduleFn) {
+  (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();
+}
+
+class SignalImpl extends CallableObject {
+  constructor(_c) {
+    super(_c.getValue.bind(_c));
+    this._c = _c;
+  }
+  get value() {
+    return this();
+  }
+  valueOf() {
+    return this();
+  }
+  toString() {
+    return "" + this();
+  }
+  toJSON() {
+    return this();
+  }
+  peek() {
+    return peek(this);
+  }
+  asReadonly() {
+    return this;
+  }
+  withSet(set) {
+    return Object.assign(new WritableImpl(this._c), { set });
+  }
+  *"uneventful.next"() {
+    return yield (r) => {
+      let seen = false, res;
+      rule((stop) => {
+        try {
+          res = this();
+        } catch (e) {
+          stop();
+          reject(r, e);
+        }
+        if (seen) {
+          stop();
+          resolve(r, res);
+        }
+        seen = true;
+      });
+    };
+  }
+  *"uneventful.until"() {
+    return yield (r) => {
+      let res;
+      try {
+        res = this();
+      } catch (e) {
+        reject(r, e);
+        return;
+      }
+      if (res)
+        return resolve(r, res);
+      rule((stop) => {
+        try {
+          res = this();
+        } catch (e) {
+          stop();
+          reject(r, e);
+        }
+        if (res) {
+          stop();
+          resolve(r, res);
+        }
+      });
+    };
+  }
+}
+class WritableImpl extends SignalImpl {
+  constructor() {
+    super(...arguments);
+    this.set = (val) => {
+      this._c.setValue(val, false);
+    };
+  }
+  get value() {
+    return this();
+  }
+  set value(val) {
+    this.set(val);
+  }
+  asReadonly() {
+    return new SignalImpl(this._c);
+  }
+}
+class ConfigurableImpl extends WritableImpl {
+  setf(expr) {
+    this._c.setCalc(expr);
+    return this;
+  }
+}
+function value(val) {
+  const cell = Cell.mkValue(val);
+  return new ConfigurableImpl(cell);
+}
+function cached(compute, initVal) {
+  if (compute instanceof SignalImpl)
+    return compute;
+  return new SignalImpl(
+    compute.length ? Cell.mkStream(compute, initVal) : Cell.mkCached(compute)
+  );
+}
+function peek(fn, ...args) {
+  if (!current.cell)
+    return fn(...args);
+  const old = swapCtx(makeCtx(current.job));
+  try {
+    return fn.apply(null, args);
+  } finally {
+    freeCtx(swapCtx(old));
+  }
+}
+function recalcWhen(fnOrKey, fn) {
+  current.cell?.recalcWhen(fnOrKey, fn);
+}
+function action(fn, _ctx, desc) {
+  if (desc)
+    return { ...desc, value: action(desc.value) };
+  return function() {
+    if (!current.cell)
+      return fn.apply(this, arguments);
+    const old = swapCtx(makeCtx(current.job));
+    try {
+      return fn.apply(this, arguments);
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  };
+}
+
+function must(cleanup) {
+  return getJob().must(cleanup);
+}
+function start(init, fn) {
+  return getJob().start(init, fn);
+}
+function isJobActive() {
+  return !!current.job;
+}
+const timers = /* @__PURE__ */ new WeakMap();
+function timeout(ms = 0, job = getJob()) {
+  let timer = timers.get(job);
+  if (timer) {
+    clearTimeout(timer);
+  } else if (timer === void 0 && !job.result()) {
+    job.must(timeout.bind(null, 0, job));
+  }
+  if (job.result()) {
+    timers.delete(job);
+  } else if (ms) {
+    timers.set(job, setTimeout(() => {
+      timers.set(job, null);
+      job.end();
+    }, ms));
+  } else {
+    timers.set(job, null);
+  }
+  return job;
+}
+const abortSignals = /* @__PURE__ */ new WeakMap();
+function abortSignal(job = getJob()) {
+  let signal = abortSignals.get(job);
+  if (!signal) {
+    const ctrl = new AbortController();
+    signal = ctrl.signal;
+    job.do(() => {
+      abortSignals.set(job, null);
+      ctrl.abort();
+    });
+    abortSignals.set(job, signal);
+    if (job.result())
+      ctrl.abort();
+  }
+  return signal;
+}
+function restarting(task2) {
+  const outer = getJob(), inner = makeJob(outer), { end } = inner;
+  task2 ||= (f) => {
+    inner.must(f());
+  };
+  inner.asyncCatch((e) => outer.asyncThrow(e));
+  return function() {
+    inner.restart().must(outer.release(end));
+    const old = swapCtx(makeCtx(inner));
+    try {
+      return task2.apply(this, arguments);
+    } catch (e) {
+      inner.restart();
+      throw e;
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  };
+}
+function task(fn, _ctx, desc) {
+  if (desc)
+    return { ...desc, value: task(desc.value) };
+  return function(...args) {
+    return start(() => fn.apply(this, args));
+  };
+}
+
+function emitter() {
+  const emit = mockSource();
+  emit.source = share(emit.source);
+  return emit;
+}
+function empty() {
+  return (_, conn) => (conn?.return(), IsStream);
+}
+function fromAsyncIterable(iterable) {
+  return (sink, conn = start(), inlet) => {
+    const ready = backpressure(inlet);
+    const iter = iterable[Symbol.asyncIterator]();
+    if (iter.return)
+      must(() => iter.return());
+    return ready(next), IsStream;
+    function next() {
+      iter.next().then(({ value, done }) => {
+        if (done)
+          conn.return();
+        else
+          ready(() => {
+            if (sink(value), ready())
+              next();
+            else
+              ready(next);
+          });
+      }, (e) => conn.throw(e));
+    }
+  };
+}
+function fromDomEvent(target, type, options) {
+  return (sink) => {
+    function push(v) {
+      sink(v);
+    }
+    target.addEventListener(type, push, options);
+    must(() => target.removeEventListener(type, push, options));
+    return IsStream;
+  };
+}
+function fromIterable(iterable) {
+  return (sink, conn = start(), inlet) => {
+    const ready = backpressure(inlet);
+    const iter = iterable[Symbol.iterator]();
+    if (iter.return)
+      must(() => iter.return());
+    return ready(loop), IsStream;
+    function loop() {
+      try {
+        for (; ; ) {
+          const { value, done } = iter.next();
+          if (done)
+            return conn.return();
+          if (sink(value), !ready())
+            return ready(loop);
+        }
+      } catch (e) {
+        conn.throw(e);
+      }
+    }
+  };
+}
+function fromPromise(promise) {
+  return (sink, conn) => {
+    const job = getJob();
+    Promise.resolve(promise).then(
+      (v) => void (job.result() || (sink(v), conn?.return())),
+      (e) => void (job.result() || conn?.throw(e))
+    );
+    return IsStream;
+  };
+}
+function fromSubscribe(subscribe) {
+  return (sink) => {
+    const f = getJob().must(() => sink = noop);
+    return defer(() => f.must(subscribe((v) => {
+      sink(v);
+    }))), IsStream;
+  };
+}
+function fromValue(val) {
+  return (sink, conn) => {
+    must(() => {
+      sink = noop;
+      conn = void 0;
+    });
+    return defer(() => {
+      sink(val);
+      conn?.return();
+    }), IsStream;
+  };
+}
+function interval(ms) {
+  return (sink) => {
+    let idx = 0, id = setInterval(() => sink(idx++), ms);
+    return must(() => clearInterval(id)), IsStream;
+  };
+}
+function lazy(factory) {
+  return (sink, conn, inlet) => factory()(sink, conn, inlet);
+}
+function mockSource() {
+  let write, outlet, ready;
+  const emit = (val) => {
+    if (write)
+      write(val);
+  };
+  emit.source = (sink, conn, inlet) => {
+    write = sink;
+    outlet = conn;
+    ready = backpressure(inlet);
+    must(() => write = outlet = ready = void 0);
+    return IsStream;
+  };
+  emit.end = () => outlet?.return();
+  emit.throw = (e) => outlet?.throw(e);
+  emit.ready = (cb) => ready(cb);
+  return emit;
+}
+function never() {
+  return () => IsStream;
+}
+function share(source) {
+  let uplink;
+  const links = /* @__PURE__ */ new Set(), inlets = /* @__PURE__ */ new Map(), t = throttle(), multi = {
+    // A multi-connection inlet that requires all downstreams to be ready
+    isOpen() {
+      return !uplink?.result();
+    },
+    isReady() {
+      if (this.isOpen()) {
+        for (const [i] of inlets)
+          if (!i.isReady())
+            return t.pause(), false;
+        return true;
+      }
+      t.pause();
+      return false;
+    },
+    onReady(cb, job) {
+      if (this.isOpen()) {
+        t.onReady(cb, job);
+        for (const [i] of inlets)
+          i.isReady() || i.onReady(produce, job);
+      }
+      return this;
+    }
+  };
+  function produce() {
+    multi.isReady() && t.resume();
+  }
+  return (sink, conn = start(), inlet) => {
+    const self = [sink, conn];
+    links.add(self);
+    if (inlet)
+      inlets.set(inlet, 1 + (inlets.get(inlet) || 0));
+    conn.must(() => {
+      links.delete(self);
+      if (inlet) {
+        inlets.set(inlet, inlets.get(inlet) - 1);
+        if (!inlets.get(inlet))
+          inlets.delete(inlet);
+      }
+      if (!links.size)
+        uplink?.end();
+      else if (multi.isReady() && !t.isReady())
+        defer(produce);
+    });
+    if (links.size === 1) {
+      uplink = detached.connect(source, (v) => {
+        for (const [s, c] of links)
+          try {
+            s(v);
+          } catch (e) {
+            c.throw(e);
+          }
+      }, multi).do((r) => {
+        uplink = void 0;
+        if (isCancel(r))
+          return;
+        if (isUnhandled(r))
+          markHandled(r);
+        for (const [_, c] of links)
+          isError(r) ? c.throw(r.err) : c.return();
+      });
+    }
+    return IsStream;
+  };
+}
+
+function* each(src) {
+  let yielded = false, waiter;
+  const result = { value: { item: void 0, next: next2 }, done: false };
+  const t = throttle(), conn = getJob().connect(src, (v) => {
+    t.pause();
+    if (!waiter || conn.result())
+      return;
+    result.value.item = v;
+    resolve(waiter, waiter = void 0);
+  }, t).do((r) => {
+    if (isError(r))
+      markHandled(r);
+    if (waiter) {
+      defer(next2.bind(null, waiter));
+      waiter = void 0;
+    }
+  });
+  t.pause();
+  yield next2;
+  return {
+    [Symbol.iterator]() {
+      return this;
+    },
+    next() {
+      if (!yielded)
+        throw new Error("Must `yield next` in loop");
+      yielded = false;
+      return result;
+    },
+    return() {
+      conn.end();
+      return { value: void 0, done: true };
+    }
+  };
+  function next2(r) {
+    if (waiter)
+      throw new Error("Multiple `yield next` in loop");
+    yielded = true;
+    if (conn.result()) {
+      result.value = void 0;
+      result.done = true;
+      fulfillPromise(resolver(r), rejecter(r), conn.result());
+    } else {
+      waiter = r;
+      t.resume();
+    }
+  }
+}
+function until(source) {
+  return callOrWait(source, "uneventful.until", waitTruthy, recache);
+}
+function recache(s) {
+  return until(cached(s));
+}
+function waitTruthy(job, v) {
+  v && job.return(v);
+}
+function next(source) {
+  return callOrWait(source, "uneventful.next", waitAny, mustBeSourceOrSignal);
+}
+function waitAny(job, v) {
+  job.return(v);
+}
+function callOrWait(source, method, handler, noArgs) {
+  if (source && isFunction(source[method]))
+    return source[method]();
+  if (isFunction(source))
+    return (source.length === 0 ? noArgs(source) : false) || start((job) => {
+      connect(source, (v) => handler(job, v)).do((r) => {
+        if (isValue(r))
+          job.throw(new Error("Stream ended"));
+        else if (isError(r))
+          job.throw(markHandled(r));
+      });
+    });
+  mustBeSourceOrSignal();
+}
+function mustBeSourceOrSignal() {
+  throw new TypeError("not a source or signal");
+}
+function forEach(src, sink, inlet) {
+  if (isFunction(sink))
+    return start((j) => {
+      src(restarting(sink), j, inlet);
+    });
+  inlet = sink;
+  sink = src;
+  return (src2) => forEach(src2, sink, inlet);
+}
+
+function concat(sources) {
+  return concatAll(fromIterable(sources));
+}
+function concatAll(sources) {
+  return (sink, conn = start(), inlet) => {
+    let inner;
+    const inputs = [], t = throttle();
+    let outer = conn.connect(sources, (s) => {
+      inputs.push(s);
+      startNext();
+      t.pause();
+    }, t).do((r) => {
+      outer = void 0;
+      inputs.length || inner || !isValue(r) || conn.return();
+    });
+    function startNext() {
+      inner ||= conn.connect(inputs.shift(), sink, inlet).do((r) => {
+        inner = void 0;
+        inputs.length ? startNext() : outer ? t.resume() : !isValue(r) || conn.return();
+      });
+    }
+    return IsStream;
+  };
+}
+function concatMap(mapper) {
+  return (src) => concatAll(map(mapper)(src));
+}
+function filter(filter2) {
+  return (src) => (sink, conn, inlet) => {
+    let idx = 0;
+    return src((v) => filter2(v, idx++) && sink(v), conn, inlet);
+  };
+}
+function map(mapper) {
+  return (src) => (sink, conn, inlet) => {
+    let idx = 0;
+    return src((v) => sink(mapper(v, idx++)), conn, inlet);
+  };
+}
+function merge(sources) {
+  return mergeAll(fromIterable(sources));
+}
+function mergeAll(sources) {
+  return (sink, conn = start(), inlet) => {
+    const uplinks = /* @__PURE__ */ new Set();
+    let outer = conn.connect(sources, (s) => {
+      const c = conn.connect(s, sink, inlet).do((r) => {
+        uplinks.delete(c);
+        uplinks.size || outer || !isValue(r) || conn.return();
+      });
+      uplinks.add(c);
+    }).do((r) => {
+      outer = void 0;
+      uplinks.size || !isValue(r) || conn.return();
+    });
+    return IsStream;
+  };
+}
+function mergeMap(mapper) {
+  return (src) => mergeAll(map(mapper)(src));
+}
+function skip(n) {
+  return skipWhile((_, i) => i < n);
+}
+function skipUntil(notifier) {
+  return (src) => (sink, conn = start(), inlet) => {
+    let taking = false;
+    const c = conn.connect(notifier, () => {
+      taking = true;
+      c.end();
+    });
+    return src((v) => taking && sink(v), conn, inlet);
+  };
+}
+function skipWhile(condition) {
+  return (src) => (sink, conn, inlet) => {
+    let idx = 0, met = false;
+    return src((v) => (met ||= !condition(v, idx++)) && sink(v), conn, inlet);
+  };
+}
+function slack(size, dropped = noop) {
+  const max = Math.abs(size);
+  return (src) => (sink, conn = start(), inlet) => {
+    const buffer = [], ready = backpressure(inlet);
+    let paused = false, draining = false;
+    const t = throttle();
+    conn.connect(src, (v) => {
+      buffer.push(v);
+      if (!draining && ready())
+        return drain();
+      while (buffer.length > max) {
+        dropped(size < 0 ? buffer.pop() : buffer.shift());
+      }
+      if (buffer.length === max) {
+        t.pause();
+        paused = true;
+      }
+      if (buffer.length)
+        ready(drain);
+    }, t).do((r) => {
+      if (isValue(r))
+        conn.return();
+    });
+    function drain() {
+      draining = true;
+      try {
+        while (buffer.length) {
+          sink(buffer.shift());
+          if (paused && ready()) {
+            paused = false;
+            t.resume();
+          }
+          if (buffer.length && !ready()) {
+            return ready(drain);
+          }
+        }
+      } finally {
+        draining = false;
+      }
+    }
+    return IsStream;
+  };
+}
+function switchAll(sources) {
+  return (sink, conn = start(), inlet) => {
+    let inner;
+    let outer = conn.connect(sources, (s) => {
+      inner?.end();
+      inner = conn.connect(s, sink, inlet).do((r) => {
+        inner = void 0;
+        outer || !isValue(r) || conn.return();
+      });
+    }).do((r) => {
+      outer = void 0;
+      inner || !isValue(r) || conn.return();
+    });
+    return IsStream;
+  };
+}
+function switchMap(mapper) {
+  return (src) => switchAll(map(mapper)(src));
+}
+function take(n) {
+  return takeWhile((_, i) => i < n);
+}
+function takeUntil(notifier) {
+  return (src) => (sink, conn = start(), inlet) => {
+    conn.connect(notifier, () => conn.return());
+    return src(sink, conn, inlet);
+  };
+}
+function takeWhile(condition) {
+  return (src) => (sink, conn, inlet) => {
+    let idx = 0;
+    return src((v) => condition(v, idx++) ? sink(v) : conn?.return(), conn, inlet);
+  };
+}
+
+export { CancelError, CancelResult, CircularDependency, ConfigurableImpl, ErrorResult, IsStream, SignalImpl, ValueResult, WritableImpl, WriteConflict, abortSignal, action, backpressure, cached, compose, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, getResult, interval, into, isCancel, isError, isFunction, isHandled, isJobActive, isUnhandled, isValue, lazy, makeJob, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, nativePromise, never, next, noop, peek, pipe, propagateResult, recalcWhen, reject, rejecter, resolve, resolver, restarting, rule, runRules, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, task, throttle, timeout, to, until, value };
 //# sourceMappingURL=mod.mjs.map