@soffinal/stream 0.1.4 → 0.2.0

package/src/transformers/filter.md

@@ -0,0 +1,161 @@
+# Filter Transformer
+
+## The Adaptive Gatekeeper
+
+Traditional filtering is binary and stateless - a value either passes or doesn't. But real-world filtering often requires **memory, learning, and evolution**. The `filter` transformer embodies **Adaptive Reactive Programming** - where the gatekeeper remembers, and can even decide when to stop.
+
+## Design
+
+### Why State-First Architecture?
+
+```typescript
+filter(initialState, (state, value) => [boolean, newState]);
+```
+
+**State comes first** because it's the foundation of adaptation. This isn't just filtering - it's **Adaptive gatekeeping** that evolves with each event.
+
+### The Dual Return Pattern
+
+```typescript
+return [shouldPass, newState]; // Continue with evolution
+return; // Terminate with wisdom
+```
+
+**Two outcomes, infinite possibilities:**
+
+- `[boolean, state]` - The filter learns and continues
+- `void` - The filter decides the stream has served its purpose
+
+This mirrors human decision-making: we either let something through (and remember why), or we decide we've seen enough.
+
+### Argument Order
+
+```typescript
+(state, value) => // State first, value second
+```
+
+**State precedes value** because context shapes perception. We don't judge events in isolation - we judge them based on what we've learned. The state is the accumulated transformations; the value is just the current moment.
+
+## The Adaptive Constraint System
+
+### Level 1: Simple Gatekeeping
+
+```typescript
+// Traditional filtering - no memory, no learning
+stream.pipe(filter({}, (_, value) => [value > 0, {}]));
+```
+
+Even "simple" filtering uses the adaptive architecture. The empty state `{}` represents a gatekeeper that doesn't need memory - but could develop it.
+
+### Level 2: Memory-Based Filtering
+
+```typescript
+// The gatekeeper remembers and counts
+stream.pipe(
+  filter({ count: 0 }, (state, value) => {
+    const newCount = state.count + 1;
+    return [newCount % 3 === 0, { count: newCount }]; // Every 3rd passes
+  })
+);
+```
+
+### Level 3: Termination
+
+```typescript
+// The gatekeeper knows when enough is enough
+stream.pipe(
+  filter({ seen: 0 }, (state, value) => {
+    if (state.seen >= 10) return; // Wisdom: we've seen enough
+    return [value > 0, { seen: state.seen + 1 }];
+  })
+);
+```
+
+**Stream termination** represents the ultimate adaptive behavior - knowing when to stop. This isn't just filtering; it's **stream lifecycle management**.
+
+### Level 4: Async
+
+```typescript
+// The gatekeeper consults external validation
+stream.pipe(
+  filter({ cache: new Map() }, async (state, value) => {
+    if (state.cache.has(value)) {
+      return [state.cache.get(value), state]; // Remember previous decisions
+    }
+
+    const isValid = await validateAsync(value);
+    state.cache.set(value, isValid); // Learn for next time
+    return [isValid, state];
+  })
+);
+```
+
+**Async filtering with memory** - the gatekeeper doesn't just validate, it **builds institutional knowledge**.
+
+## Essential Copy-Paste Transformers
+
+### simpleFilter - Gateway to Adaptation
+
+```typescript
+// For users transitioning from traditional filtering
+const simpleFilter = <T>(predicate: (value: T) => boolean | Promise<boolean>) =>
+  filter<T, {}>({}, async (_, value) => {
+    const shouldPass = await predicate(value);
+    return [shouldPass, {}];
+  });
+
+// Usage: familiar syntax, adaptive foundation
+stream.pipe(simpleFilter((x) => x > 0));
+stream.pipe(simpleFilter(async (user) => await isValid(user)));
+```
+
+**Design choice**: `simpleFilter` is a **bridge**, not a replacement. It introduces users to the adaptive architecture while providing familiar syntax. The empty state `{}` is an invitation to evolution.
+
+### take - The Counting Gatekeeper
+
+```typescript
+const take = <T>(n: number) =>
+  filter<T, { count: number }>({ count: 0 }, (state, value) => {
+    if (state.count >= n) return; // Wisdom: we have enough
+    return [true, { count: state.count + 1 }];
+  });
+```
+
+**Psychology**: `take` demonstrates **self-limiting behavior** - the filter knows its purpose and fulfills it completely, then gracefully terminates.
+
+### distinct - The Memory Gatekeeper
+
+```typescript
+const distinct = <T>() =>
+  filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {
+    if (state.seen.has(value)) return [false, state];
+    state.seen.add(value);
+    return [true, state];
+  });
+```
+
+**Philosophy**: `distinct` embodies **perfect memory** - it never forgets what it has seen, ensuring uniqueness through accumulated values.
+
+## The Termination
+
+Stream termination isn't failure - it's **purposeful completion**. When a filter returns `void`, it's saying: "I have served my purpose, and this stream's journey ends here."
+
+```typescript
+// A filter that knows its mission
+const untilCondition = <T>(condition: (value: T) => boolean) =>
+  filter<T, {}>({}, (_, value) => {
+    if (condition(value)) return; // Mission complete
+    return [true, {}];
+  });
+```
+
+This represents a fundamental shift from infinite streams to **purpose-driven streams** that know when their work is done.
+
+## Conclusion
+
+The `filter` transformer isn't just about removing unwanted values - it's about **intelligent gatekeeping** that:
+
+- **Remembers** previous decisions (state)
+- **Learns** from patterns (adaptation)
+- **Evolves** behavior over time (constraints)
+- **Knows** when to stop (termination)

package/src/transformers/flat.md

@@ -0,0 +1,56 @@
+# Flat Transformer
+
+## Event Multiplication
+
+The `flat` transformer converts array events into individual events - essentially `Array.prototype.flat()` for streams.
+
+**Core Concept**: 1 array event → N individual events
+
+## Usage
+
+```typescript
+stream.pipe(flat(depth?));
+```
+
+- **Input**: `Stream<T[]>`
+- **Output**: `Stream<T>`
+- **Transformation**: Each array becomes separate events
+
+## Basic Example
+
+```typescript
+const arrayStream = new Stream<number[]>();
+const flattened = arrayStream.pipe(flat());
+
+arrayStream.push([1, 2, 3]);
+// Emits: 1, 2, 3 as separate events
+
+flattened.listen((value) => console.log(value));
+// Logs: 1, 2, 3
+```
+
+## Depth Control
+
+```typescript
+const nested = new Stream<number[][]>();
+const flattened = nested.pipe(flat(1)); // Flatten 2 levels
+
+nested.push([
+  [1, 2],
+  [3, 4],
+]);
+// Emits: 1, 2, 3, 4 as separate events
+```
+
+## Common Pattern
+
+```typescript
+// Map then flatten
+const sentences = new Stream<string>();
+const characters = sentences.pipe(map({}, (_, s) => [s.split(""), {}])).pipe(flat());
+
+sentences.push("hello");
+// Emits: 'h', 'e', 'l', 'l', 'o' as separate events
+```
+
+That's it. Simple event multiplication for arrays.

package/src/transformers/map.md

@@ -0,0 +1,184 @@
+# Map Transformer
+
+## The Adaptive Alchemist
+
+Traditional mapping is a simple function application - transform input A to output B. But real-world transformation often requires **context, memory, and evolution**. The `map` transformer embodies **Adaptive Reactive Programming** - where the alchemist remembers previous transformations and evolves its craft.
+
+## Design
+
+### Why State-First Architecture?
+
+```typescript
+map(initialState, (state, value) => [transformed, newState]);
+```
+
+**State comes first** because transformation is contextual. We don't transform values in isolation - we transform them based on what we've learned, what we've seen, and where we're going. The state is the accumulated knowledge; the value is just the raw material.
+
+### The Dual Return Pattern
+
+```typescript
+return [transformedValue, newState]; // Transform and evolve
+```
+
+**Every transformation teaches us something.** The dual return forces us to consider: "How does this transformation change our understanding?" Even if the state doesn't change, we must consciously decide that.
+
+### Argument Order
+
+```typescript
+(state, value) => // Context first, content second
+```
+
+**Context shapes transformation.** A value of `5` might become `10` (double), `"5"` (stringify), or `{ count: 5, timestamp: now }` (enrich) - depending on the accumulated state. The transformer's history determines the value's destiny.
+
+## The Adaptive Transformation System
+
+### Level 1: Simple Alchemy
+
+```typescript
+// Traditional transformation - no memory, no learning
+stream.pipe(map({}, (_, value) => [value * 2, {}]));
+```
+
+Even "simple" mapping uses the adaptive architecture. The empty state `{}` represents a state that doesn't need memory - but could develop it.
+
+### Level 2: Contextual Transformation
+
+```typescript
+// The alchemist remembers and enriches
+stream.pipe(
+  map({ sum: 0, count: 0 }, (state, value) => {
+    const newSum = state.sum + value;
+    const newCount = state.count + 1;
+    const average = newSum / newCount;
+
+    return [
+      { value, runningSum: newSum, runningAverage: average },
+      { sum: newSum, count: newCount },
+    ];
+  })
+);
+```
+
+### Level 3: Evolutionary Transformation
+
+```typescript
+// The alchemist adapts its formula based on patterns
+stream.pipe(
+  map({ multiplier: 1, trend: "stable" }, (state, value) => {
+    // Adapt the transformation based on observed patterns
+    const newMultiplier = value > 100 ? state.multiplier * 1.1 : state.multiplier * 0.9;
+    const trend = newMultiplier > state.multiplier ? "growing" : "shrinking";
+
+    return [value * newMultiplier, { multiplier: newMultiplier, trend }];
+  })
+);
+```
+
+**Adaptive transformation** - the formula itself evolves based on the data it processes.
+
+### Level 4: Async with Order Preservation
+
+```typescript
+// The alchemist consults external sources while maintaining order
+stream.pipe(
+  map({ cache: new Map() }, async (state, value) => {
+    if (state.cache.has(value)) {
+      return [state.cache.get(value), state];
+    }
+
+    const enriched = await enrichWithAPI(value);
+    state.cache.set(value, enriched); // Learn for next time
+    return [enriched, state];
+  })
+);
+```
+
+**Async transformation with memory** - the alchemist doesn't just transform, it **builds institutional knowledge** while preserving the natural order of events.
+
+## Essential Copy-Paste Transformers
+
+### simpleMap - Gateway to Adaptation
+
+```typescript
+// For users transitioning from traditional mapping
+const simpleMap = <T, U>(fn: (value: T) => U | Promise<U>) =>
+  map<T, {}, U>({}, async (_, value) => {
+    const result = await fn(value);
+    return [result, {}];
+  });
+
+// Usage: familiar syntax, adaptive foundation
+stream.pipe(simpleMap((x) => x * 2));
+stream.pipe(simpleMap(async (user) => await enrichUser(user)));
+```
+
+**Design choice**: `simpleMap` is a **bridge**, not a replacement. It introduces users to the adaptive architecture while providing familiar syntax. The empty state `{}` is an invitation to evolution.
+
+### withIndex - The Counting Alchemist
+
+```typescript
+const withIndex = <T>() =>
+  map<T, { index: number }, { value: T; index: number }>({ index: 0 }, (state, value) => [
+    { value, index: state.index },
+    { index: state.index + 1 },
+  ]);
+```
+
+`withIndex` demonstrates **sequential awareness** - the transformer knows its place in the stream's history and shares that knowledge.
+
+### delay - The Patient Alchemist
+
+```typescript
+const delay = <T>(ms: number) =>
+  map<T, {}, T>({}, async (_, value) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return [value, {}];
+  });
+```
+
+`delay` embodies **temporal transformation** - sometimes the most important transformation is time itself.
+
+### pluck - The Focused Alchemist
+
+```typescript
+const pluck = <T, K extends keyof T>(key: K) => map<T, {}, T[K]>({}, (_, value) => [value[key], {}]);
+```
+
+`pluck` demonstrates **selective transformation** - the alchemist knows exactly what it wants and ignores everything else.
+
+## The Order Preservation
+
+Async transformations maintain order because **sequence matters**. Even if transformation B completes before transformation A, the stream waits. This isn't just about correctness - it's about **respecting the narrative** of the data.
+
+```typescript
+// Order is preserved even with varying async delays
+stream.pipe(
+  map({}, async (_, value) => {
+    const delay = Math.random() * 1000; // Random processing time
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return [await processValue(value), {}];
+  })
+);
+```
+
+**Philosophy**: The stream is a story, and stories must be told in order.
+
+## The State Evolution Pattern
+
+State evolution follows a natural progression:
+
+1. **Empty State** `{}` - The transformer starts innocent
+2. **Simple State** `{ count: 0 }` - It learns to count
+3. **Rich State** `{ sum: 0, count: 0, average: 0 }` - It develops complex understanding
+4. **Intelligent State** `{ cache: Map, patterns: [], predictions: {} }` - It becomes wise
+
+This mirrors how expertise develops in any field - from simple rules to nuanced understanding.
+
+## Conclusion
+
+The `map` transformer isn't just about changing values - it's about **intelligent transformation** that:
+
+- **Remembers** previous transformations (state)
+- **Learns** from patterns (adaptation)
+- **Evolves** its approach over time (constraints)
+- **Preserves** the narrative order (respect)

package/src/transformers/merge.md

@@ -0,0 +1,79 @@
+# Merge Transformer
+
+## Temporal Orchestration
+
+The `merge` transformer combines multiple streams into one unified flow while preserving temporal order - like conducting multiple instruments into a single symphony.
+
+**Core Concept**: Multiple streams → One unified stream with union types
+
+## Usage
+
+```typescript
+stream.pipe(merge(...otherStreams));
+```
+
+- **Input**: `Stream<T>` + `Stream<U>[]`
+- **Output**: `Stream<T | U>`
+- **Order**: Maintains chronological sequence across all streams
+
+## Basic Example
+
+```typescript
+const numbers = new Stream<number>();
+const strings = new Stream<string>();
+
+const combined = numbers.pipe(merge(strings));
+// Type: Stream<number | string>
+
+combined.listen((value) => {
+  if (typeof value === "number") {
+    console.log("Number:", value);
+  } else {
+    console.log("String:", value);
+  }
+});
+
+numbers.push(1, 2);
+strings.push("a", "b");
+// Output: 1, 2, "a", "b" (in temporal order)
+```
+
+## Multiple Streams
+
+```typescript
+const events = new Stream<Event>();
+const errors = new Stream<Error>();
+const logs = new Stream<LogEntry>();
+
+const allActivity = events.pipe(merge(errors, logs));
+// Type: Stream<Event | Error | LogEntry>
+
+// All streams flow into one unified timeline
+```
+
+## Type Safety
+
+```typescript
+interface UserEvent {
+  type: "user";
+  data: any;
+}
+interface SystemEvent {
+  type: "system";
+  data: any;
+}
+
+const userEvents = new Stream<UserEvent>();
+const systemEvents = new Stream<SystemEvent>();
+
+const allEvents = userEvents.pipe(merge(systemEvents));
+
+allEvents.listen((event) => {
+  switch (event.type) {
+    case "user" /* handle user event */:
+      break;
+    case "system" /* handle system event */:
+      break;
+  }
+});
+```

package/dist/benchmark.d.ts

@@ -1,16 +0,0 @@
-interface BenchmarkResult {
-    name: string;
-    operations: number;
-    duration: number;
-    opsPerSecond: number;
-    memoryUsage?: number;
-}
-declare class Benchmark {
-    private results;
-    run(name: string, operations: number, fn: () => Promise<void> | void): Promise<BenchmarkResult>;
-    getResults(): BenchmarkResult[];
-    printSummary(): void;
-}
-declare function runBenchmarks(): Promise<void>;
-export { runBenchmarks, Benchmark };
-//# sourceMappingURL=benchmark.d.ts.map

package/dist/benchmark.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../src/benchmark.ts"],"names":[],"mappings":"AAEA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,cAAM,SAAS;IACb,OAAO,CAAC,OAAO,CAAyB;IAElC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAgCrG,UAAU,IAAI,eAAe,EAAE;IAI/B,YAAY;CAMb;AAED,iBAAe,aAAa,kBAwI3B;AAOD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC"}

package/dist/list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,IAAI,CAAC,KAAK,CAAE,YAAW,QAAQ,CAAC,KAAK,CAAC;IACjD,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAEnC;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAElF;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAEjF;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAiGnC;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIrC;;;;;;;;;;;OAWG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;;;;;;;OAUG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAGjC;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC;CAG7C"}

package/dist/map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../src/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,GAAG,CAAC,GAAG,EAAE,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;IAC7D,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC5C,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC/C,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;OAaG;IACK,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAEvE;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;OAoBG;gBACS,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;CAuD7C"}

package/dist/set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../src/set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,GAAG,CAAC,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;IACnD,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACrC,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;OAYG;IACK,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEtD;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5D;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;OAiBG;gBACS,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CAqDrC"}

package/dist/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC7C,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;IAExB;;;;;;;;;;;OAWG;gBACS,YAAY,EAAE,KAAK;IAI/B;;;;;;;;;;;;;;OAcG;IACM,IAAI,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAKvC;;;;;;;;OAQG;IACH,IAAI,KAAK,IAAI,KAAK,CAEjB;IACD;;;;;;;;;;;;;OAaG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,EAGrB;CACF"}