@soffinal/stream 0.2.2 → 0.2.4

package/README.md

@@ -5,9 +5,9 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/@soffinal/stream)](https://bundlephobia.com/package/@soffinal/stream)
 
-> **Enhanced event emitters with functional composition**
+> **Type-safe event emitters that scale**
 
-A modern event emitter that's multicast, awaitable, async iterable, async generable, and pipeable. Like EventEmitter but with functional transformations, perfect TypeScript inference, and copy-paste transformers embedded in JSDoc.
+Stream is like EventEmitter, but better. Send events to multiple listeners, transform data with `filter` and `map`, and never worry about memory leaks. Works with DOM elements, WebSockets, user interactions, or any async data source. Fully typed, zero dependencies, 5.5KB.
 
 ## Table of Contents
 
@@ -25,34 +25,70 @@ A modern event emitter that's multicast, awaitable, async iterable, async genera
 
 ## Features
 
-- 🧠 **Adaptive Constraints** - Transformers that learn and evolve based on stream history
-- 🔧 **Universal Primitives** - Four algebraic primitives: `filter`, `map`, `merge`, `flat`
-- 📚 **Documentation-as-Distribution** - Copy-paste transformers embedded in JSDoc, no separate packages needed
-- ⚡ **Async-First** - All operations support async with order preservation
-- 🔄 **Multicast Streams** - One stream, unlimited consumers
-- ⏳ **Awaitable** - `await stream` for next value
-- 🔁 **Async Iterable** - Native `for await` loop support
-- 🛠️ **Pipe Composition** - Functional transformer composition
-- 📊 **Reactive State** - Stateful values with automatic change propagation
-- 📋 **Reactive Collections** - Lists, Maps, Sets with fine-grained events
-- 🗑️ **Stream Termination** - Declarative stream lifecycle control
-- 📦 **Zero Dependencies** - Lightweight and tree-shakeable
-- 🌐 **Universal** - Node.js, browsers, Deno, Bun, Cloudflare Workers
-- 📘 **Full TypeScript** - Complete type safety without the burden
+- **Adaptive Constraints** - Transformers that learn and evolve based on stream history
+- **Universal Primitives** - Four primitives: `filter`, `map`, `merge`, `flat`
+- **Documentation-as-Distribution** - Copy-paste transformers embedded in JSDoc, no separate packages needed
+- **Async-First** - Native async/await support with configurable concurrency control
+- **Concurrency Strategies** - Sequential, concurrent-unordered, concurrent-ordered processing
+- **Automatic Cleanup** - WeakRef-based listener cleanup prevents memory leaks
+- **Multicast Streams** - One stream, unlimited consumers
+- **Awaitable** - `await stream` for next value
+- **Async Iterable** - Native `for await` loop support
+- **Pipe Composition** - Stream-to-stream functional composition
+- **Type Guards** - Built-in TypeScript type narrowing support
+- **Reactive State** - Stateful values with automatic change propagation
+- **Reactive Collections** - Lists, Maps, Sets with fine-grained events
+- **Stream Termination** - Declarative stream lifecycle control
+- **Zero Dependencies** - Lightweight and tree-shakeable
+- **Universal** - Node.js, browsers, Deno, Bun, Cloudflare Workers
+- **Full TypeScript** - Complete type safety without the burden
 
 ## Quick Start
 
+```typescript
+import { Stream } from "@soffinal/stream";
+
+const events = new Stream<string>();
+
+events.listen(console.log);
+
+events.push("Hello"); //log: Hello
+```
+
+## Examples
+
 ```typescript
 import { Stream, State, filter, map, merge } from "@soffinal/stream";
 
-// Create reactive streams
+// Create  streams
 const events = new Stream<string>();
 const numbers = new Stream<number>();
 
-// Pipe-based transformation with Adaptive Constraints
+// Pull-based stream from async generator
+const websocketStream = new Stream(async function* () {
+  const ws = new WebSocket("ws://localhost:8080");
+  while (ws.readyState === WebSocket.OPEN) {
+    yield await new Promise((resolve) => {
+      ws.onmessage = (event) => resolve(JSON.parse(event.data));
+    });
+  }
+});
+
+// Simple transformations
 const processed = events
-  .pipe(simpleFilter((msg) => msg.length > 3)) // Simple filtering
-  .pipe(simpleMap((msg) => msg.toUpperCase())); // Transform to uppercase
+  .pipe(filter((msg) => msg.length > 3)) // Simple filtering
+  .pipe(map((msg) => msg.toUpperCase())); // Transform to uppercase
+
+// Async transformations with concurrency
+const validated = events.pipe(
+  filter(
+    async (msg) => {
+      const isValid = await validateAsync(msg);
+      return isValid;
+    },
+    { strategy: "concurrent-ordered" }
+  ) // Parallel validation, ordered results
+);
 
 // Stateful transformers that learn and adapt
 const runningAverage = numbers
@@ -75,6 +111,12 @@ const runningAverage = numbers
     })
   );
 
+// Automatic cleanup with DOM elements
+const element = document.createElement('div');
+events.listen(value => {
+  element.textContent = value;
+}, element); // Auto-removed when element is GC'd
+
 // Copy-paste transformers from JSDoc
 const limited = numbers.pipe(take(5)); // Limit to 5 items
 const indexed = events.pipe(withIndex()); // Add indices
@@ -82,6 +124,7 @@ const delayed = processed.pipe(delay(100)); // Delay each value
 
 // Multiple consumers
 processed.listen((msg) => console.log("Processed:", msg));
+validated.listen((msg) => console.log("Validated:", msg));
 runningAverage.listen(({ value, average }) => console.log(`Value: ${value}, Running Average: ${average}`));
 
 // Reactive state
@@ -150,20 +193,69 @@ for await (const event of userEvents) {
 }
 ```
 
+### Automatic Listener Cleanup
+
+Stream provides three cleanup mechanisms to prevent memory leaks:
+
+```typescript
+const stream = new Stream<string>();
+
+// 1. Manual cleanup
+const cleanup = stream.listen(value => console.log(value));
+cleanup(); // Remove listener
+
+// 2. AbortSignal cleanup
+const controller = new AbortController();
+stream.listen(value => console.log(value), controller.signal);
+controller.abort(); // Remove listener
+
+// 3. WeakRef automatic cleanup (NEW!)
+const element = document.createElement('div');
+stream.listen(value => {
+  element.textContent = value;
+}, element);
+// Listener automatically removed when element is garbage collected
+// Perfect for DOM elements, components, and temporary objects
+```
+
+**WeakRef Benefits:**
+- Zero memory leaks with DOM elements
+- No manual cleanup needed
+- Works with any object (components, instances, etc.)
+- Leverages JavaScript's garbage collector
+- Ideal for UI frameworks (React, Vue, Svelte, etc.)
+
+```typescript
+// Real-world example: Component lifecycle
+function createComponent() {
+  const element = document.createElement('div');
+  const dataStream = new Stream<Data>();
+  
+  // Auto-cleanup when component unmounts
+  dataStream.listen(data => {
+    element.innerHTML = renderTemplate(data);
+  }, element);
+  
+  return element;
+}
+
+// When element is removed from DOM and GC'd, listener is automatically cleaned up
+```
+
 ### Pipe: Stream-to-Stream Composition
 
-The `pipe` method enforces reactive composition - it only accepts functions that return Stream instances, maintaining the infinite reactive pipeline:
+The `pipe` method enforces composition - it only accepts functions that return Stream instances, maintaining the infinite pipeline:
 
 ```typescript
 // All transformers return Streams - infinite chaining
-stream.pipe(filter({}, (_, v) => [v > 0, {}])); // → Stream<T>
-stream.pipe(map({}, (_, v) => [v.toString(), {}])); // → Stream<string>
+stream.pipe(filter((v) => v > 0)); // → Stream<T>
+stream.pipe(map((v) => v.toString())); // → Stream<string>
 stream.pipe(toState("initial")); // → State<string> (extends Stream)
 
 // Infinite chaining - every pipe returns a Stream
 const result = stream
-  .pipe(filter({}, (_, v) => [v > 0, {}]))
-  .pipe(map({}, (_, v) => [v * 2, {}]))
+  .pipe(filter((v) => v > 0))
+  .pipe(map((v) => v * 2))
   .pipe(take(5))
   .pipe(delay(100))
   .pipe(distinct()); // Always chainable
@@ -177,8 +269,8 @@ const result = stream
 const numbers = new Stream<number>();
 
 // TypeScript knows these are all Streams
-const doubled = numbers.pipe(map({}, (_, n) => [n * 2, {}])); // Stream<number>
-const strings = numbers.pipe(map({}, (_, n) => [n.toString(), {}])); // Stream<string>
+const doubled = numbers.pipe(map((n) => n * 2)); // Stream<number>
+const strings = numbers.pipe(map((n) => n.toString())); // Stream<string>
 const state = numbers.pipe(toState(0)); // State<number>
 ```
 
@@ -186,13 +278,27 @@ const state = numbers.pipe(toState(0)); // State<number>
 
 All stream operations are built from four universal primitives with **Adaptive Constraints**:
 
-#### 1. Filter - Adaptive Gatekeeper
+#### 1. Filter
 
 ```typescript
 import { filter } from "@soffinal/stream";
 
 // Simple filtering
-stream.pipe(filter({}, (_, value) => [value > 0, {}]));
+stream.pipe(filter((value) => value > 0));
+
+// Type guard filtering
+stream.pipe(filter((value): value is number => typeof value === "number"));
+
+// Async filtering with concurrency strategies
+stream.pipe(
+  filter(
+    async (value) => {
+      const isValid = await validateAsync(value);
+      return isValid;
+    },
+    { strategy: "concurrent-ordered" }
+  ) // Parallel validation, ordered results
+);
 
 // Stateful filtering with termination
 stream.pipe(
@@ -201,14 +307,6 @@ stream.pipe(
     return [value > 0, { count: state.count + 1 }];
   })
 );
-
-// Async filtering
-stream.pipe(
-  filter({}, async (_, value) => {
-    const isValid = await validateAsync(value);
-    return [isValid, {}];
-  })
-);
 ```
 
 **[📖 Complete Filter Documentation →](src/transformers/filter.md)**
@@ -219,7 +317,21 @@ stream.pipe(
 import { map } from "@soffinal/stream";
 
 // Simple transformation
-stream.pipe(map({}, (_, value) => [value * 2, {}]));
+stream.pipe(map((value) => value * 2));
+
+// Type transformation
+stream.pipe(map((value: number) => value.toString()));
+
+// Async transformation with concurrency strategies
+stream.pipe(
+  map(
+    async (value) => {
+      const enriched = await enrichWithAPI(value);
+      return enriched;
+    },
+    { strategy: "concurrent-unordered" }
+  ) // Parallel processing, results as completed
+);
 
 // Stateful transformation with context
 stream.pipe(
@@ -228,14 +340,6 @@ stream.pipe(
     return [{ value, runningSum: newSum }, { sum: newSum }];
   })
 );
-
-// Async transformation with order preservation
-stream.pipe(
-  map({}, async (_, value) => {
-    const enriched = await enrichWithAPI(value);
-    return [{ original: value, enriched }, {}];
-  })
-);
 ```
 
 **[📖 Complete Map Documentation →](src/transformers/map.md)**
@@ -273,10 +377,12 @@ const arrayStream = new Stream<number[]>();
 const individualNumbers = arrayStream.pipe(flat());
 
 arrayStream.push([1, 2, 3]); // Emits: 1, 2, 3 as separate events
+// Type: Stream<number>
 
 // Configurable depth flattening
 const deepArrays = new Stream<number[][][]>();
 const flattened = deepArrays.pipe(flat(2)); // Flatten 2 levels deep
+// Type: Stream<number>
 ```
 
 **[📖 Complete Flat Documentation →](src/transformers/flat.md)**
@@ -285,9 +391,7 @@ const flattened = deepArrays.pipe(flat(2)); // Flatten 2 levels deep
 
 No separate repos, no CLI tools, no package management - just copy-paste ready transformers embedded in JSDoc!
 
-But more importantly: **Documentation-as-Distribution is actually Education-as-Distribution.**
-
-#### The Educational Transparency Revolution
+#### The Educational Transparency
 
 Our approach makes **every implementation pattern visible and learnable**:
 
@@ -299,7 +403,6 @@ Our approach makes **every implementation pattern visible and learnable**:
 const searchInput = new Stream<string>(); // ← Hover here for full library
 const searchResults = searchInput
   .pipe(distinct()) // Copy from Stream JSDoc - learn deduplication patterns
-  .pipe(simpleFilter((q) => q.length > 2)) // Copy from Stream JSDoc - learn filtering logic
   .pipe(take(10)) // Copy from Stream JSDoc - learn termination patterns
   .pipe(delay(300)) // Copy from Stream JSDoc - learn async transformation
   .pipe(simpleMap((query) => searchAPI(query))); // Copy from Stream JSDoc - learn mapping patterns
@@ -383,8 +486,6 @@ Documentation-as-Distribution creates **multiplicative value**:
 
 - `take(n)`, `skip(n)`, `distinct()`, `tap(fn)` - Essential filtering patterns
 - `withIndex()`, `delay(ms)`, `pluck(key)`, `scan(fn, initial)` - Common transformation patterns
-- `simpleFilter(predicate)` - Convenient filtering without state
-- `simpleMap(fn)` - Convenient mapping without state
 - `toState(initialValue)` - Convert streams to reactive state
 - More transformers added with each release!
 
@@ -425,20 +526,20 @@ counter.value = 5;
 
 // State from transformed streams
 const source = new Stream<number>();
-const derivedState = new State(0, source.pipe(map({}, (_, v) => [v * 2, {}])));
+const derivedState = new State(0, source.pipe(map((v) => v * 2)));
 
 // Derived state using transformers
-const isLoggedIn = user.pipe(map({}, (_, u) => [u !== null, {}]));
+const isLoggedIn = user.pipe(map((u) => u !== null));
 
 const userDisplayName = user.pipe(
-  filter({}, (_, u) => [u !== null, {}]),
-  map({}, (_, u) => [`${u.firstName} ${u.lastName}`, {}])
+  filter((u) => u !== null),
+  map((u) => `${u.firstName} ${u.lastName}`)
 );
 
 // Convert streams to state with toState transformer
 const processedState = source
-  .pipe(filter({}, (_, v) => [v > 0, {}]))
-  .pipe(map({}, (_, v) => [v.toString(), {}]))
+  .pipe(filter((v) => v > 0))
+  .pipe(map((v) => v.toString()))
   .pipe(toState("0")); // Explicit initial value
 
 // Automatic UI updates
@@ -502,9 +603,10 @@ activeUsers.add("user1");
 
 #### Core Methods
 
-- `push(...values: T[]): void` - Emit values to all listeners
-- `listen(callback: (value: T) => void, signal?: AbortSignal | Stream<any>): () => void` - Add listener, returns cleanup
-- `pipe<OUTPUT>(transformer: (stream: this) => OUTPUT): OUTPUT` - Apply any transformer (flexible return type)
+- `push(...values: T[]): void` - Emit values to all listeners (auto-removes GC'd listeners)
+- `listen(callback: (value: T) => void, context?: AbortSignal | Stream<any> | object): () => void` - Add listener with optional cleanup
+- `pipe<OUTPUT extends Stream<any>>(transformer: (stream: this) => OUTPUT): OUTPUT` - Apply any transformer
+- `withContext(context: object): AsyncIterator<T>` - Async iterator bound to context lifetime
 
 #### Async Interface
 
@@ -530,18 +632,21 @@ activeUsers.add("user1");
 
 ### Universal Transformers
 
-#### filter(initialState, accumulator)
+#### filter(predicate, options?)
 
-- **Simple**: `filter({}, (_, value) => [boolean, {}])`
-- **Stateful**: `filter(state, (state, value) => [boolean, newState])`
-- **Async**: `filter({}, async (_, value) => [boolean, {}])`
+- **Simple**: `filter((value) => boolean)`
+- **Type Guard**: `filter((value): value is Type => boolean)` (sync only)
+- **Async**: `filter(async (value) => boolean, { strategy? })` with concurrency options
+- **Stateful**: `filter(state, (state, value) => [boolean, newState])` (always sequential)
 - **Termination**: Return `undefined` to terminate stream
+- **Strategies**: `"sequential"` | `"concurrent-unordered"` | `"concurrent-ordered"`
 
-#### map(initialState, accumulator)
+#### map(mapper, options?)
 
-- **Simple**: `map({}, (_, value) => [newValue, {}])`
-- **Stateful**: `map(state, (state, value) => [newValue, newState])`
-- **Async**: `map({}, async (_, value) => [newValue, {}])`
+- **Simple**: `map((value) => newValue)`
+- **Async**: `map(async (value) => newValue, { strategy? })` with concurrency options
+- **Stateful**: `map(state, (state, value) => [newValue, newState])` (always sequential)
+- **Strategies**: `"sequential"` | `"concurrent-unordered"` | `"concurrent-ordered"`
 
 #### merge(...streams)
 
@@ -589,10 +694,11 @@ activeUsers.add("user1");
 - **Fast startup** - Zero dependencies, instant initialization
 - **Efficient pipelines** - Optimized transformer composition
 - **Memory bounded** - Built-in backpressure handling
+- **Automatic cleanup** - WeakRef prevents memory leaks
 
 ## Runtime Support
 
-- **Modern browsers** supporting ES2020+
+- **Modern browsers** supporting ES2020+ (WeakRef support)
 - **Node.js** 16+
 - **Deno** 1.0+
 - **Bun** 1.0+
@@ -620,20 +726,11 @@ stream.push("hello");
 
 ### Transformer Guides
 
-- **[Filter Transformer →](src/transformers/filter.md)** - Adaptive constraints and stream termination
-- **[Map Transformer →](src/transformers/map.md)** - Stateful transformations and async processing
+- **[Filter Transformer →](src/transformers/filter.md)** - Concurrency strategies, type guards, stateful filtering, and stream termination
+- **[Map Transformer →](src/transformers/map.md)** - Concurrency strategies, type transformations, stateful mapping, and performance optimization
 - **[Merge Transformer →](src/transformers/merge.md)** - Stream orchestration and type-safe combination
 - **[Flat Transformer →](src/transformers/flat.md)** - Event multiplication and array flattening
 
-### Philosophy
-
-**Adaptive Reactive Programming** - A new paradigm where transformers maintain state and evolve their behavior based on stream history. This enables:
-
-- **Learning transformers** that adapt to data patterns
-- **Stateful operations** with memory between events
-- **Stream termination** for lifecycle control
-- **Zero-overhead types** with perfect inference
-
 ## Contributing
 
 We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

package/dist/index.js

@@ -1,4 +1,4 @@
-class Z{_listeners=new Set;_generatorFn;_generator;_listenerAdded;_listenerRemoved;constructor(Y){this._generatorFn=Y instanceof Z?()=>Y[Symbol.asyncIterator]():Y}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 Y=[],G,J=this.listen((K)=>{Y.push(K),G?.()});try{while(!0)if(Y.length)yield Y.shift();else await new Promise((K)=>G=K)}finally{J(),Y.length=0,G=void 0;return}}push(Y,...G){G.unshift(Y);for(let J of G)for(let K of this._listeners)K(J)}listen(Y,G){let J=this,K;if(G instanceof AbortSignal){if(G?.aborted)return()=>{};G?.addEventListener("abort",Q),K=()=>G?.removeEventListener("abort",Q)}else K=G?.listen(Q);if(J._listeners.add(Y),J._listenerAdded?.push(),J._generatorFn&&J._listeners.size===1)J._generator=J._generatorFn(),(async()=>{for await(let X of J._generator)J.push(X)})();return Q;function Q(){if(J._listeners.delete(Y),J._listenerRemoved?.push(),J._listeners.size===0)J._generator?.return(),J._generator=void 0;K?.()}}then(Y){return new Promise((G)=>{let J=this.listen((K)=>{G(K),J()})}).then(Y)}pipe(Y){return Y(this)}}function F(Y,G){return(J)=>new Z(async function*(){let K=Y;for await(let Q of J){let X=await G(K,Q);if(!X)return;let[$,z]=X;if(K=z,$)yield Q}})}function _(Y,G){return(J)=>new Z(async function*(){let K=Y;for await(let Q of J){let[X,$]=await G(K,Q);K=$,yield X}})}function V(...Y){return(G)=>new Z(async function*(){let J=[G,...Y],K=[],Q,X=J.map(($)=>$.listen((z)=>{K.push(z),Q?.()}));try{while(!0)if(K.length)yield K.shift();else await new Promise(($)=>Q=$)}finally{X.forEach(($)=>$())}})}function E(Y=0){return(G)=>{return new Z(async function*(){for await(let J of G)if(Array.isArray(J)){let K=J.flat(Y);for(let Q=0;Q<K.length;Q++)yield K[Q]}else yield J})}}class H{_items=[];_insertStream;_deleteStream;_clearStream;constructor(Y){if(Y)this._items=[...Y];let G=this;function J(Q,X){if(X===0)return 0;return Q<0?(Q%X+X)%X:Q%X}this.insert=new Proxy((Q,X)=>{let $=Q<0?Math.max(0,G._items.length+Q+1):Math.min(Q,G._items.length);return G._items.splice($,0,X),G._insertStream?.push([$,X]),K},{get(Q,X){if(X in Q)return Q[X];if(!G._insertStream)G._insertStream=new Z;return G._insertStream[X]}}),this.delete=new Proxy((Q)=>{if(Q<0||Q>=G._items.length)return;let X=G._items.splice(Q,1)[0];return G._deleteStream?.push([Q,X]),X},{get(Q,X){if(X in Q)return Q[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(Q,X){if(X in Q)return Q[X];if(!G._clearStream)G._clearStream=new Z;return G._clearStream[X]}});let K=new Proxy(this,{get(Q,X){if(typeof X==="string"&&/^-?\d+$/.test(X)){let $=parseInt(X);if(Q._items.length===0)return;let z=J($,Q._items.length);return Q._items[z]}return Q[X]},set(Q,X,$){if(typeof X==="string"&&/^-?\d+$/.test(X)){let z=parseInt(X);if(Q._items.length===0)return Q._items.push($),Q._insertStream?.push([0,$]),!0;let B=J(z,Q._items.length);if(Q._items[B]!==$)Q._items[B]=$,Q._insertStream?.push([B,$]);return!0}return Q[X]=$,!0}});return K}get(Y){return this._items[Y]}get length(){return this._items.length}values(){return this._items[Symbol.iterator]()}[Symbol.iterator](){return this._items[Symbol.iterator]()}}class O extends globalThis.Map{_setStream;_deleteStream;_clearStream;constructor(Y){super(Y);let G=this;this.set=new Proxy((J,K)=>{if(globalThis.Map.prototype.has.call(G,J)&&globalThis.Map.prototype.get.call(G,J)===K)return G;return globalThis.Map.prototype.set.call(G,J,K),G._setStream?.push([J,K]),G},{get(J,K){if(K in J)return J[K];if(!G._setStream)G._setStream=new Z;return G._setStream[K]}}),this.delete=new Proxy((J)=>{if(!globalThis.Map.prototype.has.call(G,J))return!1;let K=globalThis.Map.prototype.get.call(G,J);return globalThis.Map.prototype.delete.call(G,J),G._deleteStream?.push([J,K]),!0},{get(J,K){if(K in J)return J[K];if(!G._deleteStream)G._deleteStream=new Z;return G._deleteStream[K]}}),this.clear=new Proxy(()=>{if(G.size>0)globalThis.Map.prototype.clear.call(G),G._clearStream?.push()},{get(J,K){if(K in J)return J[K];if(!G._clearStream)G._clearStream=new Z;return G._clearStream[K]}})}}class W extends globalThis.Set{_addStream;_deleteStream;_clearStream;constructor(Y){super(Y);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,K){if(K in J)return J[K];if(!G._addStream)G._addStream=new Z;return G._addStream[K]}}),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,K){if(K in J)return J[K];if(!G._deleteStream)G._deleteStream=new Z;return G._deleteStream[K]}}),this.clear=new Proxy(()=>{if(G.size>0)globalThis.Set.prototype.clear.call(G),G._clearStream?.push()},{get(J,K){if(K in J)return J[K];if(!G._clearStream)G._clearStream=new Z;return G._clearStream[K]}})}}class j extends Z{_value;constructor(Y,G){G?super(G):super(),this._value=Y}push(...Y){for(let G of Y)this.value=G}get value(){return this._value}set value(Y){this._value=Y,super.push(Y)}}export{V as merge,_ as map,E as flat,F as filter,Z as Stream,j as State,W as Set,O as Map,H as List};
+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};
 
-//# debugId=C7D29CD74B2C788064756E2164756E21
+//# debugId=652D0058F0A0040264756E2164756E21
 //# sourceMappingURL=index.js.map