@soffinal/stream 0.2.4 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./stream.ts";
 export * from "./transformers/index.ts";
-export * from "./reactive/index.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-class z{_listeners=new Map;_generatorFn;_generator;_listenerAdded;_listenerRemoved;constructor(Z){this._generatorFn=Z instanceof z?()=>Z[Symbol.asyncIterator]():Z}get hasListeners(){return this._listeners.size>0}get listenerAdded(){if(!this._listenerAdded)this._listenerAdded=new z;return this._listenerAdded}get listenerRemoved(){if(!this._listenerRemoved)this._listenerRemoved=new z;return this._listenerRemoved}async*[Symbol.asyncIterator](){let Z=[],G,J=this.listen((Q)=>{Z.push(Q),G?.()});try{while(!0)if(Z.length)yield Z.shift();else await new Promise((Q)=>G=Q)}finally{J(),Z.length=0,G=void 0;return}}push(Z,...G){G.unshift(Z);let J=[];for(let Q of G)for(let[K,X]of this._listeners){if(X&&!X.deref()){J.push(K);continue}K(Q)}for(let Q of J)this._listeners.delete(Q)}async*withContext(Z){let G=new WeakRef(Z);try{for await(let J of this){if(!G.deref())break;yield J}}finally{return}}listen(Z,G){let J=this,Q,K;if(G instanceof AbortSignal){if(G?.aborted)return()=>{};G?.addEventListener("abort",X),Q=()=>G?.removeEventListener("abort",X)}else if(G instanceof z)Q=G?.listen(X);else if(G)K=new WeakRef(G);if(J._listeners.set(Z,K),J._listenerAdded?.push(),J._generatorFn&&J._listeners.size===1)J._generator=J._generatorFn(),(async()=>{for await(let Y of J._generator)J.push(Y)})();return X;function X(){if(J._listeners.delete(Z),J._listenerRemoved?.push(),J._listeners.size===0)J._generator?.return(),J._generator=void 0;Q?.(),Q=void 0,K=void 0}}then(Z){return new Promise((G)=>{let J=this.listen((Q)=>{G(Q),J()})}).then(Z)}pipe(Z){return Z(this)}}var V=(Z,G)=>{return(J)=>{if(!G||typeof G==="object"){let{strategy:K="sequential"}=G??{},X=Z;if(K==="sequential")return new z(async function*(){for await(let Y of J){let $=await X(Y);if($)yield Y;if($===void 0)return}});if(K==="concurrent-unordered")return new z(async function*(){let Y=Symbol.for("__abort"),$=[],_,H=J.listen(async(W)=>{let j=await X(W);if(j!==!1)j===void 0?$.push(Y):$.push(W),_?.(),_=void 0});try{while(!0)if($.length){let W=$.shift();if(W===Y)break;yield W}else await new Promise((W)=>_=W)}finally{$.length=0,H(),_=void 0}});if(K==="concurrent-ordered")return new z(async function*(){let Y=[],$,_=J.listen((H)=>{let W=X(H);Y.push({resultPromise:W,value:H}),(async()=>{await W,$?.(),$=void 0})()});try{while(!0)if(Y.length){let{resultPromise:H,value:W}=Y.shift(),j=await H;if(j)yield W;if(j===void 0)break}else await new Promise((H)=>$=H)}finally{Y.length=0,_(),$=void 0}})}let Q=G;return new z(async function*(){let K=Z;for await(let X of J){let Y=await Q(K,X);if(!Y)return;let[$,_]=Y;if(K=_,$)yield X}})}};var I=(Z,G)=>{return(J)=>{if(!G||typeof G==="object"){let{strategy:K="sequential"}=G??{},X=Z;if(K==="sequential")return new z(async function*(){for await(let Y of J)yield await X(Y)});if(K==="concurrent-unordered")return new z(async function*(){let Y=[],$,_=J.listen(async(H)=>{Y.push(await X(H)),$?.(),$=void 0});try{while(!0)if(Y.length)yield Y.shift();else await new Promise((H)=>$=H)}finally{Y.length=0,_(),$=void 0}});if(K==="concurrent-ordered")return new z(async function*(){let Y=[],$,_=J.listen((H)=>{let W=X(H);Y.push(W),(async()=>{await W,$?.(),$=void 0})()});try{while(!0)if(Y.length)yield await Y.shift();else await new Promise((H)=>$=H)}finally{Y.length=0,_(),$=void 0}})}let Q=G;return new z(async function*(){let K=Z;for await(let X of J){let[Y,$]=await Q(K,X);K=$,yield Y}})}};function q(...Z){return(G)=>new z(async function*(){let J=[G,...Z],Q=[],K,X=J.map((Y)=>Y.listen(($)=>{Q.push($),K?.()}));try{while(!0)if(Q.length)yield Q.shift();else await new Promise((Y)=>K=Y)}finally{X.forEach((Y)=>Y())}})}function A(Z=0){return(G)=>{return new z(async function*(){for await(let J of G)if(Array.isArray(J)){let Q=J.flat(Z);for(let K=0;K<Q.length;K++)yield Q[K]}else yield J})}}class B{_items=[];_insertStream;_deleteStream;_clearStream;constructor(Z){if(Z)this._items=[...Z];let G=this;function J(K,X){if(X===0)return 0;return K<0?(K%X+X)%X:K%X}this.insert=new Proxy((K,X)=>{let Y=K<0?Math.max(0,G._items.length+K+1):Math.min(K,G._items.length);return G._items.splice(Y,0,X),G._insertStream?.push([Y,X]),Q},{get(K,X){if(X in K)return K[X];if(!G._insertStream)G._insertStream=new z;return G._insertStream[X]}}),this.delete=new Proxy((K)=>{if(K<0||K>=G._items.length)return;let X=G._items.splice(K,1)[0];return G._deleteStream?.push([K,X]),X},{get(K,X){if(X in K)return K[X];if(!G._deleteStream)G._deleteStream=new z;return G._deleteStream[X]}}),this.clear=new Proxy(()=>{if(G._items.length>0)G._items.length=0,G._clearStream?.push()},{get(K,X){if(X in K)return K[X];if(!G._clearStream)G._clearStream=new z;return G._clearStream[X]}});let Q=new Proxy(this,{get(K,X){if(typeof X==="string"&&/^-?\d+$/.test(X)){let Y=parseInt(X);if(K._items.length===0)return;let $=J(Y,K._items.length);return K._items[$]}return K[X]},set(K,X,Y){if(typeof X==="string"&&/^-?\d+$/.test(X)){let $=parseInt(X);if(K._items.length===0)return K._items.push(Y),K._insertStream?.push([0,Y]),!0;let _=J($,K._items.length);if(K._items[_]!==Y)K._items[_]=Y,K._insertStream?.push([_,Y]);return!0}return K[X]=Y,!0}});return Q}get(Z){return this._items[Z]}get length(){return this._items.length}values(){return this._items[Symbol.iterator]()}[Symbol.iterator](){return this._items[Symbol.iterator]()}}class D extends globalThis.Map{_setStream;_deleteStream;_clearStream;constructor(Z){super(Z);let G=this;this.set=new Proxy((J,Q)=>{if(globalThis.Map.prototype.has.call(G,J)&&globalThis.Map.prototype.get.call(G,J)===Q)return G;return globalThis.Map.prototype.set.call(G,J,Q),G._setStream?.push([J,Q]),G},{get(J,Q){if(Q in J)return J[Q];if(!G._setStream)G._setStream=new z;return G._setStream[Q]}}),this.delete=new Proxy((J)=>{if(!globalThis.Map.prototype.has.call(G,J))return!1;let Q=globalThis.Map.prototype.get.call(G,J);return globalThis.Map.prototype.delete.call(G,J),G._deleteStream?.push([J,Q]),!0},{get(J,Q){if(Q in J)return J[Q];if(!G._deleteStream)G._deleteStream=new z;return G._deleteStream[Q]}}),this.clear=new Proxy(()=>{if(G.size>0)globalThis.Map.prototype.clear.call(G),G._clearStream?.push()},{get(J,Q){if(Q in J)return J[Q];if(!G._clearStream)G._clearStream=new z;return G._clearStream[Q]}})}}class F extends globalThis.Set{_addStream;_deleteStream;_clearStream;constructor(Z){super(Z);let G=this;this.add=new Proxy((J)=>{if(globalThis.Set.prototype.has.call(G,J))return G;return globalThis.Set.prototype.add.call(G,J),G._addStream?.push(J),G},{get(J,Q){if(Q in J)return J[Q];if(!G._addStream)G._addStream=new z;return G._addStream[Q]}}),this.delete=new Proxy((J)=>{if(!globalThis.Set.prototype.has.call(G,J))return!1;return globalThis.Set.prototype.delete.call(G,J),G._deleteStream?.push(J),!0},{get(J,Q){if(Q in J)return J[Q];if(!G._deleteStream)G._deleteStream=new z;return G._deleteStream[Q]}}),this.clear=new Proxy(()=>{if(G.size>0)globalThis.Set.prototype.clear.call(G),G._clearStream?.push()},{get(J,Q){if(Q in J)return J[Q];if(!G._clearStream)G._clearStream=new z;return G._clearStream[Q]}})}}class N extends z{_value;constructor(Z,G){super(G);this._value=Z}push(...Z){for(let G of Z)this.value=G}get value(){return this._value}set value(Z){this._value=Z,super.push(Z)}}export{q as merge,I as map,A as flat,V as filter,z as Stream,N as State,F as Set,D as Map,B as List};
+class t{_listeners=new Map;_generatorFn;_generator;_listenerAdded;_listenerRemoved;constructor(A){this._generatorFn=A instanceof t?()=>A[Symbol.asyncIterator]():A}get hasListeners(){return this._listeners.size>0}get listenerAdded(){if(!this._listenerAdded)this._listenerAdded=new t;return this._listenerAdded}get listenerRemoved(){if(!this._listenerRemoved)this._listenerRemoved=new t;return this._listenerRemoved}async*[Symbol.asyncIterator](){let A=[],n,E=this.listen((i)=>{A.push(i),n?.()});try{while(!0)if(A.length)yield A.shift();else await new Promise((i)=>n=i)}finally{E(),A.length=0,n=void 0;return}}push(A,...n){n.unshift(A);let E=[];for(let i of n)for(let[e,o]of this._listeners){if(o&&!o.deref()){E.push(e);continue}e(i)}for(let i of E)this._listeners.delete(i)}async*withContext(A){let n=new WeakRef(A);try{for await(let E of this){if(!n.deref())break;yield E}}finally{return}}listen(A,n){let E=this,i,e;if(n instanceof AbortSignal){if(n?.aborted)return o;n?.addEventListener("abort",o),i=()=>n?.removeEventListener("abort",o)}else if(n instanceof t)i=n?.listen(o);else if(n)e=new WeakRef(n);if(E._listeners.set(A,e),E._listenerAdded?.push(),E._generatorFn&&E._listeners.size===1)E._generator=E._generatorFn(),(async()=>{for await(let r of E._generator)E.push(r)})();return o[Symbol.dispose]=o,o;function o(){if(E._listeners.delete(A),E._listenerRemoved?.push(),E._listeners.size===0)E._generator?.return(),E._generator=void 0;i?.(),i=void 0,e=void 0}}then(A){return new Promise((n)=>{let E=this.listen((i)=>{n(i),E()})}).then(A)}pipe(A){return A(this)}[Symbol.dispose](){this.clear()}clear(){this._listeners.clear(),this._listenerAdded?.clear(),this._listenerRemoved?.clear()}}var V=(A,n)=>{return(E)=>{if(!n||typeof n==="object"){let{strategy:e="sequential"}=n??{},o=A;if(e==="sequential")return new t(async function*(){for await(let r of E){let T=await o(r);if(T)yield r;if(T===void 0)return}});if(e==="concurrent-unordered")return new t(async function*(){let r=Symbol.for("__abort"),T=[],d,f=E.listen(async(L)=>{let P=await o(L);if(P!==!1)P===void 0?T.push(r):T.push(L),d?.(),d=void 0});try{while(!0)if(T.length){let L=T.shift();if(L===r)break;yield L}else await new Promise((L)=>d=L)}finally{T.length=0,f(),d=void 0}});if(e==="concurrent-ordered")return new t(async function*(){let r=[],T,d=E.listen((f)=>{let L=o(f);r.push({resultPromise:L,value:f}),(async()=>{await L,T?.(),T=void 0})()});try{while(!0)if(r.length){let{resultPromise:f,value:L}=r.shift(),P=await f;if(P)yield L;if(P===void 0)break}else await new Promise((f)=>T=f)}finally{r.length=0,d(),T=void 0}})}let i=n;return new t(async function*(){let e=A;for await(let o of E){let r=await i(e,o);if(!r)return;let[T,d]=r;if(e=d,T)yield o}})}};var y=(A,n)=>{return(E)=>{if(!n||typeof n==="object"){let{strategy:e="sequential"}=n??{},o=A;if(e==="sequential")return new t(async function*(){for await(let r of E)yield await o(r)});if(e==="concurrent-unordered")return new t(async function*(){let r=[],T,d=E.listen(async(f)=>{r.push(await o(f)),T?.(),T=void 0});try{while(!0)if(r.length)yield r.shift();else await new Promise((f)=>T=f)}finally{r.length=0,d(),T=void 0}});if(e==="concurrent-ordered")return new t(async function*(){let r=[],T,d=E.listen((f)=>{let L=o(f);r.push(L),(async()=>{await L,T?.(),T=void 0})()});try{while(!0)if(r.length)yield await r.shift();else await new Promise((f)=>T=f)}finally{r.length=0,d(),T=void 0}})}let i=n;return new t(async function*(){let e=A;for await(let o of E){let[r,T]=await i(e,o);e=T,yield r}})}};function M(...A){return(n)=>new t(async function*(){let E=[n,...A],i=[],e,o=E.map((r)=>r.listen((T)=>{i.push(T),e?.()}));try{while(!0)if(i.length)yield i.shift();else await new Promise((r)=>e=r)}finally{o.forEach((r)=>r())}})}function h(A=0){return(n)=>{return new t(async function*(){for await(let E of n)if(Array.isArray(E)){let i=E.flat(A);for(let e=0;e<i.length;e++)yield i[e]}else yield E})}}function _(A){return(n)=>{let E=A,i=new t(async function*(){for await(let e of n)E=e,yield e});return Object.defineProperty(i,"state",{value:{get value(){return E},set value(e){E=e,i.push(e)}},enumerable:!0,configurable:!1}),i}}function K(){return(A)=>{let n=!0,E=new t(async function*(){for await(let i of A)if(n)yield i});return Object.defineProperty(E,"gate",{value:{open:()=>n=!0,close:()=>n=!1,get isOpen(){return n}},enumerable:!0,configurable:!1}),E}}export{_ as state,M as merge,y as map,K as gate,h as flat,V as filter,t as Stream};
 
-//# debugId=652D0058F0A0040264756E2164756E21
+//# debugId=CFE062DFAC70A40164756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,18 +1,16 @@
 {
   "version": 3,
-  "sources": ["../src/stream.ts", "../src/transformers/filter.ts", "../src/transformers/map.ts", "../src/transformers/merge.ts", "../src/transformers/flat.ts", "../src/reactive/list.ts", "../src/reactive/map.ts", "../src/reactive/set.ts", "../src/reactive/state.ts"],
+  "sources": ["../src/stream.ts", "../src/transformers/filter/filter.ts", "../src/transformers/map/map.ts", "../src/transformers/merge/merge.ts", "../src/transformers/flat/flat.ts", "../src/transformers/state/state.ts", "../src/transformers/gate/gate.ts"],
   "sourcesContent": [
-    "/**\n * A reactive streaming library that provides async-first data structures with built-in event streams.\n *\n * @template VALUE - The type of values that flow through the stream\n *\n * @example\n * ```typescript\n * // Basic usage\n * const stream = new Stream<number>();\n * stream.listen(value => console.log(value));\n * stream.push(1, 2, 3);\n *\n * // With async generator\n * const timerStream = new Stream(async function* () {\n *   let count = 0;\n *   while (count < 5) {\n *     yield count++;\n *     await new Promise(resolve => setTimeout(resolve, 1000));\n *   }\n * });\n *\n * // Async iteration\n * for await (const value of stream) {\n *   console.log(value);\n *   if (value === 10) break;\n * }\n * ```\n *\n * @example\n * // 📦 COPY-PASTE TRANSFORMERS LIBRARY - Essential transformers for immediate use\n *\n * // FILTERING TRANSFORMERS\n *\n * const take = <T>(n: number) =>\n *   filter<T, { count: number }>({ count: 0 }, (state, value) => {\n *     if (state.count >= n) return;\n *     return [true, { count: state.count + 1 }];\n *   });\n *\n * const distinct = <T>() =>\n *   filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {\n *     if (state.seen.has(value)) return [false, state];\n *     state.seen.add(value);\n *     return [true, state];\n *   });\n *\n * const tap = <T>(fn: (value: T) => void | Promise<void>) =>\n *   filter<T, {}>({}, async (_, value) => {\n *     await fn(value);\n *     return [true, {}];\n *   });\n *\n * // MAPPING TRANSFORMERS\n *\n * const withIndex = <T>() =>\n *   map<T, { index: number }, { value: T; index: number }>(\n *     { index: 0 },\n *     (state, value) => [\n *       { value, index: state.index },\n *       { index: state.index + 1 }\n *     ]\n *   );\n *\n * const delay = <T>(ms: number) =>\n *   map<T, {}, T>({}, async (_, value) => {\n *     await new Promise(resolve => setTimeout(resolve, ms));\n *     return [value, {}];\n *   });\n *\n * const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>\n *   map<T, { acc: U }, U>({ acc: initial }, (state, value) => {\n *     const newAcc = fn(state.acc, value);\n *     return [newAcc, { acc: newAcc }];\n *   });\n *\n * // STATE CONVERTER\n * const toState = <T>(initialValue: T) => (stream: Stream<T>) => {\n *   return new State(initialValue, stream);\n * };\n *\n * // Usage: stream.pipe(filter(x => x > 0)).pipe(take(5)).pipe(toState(0));\n */\nexport class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {\n  protected _listeners: Map<(value: VALUE) => void, WeakRef<object> | undefined> = new Map();\n  protected _generatorFn: Stream.FunctionGenerator<VALUE> | undefined;\n  protected _generator: AsyncGenerator<VALUE, void> | undefined;\n  protected _listenerAdded: Stream<void> | undefined;\n  protected _listenerRemoved: Stream<void> | undefined;\n\n  /**\n   * Creates a new Stream instance.\n   *\n   * @param generatorFn - Optional async generator function to produce values you can use it for creating stream with custom transformation\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * // Empty stream\n   * const stream = new Stream<string>();\n   *\n   * // Stream with generator\n   * const countdown = new Stream(async function* () {\n   *   for (let i = 5; i > 0; i--) {\n   *     yield i;\n   *     await new Promise(resolve => setTimeout(resolve, 1000));\n   *   }\n   * });\n   *\n   * // Stream with custom transformer\n   * function filter<VALUE>(source:Stream<VALUE>,predicate:(value:VALUE) => boolean):Stream<VALUE>{\n   *  return new Stream<VALUE>(async function* () {\n   *   for await (const value of source) {\n   *     if (predicate(value)) yield value ;\n   *   }\n   *  });\n   * }\n   * const source = new Stream<number>();\n   * const even = filter(source,v=> v % 2 === 0)\n   * even.listen(console.log);\n   * source.push(1, 2, 3, 4); // 2,4\n   * ```\n   */\n  constructor();\n  constructor(stream: Stream.FunctionGenerator<VALUE> | Stream<VALUE>);\n  constructor(stream?: Stream.FunctionGenerator<VALUE> | Stream<VALUE>) {\n    this._generatorFn = stream instanceof Stream ? () => stream[Symbol.asyncIterator]() : stream;\n  }\n\n  /**\n   * Returns true if the stream has active listeners.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * console.log(stream.hasListeners); // false\n   *\n   * const cleanup = stream.listen(value => console.log(value));\n   * console.log(stream.hasListeners); // true\n   *\n   * cleanup();\n   * console.log(stream.hasListeners); // false\n   * ```\n   */\n  get hasListeners(): boolean {\n    return this._listeners.size > 0;\n  }\n\n  /**\n   * Stream that emits when a listener is added.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listenerAdded.listen(() => console.log('Listener added'));\n   *\n   * stream.listen(value => console.log(value)); // Triggers 'Listener added'\n   * ```\n   */\n  get listenerAdded(): Stream<void> {\n    if (!this._listenerAdded) this._listenerAdded = new Stream<void>();\n    return this._listenerAdded;\n  }\n\n  /**\n   * Stream that emits when a listener is removed.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listenerRemoved.listen(() => console.log('Listener removed'));\n   *\n   * const cleanup = stream.listen(value => console.log(value));\n   * cleanup(); // Triggers 'Listener removed'\n   * ```\n   */\n  get listenerRemoved(): Stream<void> {\n    if (!this._listenerRemoved) this._listenerRemoved = new Stream<void>();\n    return this._listenerRemoved;\n  }\n  async *[Symbol.asyncIterator](): AsyncGenerator<VALUE, void> {\n    const queue: VALUE[] = [];\n    let resolver: Function | undefined;\n\n    const abort = this.listen((value) => {\n      queue.push(value);\n      resolver?.();\n    });\n\n    try {\n      while (true) {\n        if (queue.length) yield queue.shift()!;\n        else await new Promise<void>((resolve) => (resolver = resolve));\n      }\n    } finally {\n      abort();\n      queue.length = 0;\n      resolver = undefined;\n      return;\n    }\n  }\n\n  /**\n   * Pushes one or more values to all listeners.\n   * Automatically removes listeners whose context objects have been garbage collected.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @param value - The first value to push\n   * @param values - Additional values to push\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listen(value => console.log('Received:', value));\n   *\n   * stream.push(1); // Received: 1\n   * stream.push(2, 3, 4); // Received: 2, Received: 3, Received: 4\n   * ```\n   */\n  push(value: VALUE, ...values: VALUE[]): void {\n    values.unshift(value);\n    const deadListeners = [];\n    for (const value of values) {\n      for (const [listener, ctx] of this._listeners) {\n        if (ctx && !ctx.deref()) {\n          deadListeners.push(listener);\n          continue;\n        }\n        listener(value);\n      }\n    }\n    for (const listener of deadListeners) {\n      this._listeners.delete(listener);\n    }\n  }\n\n  /**\n   * Creates an async iterator bound to a context object's lifetime.\n   * Automatically stops iteration when the context is garbage collected.\n   *\n   * @param context - Object whose lifetime controls the iteration\n   * @returns Async generator that stops when context is GC'd\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * const element = document.createElement('div');\n   *\n   * (async () => {\n   *   for await (const value of stream.withContext(element)) {\n   *     element.textContent = String(value);\n   *   }\n   * })();\n   *\n   * // When element is removed and GC'd, iteration stops automatically\n   * ```\n   */\n  async *withContext(context: object) {\n    const ref = new WeakRef(context);\n    try {\n      for await (const value of this) {\n        if (!ref.deref()) break;\n        yield value;\n      }\n    } finally {\n      return;\n    }\n  }\n\n  /**\n   * Adds a listener to the stream with optional automatic cleanup.\n   *\n   * @param listener - Function to call when values are pushed\n   * @param signalOrStreamOrContext - Optional cleanup mechanism:\n   *   - AbortSignal: Remove listener when signal is aborted\n   *   - Stream: Remove listener when stream emits\n   *   - Object: Remove listener when object is garbage collected (WeakRef)\n   * @returns Cleanup function to remove the listener\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<string>();\n   *\n   * // Basic listener\n   * const cleanup = stream.listen(value => console.log(value));\n   *\n   * // With AbortSignal\n   * const controller = new AbortController();\n   * stream.listen(value => console.log(value), controller.signal);\n   * controller.abort(); // Removes listener\n   *\n   * // With Stream\n   * const stopSignal = new Stream<void>();\n   * stream.listen(value => console.log(value), stopSignal);\n   * stopSignal.push(); // Removes listener\n   *\n   * // With DOM element (auto-cleanup when GC'd)\n   * const element = document.createElement('div');\n   * stream.listen(value => element.textContent = value, element);\n   * // Listener automatically removed when element is garbage collected\n   *\n   * // Manual cleanup\n   * cleanup();\n   * ```\n   */\n  listen(listener: (value: VALUE) => void): () => void;\n  listen(listener: (value: VALUE) => void, signal: AbortSignal): () => void;\n  listen(listener: (value: VALUE) => void, stream: Stream<any>): () => void;\n  listen(listener: (value: VALUE) => void, context: object): () => void;\n  listen(listener: (value: VALUE) => void, signalOrStreamOrContext?: AbortSignal | Stream<any> | object): () => void {\n    const self = this;\n    let signalAbort: Function | undefined;\n    let context: WeakRef<object> | undefined;\n\n    if (signalOrStreamOrContext instanceof AbortSignal) {\n      if (signalOrStreamOrContext?.aborted) return () => {};\n      signalOrStreamOrContext?.addEventListener(\"abort\", abort);\n      signalAbort = () => signalOrStreamOrContext?.removeEventListener(\"abort\", abort);\n    } else if (signalOrStreamOrContext instanceof Stream) {\n      signalAbort = signalOrStreamOrContext?.listen(abort);\n    } else if (signalOrStreamOrContext) {\n      context = new WeakRef(signalOrStreamOrContext);\n    }\n\n    self._listeners.set(listener, context);\n\n    self._listenerAdded?.push();\n\n    if (self._generatorFn && self._listeners.size === 1) {\n      self._generator = self._generatorFn();\n      (async () => {\n        for await (const value of self._generator!) {\n          self.push(value);\n        }\n      })();\n    }\n    return abort;\n    function abort(): void {\n      self._listeners.delete(listener);\n      self._listenerRemoved?.push();\n      if (self._listeners.size === 0) {\n        self._generator?.return();\n        self._generator = undefined;\n      }\n      signalAbort?.();\n      signalAbort = undefined;\n      context = undefined;\n    }\n  }\n\n  /**\n   * Promise-like interface that resolves with the next value.\n   *\n   * @param onfulfilled - Optional transformation function\n   * @returns Promise that resolves with the first value\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   *\n   * setTimeout(()=>{\n   *  stream.push(5);\n   * })\n   * // Wait for first value\n   * const firstValue = await stream; // Resolves promises with 5\n   *\n   *\n   * ```\n   */\n  then(onfulfilled?: ((value: VALUE) => VALUE | PromiseLike<VALUE>) | null): Promise<VALUE> {\n    return new Promise<VALUE>((resolve) => {\n      const abort = this.listen((value) => {\n        resolve(value);\n        abort();\n      });\n    }).then(onfulfilled);\n  }\n\n  /**\n   * Applies a transformer function to this stream, enabling functional composition.\n   *\n   * @param transformer - Function that takes a stream and returns any output type\n   * @returns The result of the transformer function\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const numbers = new Stream<number>();\n   *\n   * // Chain transformers\n   * const result = numbers\n   *   .pipe(filter({}, (_, n) => [n > 0, {}]))\n   *   .pipe(map({}, (_, n) => [n * 2, {}]))\n   *   .pipe(toState(0));\n   *\n   * // Custom transformer\n   * const throttle = <T>(ms: number) => (stream: Stream<T>) =>\n   *   new Stream<T>(async function* () {\n   *     let lastEmit = 0;\n   *     for await (const value of stream) {\n   *       const now = Date.now();\n   *       if (now - lastEmit >= ms) {\n   *         yield value;\n   *         lastEmit = now;\n   *       }\n   *     }\n   *   });\n   *\n   * // Transform to any type\n   * const stringResult = numbers.pipe(throttle(1000));\n   * const stateResult = numbers.pipe(toState(0));\n   * ```\n   */\n  pipe<OUTPUT extends Stream<any>>(transformer: (stream: this) => OUTPUT): OUTPUT {\n    return transformer(this);\n  }\n}\n\nexport namespace Stream {\n  export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;\n  export type FunctionGenerator<VALUE> = () => AsyncGenerator<VALUE, void>;\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * Adaptive filter transformer that maintains state and can terminate streams.\n * Supports multiple concurrency strategies for async predicates.\n *\n * @template VALUE - The type of values flowing through the stream\n * @template STATE - The type of the internal state object\n * @template FILTERED - The type of filtered values (for type guards)\n *\n * @param initialStateOrPredicate - Initial state object or predicate function\n * @param statefulPredicateOrOptions - Stateful predicate function or options for simple predicates\n *\n * @returns A transformer function that can be used with `.pipe()`\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * // Simple synchronous filtering\n * stream.pipe(filter((value) => value > 0))\n *\n * @example\n * // Type guard filtering (synchronous only)\n * stream.pipe(filter((value): value is number => typeof value === \"number\"))\n *\n * @example\n * // Async filtering with sequential strategy (default)\n * stream.pipe(\n *   filter(async (value) => {\n *     const valid = await validateAsync(value);\n *     return valid;\n *   })\n * )\n *\n * @example\n * // Async filtering with concurrent-unordered strategy\n * stream.pipe(\n *   filter(async (value) => {\n *     const result = await expensiveCheck(value);\n *     return result;\n *   }, { strategy: \"concurrent-unordered\" })\n * )\n *\n * @example\n * // Async filtering with concurrent-ordered strategy\n * stream.pipe(\n *   filter(async (value) => {\n *     const result = await apiValidation(value);\n *     return result;\n *   }, { strategy: \"concurrent-ordered\" })\n * )\n *\n * @example\n * // Stateful filtering (always sequential)\n * stream.pipe(\n *   filter({ count: 0 }, (state, value) => {\n *     if (state.count >= 10) return; // Terminate after 10 items\n *     return [value > 0, { count: state.count + 1 }];\n *   })\n * )\n *\n * @example\n * // Stateful filtering with complex state\n * stream.pipe(\n *   filter({ seen: new Set() }, (state, value) => {\n *     if (state.seen.has(value)) return [false, state]; // Duplicate\n *     state.seen.add(value);\n *     return [true, state]; // First occurrence\n *   })\n * )\n *\n * @example\n * // Stream termination\n * stream.pipe(\n *   filter(async (value) => {\n *     if (value === \"STOP\") return; // Terminates stream\n *     return value.length > 3;\n *   })\n * )\n */\nexport const filter: filter.Filter = <\n  VALUE,\n  STATE extends Record<string, unknown> = {},\n  FILTERED extends VALUE = VALUE\n>(\n  initialStateOrPredicate: STATE | filter.Predicate<VALUE> | filter.GuardPredicate<VALUE, FILTERED>,\n  statefulPredicateOrOptions?:\n    | filter.StatefulPredicate<VALUE, STATE>\n    | filter.StatefulGuardPredicate<VALUE, STATE, FILTERED>\n    | filter.Options\n): ((stream: Stream<VALUE>) => Stream<FILTERED>) => {\n  return (stream: Stream<VALUE>): Stream<FILTERED> => {\n    if (!statefulPredicateOrOptions || typeof statefulPredicateOrOptions === \"object\") {\n      const { strategy = \"sequential\" } = statefulPredicateOrOptions ?? {};\n\n      const predicate = initialStateOrPredicate as filter.Predicate<VALUE>;\n\n      if (strategy === \"sequential\") {\n        return new Stream<FILTERED>(async function* () {\n          for await (const value of stream) {\n            const result = await predicate(value);\n            if (result) yield value as FILTERED;\n            if (result === undefined) return;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-unordered\") {\n        return new Stream<FILTERED>(async function* () {\n          const ABORT = Symbol.for(\"__abort\");\n\n          let queue = new Array<FILTERED | typeof ABORT>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen(async (value) => {\n            const result = await predicate(value);\n            if (result !== false) {\n              result === undefined ? queue.push(ABORT) : queue.push(value as FILTERED);\n              resolver?.();\n              resolver = undefined;\n            }\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                const value = queue.shift()!;\n                if (value === ABORT) break;\n                yield value;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-ordered\") {\n        return new Stream<FILTERED>(async function* () {\n          let queue = new Array<{ resultPromise: boolean | void | Promise<boolean | void>; value: VALUE }>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen((value) => {\n            const pormise = predicate(value);\n            queue.push({ resultPromise: pormise, value });\n            (async () => {\n              await pormise;\n              resolver?.();\n              resolver = undefined;\n            })();\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                const { resultPromise, value } = queue.shift()!;\n                const result = await resultPromise;\n                if (result) yield value as FILTERED;\n                if (result === undefined) break;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n    }\n\n    const predicate = statefulPredicateOrOptions as filter.StatefulGuardPredicate<VALUE, STATE>;\n\n    return new Stream<FILTERED>(async function* () {\n      let currentState = initialStateOrPredicate as STATE;\n      for await (const value of stream) {\n        const result = await predicate(currentState, value);\n        if (!result) return;\n        const [emit, state] = result;\n        currentState = state;\n        if (emit) {\n          yield value as FILTERED;\n        }\n      }\n    });\n  };\n};\n\nexport namespace filter {\n  export type Options = { strategy: \"sequential\" | \"concurrent-unordered\" | \"concurrent-ordered\" };\n  export type Predicate<VALUE = unknown> = (value: VALUE) => boolean | void | Promise<boolean | void>;\n  export type GuardPredicate<VALUE = unknown, FILTERED extends VALUE = VALUE> = (value: VALUE) => value is FILTERED;\n  export type StatefulPredicate<VALUE = unknown, STATE extends Record<string, unknown> = {}> = (\n    state: STATE,\n    value: VALUE\n  ) => [boolean, STATE] | void | Promise<[boolean, STATE] | void>;\n  export type StatefulGuardPredicate<\n    VALUE = unknown,\n    STATE extends Record<string, unknown> = {},\n    FILTERED extends VALUE = VALUE\n  > = (state: STATE, value: VALUE) => [boolean, STATE, FILTERED] | void | Promise<[boolean, STATE, FILTERED] | void>;\n  export interface Filter {\n    <VALUE, FILTERED extends VALUE = VALUE>(predicate: GuardPredicate<VALUE, FILTERED>): (\n      stream: Stream<VALUE>\n    ) => Stream<FILTERED>;\n\n    <VALUE>(predicate: Predicate<VALUE>, options?: Options): (stream: Stream<VALUE>) => Stream<VALUE>;\n\n    <VALUE, STATE extends Record<string, unknown> = {}>(\n      initialState: STATE,\n      predicate: StatefulPredicate<VALUE, STATE>\n    ): (stream: Stream<VALUE>) => Stream<VALUE>;\n\n    <VALUE, STATE extends Record<string, unknown> = {}, FILTERED extends VALUE = VALUE>(\n      initialState: STATE,\n      predicate: StatefulGuardPredicate<VALUE, STATE, FILTERED>\n    ): (stream: Stream<VALUE>) => Stream<FILTERED>;\n  }\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * Adaptive map transformer that transforms values while maintaining state.\n * Supports multiple concurrency strategies for async mappers.\n *\n * @template VALUE - The type of input values\n * @template STATE - The type of the internal state object\n * @template MAPPED - The type of output values after transformation\n *\n * @param initialStateOrMapper - Initial state object or mapper function\n * @param statefulMapperOrOptions - Stateful mapper function or options for simple mappers\n *\n * @returns A transformer function that can be used with `.pipe()`\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * // Simple synchronous transformation\n * stream.pipe(map((value) => value * 2))\n *\n * @example\n * // Type transformation\n * stream.pipe(map((value: number) => value.toString()))\n *\n * @example\n * // Async transformation with sequential strategy (default)\n * stream.pipe(\n *   map(async (value) => {\n *     const result = await processAsync(value);\n *     return result;\n *   })\n * )\n *\n * @example\n * // Async transformation with concurrent-unordered strategy\n * stream.pipe(\n *   map(async (value) => {\n *     const enriched = await enrichWithAPI(value);\n *     return enriched;\n *   }, { strategy: \"concurrent-unordered\" })\n * )\n *\n * @example\n * // Async transformation with concurrent-ordered strategy\n * stream.pipe(\n *   map(async (value) => {\n *     const processed = await heavyProcessing(value);\n *     return processed;\n *   }, { strategy: \"concurrent-ordered\" })\n * )\n *\n * @example\n * // Stateful transformation (always sequential)\n * stream.pipe(\n *   map({ sum: 0 }, (state, value) => {\n *     const newSum = state.sum + value;\n *     return [{ value, runningSum: newSum }, { sum: newSum }];\n *   })\n * )\n *\n * @example\n * // Complex stateful transformation\n * stream.pipe(\n *   map({ count: 0, items: [] }, (state, value) => {\n *     const newItems = [...state.items, value];\n *     const newCount = state.count + 1;\n *     return [\n *       {\n *         item: value,\n *         index: newCount,\n *         total: newItems.length,\n *         history: newItems\n *       },\n *       { count: newCount, items: newItems }\n *     ];\n *   })\n * )\n *\n * @example\n * // Async stateful transformation\n * stream.pipe(\n *   map({ cache: new Map() }, async (state, value) => {\n *     const cached = state.cache.get(value);\n *     if (cached) return [cached, state];\n *\n *     const processed = await expensiveOperation(value);\n *     const newCache = new Map(state.cache);\n *     newCache.set(value, processed);\n *\n *     return [processed, { cache: newCache }];\n *   })\n * )\n */\nexport const map: map.Map = <VALUE, STATE extends Record<string, unknown>, MAPPED>(\n  initialStateOrMapper: STATE | map.Mapper<VALUE, MAPPED>,\n  statefulMapper?: map.StatefulMapper<VALUE, STATE, MAPPED> | map.Options\n): ((stream: Stream<VALUE>) => Stream<MAPPED>) => {\n  return (stream: Stream<VALUE>): Stream<MAPPED> => {\n    if (!statefulMapper || typeof statefulMapper === \"object\") {\n      const { strategy = \"sequential\" } = statefulMapper ?? {};\n      const mapper = initialStateOrMapper as map.Mapper<VALUE, MAPPED>;\n\n      if (strategy === \"sequential\") {\n        return new Stream<MAPPED>(async function* () {\n          for await (const value of stream) {\n            yield await mapper(value);\n          }\n        });\n      }\n      if (strategy === \"concurrent-unordered\") {\n        return new Stream<MAPPED>(async function* () {\n          let queue = new Array<MAPPED>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen(async (value) => {\n            queue.push(await mapper(value));\n            resolver?.();\n            resolver = undefined;\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                yield queue.shift()!;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-ordered\") {\n        return new Stream<MAPPED>(async function* () {\n          let queue = new Array<MAPPED | Promise<MAPPED>>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen((value) => {\n            const promise = mapper(value);\n\n            queue.push(promise);\n\n            (async () => {\n              await promise;\n              resolver?.();\n              resolver = undefined;\n            })();\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                yield await queue.shift()!;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n    }\n\n    const mapper = statefulMapper as map.StatefulMapper<VALUE, STATE, MAPPED>;\n\n    return new Stream<MAPPED>(async function* () {\n      let currentState = initialStateOrMapper as STATE;\n      for await (const value of stream) {\n        const [mapped, state] = await mapper(currentState, value);\n        currentState = state;\n        yield mapped;\n      }\n    });\n  };\n};\n\nexport namespace map {\n  export type Options = { strategy: \"sequential\" | \"concurrent-unordered\" | \"concurrent-ordered\" };\n  export type Mapper<VALUE = unknown, MAPPED = VALUE> = (value: VALUE) => MAPPED | Promise<MAPPED>;\n  export type StatefulMapper<VALUE = unknown, STATE extends Record<string, unknown> = {}, MAPPED = VALUE> = (\n    state: STATE,\n    value: VALUE\n  ) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>;\n\n  export interface Map {\n    <VALUE, MAPPED>(mapper: Mapper<VALUE, MAPPED>, options?: Options): (stream: Stream<VALUE>) => Stream<MAPPED>;\n    <VALUE, STATE extends Record<string, unknown> = {}, MAPPED = VALUE>(\n      initialState: STATE,\n      mapper: StatefulMapper<VALUE, STATE, MAPPED>\n    ): (stream: Stream<VALUE>) => Stream<MAPPED>;\n  }\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * Merge multiple streams into a single stream with temporal ordering.\n * \n * @template VALUE - The type of values from the source stream\n * @template STREAMS - Tuple type of additional streams to merge\n * \n * @param streams - Additional streams to merge with the source stream\n * \n * @returns A transformer that merges all streams into one with union types\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * // Basic merge with type safety\n * const numbers = new Stream<number>();\n * const strings = new Stream<string>();\n * const merged = numbers.pipe(merge(strings));\n * // Type: Stream<number | string>\n * \n * @example\n * // Multiple streams\n * const stream1 = new Stream<number>();\n * const stream2 = new Stream<string>();\n * const stream3 = new Stream<boolean>();\n * \n * const combined = stream1.pipe(merge(stream2, stream3));\n * // Type: Stream<number | string | boolean>\n * \n\n */\nexport function merge<VALUE, STREAMS extends [Stream<any>, ...Stream<any>[]]>(\n  ...streams: STREAMS\n): (stream: Stream<VALUE>) => Stream<VALUE | Stream.ValueOf<STREAMS[number]>> {\n  return (stream: Stream<VALUE>): Stream<VALUE | Stream.ValueOf<STREAMS[number]>> =>\n    new Stream<VALUE | Stream.ValueOf<STREAMS[number]>>(async function* () {\n      const allStreams = [stream, ...streams];\n      const queue: (VALUE | Stream.ValueOf<STREAMS[number]>)[] = [];\n      let resolver: Function | undefined;\n\n      const cleanups = allStreams.map((s) =>\n        s.listen((value) => {\n          queue.push(value);\n          resolver?.();\n        })\n      );\n\n      try {\n        while (true) {\n          if (queue.length) {\n            yield queue.shift()!;\n          } else {\n            await new Promise((resolve) => (resolver = resolve));\n          }\n        }\n      } finally {\n        cleanups.forEach((cleanup) => cleanup());\n      }\n    });\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * Flatten arrays in a stream, converting 1 array event into N individual events.\n *\n * @template VALUE - The type of values in the stream (should be arrays)\n * @template DEPTH - The depth of flattening (0 = one level, 1 = two levels, etc.)\n *\n * @param depth - How many levels deep to flatten (default: 0 = one level)\n *\n * @returns A transformer that flattens array values into individual events\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * // Basic flattening - 1 array → N events\n * const arrayStream = new Stream<number[]>();\n * const individualNumbers = arrayStream.pipe(flat());\n *\n * arrayStream.push([1, 2, 3]); // Emits: 1, 2, 3 as separate events\n *\n * @example\n * // Deep flattening\n * const deepArrays = new Stream<number[][]>();\n * const flattened = deepArrays.pipe(flat(1)); // Flatten 2 levels\n *\n * deepArrays.push([[1, 2], [3, 4]]);\n * // Emits: 1, 2, 3, 4 as separate events\n *\n */\nexport function flat<VALUE, DEPTH extends number = 0>(\n  depth: DEPTH = 0 as DEPTH\n): (stream: Stream<VALUE>) => Stream<FlatArray<VALUE, DEPTH>> {\n  return (stream: Stream<VALUE>): Stream<FlatArray<VALUE, DEPTH>> => {\n    return new Stream<FlatArray<VALUE, DEPTH>>(async function* () {\n      for await (const value of stream) {\n        if (Array.isArray(value)) {\n          const values = value.flat(depth);\n          for (let i = 0; i < values.length; i++) {\n            yield values[i]!;\n          }\n        } else {\n          yield value as FlatArray<VALUE, DEPTH>;\n        }\n      }\n    });\n  };\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * A reactive List that provides array-like functionality with stream-based mutation events.\n * Emits events when items are inserted, deleted, or the list is cleared.\n * Supports negative indexing with modulo wrapping.\n * @template VALUE - The type of values stored in the list\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * ```typescript\n * const todos = new List<string>();\n *\n * // Listen to insertions\n * todos.insert.listen(([index, item]) => {\n *   console.log(`Added \"${item}\" at index ${index}`);\n * });\n *\n * // Listen to deletions\n * todos.delete.listen(([index, item]) => {\n *   console.log(`Removed \"${item}\" from index ${index}`);\n * });\n *\n * todos.insert(0, \"Buy milk\"); //Added \"Buy milk\" at index 0\n * todos.insert(1, \"Walk dog\"); //Added \"Walk dog\" at index 1\n * todos.insert(-1, \"kechma haja\"); //Added \"kechma haja\" at index 2\n * todos[0] = \"Buy organic milk\"; // Added \"Buy organic milk\" at index 0\n * ```\n */\nexport class List<VALUE> implements Iterable<VALUE> {\n  private _items: VALUE[] = [];\n  private _insertStream?: Stream<[number, VALUE]>;\n  private _deleteStream?: Stream<[number, VALUE]>;\n  private _clearStream?: Stream<void>;\n\n  [index: number]: VALUE | undefined;\n\n  /**\n   * Inserts a value at the specified index and emits the insertion event.\n   * Negative indices are handled specially for insertion positioning.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List([1, 2, 3]);\n   * list.insert.listen(([index, value]) => console.log(`Inserted ${value} at ${index}`));\n   *\n   * list.insert(1, 99); // Inserted 99 at 1 → [1, 99, 2, 3]\n   * list.insert(-1, 88); // Insert at end → [1, 99, 2, 3, 88]\n   * ```\n   */\n  declare insert: ((index: number, value: VALUE) => this) & Stream<[number, VALUE]>;\n\n  /**\n   * Deletes a value at the specified index and emits the deletion event.\n   * Returns the deleted value or undefined if index is invalid.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List(['a', 'b', 'c']);\n   * list.delete.listen(([index, value]) => console.log(`Deleted ${value} from ${index}`));\n   *\n   * const deleted = list.delete(1); // Deleted b from 1\n   * console.log(deleted); // 'b'\n   * ```\n   */\n  declare delete: ((index: number) => VALUE | undefined) & Stream<[number, VALUE]>;\n\n  /**\n   * Clears all items from the list and emits the clear event.\n   * Only emits if the list was not already empty.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List([1, 2, 3]);\n   * list.clear.listen(() => console.log('List cleared'));\n   *\n   * list.clear(); // List cleared\n   * list.clear(); // No emission (already empty)\n   * ```\n   */\n  declare clear: (() => void) & Stream<void>;\n\n  /**\n   * Creates a new reactive List.\n   *\n   * @param items - Optional iterable of initial items\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * // Empty list\n   * const list = new List<number>();\n   *\n   * // With initial items\n   * const todos = new List(['Buy milk', 'Walk dog']);\n   *\n   * // Listen to changes\n   * todos.insert.listen(([index, item]) => updateUI(index, item));\n   * todos.delete.listen(([index, item]) => removeFromUI(index));\n   *\n   * // Index access with modulo wrapping\n   * console.log(todos[0]);  // 'Buy milk'\n   * console.log(todos[-1]); // 'Walk dog' (last item)\n   * ```\n   */\n  constructor(items?: Iterable<VALUE>) {\n    if (items) this._items = [...items];\n\n    const self = this;\n\n    function normalizeIndex(index: number, length: number): number {\n      if (length === 0) return 0;\n      return index < 0 ? ((index % length) + length) % length : index % length;\n    }\n\n    this.insert = new Proxy(\n      (index: number, value: VALUE): this => {\n        const actualIndex =\n          index < 0 ? Math.max(0, self._items.length + index + 1) : Math.min(index, self._items.length);\n        self._items.splice(actualIndex, 0, value);\n        self._insertStream?.push([actualIndex, value]);\n        return proxy;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._insertStream) self._insertStream = new Stream();\n          return (self._insertStream as any)[prop];\n        },\n      }\n    ) as any;\n    this.delete = new Proxy(\n      (index: number): VALUE | undefined => {\n        if (index < 0 || index >= self._items.length) return undefined;\n        const value = self._items.splice(index, 1)[0]!;\n        self._deleteStream?.push([index, value]);\n        return value;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._deleteStream) self._deleteStream = new Stream();\n          return (self._deleteStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    this.clear = new Proxy(\n      (): void => {\n        if (self._items.length > 0) {\n          self._items.length = 0;\n          self._clearStream?.push();\n        }\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._clearStream) self._clearStream = new Stream();\n          return (self._clearStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    const proxy = new Proxy(this, {\n      get(target, prop) {\n        if (typeof prop === \"string\" && /^-?\\d+$/.test(prop)) {\n          const index = parseInt(prop);\n          if (target._items.length === 0) return undefined;\n          const actualIndex = normalizeIndex(index, target._items.length);\n          return target._items[actualIndex];\n        }\n        return (target as any)[prop];\n      },\n\n      set(target, prop, value) {\n        if (typeof prop === \"string\" && /^-?\\d+$/.test(prop)) {\n          const index = parseInt(prop);\n\n          if (target._items.length === 0) {\n            // Empty array: any index mutation adds first element at index 0\n            target._items.push(value);\n            target._insertStream?.push([0, value]);\n            return true;\n          }\n\n          const actualIndex = normalizeIndex(index, target._items.length);\n          const oldValue = target._items[actualIndex];\n\n          if (oldValue !== value) {\n            target._items[actualIndex] = value;\n            target._insertStream?.push([actualIndex, value]);\n          }\n          return true;\n        }\n        (target as any)[prop] = value;\n        return true;\n      },\n    });\n\n    return proxy;\n  }\n\n  /**\n   * Gets the value at the specified index without modulo wrapping.\n   *\n   * @param index - The index to access\n   * @returns The value at the index or undefined\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List([10, 20, 30]);\n   * console.log(list.get(1)); // 20\n   * console.log(list.get(5)); // undefined\n   * ```\n   */\n  get(index: number): VALUE | undefined {\n    return this._items[index];\n  }\n\n  /**\n   * Gets the current length of the list.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List([1, 2, 3]);\n   * console.log(list.length); // 3\n   *\n   * list.insert(0, 0);\n   * console.log(list.length); // 4\n   * ```\n   */\n  get length(): number {\n    return this._items.length;\n  }\n  /**\n   * Returns an iterator for the list values.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List([1, 2, 3]);\n   * for (const value of list.values()) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  values(): IterableIterator<VALUE> {\n    return this._items[Symbol.iterator]();\n  }\n  /**\n   * Makes the list iterable.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const list = new List(['a', 'b', 'c']);\n   * for (const item of list) {\n   *   console.log(item); // 'a', 'b', 'c'\n   * }\n   *\n   * const array = [...list]; // ['a', 'b', 'c']\n   * ```\n   */\n  [Symbol.iterator](): IterableIterator<VALUE> {\n    return this._items[Symbol.iterator]();\n  }\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * A reactive Map that extends the native Map with stream-based mutation events.\n * Emits events when entries are set, deleted, or the map is cleared.\n *\n * @template KEY - The type of keys in the map\n * @template VALUE - The type of values in the map\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * ```typescript\n * const cache = new Map<string, any>();\n *\n * // Listen to cache updates\n * cache.set.listen(([key, value]) => {\n *   console.log(`Cache updated: ${key} = ${value}`);\n * });\n *\n * // Listen to cache evictions\n * cache.delete.listen(([key, value]) => {\n *   console.log(`Cache evicted: ${key}`);\n * });\n *\n * cache.set('user:123', { name: 'John' });\n * cache.delete('user:123');\n * ```\n */\nexport class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {\n  protected _setStream?: Stream<[KEY, VALUE]>;\n  protected _deleteStream?: Stream<[KEY, VALUE]>;\n  protected _clearStream?: Stream<void>;\n\n  /**\n   * Sets a key-value pair in the map and emits the entry to listeners.\n   * Only emits if the value actually changes (not same key-value pair).\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const config = new Map<string, string>();\n   * config.set.listen(([key, value]) => console.log(`Set: ${key}=${value}`));\n   *\n   * config.set('theme', 'dark'); // Set: theme=dark\n   * config.set('theme', 'dark'); // No emission (same value)\n   * config.set('theme', 'light'); // Set: theme=light\n   * ```\n   */\n  declare set: ((key: KEY, value: VALUE) => this) & Stream<[KEY, VALUE]>;\n\n  /**\n   * Deletes a key from the map and emits the deleted entry to listeners.\n   * Only emits if the key was actually deleted (existed in map).\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const users = new Map([['alice', { age: 30 }], ['bob', { age: 25 }]]);\n   * users.delete.listen(([key, value]) => console.log(`Removed: ${key}`));\n   *\n   * users.delete('alice'); // Removed: alice\n   * users.delete('charlie'); // No emission (didn't exist)\n   * ```\n   */\n  declare delete: ((key: KEY) => boolean) & Stream<[KEY, VALUE]>;\n\n  /**\n   * Clears all entries from the map and emits to listeners.\n   * Only emits if the map was not already empty.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const store = new Map([['a', 1], ['b', 2]]);\n   * store.clear.listen(() => console.log('Store cleared'));\n   *\n   * store.clear(); // Store cleared\n   * store.clear(); // No emission (already empty)\n   * ```\n   */\n  declare clear: (() => void) & Stream<void>;\n\n  /**\n   * Creates a new reactive Map.\n   *\n   * @param entries - Optional iterable of initial key-value pairs\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * // Empty map\n   * const cache = new Map<string, any>();\n   *\n   * // With initial entries\n   * const config = new Map([\n   *   ['theme', 'dark'],\n   *   ['lang', 'en']\n   * ]);\n   *\n   * // Listen to changes\n   * config.set.listen(([key, value]) => saveConfig(key, value));\n   * config.delete.listen(([key]) => removeConfig(key));\n   * ```\n   */\n  constructor(entries?: Iterable<[KEY, VALUE]>) {\n    super(entries);\n\n    const self = this;\n\n    this.set = new Proxy(\n      (key: KEY, value: VALUE): this => {\n        if (globalThis.Map.prototype.has.call(self, key) && globalThis.Map.prototype.get.call(self, key) === value)\n          return self;\n        globalThis.Map.prototype.set.call(self, key, value);\n        self._setStream?.push([key, value]);\n        return self;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._setStream) self._setStream = new Stream();\n          return (self._setStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    this.delete = new Proxy(\n      (key: KEY): boolean => {\n        if (!globalThis.Map.prototype.has.call(self, key)) return false;\n        const value = globalThis.Map.prototype.get.call(self, key);\n        globalThis.Map.prototype.delete.call(self, key);\n        self._deleteStream?.push([key, value]);\n        return true;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._deleteStream) self._deleteStream = new Stream();\n          return (self._deleteStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    this.clear = new Proxy(\n      (): void => {\n        if (self.size > 0) {\n          globalThis.Map.prototype.clear.call(self);\n          self._clearStream?.push();\n        }\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._clearStream) self._clearStream = new Stream();\n          return (self._clearStream as any)[prop];\n        },\n      }\n    ) as any;\n  }\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * A reactive Set that extends the native Set with stream-based mutation events.\n * Emits events when items are added, deleted, or the set is cleared.\n *\n * @template VALUE - The type of values stored in the set\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * ```typescript\n * const activeUsers = new Set<string>();\n *\n * // Listen to additions\n * activeUsers.add.listen(userId => {\n *   console.log(`User ${userId} came online`);\n * });\n *\n * // Listen to deletions\n * activeUsers.delete.listen(userId => {\n *   console.log(`User ${userId} went offline`);\n * });\n *\n * activeUsers.add('alice'); // User alice came online\n * activeUsers.delete('alice'); // User alice went offline\n * ```\n */\nexport class Set<VALUE> extends globalThis.Set<VALUE> {\n  protected _addStream?: Stream<VALUE>;\n  protected _deleteStream?: Stream<VALUE>;\n  protected _clearStream?: Stream<void>;\n\n  /**\n   * Adds a value to the set and emits the value to listeners.\n   * Only emits if the value is actually added (not a duplicate).\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const tags = new Set<string>();\n   * tags.add.listen(tag => console.log('Added:', tag));\n   *\n   * tags.add('javascript'); // Added: javascript\n   * tags.add('javascript'); // No emission (duplicate)\n   * ```\n   */\n  declare add: ((value: VALUE) => this) & Stream<VALUE>;\n\n  /**\n   * Deletes a value from the set and emits the value to listeners.\n   * Only emits if the value was actually deleted (existed in set).\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const items = new Set(['a', 'b', 'c']);\n   * items.delete.listen(item => console.log('Removed:', item));\n   *\n   * items.delete('b'); // Removed: b\n   * items.delete('x'); // No emission (didn't exist)\n   * ```\n   */\n  declare delete: ((value: VALUE) => boolean) & Stream<VALUE>;\n\n  /**\n   * Clears all values from the set and emits to listeners.\n   * Only emits if the set was not already empty.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const cache = new Set([1, 2, 3]);\n   * cache.clear.listen(() => console.log('Cache cleared'));\n   *\n   * cache.clear(); // Cache cleared\n   * cache.clear(); // No emission (already empty)\n   * ```\n   */\n  declare clear: (() => void) & Stream<void>;\n\n  /**\n   * Creates a new reactive Set.\n   *\n   * @param values - Optional iterable of initial values\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * // Empty set\n   * const tags = new Set<string>();\n   *\n   * // With initial values\n   * const colors = new Set(['red', 'green', 'blue']);\n   *\n   * // Listen to changes\n   * colors.add.listen(color => updateUI(color));\n   * colors.delete.listen(color => removeFromUI(color));\n   * ```\n   */\n  constructor(values?: Iterable<VALUE>) {\n    super(values);\n\n    const self = this;\n\n    this.add = new Proxy(\n      (value: VALUE): this => {\n        if (globalThis.Set.prototype.has.call(self, value)) return self;\n        globalThis.Set.prototype.add.call(self, value);\n        self._addStream?.push(value);\n        return self;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._addStream) self._addStream = new Stream<VALUE>();\n          return (self._addStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    this.delete = new Proxy(\n      (value: VALUE): boolean => {\n        if (!globalThis.Set.prototype.has.call(self, value)) return false;\n        globalThis.Set.prototype.delete.call(self, value);\n        self._deleteStream?.push(value);\n        return true;\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._deleteStream) self._deleteStream = new Stream<VALUE>();\n          return (self._deleteStream as any)[prop];\n        },\n      }\n    ) as any;\n\n    this.clear = new Proxy(\n      (): void => {\n        if (self.size > 0) {\n          globalThis.Set.prototype.clear.call(self);\n          self._clearStream?.push();\n        }\n      },\n      {\n        get(target, prop) {\n          if (prop in target) return (target as any)[prop];\n          if (!self._clearStream) self._clearStream = new Stream<void>();\n          return (self._clearStream as any)[prop];\n        },\n      }\n    ) as any;\n  }\n}\n",
-    "import { Stream } from \"../stream.ts\";\n\n/**\n * A reactive state container that extends Stream to provide stateful value management.\n *\n * @template VALUE - The type of the state value\n *\n * @see {@link Stream} - Complete copy-paste transformers library\n *\n * @example\n * ```typescript\n * // Basic state\n * const counter = new State(0);\n * counter.listen(value => console.log('Counter:', value));\n * counter.value = 5; // Counter: 5\n *\n * // State from stream\n * const source = new Stream<number>();\n * const state = new State(0, source);\n * state.listen(value => console.log('State:', value));\n * source.push(1, 2, 3); // State: 1, State: 2, State: 3\n *\n * // State from transformed stream\n * const filtered = source.pipe(filter({}, (_, v) => [v > 0, {}]));\n * const derivedState = new State(-1, filtered);\n * ```\n */\nexport class State<VALUE = unknown> extends Stream<VALUE> {\n  protected _value: VALUE;\n  constructor(initialValue: VALUE);\n  constructor(initialValue: VALUE, stream: Stream.FunctionGenerator<VALUE> | Stream<VALUE>);\n  /**\n   * Creates a new State with an initial value.\n   *\n   * @param initialValue - The initial state value\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const count = new State(0);\n   * const theme = new State<'light' | 'dark'>('light');\n   * const user = new State<User | null>(null);\n   * ```\n   */\n  constructor(initialValue: VALUE, stream?: Stream.FunctionGenerator<VALUE> | Stream<VALUE>) {\n    super(stream!);\n    this._value = initialValue;\n  }\n  /**\n   * Updates the state with one or more values sequentially.\n   * Each value triggers listeners and updates the current state.\n   *\n   * @param values - Values to set as state\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const state = new State(0);\n   * state.listen(v => console.log(v));\n   *\n   * state.push(1, 2, 3); // Logs: 1, 2, 3\n   * console.log(state.value); // 3\n   * ```\n   */\n  override push(...values: VALUE[]): void {\n    for (const value of values) {\n      this.value = value;\n    }\n  }\n  /**\n   * Gets the current state value.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const state = new State('hello');\n   * console.log(state.value); // 'hello'\n   * ```\n   */\n  get value(): VALUE {\n    return this._value;\n  }\n  /**\n   * Sets the current state value and notifies all listeners.\n   *\n   * @param value - The new state value\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const state = new State(0);\n   * state.listen(v => console.log('New value:', v));\n   *\n   * state.value = 42; // New value: 42\n   * state.value = 100; // New value: 100\n   * ```\n   */\n  set value(value: VALUE) {\n    this._value = value;\n    super.push(value);\n  }\n}\n"
+    "/**\n * A reactive streaming library that provides async-first data structures with built-in event streams.\n *\n * @template VALUE - The type of values that flow through the stream\n *\n * @example\n * ```typescript\n * // Basic usage\n * const stream = new Stream<number>();\n * stream.listen(value => console.log(value));\n * stream.push(1, 2, 3);\n *\n * // With async generator\n * const timerStream = new Stream(async function* () {\n *   let count = 0;\n *   while (count < 5) {\n *     yield count++;\n *     await new Promise(resolve => setTimeout(resolve, 1000));\n *   }\n * });\n *\n * // Async iteration\n * for await (const value of stream) {\n *   console.log(value);\n *   if (value === 10) break;\n * }\n * ```\n *\n * @example\n * // 📦 COPY-PASTE TRANSFORMERS LIBRARY - Essential transformers for immediate use\n *\n * // FILTERING TRANSFORMERS\n *\n * const take = <T>(n: number) =>\n *   filter<T, { count: number }>({ count: 0 }, (state, value) => {\n *     if (state.count >= n) return;\n *     return [true, { count: state.count + 1 }];\n *   });\n *\n * const distinct = <T>() =>\n *   filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {\n *     if (state.seen.has(value)) return [false, state];\n *     state.seen.add(value);\n *     return [true, state];\n *   });\n *\n * const tap = <T>(fn: (value: T) => void | Promise<void>) =>\n *   filter<T, {}>({}, async (_, value) => {\n *     await fn(value);\n *     return [true, {}];\n *   });\n *\n * // MAPPING TRANSFORMERS\n *\n * const withIndex = <T>() =>\n *   map<T, { index: number }, { value: T; index: number }>(\n *     { index: 0 },\n *     (state, value) => [\n *       { value, index: state.index },\n *       { index: state.index + 1 }\n *     ]\n *   );\n *\n * const delay = <T>(ms: number) =>\n *   map<T, {}, T>({}, async (_, value) => {\n *     await new Promise(resolve => setTimeout(resolve, ms));\n *     return [value, {}];\n *   });\n *\n * const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>\n *   map<T, { acc: U }, U>({ acc: initial }, (state, value) => {\n *     const newAcc = fn(state.acc, value);\n *     return [newAcc, { acc: newAcc }];\n *   });\n *\n * // STATE CONVERTER\n * const toState = <T>(initialValue: T) => (stream: Stream<T>) => {\n *   return new State(initialValue, stream);\n * };\n *\n * // Usage: stream.pipe(filter(x => x > 0)).pipe(take(5)).pipe(toState(0));\n */\nexport class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {\n  protected _listeners: Map<(value: VALUE) => void, WeakRef<object> | undefined> = new Map();\n  protected _generatorFn: Stream.FunctionGenerator<VALUE> | undefined;\n  protected _generator: AsyncGenerator<VALUE, void> | undefined;\n  protected _listenerAdded: Stream<void> | undefined;\n  protected _listenerRemoved: Stream<void> | undefined;\n\n  /**\n   * Creates a new Stream instance.\n   *\n   * @param generatorFn - Optional async generator function to produce values you can use it for creating stream with custom transformation\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * // Empty stream\n   * const stream = new Stream<string>();\n   *\n   * // Stream with generator\n   * const countdown = new Stream(async function* () {\n   *   for (let i = 5; i > 0; i--) {\n   *     yield i;\n   *     await new Promise(resolve => setTimeout(resolve, 1000));\n   *   }\n   * });\n   *\n   * // Stream with custom transformer\n   * function filter<VALUE>(source:Stream<VALUE>,predicate:(value:VALUE) => boolean):Stream<VALUE>{\n   *  return new Stream<VALUE>(async function* () {\n   *   for await (const value of source) {\n   *     if (predicate(value)) yield value ;\n   *   }\n   *  });\n   * }\n   * const source = new Stream<number>();\n   * const even = filter(source,v=> v % 2 === 0)\n   * even.listen(console.log);\n   * source.push(1, 2, 3, 4); // 2,4\n   * ```\n   */\n  constructor();\n  constructor(stream: Stream.FunctionGenerator<VALUE> | Stream<VALUE>);\n  constructor(stream?: Stream.FunctionGenerator<VALUE> | Stream<VALUE>) {\n    this._generatorFn = stream instanceof Stream ? () => stream[Symbol.asyncIterator]() : stream;\n  }\n\n  /**\n   * Returns true if the stream has active listeners.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * console.log(stream.hasListeners); // false\n   *\n   * const cleanup = stream.listen(value => console.log(value));\n   * console.log(stream.hasListeners); // true\n   *\n   * cleanup();\n   * console.log(stream.hasListeners); // false\n   * ```\n   */\n  get hasListeners(): boolean {\n    return this._listeners.size > 0;\n  }\n\n  /**\n   * Stream that emits when a listener is added.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listenerAdded.listen(() => console.log('Listener added'));\n   *\n   * stream.listen(value => console.log(value)); // Triggers 'Listener added'\n   * ```\n   */\n  get listenerAdded(): Stream<void> {\n    if (!this._listenerAdded) this._listenerAdded = new Stream<void>();\n    return this._listenerAdded;\n  }\n\n  /**\n   * Stream that emits when a listener is removed.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listenerRemoved.listen(() => console.log('Listener removed'));\n   *\n   * const cleanup = stream.listen(value => console.log(value));\n   * cleanup(); // Triggers 'Listener removed'\n   * ```\n   */\n  get listenerRemoved(): Stream<void> {\n    if (!this._listenerRemoved) this._listenerRemoved = new Stream<void>();\n    return this._listenerRemoved;\n  }\n  async *[Symbol.asyncIterator](): AsyncGenerator<VALUE, void> {\n    const queue: VALUE[] = [];\n    let resolver: Function | undefined;\n\n    const abort = this.listen((value) => {\n      queue.push(value);\n      resolver?.();\n    });\n\n    try {\n      while (true) {\n        if (queue.length) yield queue.shift()!;\n        else await new Promise<void>((resolve) => (resolver = resolve));\n      }\n    } finally {\n      abort();\n      queue.length = 0;\n      resolver = undefined;\n      return;\n    }\n  }\n\n  /**\n   * Pushes one or more values to all listeners.\n   * Automatically removes listeners whose context objects have been garbage collected.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @param value - The first value to push\n   * @param values - Additional values to push\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listen(value => console.log('Received:', value));\n   *\n   * stream.push(1); // Received: 1\n   * stream.push(2, 3, 4); // Received: 2, Received: 3, Received: 4\n   * ```\n   */\n  push(value: VALUE, ...values: VALUE[]): void {\n    values.unshift(value);\n    const deadListeners = [];\n    for (const value of values) {\n      for (const [listener, ctx] of this._listeners) {\n        if (ctx && !ctx.deref()) {\n          deadListeners.push(listener);\n          continue;\n        }\n        listener(value);\n      }\n    }\n    for (const listener of deadListeners) {\n      this._listeners.delete(listener);\n    }\n  }\n\n  /**\n   * Creates an async iterator bound to a context object's lifetime.\n   * Automatically stops iteration when the context is garbage collected.\n   *\n   * @param context - Object whose lifetime controls the iteration\n   * @returns Async generator that stops when context is GC'd\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * const element = document.createElement('div');\n   *\n   * (async () => {\n   *   for await (const value of stream.withContext(element)) {\n   *     element.textContent = String(value);\n   *   }\n   * })();\n   *\n   * // When element is removed and GC'd, iteration stops automatically\n   * ```\n   */\n  async *withContext(context: object): AsyncGenerator<VALUE, void> {\n    const ref = new WeakRef(context);\n    try {\n      for await (const value of this) {\n        if (!ref.deref()) break;\n        yield value;\n      }\n    } finally {\n      return;\n    }\n  }\n\n  /**\n   * Adds a listener to the stream with optional automatic cleanup.\n   *\n   * @param listener - Function to call when values are pushed\n   * @param signalOrStreamOrContext - Optional cleanup mechanism:\n   *   - AbortSignal: Remove listener when signal is aborted\n   *   - Stream: Remove listener when stream emits\n   *   - Object: Remove listener when object is garbage collected (WeakRef)\n   * @returns Cleanup function to remove the listener\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<string>();\n   *\n   * // Basic listener\n   * const cleanup = stream.listen(value => console.log(value));\n   *\n   * // With AbortSignal\n   * const controller = new AbortController();\n   * stream.listen(value => console.log(value), controller.signal);\n   * controller.abort(); // Removes listener\n   *\n   * // With Stream\n   * const stopSignal = new Stream<void>();\n   * stream.listen(value => console.log(value), stopSignal);\n   * stopSignal.push(); // Removes listener\n   *\n   * // With DOM element (auto-cleanup when GC'd)\n   * const element = document.createElement('div');\n   * stream.listen(value => element.textContent = value, element);\n   * // Listener automatically removed when element is garbage collected\n   *\n   * // Manual cleanup\n   * cleanup();\n   * ```\n   */\n  listen(listener: (value: VALUE) => void): Stream.Abort;\n  listen(listener: (value: VALUE) => void, signal: AbortSignal): Stream.Abort;\n  listen(listener: (value: VALUE) => void, stream: Stream<any>): Stream.Abort;\n  listen(listener: (value: VALUE) => void, context: object): Stream.Abort;\n  listen(listener: (value: VALUE) => void, signalOrStreamOrContext?: AbortSignal | Stream<any> | object): Stream.Abort {\n    const self = this;\n    let signalAbort: Function | undefined;\n    let context: WeakRef<object> | undefined;\n\n    if (signalOrStreamOrContext instanceof AbortSignal) {\n      if (signalOrStreamOrContext?.aborted) return abort;\n      signalOrStreamOrContext?.addEventListener(\"abort\", abort);\n      signalAbort = () => signalOrStreamOrContext?.removeEventListener(\"abort\", abort);\n    } else if (signalOrStreamOrContext instanceof Stream) {\n      signalAbort = signalOrStreamOrContext?.listen(abort);\n    } else if (signalOrStreamOrContext) {\n      context = new WeakRef(signalOrStreamOrContext);\n    }\n\n    self._listeners.set(listener, context);\n\n    self._listenerAdded?.push();\n\n    if (self._generatorFn && self._listeners.size === 1) {\n      self._generator = self._generatorFn();\n      (async () => {\n        for await (const value of self._generator!) {\n          self.push(value);\n        }\n      })();\n    }\n\n    abort[Symbol.dispose] = abort;\n\n    return abort;\n    function abort(): void {\n      self._listeners.delete(listener);\n      self._listenerRemoved?.push();\n      if (self._listeners.size === 0) {\n        self._generator?.return();\n        self._generator = undefined;\n      }\n      signalAbort?.();\n      signalAbort = undefined;\n      context = undefined;\n    }\n  }\n\n  /**\n   * Promise-like interface that resolves with the next value.\n   *\n   * @param onfulfilled - Optional transformation function\n   * @returns Promise that resolves with the first value\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   *\n   * setTimeout(()=>{\n   *  stream.push(5);\n   * })\n   * // Wait for first value\n   * const firstValue = await stream; // Resolves promises with 5\n   *\n   *\n   * ```\n   */\n  then(onfulfilled?: ((value: VALUE) => VALUE | PromiseLike<VALUE>) | null): Promise<VALUE> {\n    return new Promise<VALUE>((resolve) => {\n      const abort = this.listen((value) => {\n        resolve(value);\n        abort();\n      });\n    }).then(onfulfilled);\n  }\n\n  /**\n   * Applies a transformer function to this stream, enabling functional composition.\n   *\n   * @param transformer - Function that takes a stream and returns any output type\n   * @returns The result of the transformer function\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const numbers = new Stream<number>();\n   *\n   * // Chain transformers\n   * const result = numbers\n   *   .pipe(filter({}, (_, n) => [n > 0, {}]))\n   *   .pipe(map({}, (_, n) => [n * 2, {}]))\n   *   .pipe(toState(0));\n   *\n   * // Custom transformer\n   * const throttle = <T>(ms: number) => (stream: Stream<T>) =>\n   *   new Stream<T>(async function* () {\n   *     let lastEmit = 0;\n   *     for await (const value of stream) {\n   *       const now = Date.now();\n   *       if (now - lastEmit >= ms) {\n   *         yield value;\n   *         lastEmit = now;\n   *       }\n   *     }\n   *   });\n   *\n   * // Transform to any type\n   * const stringResult = numbers.pipe(throttle(1000));\n   * const stateResult = numbers.pipe(toState(0));\n   * ```\n   */\n  pipe<OUTPUT extends Stream<any>>(transformer: Stream.Transformer<typeof this, OUTPUT>): OUTPUT {\n    return transformer(this);\n  }\n  [Symbol.dispose](): void {\n    this.clear();\n  }\n  /**\n   * Removes all listeners from the stream.\n   *\n   * @see {@link Stream} - Complete copy-paste transformers library\n   *\n   * @example\n   * ```typescript\n   * const stream = new Stream<number>();\n   * stream.listen(value => console.log(value));\n   *\n   * console.log(stream.hasListeners); // true\n   * stream.clear();\n   * console.log(stream.hasListeners); // false\n   * ```\n   */\n  clear() {\n    this._listeners.clear();\n    this._listenerAdded?.clear();\n    this._listenerRemoved?.clear();\n  }\n}\n\nexport namespace Stream {\n  export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;\n  export type FunctionGenerator<VALUE> = () => AsyncGenerator<VALUE, void>;\n  export type Abort = (() => void) & Disposable;\n  export type Transformer<T extends Stream<any>, U extends Stream<any>> = (stream: T) => U;\n}\n",
+    "import { Stream } from \"../../stream.ts\";\n\nexport const filter: filter.Filter = <\n  VALUE,\n  STATE extends Record<string, unknown> = {},\n  FILTERED extends VALUE = VALUE,\n>(\n  initialStateOrPredicate: STATE | filter.Predicate<VALUE> | filter.GuardPredicate<VALUE, FILTERED>,\n  statefulPredicateOrOptions?:\n    | filter.StatefulPredicate<VALUE, STATE>\n    | filter.StatefulGuardPredicate<VALUE, STATE, FILTERED>\n    | filter.Options,\n): Stream.Transformer<Stream<VALUE>, Stream<FILTERED>> => {\n  return (stream: Stream<VALUE>): Stream<FILTERED> => {\n    if (!statefulPredicateOrOptions || typeof statefulPredicateOrOptions === \"object\") {\n      const { strategy = \"sequential\" } = statefulPredicateOrOptions ?? {};\n\n      const predicate = initialStateOrPredicate as filter.Predicate<VALUE>;\n\n      if (strategy === \"sequential\") {\n        return new Stream<FILTERED>(async function* () {\n          for await (const value of stream) {\n            const result = await predicate(value);\n            if (result) yield value as FILTERED;\n            if (result === undefined) return;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-unordered\") {\n        return new Stream<FILTERED>(async function* () {\n          const ABORT = Symbol.for(\"__abort\");\n\n          let queue = new Array<FILTERED | typeof ABORT>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen(async (value) => {\n            const result = await predicate(value);\n            if (result !== false) {\n              result === undefined ? queue.push(ABORT) : queue.push(value as FILTERED);\n              resolver?.();\n              resolver = undefined;\n            }\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                const value = queue.shift()!;\n                if (value === ABORT) break;\n                yield value;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-ordered\") {\n        return new Stream<FILTERED>(async function* () {\n          let queue = new Array<{ resultPromise: boolean | void | Promise<boolean | void>; value: VALUE }>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen((value) => {\n            const pormise = predicate(value);\n            queue.push({ resultPromise: pormise, value });\n            (async () => {\n              await pormise;\n              resolver?.();\n              resolver = undefined;\n            })();\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                const { resultPromise, value } = queue.shift()!;\n                const result = await resultPromise;\n                if (result) yield value as FILTERED;\n                if (result === undefined) break;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n    }\n\n    const predicate = statefulPredicateOrOptions as filter.StatefulGuardPredicate<VALUE, STATE>;\n\n    return new Stream<FILTERED>(async function* () {\n      let currentState = initialStateOrPredicate as STATE;\n      for await (const value of stream) {\n        const result = await predicate(currentState, value);\n        if (!result) return;\n        const [emit, state] = result;\n        currentState = state;\n        if (emit) {\n          yield value as FILTERED;\n        }\n      }\n    });\n  };\n};\n\nexport namespace filter {\n  export type Options = { strategy: \"sequential\" | \"concurrent-unordered\" | \"concurrent-ordered\" };\n  export type Predicate<VALUE = unknown> = (value: VALUE) => boolean | void | Promise<boolean | void>;\n  export type GuardPredicate<VALUE = unknown, FILTERED extends VALUE = VALUE> = (value: VALUE) => value is FILTERED;\n  export type StatefulPredicate<VALUE = unknown, STATE extends Record<string, unknown> = {}> = (\n    state: STATE,\n    value: VALUE,\n  ) => [boolean, STATE] | void | Promise<[boolean, STATE] | void>;\n  export type StatefulGuardPredicate<\n    VALUE = unknown,\n    STATE extends Record<string, unknown> = {},\n    FILTERED extends VALUE = VALUE,\n  > = (state: STATE, value: VALUE) => [boolean, STATE, FILTERED] | void | Promise<[boolean, STATE, FILTERED] | void>;\n  export interface Filter {\n    <VALUE, FILTERED extends VALUE = VALUE>(\n      predicate: GuardPredicate<VALUE, FILTERED>,\n    ): Stream.Transformer<Stream<VALUE>, Stream<FILTERED>>;\n\n    <VALUE>(predicate: Predicate<VALUE>, options?: Options): Stream.Transformer<Stream<VALUE>, Stream<VALUE>>;\n\n    <VALUE, STATE extends Record<string, unknown> = {}>(\n      initialState: STATE,\n      predicate: StatefulPredicate<VALUE, STATE>,\n    ): Stream.Transformer<Stream<VALUE>, Stream<VALUE>>;\n\n    <VALUE, STATE extends Record<string, unknown> = {}, FILTERED extends VALUE = VALUE>(\n      initialState: STATE,\n      predicate: StatefulGuardPredicate<VALUE, STATE, FILTERED>,\n    ): Stream.Transformer<Stream<VALUE>, Stream<FILTERED>>;\n  }\n}\n",
+    "import { Stream } from \"../../stream.ts\";\n\nexport const map: map.Map = <VALUE, STATE extends Record<string, unknown>, MAPPED>(\n  initialStateOrMapper: STATE | map.Mapper<VALUE, MAPPED>,\n  statefulMapper?: map.StatefulMapper<VALUE, STATE, MAPPED> | map.Options,\n): Stream.Transformer<Stream<VALUE>, Stream<MAPPED>> => {\n  return (stream: Stream<VALUE>): Stream<MAPPED> => {\n    if (!statefulMapper || typeof statefulMapper === \"object\") {\n      const { strategy = \"sequential\" } = statefulMapper ?? {};\n      const mapper = initialStateOrMapper as map.Mapper<VALUE, MAPPED>;\n\n      if (strategy === \"sequential\") {\n        return new Stream<MAPPED>(async function* () {\n          for await (const value of stream) {\n            yield await mapper(value);\n          }\n        });\n      }\n      if (strategy === \"concurrent-unordered\") {\n        return new Stream<MAPPED>(async function* () {\n          let queue = new Array<MAPPED>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen(async (value) => {\n            queue.push(await mapper(value));\n            resolver?.();\n            resolver = undefined;\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                yield queue.shift()!;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n\n      if (strategy === \"concurrent-ordered\") {\n        return new Stream<MAPPED>(async function* () {\n          let queue = new Array<MAPPED | Promise<MAPPED>>();\n          let resolver: Function | undefined;\n\n          const abort = stream.listen((value) => {\n            const promise = mapper(value);\n\n            queue.push(promise);\n\n            (async () => {\n              await promise;\n              resolver?.();\n              resolver = undefined;\n            })();\n          });\n\n          try {\n            while (true) {\n              if (queue.length) {\n                yield await queue.shift()!;\n              } else {\n                await new Promise<void>((r) => (resolver = r));\n              }\n            }\n          } finally {\n            queue.length = 0;\n            abort();\n            resolver = undefined;\n          }\n        });\n      }\n    }\n\n    const mapper = statefulMapper as map.StatefulMapper<VALUE, STATE, MAPPED>;\n\n    return new Stream<MAPPED>(async function* () {\n      let currentState = initialStateOrMapper as STATE;\n      for await (const value of stream) {\n        const [mapped, state] = await mapper(currentState, value);\n        currentState = state;\n        yield mapped;\n      }\n    });\n  };\n};\n\nexport namespace map {\n  export type Options = { strategy: \"sequential\" | \"concurrent-unordered\" | \"concurrent-ordered\" };\n  export type Mapper<VALUE = unknown, MAPPED = VALUE> = (value: VALUE) => MAPPED | Promise<MAPPED>;\n  export type StatefulMapper<VALUE = unknown, STATE extends Record<string, unknown> = {}, MAPPED = VALUE> = (\n    state: STATE,\n    value: VALUE,\n  ) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>;\n\n  export interface Map {\n    <VALUE, MAPPED>(\n      mapper: Mapper<VALUE, MAPPED>,\n      options?: Options,\n    ): Stream.Transformer<Stream<VALUE>, Stream<MAPPED>>;\n    <VALUE, STATE extends Record<string, unknown> = {}, MAPPED = VALUE>(\n      initialState: STATE,\n      mapper: StatefulMapper<VALUE, STATE, MAPPED>,\n    ): Stream.Transformer<Stream<VALUE>, Stream<MAPPED>>;\n  }\n}\n",
+    "import { Stream } from \"../../stream.ts\";\n\nexport function merge<VALUE, STREAMS extends [Stream<any>, ...Stream<any>[]]>(\n  ...streams: STREAMS\n): Stream.Transformer<Stream<VALUE>, Stream<VALUE | Stream.ValueOf<STREAMS[number]>>> {\n  return (stream: Stream<VALUE>): Stream<VALUE | Stream.ValueOf<STREAMS[number]>> =>\n    new Stream<VALUE | Stream.ValueOf<STREAMS[number]>>(async function* () {\n      const allStreams = [stream, ...streams];\n      const queue: (VALUE | Stream.ValueOf<STREAMS[number]>)[] = [];\n      let resolver: Function | undefined;\n\n      const cleanups = allStreams.map((s) =>\n        s.listen((value) => {\n          queue.push(value);\n          resolver?.();\n        }),\n      );\n\n      try {\n        while (true) {\n          if (queue.length) {\n            yield queue.shift()!;\n          } else {\n            await new Promise((resolve) => (resolver = resolve));\n          }\n        }\n      } finally {\n        cleanups.forEach((cleanup) => cleanup());\n      }\n    });\n}\n",
+    "import { Stream } from \"../../stream.ts\";\n\nexport function flat<VALUE, DEPTH extends number = 0>(\n  depth: DEPTH = 0 as DEPTH,\n): Stream.Transformer<Stream<VALUE>, Stream<FlatArray<VALUE, DEPTH>>> {\n  return (stream: Stream<VALUE>): Stream<FlatArray<VALUE, DEPTH>> => {\n    return new Stream<FlatArray<VALUE, DEPTH>>(async function* () {\n      for await (const value of stream) {\n        if (Array.isArray(value)) {\n          const values = value.flat(depth);\n          for (let i = 0; i < values.length; i++) {\n            yield values[i]!;\n          }\n        } else {\n          yield value as FlatArray<VALUE, DEPTH>;\n        }\n      }\n    });\n  };\n}\n",
+    "import { Stream } from \"../../stream\";\n\n/**\n * Stream with reactive state management via getter/setter.\n *\n * @template T - The type of values in the stream\n */\nexport type State<T> = Stream<T> & {\n  state: {\n    value: T;\n  };\n};\n\n/**\n * Adds `.state.value` getter/setter to a stream for reactive state management.\n *\n * @template T - The type of values in the stream\n * @param initialValue - Initial state value\n * @returns Transformer that adds state behavior\n *\n * @example\n * ```typescript\n * const counter = new Stream<number>().pipe(state(0));\n * counter.listen(n => console.log(n));\n * counter.state.value = 5; // Triggers listener\n * console.log(counter.state.value); // 5\n * ```\n *\n * @example\n * ```typescript\n * const source = new Stream<number>();\n * const stateful = source.pipe(state(0));\n * source.push(10); // Updates stateful.state.value to 10\n * ```\n */\nexport function state<T>(initialValue: T): Stream.Transformer<Stream<T>, Stream<T>> {\n  return (source: Stream<T>): State<T> => {\n    let current = initialValue;\n    const output = new Stream<T>(async function* () {\n      for await (const value of source) {\n        current = value;\n        yield value;\n      }\n    });\n\n    Object.defineProperty(output, \"state\", {\n      value: {\n        get value() {\n          return current;\n        },\n        set value(newValue: T) {\n          current = newValue;\n          output.push(newValue);\n        },\n      },\n      enumerable: true,\n      configurable: false,\n    });\n\n    return output as State<T>;\n  };\n}\n",
+    "import { Stream } from \"../../stream\";\n\n/**\n * Stream with flow control via open/close methods.\n *\n * @template T - The type of values in the stream\n */\nexport type Gate<T> = Stream<T> & {\n  gate: {\n    open(): void;\n    close(): void;\n    readonly isOpen: boolean;\n  };\n};\n\n/**\n * Adds flow control to a stream with `.gate.open()` and `.gate.close()` methods.\n * Gate starts open by default. Closed gate blocks all values.\n *\n * @template T - The type of values in the stream\n * @returns Transformer that adds gate behavior\n *\n * @example\n * ```typescript\n * const source = new Stream<number>();\n * const gated = source.pipe(gate());\n *\n * gated.listen(n => console.log(n));\n * source.push(1); // Logs: 1\n * gated.gate.close();\n * source.push(2); // Blocked\n * gated.gate.open();\n * source.push(3); // Logs: 3\n * ```\n *\n * @example\n * ```typescript\n * const events = new Stream<string>().pipe(gate());\n * console.log(events.gate.isOpen); // true\n * events.gate.close();\n * console.log(events.gate.isOpen); // false\n * ```\n */\nexport function gate<T>(): Stream.Transformer<Stream<T>, Stream<T>> {\n  return (source: Stream<T>): Gate<T> => {\n    let isOpen = true;\n\n    const output = new Stream<T>(async function* () {\n      for await (const value of source) {\n        if (isOpen) yield value;\n      }\n    });\n\n    Object.defineProperty(output, \"gate\", {\n      value: {\n        open: () => (isOpen = true),\n        close: () => (isOpen = false),\n        get isOpen() {\n          return isOpen;\n        },\n      },\n      enumerable: true,\n      configurable: false,\n    });\n\n    return output as Gate<T>;\n  };\n}\n"
   ],
-  "mappings": "AAkFO,MAAM,CAAwD,CACzD,WAAuE,IAAI,IAC3E,aACA,WACA,eACA,iBAsCV,WAAW,CAAC,EAA0D,CACpE,KAAK,aAAe,aAAkB,EAAS,IAAM,EAAO,OAAO,eAAe,EAAI,KAoBpF,aAAY,EAAY,CAC1B,OAAO,KAAK,WAAW,KAAO,KAgB5B,cAAa,EAAiB,CAChC,GAAI,CAAC,KAAK,eAAgB,KAAK,eAAiB,IAAI,EACpD,OAAO,KAAK,kBAiBV,gBAAe,EAAiB,CAClC,GAAI,CAAC,KAAK,iBAAkB,KAAK,iBAAmB,IAAI,EACxD,OAAO,KAAK,wBAEN,OAAO,cAAc,EAAgC,CAC3D,IAAM,EAAiB,CAAC,EACpB,EAEE,EAAQ,KAAK,OAAO,CAAC,IAAU,CACnC,EAAM,KAAK,CAAK,EAChB,IAAW,EACZ,EAED,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OAAQ,MAAM,EAAM,MAAM,EAC/B,WAAM,IAAI,QAAc,CAAC,IAAa,EAAW,CAAQ,SAEhE,CACA,EAAM,EACN,EAAM,OAAS,EACf,EAAW,OACX,QAsBJ,IAAI,CAAC,KAAiB,EAAuB,CAC3C,EAAO,QAAQ,CAAK,EACpB,IAAM,EAAgB,CAAC,EACvB,QAAW,KAAS,EAClB,QAAY,EAAU,KAAQ,KAAK,WAAY,CAC7C,GAAI,GAAO,CAAC,EAAI,MAAM,EAAG,CACvB,EAAc,KAAK,CAAQ,EAC3B,SAEF,EAAS,CAAK,EAGlB,QAAW,KAAY,EACrB,KAAK,WAAW,OAAO,CAAQ,QA2B5B,WAAW,CAAC,EAAiB,CAClC,IAAM,EAAM,IAAI,QAAQ,CAAO,EAC/B,GAAI,CACF,cAAiB,KAAS,KAAM,CAC9B,GAAI,CAAC,EAAI,MAAM,EAAG,MAClB,MAAM,UAER,CACA,QA8CJ,MAAM,CAAC,EAAkC,EAA0E,CACjH,IAAM,EAAO,KACT,EACA,EAEJ,GAAI,aAAmC,YAAa,CAClD,GAAI,GAAyB,QAAS,MAAO,IAAM,GACnD,GAAyB,iBAAiB,QAAS,CAAK,EACxD,EAAc,IAAM,GAAyB,oBAAoB,QAAS,CAAK,EAC1E,QAAI,aAAmC,EAC5C,EAAc,GAAyB,OAAO,CAAK,EAC9C,QAAI,EACT,EAAU,IAAI,QAAQ,CAAuB,EAO/C,GAJA,EAAK,WAAW,IAAI,EAAU,CAAO,EAErC,EAAK,gBAAgB,KAAK,EAEtB,EAAK,cAAgB,EAAK,WAAW,OAAS,EAChD,EAAK,WAAa,EAAK,aAAa,GACnC,SAAY,CACX,cAAiB,KAAS,EAAK,WAC7B,EAAK,KAAK,CAAK,IAEhB,EAEL,OAAO,EACP,SAAS,CAAK,EAAS,CAGrB,GAFA,EAAK,WAAW,OAAO,CAAQ,EAC/B,EAAK,kBAAkB,KAAK,EACxB,EAAK,WAAW,OAAS,EAC3B,EAAK,YAAY,OAAO,EACxB,EAAK,WAAa,OAEpB,IAAc,EACd,EAAc,OACd,EAAU,QAyBd,IAAI,CAAC,EAAqF,CACxF,OAAO,IAAI,QAAe,CAAC,IAAY,CACrC,IAAM,EAAQ,KAAK,OAAO,CAAC,IAAU,CACnC,EAAQ,CAAK,EACb,EAAM,EACP,EACF,EAAE,KAAK,CAAW,EAuCrB,IAAgC,CAAC,EAA+C,CAC9E,OAAO,EAAY,IAAI,EAE3B,CC9VO,IAAM,EAAwB,CAKnC,EACA,IAIkD,CAClD,MAAO,CAAC,IAA4C,CAClD,GAAI,CAAC,GAA8B,OAAO,IAA+B,SAAU,CACjF,IAAQ,WAAW,cAAiB,GAA8B,CAAC,EAE7D,EAAY,EAElB,GAAI,IAAa,aACf,OAAO,IAAI,EAAiB,eAAgB,EAAG,CAC7C,cAAiB,KAAS,EAAQ,CAChC,IAAM,EAAS,MAAM,EAAU,CAAK,EACpC,GAAI,EAAQ,MAAM,EAClB,GAAI,IAAW,OAAW,QAE7B,EAGH,GAAI,IAAa,uBACf,OAAO,IAAI,EAAiB,eAAgB,EAAG,CAC7C,IAAM,EAAQ,OAAO,IAAI,SAAS,EAE9B,EAAQ,GACR,EAEE,EAAQ,EAAO,OAAO,MAAO,IAAU,CAC3C,IAAM,EAAS,MAAM,EAAU,CAAK,EACpC,GAAI,IAAW,GACb,IAAW,OAAY,EAAM,KAAK,CAAK,EAAI,EAAM,KAAK,CAAiB,EACvE,IAAW,EACX,EAAW,OAEd,EAED,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OAAQ,CAChB,IAAM,EAAQ,EAAM,MAAM,EAC1B,GAAI,IAAU,EAAO,MACrB,MAAM,EAEN,WAAM,IAAI,QAAc,CAAC,IAAO,EAAW,CAAE,SAGjD,CACA,EAAM,OAAS,EACf,EAAM,EACN,EAAW,QAEd,EAGH,GAAI,IAAa,qBACf,OAAO,IAAI,EAAiB,eAAgB,EAAG,CAC7C,IAAI,EAAQ,GACR,EAEE,EAAQ,EAAO,OAAO,CAAC,IAAU,CACrC,IAAM,EAAU,EAAU,CAAK,EAC/B,EAAM,KAAK,CAAE,cAAe,EAAS,OAAM,CAAC,GAC3C,SAAY,CACX,MAAM,EACN,IAAW,EACX,EAAW,SACV,EACJ,EAED,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OAAQ,CAChB,IAAQ,gBAAe,SAAU,EAAM,MAAM,EACvC,EAAS,MAAM,EACrB,GAAI,EAAQ,MAAM,EAClB,GAAI,IAAW,OAAW,MAE1B,WAAM,IAAI,QAAc,CAAC,IAAO,EAAW,CAAE,SAGjD,CACA,EAAM,OAAS,EACf,EAAM,EACN,EAAW,QAEd,EAIL,IAAM,EAAY,EAElB,OAAO,IAAI,EAAiB,eAAgB,EAAG,CAC7C,IAAI,EAAe,EACnB,cAAiB,KAAS,EAAQ,CAChC,IAAM,EAAS,MAAM,EAAU,EAAc,CAAK,EAClD,GAAI,CAAC,EAAQ,OACb,IAAO,EAAM,GAAS,EAEtB,GADA,EAAe,EACX,EACF,MAAM,GAGX,IC/FE,IAAM,EAAe,CAC1B,EACA,IACgD,CAChD,MAAO,CAAC,IAA0C,CAChD,GAAI,CAAC,GAAkB,OAAO,IAAmB,SAAU,CACzD,IAAQ,WAAW,cAAiB,GAAkB,CAAC,EACjD,EAAS,EAEf,GAAI,IAAa,aACf,OAAO,IAAI,EAAe,eAAgB,EAAG,CAC3C,cAAiB,KAAS,EACxB,MAAM,MAAM,EAAO,CAAK,EAE3B,EAEH,GAAI,IAAa,uBACf,OAAO,IAAI,EAAe,eAAgB,EAAG,CAC3C,IAAI,EAAQ,GACR,EAEE,EAAQ,EAAO,OAAO,MAAO,IAAU,CAC3C,EAAM,KAAK,MAAM,EAAO,CAAK,CAAC,EAC9B,IAAW,EACX,EAAW,OACZ,EAED,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OACR,MAAM,EAAM,MAAM,EAElB,WAAM,IAAI,QAAc,CAAC,IAAO,EAAW,CAAE,SAGjD,CACA,EAAM,OAAS,EACf,EAAM,EACN,EAAW,QAEd,EAGH,GAAI,IAAa,qBACf,OAAO,IAAI,EAAe,eAAgB,EAAG,CAC3C,IAAI,EAAQ,GACR,EAEE,EAAQ,EAAO,OAAO,CAAC,IAAU,CACrC,IAAM,EAAU,EAAO,CAAK,EAE5B,EAAM,KAAK,CAAO,GAEjB,SAAY,CACX,MAAM,EACN,IAAW,EACX,EAAW,SACV,EACJ,EAED,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OACR,MAAM,MAAM,EAAM,MAAM,EAExB,WAAM,IAAI,QAAc,CAAC,IAAO,EAAW,CAAE,SAGjD,CACA,EAAM,OAAS,EACf,EAAM,EACN,EAAW,QAEd,EAIL,IAAM,EAAS,EAEf,OAAO,IAAI,EAAe,eAAgB,EAAG,CAC3C,IAAI,EAAe,EACnB,cAAiB,KAAS,EAAQ,CAChC,IAAO,EAAQ,GAAS,MAAM,EAAO,EAAc,CAAK,EACxD,EAAe,EACf,MAAM,GAET,ICpJE,SAAS,CAA6D,IACxE,EACyE,CAC5E,MAAO,CAAC,IACN,IAAI,EAAgD,eAAgB,EAAG,CACrE,IAAM,EAAa,CAAC,EAAQ,GAAG,CAAO,EAChC,EAAqD,CAAC,EACxD,EAEE,EAAW,EAAW,IAAI,CAAC,IAC/B,EAAE,OAAO,CAAC,IAAU,CAClB,EAAM,KAAK,CAAK,EAChB,IAAW,EACZ,CACH,EAEA,GAAI,CACF,MAAO,GACL,GAAI,EAAM,OACR,MAAM,EAAM,MAAM,EAElB,WAAM,IAAI,QAAQ,CAAC,IAAa,EAAW,CAAQ,SAGvD,CACA,EAAS,QAAQ,CAAC,IAAY,EAAQ,CAAC,GAE1C,EC7BE,SAAS,CAAqC,CACnD,EAAe,EAC6C,CAC5D,MAAO,CAAC,IAA2D,CACjE,OAAO,IAAI,EAAgC,eAAgB,EAAG,CAC5D,cAAiB,KAAS,EACxB,GAAI,MAAM,QAAQ,CAAK,EAAG,CACxB,IAAM,EAAS,EAAM,KAAK,CAAK,EAC/B,QAAS,EAAI,EAAG,EAAI,EAAO,OAAQ,IACjC,MAAM,EAAO,GAGf,WAAM,EAGX,GCfE,MAAM,CAAuC,CAC1C,OAAkB,CAAC,EACnB,cACA,cACA,aA+ER,WAAW,CAAC,EAAyB,CACnC,GAAI,EAAO,KAAK,OAAS,CAAC,GAAG,CAAK,EAElC,IAAM,EAAO,KAEb,SAAS,CAAc,CAAC,EAAe,EAAwB,CAC7D,GAAI,IAAW,EAAG,MAAO,GACzB,OAAO,EAAQ,GAAM,EAAQ,EAAU,GAAU,EAAS,EAAQ,EAGpE,KAAK,OAAS,IAAI,MAChB,CAAC,EAAe,IAAuB,CACrC,IAAM,EACJ,EAAQ,EAAI,KAAK,IAAI,EAAG,EAAK,OAAO,OAAS,EAAQ,CAAC,EAAI,KAAK,IAAI,EAAO,EAAK,OAAO,MAAM,EAG9F,OAFA,EAAK,OAAO,OAAO,EAAa,EAAG,CAAK,EACxC,EAAK,eAAe,KAAK,CAAC,EAAa,CAAK,CAAC,EACtC,GAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,cAAe,EAAK,cAAgB,IAAI,EAClD,OAAQ,EAAK,cAAsB,GAEvC,CACF,EACA,KAAK,OAAS,IAAI,MAChB,CAAC,IAAqC,CACpC,GAAI,EAAQ,GAAK,GAAS,EAAK,OAAO,OAAQ,OAC9C,IAAM,EAAQ,EAAK,OAAO,OAAO,EAAO,CAAC,EAAE,GAE3C,OADA,EAAK,eAAe,KAAK,CAAC,EAAO,CAAK,CAAC,EAChC,GAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,cAAe,EAAK,cAAgB,IAAI,EAClD,OAAQ,EAAK,cAAsB,GAEvC,CACF,EAEA,KAAK,MAAQ,IAAI,MACf,IAAY,CACV,GAAI,EAAK,OAAO,OAAS,EACvB,EAAK,OAAO,OAAS,EACrB,EAAK,cAAc,KAAK,GAG5B,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,aAAc,EAAK,aAAe,IAAI,EAChD,OAAQ,EAAK,aAAqB,GAEtC,CACF,EAEA,IAAM,EAAQ,IAAI,MAAM,KAAM,CAC5B,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,OAAO,IAAS,UAAY,UAAU,KAAK,CAAI,EAAG,CACpD,IAAM,EAAQ,SAAS,CAAI,EAC3B,GAAI,EAAO,OAAO,SAAW,EAAG,OAChC,IAAM,EAAc,EAAe,EAAO,EAAO,OAAO,MAAM,EAC9D,OAAO,EAAO,OAAO,GAEvB,OAAQ,EAAe,IAGzB,GAAG,CAAC,EAAQ,EAAM,EAAO,CACvB,GAAI,OAAO,IAAS,UAAY,UAAU,KAAK,CAAI,EAAG,CACpD,IAAM,EAAQ,SAAS,CAAI,EAE3B,GAAI,EAAO,OAAO,SAAW,EAI3B,OAFA,EAAO,OAAO,KAAK,CAAK,EACxB,EAAO,eAAe,KAAK,CAAC,EAAG,CAAK,CAAC,EAC9B,GAGT,IAAM,EAAc,EAAe,EAAO,EAAO,OAAO,MAAM,EAG9D,GAFiB,EAAO,OAAO,KAEd,EACf,EAAO,OAAO,GAAe,EAC7B,EAAO,eAAe,KAAK,CAAC,EAAa,CAAK,CAAC,EAEjD,MAAO,GAGT,OADC,EAAe,GAAQ,EACjB,GAEX,CAAC,EAED,OAAO,EAkBT,GAAG,CAAC,EAAkC,CACpC,OAAO,KAAK,OAAO,MAiBjB,OAAM,EAAW,CACnB,OAAO,KAAK,OAAO,OAerB,MAAM,EAA4B,CAChC,OAAO,KAAK,OAAO,OAAO,UAAU,GAiBrC,OAAO,SAAS,EAA4B,CAC3C,OAAO,KAAK,OAAO,OAAO,UAAU,EAExC,CC3PO,MAAM,UAAwB,WAAW,GAAgB,CACpD,WACA,cACA,aA6EV,WAAW,CAAC,EAAkC,CAC5C,MAAM,CAAO,EAEb,IAAM,EAAO,KAEb,KAAK,IAAM,IAAI,MACb,CAAC,EAAU,IAAuB,CAChC,GAAI,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAG,GAAK,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAG,IAAM,EACnG,OAAO,EAGT,OAFA,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,EAAK,CAAK,EAClD,EAAK,YAAY,KAAK,CAAC,EAAK,CAAK,CAAC,EAC3B,GAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,WAAY,EAAK,WAAa,IAAI,EAC5C,OAAQ,EAAK,WAAmB,GAEpC,CACF,EAEA,KAAK,OAAS,IAAI,MAChB,CAAC,IAAsB,CACrB,GAAI,CAAC,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAG,EAAG,MAAO,GAC1D,IAAM,EAAQ,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAG,EAGzD,OAFA,WAAW,IAAI,UAAU,OAAO,KAAK,EAAM,CAAG,EAC9C,EAAK,eAAe,KAAK,CAAC,EAAK,CAAK,CAAC,EAC9B,IAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,cAAe,EAAK,cAAgB,IAAI,EAClD,OAAQ,EAAK,cAAsB,GAEvC,CACF,EAEA,KAAK,MAAQ,IAAI,MACf,IAAY,CACV,GAAI,EAAK,KAAO,EACd,WAAW,IAAI,UAAU,MAAM,KAAK,CAAI,EACxC,EAAK,cAAc,KAAK,GAG5B,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,aAAc,EAAK,aAAe,IAAI,EAChD,OAAQ,EAAK,aAAqB,GAEtC,CACF,EAEJ,CCxIO,MAAM,UAAmB,WAAW,GAAW,CAC1C,WACA,cACA,aAyEV,WAAW,CAAC,EAA0B,CACpC,MAAM,CAAM,EAEZ,IAAM,EAAO,KAEb,KAAK,IAAM,IAAI,MACb,CAAC,IAAuB,CACtB,GAAI,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAK,EAAG,OAAO,EAG3D,OAFA,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAK,EAC7C,EAAK,YAAY,KAAK,CAAK,EACpB,GAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,WAAY,EAAK,WAAa,IAAI,EAC5C,OAAQ,EAAK,WAAmB,GAEpC,CACF,EAEA,KAAK,OAAS,IAAI,MAChB,CAAC,IAA0B,CACzB,GAAI,CAAC,WAAW,IAAI,UAAU,IAAI,KAAK,EAAM,CAAK,EAAG,MAAO,GAG5D,OAFA,WAAW,IAAI,UAAU,OAAO,KAAK,EAAM,CAAK,EAChD,EAAK,eAAe,KAAK,CAAK,EACvB,IAET,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,cAAe,EAAK,cAAgB,IAAI,EAClD,OAAQ,EAAK,cAAsB,GAEvC,CACF,EAEA,KAAK,MAAQ,IAAI,MACf,IAAY,CACV,GAAI,EAAK,KAAO,EACd,WAAW,IAAI,UAAU,MAAM,KAAK,CAAI,EACxC,EAAK,cAAc,KAAK,GAG5B,CACE,GAAG,CAAC,EAAQ,EAAM,CAChB,GAAI,KAAQ,EAAQ,OAAQ,EAAe,GAC3C,GAAI,CAAC,EAAK,aAAc,EAAK,aAAe,IAAI,EAChD,OAAQ,EAAK,aAAqB,GAEtC,CACF,EAEJ,CClIO,MAAM,UAA+B,CAAc,CAC9C,OAiBV,WAAW,CAAC,EAAqB,EAA0D,CACzF,MAAM,CAAO,EACb,KAAK,OAAS,EAmBP,IAAI,IAAI,EAAuB,CACtC,QAAW,KAAS,EAClB,KAAK,MAAQ,KAcb,MAAK,EAAU,CACjB,OAAO,KAAK,UAkBV,MAAK,CAAC,EAAc,CACtB,KAAK,OAAS,EACd,MAAM,KAAK,CAAK,EAEpB",
-  "debugId": "652D0058F0A0040264756E2164756E21",
+  "mappings": "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",
+  "debugId": "CFE062DFAC70A40164756E2164756E21",
   "names": []
 }

package/dist/stream.d.ts

@@ -212,7 +212,7 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * // When element is removed and GC'd, iteration stops automatically
      * ```
      */
-    withContext(context: object): AsyncGenerator<Awaited<VALUE>, void, unknown>;
+    withContext(context: object): AsyncGenerator<VALUE, void>;
     /**
      * Adds a listener to the stream with optional automatic cleanup.
      *
@@ -251,10 +251,10 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * cleanup();
      * ```
      */
-    listen(listener: (value: VALUE) => void): () => void;
-    listen(listener: (value: VALUE) => void, signal: AbortSignal): () => void;
-    listen(listener: (value: VALUE) => void, stream: Stream<any>): () => void;
-    listen(listener: (value: VALUE) => void, context: object): () => void;
+    listen(listener: (value: VALUE) => void): Stream.Abort;
+    listen(listener: (value: VALUE) => void, signal: AbortSignal): Stream.Abort;
+    listen(listener: (value: VALUE) => void, stream: Stream<any>): Stream.Abort;
+    listen(listener: (value: VALUE) => void, context: object): Stream.Abort;
     /**
      * Promise-like interface that resolves with the next value.
      *
@@ -313,10 +313,29 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * const stateResult = numbers.pipe(toState(0));
      * ```
      */
-    pipe<OUTPUT extends Stream<any>>(transformer: (stream: this) => OUTPUT): OUTPUT;
+    pipe<OUTPUT extends Stream<any>>(transformer: Stream.Transformer<typeof this, OUTPUT>): OUTPUT;
+    [Symbol.dispose](): void;
+    /**
+     * Removes all listeners from the stream.
+     *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     * stream.listen(value => console.log(value));
+     *
+     * console.log(stream.hasListeners); // true
+     * stream.clear();
+     * console.log(stream.hasListeners); // false
+     * ```
+     */
+    clear(): void;
 }
 export declare namespace Stream {
     type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
     type FunctionGenerator<VALUE> = () => AsyncGenerator<VALUE, void>;
+    type Abort = (() => void) & Disposable;
+    type Transformer<T extends Stream<any>, U extends Stream<any>> = (stream: T) => U;
 }
 //# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,qBAAa,MAAM,CAAC,KAAK,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAClE,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,CAAa;IAC3F,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IACpE,SAAS,CAAC,UAAU,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9D,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;;gBAES,MAAM,EAAE,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAKnE;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,CAGhC;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,CAGlC;IACM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAsB5D;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAiB5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,WAAW,CAAC,OAAO,EAAE,MAAM;IAYlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IACpD,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI;IACzE,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI;IACzE,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,IAAI;IA0CrE;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;IASzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,IAAI,CAAC,MAAM,SAAS,MAAM,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,MAAM,GAAG,MAAM;CAGhF;AAED,yBAAiB,MAAM,CAAC;IACtB,KAAY,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;IACjF,KAAY,iBAAiB,CAAC,KAAK,IAAI,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;CAC1E"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}

package/dist/transformers/filter/filter.d.ts

@@ -0,0 +1,18 @@
+import { Stream } from "../../stream.ts";
+export declare const filter: filter.Filter;
+export declare namespace filter {
+    type Options = {
+        strategy: "sequential" | "concurrent-unordered" | "concurrent-ordered";
+    };
+    type Predicate<VALUE = unknown> = (value: VALUE) => boolean | void | Promise<boolean | void>;
+    type GuardPredicate<VALUE = unknown, FILTERED extends VALUE = VALUE> = (value: VALUE) => value is FILTERED;
+    type StatefulPredicate<VALUE = unknown, STATE extends Record<string, unknown> = {}> = (state: STATE, value: VALUE) => [boolean, STATE] | void | Promise<[boolean, STATE] | void>;
+    type StatefulGuardPredicate<VALUE = unknown, STATE extends Record<string, unknown> = {}, FILTERED extends VALUE = VALUE> = (state: STATE, value: VALUE) => [boolean, STATE, FILTERED] | void | Promise<[boolean, STATE, FILTERED] | void>;
+    interface Filter {
+        <VALUE, FILTERED extends VALUE = VALUE>(predicate: GuardPredicate<VALUE, FILTERED>): Stream.Transformer<Stream<VALUE>, Stream<FILTERED>>;
+        <VALUE>(predicate: Predicate<VALUE>, options?: Options): Stream.Transformer<Stream<VALUE>, Stream<VALUE>>;
+        <VALUE, STATE extends Record<string, unknown> = {}>(initialState: STATE, predicate: StatefulPredicate<VALUE, STATE>): Stream.Transformer<Stream<VALUE>, Stream<VALUE>>;
+        <VALUE, STATE extends Record<string, unknown> = {}, FILTERED extends VALUE = VALUE>(initialState: STATE, predicate: StatefulGuardPredicate<VALUE, STATE, FILTERED>): Stream.Transformer<Stream<VALUE>, Stream<FILTERED>>;
+    }
+}
+//# sourceMappingURL=filter.d.ts.map

package/dist/transformers/filter/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../src/transformers/filter/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MA+G3B,CAAC;AAEF,yBAAiB,MAAM,CAAC;IACtB,KAAY,OAAO,GAAG;QAAE,QAAQ,EAAE,YAAY,GAAG,sBAAsB,GAAG,oBAAoB,CAAA;KAAE,CAAC;IACjG,KAAY,SAAS,CAAC,KAAK,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IACpG,KAAY,cAAc,CAAC,KAAK,GAAG,OAAO,EAAE,QAAQ,SAAS,KAAK,GAAG,KAAK,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,IAAI,QAAQ,CAAC;IAClH,KAAY,iBAAiB,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,CAC3F,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,KAAK,KACT,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;IAChE,KAAY,sBAAsB,CAChC,KAAK,GAAG,OAAO,EACf,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC1C,QAAQ,SAAS,KAAK,GAAG,KAAK,IAC5B,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IACnH,UAAiB,MAAM;QACrB,CAAC,KAAK,EAAE,QAAQ,SAAS,KAAK,GAAG,KAAK,EACpC,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,GACzC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAEvD,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAE1G,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAChD,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,GACzC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAEpD,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,SAAS,KAAK,GAAG,KAAK,EAChF,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,GACxD,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;KACxD;CACF"}

package/dist/transformers/filter/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./filter";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/filter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/filter/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/transformers/flat/flat.d.ts

@@ -0,0 +1,3 @@
+import { Stream } from "../../stream.ts";
+export declare function flat<VALUE, DEPTH extends number = 0>(depth?: DEPTH): Stream.Transformer<Stream<VALUE>, Stream<FlatArray<VALUE, DEPTH>>>;
+//# sourceMappingURL=flat.d.ts.map

package/dist/transformers/flat/flat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.d.ts","sourceRoot":"","sources":["../../../src/transformers/flat/flat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,GAAG,CAAC,EAClD,KAAK,GAAE,KAAkB,GACxB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAepE"}

package/dist/transformers/flat/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./flat";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/flat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/flat/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/transformers/gate/gate.d.ts

@@ -0,0 +1,43 @@
+import { Stream } from "../../stream";
+/**
+ * Stream with flow control via open/close methods.
+ *
+ * @template T - The type of values in the stream
+ */
+export type Gate<T> = Stream<T> & {
+    gate: {
+        open(): void;
+        close(): void;
+        readonly isOpen: boolean;
+    };
+};
+/**
+ * Adds flow control to a stream with `.gate.open()` and `.gate.close()` methods.
+ * Gate starts open by default. Closed gate blocks all values.
+ *
+ * @template T - The type of values in the stream
+ * @returns Transformer that adds gate behavior
+ *
+ * @example
+ * ```typescript
+ * const source = new Stream<number>();
+ * const gated = source.pipe(gate());
+ *
+ * gated.listen(n => console.log(n));
+ * source.push(1); // Logs: 1
+ * gated.gate.close();
+ * source.push(2); // Blocked
+ * gated.gate.open();
+ * source.push(3); // Logs: 3
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const events = new Stream<string>().pipe(gate());
+ * console.log(events.gate.isOpen); // true
+ * events.gate.close();
+ * console.log(events.gate.isOpen); // false
+ * ```
+ */
+export declare function gate<T>(): Stream.Transformer<Stream<T>, Stream<T>>;
+//# sourceMappingURL=gate.d.ts.map

package/dist/transformers/gate/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../src/transformers/gate/gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG;IAChC,IAAI,EAAE;QACJ,IAAI,IAAI,IAAI,CAAC;QACb,KAAK,IAAI,IAAI,CAAC;QACd,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;KAC1B,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAwBlE"}

package/dist/transformers/gate/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./gate";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/gate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/gate/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/transformers/index.d.ts

@@ -1,5 +1,7 @@
-export * from "./filter.ts";
-export * from "./map.ts";
-export * from "./merge.ts";
-export * from "./flat.ts";
+export * from "./filter";
+export * from "./map";
+export * from "./merge";
+export * from "./flat";
+export * from "./state";
+export * from "./gate";
 //# sourceMappingURL=index.d.ts.map

package/dist/transformers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transformers/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transformers/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}

package/dist/transformers/map/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./map";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/map/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}

package/dist/transformers/map/map.d.ts

@@ -0,0 +1,14 @@
+import { Stream } from "../../stream.ts";
+export declare const map: map.Map;
+export declare namespace map {
+    type Options = {
+        strategy: "sequential" | "concurrent-unordered" | "concurrent-ordered";
+    };
+    type Mapper<VALUE = unknown, MAPPED = VALUE> = (value: VALUE) => MAPPED | Promise<MAPPED>;
+    type StatefulMapper<VALUE = unknown, STATE extends Record<string, unknown> = {}, MAPPED = VALUE> = (state: STATE, value: VALUE) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>;
+    interface Map {
+        <VALUE, MAPPED>(mapper: Mapper<VALUE, MAPPED>, options?: Options): Stream.Transformer<Stream<VALUE>, Stream<MAPPED>>;
+        <VALUE, STATE extends Record<string, unknown> = {}, MAPPED = VALUE>(initialState: STATE, mapper: StatefulMapper<VALUE, STATE, MAPPED>): Stream.Transformer<Stream<VALUE>, Stream<MAPPED>>;
+    }
+}
+//# sourceMappingURL=map.d.ts.map

package/dist/transformers/map/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/transformers/map/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,eAAO,MAAM,GAAG,EAAE,GAAG,CAAC,GAwFrB,CAAC;AAEF,yBAAiB,GAAG,CAAC;IACnB,KAAY,OAAO,GAAG;QAAE,QAAQ,EAAE,YAAY,GAAG,sBAAsB,GAAG,oBAAoB,CAAA;KAAE,CAAC;IACjG,KAAY,MAAM,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjG,KAAY,cAAc,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,GAAG,KAAK,IAAI,CACxG,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,KAAK,KACT,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAEhD,UAAiB,GAAG;QAClB,CAAC,KAAK,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACrD,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,GAAG,KAAK,EAChE,YAAY,EAAE,KAAK,EACnB,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,GAC3C,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;KACtD;CACF"}

package/dist/transformers/merge/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./merge";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/merge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/merge/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/transformers/merge/merge.d.ts

@@ -0,0 +1,3 @@
+import { Stream } from "../../stream.ts";
+export declare function merge<VALUE, STREAMS extends [Stream<any>, ...Stream<any>[]]>(...streams: STREAMS): Stream.Transformer<Stream<VALUE>, Stream<VALUE | Stream.ValueOf<STREAMS[number]>>>;
+//# sourceMappingURL=merge.d.ts.map