@soffinal/stream 0.1.4 → 0.2.1

package/dist/transformers/map.d.ts

@@ -0,0 +1,36 @@
+import { Stream } from "../stream.ts";
+/**
+ * Adaptive map transformer that transforms values while maintaining state.
+ *
+ * @template VALUE - The type of input values
+ * @template STATE - The type of the internal state object
+ * @template MAPPED - The type of output values after transformation
+ *
+ * @param initialState - Initial state object for the transformer
+ * @param predicate - Function that transforms values and updates state
+ *   - Must return `[transformedValue, newState]`
+ *   - Can be async for complex transformations
+ *   - Preserves order even with async operations
+ *
+ * @returns A transformer function that can be used with `.pipe()`
+ *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
+ * @example
+ * // Simple transformation
+ * stream.pipe(map({}, (_, value) => [value * 2, {}]))
+ *
+ * @example
+ * // Async transformation
+ * stream.pipe(
+ *   map({}, async (_, value) => {
+ *     const result = await process(value);
+ *     return [result, {}];
+ *   })
+ * )
+ *
+
+ *
+ */
+export declare function map<VALUE, STATE extends Record<string, unknown>, MAPPED>(initialState: STATE, predicate: (state: STATE, value: VALUE) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>): (stream: Stream<VALUE>) => Stream<MAPPED>;
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/transformers/map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GACpF,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAU3C"}

package/dist/transformers/merge.d.ts

@@ -0,0 +1,35 @@
+import { Stream } from "../stream.ts";
+type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
+/**
+ * Merge multiple streams into a single stream with temporal ordering.
+ *
+ * @template VALUE - The type of values from the source stream
+ * @template STREAMS - Tuple type of additional streams to merge
+ *
+ * @param streams - Additional streams to merge with the source stream
+ *
+ * @returns A transformer that merges all streams into one with union types
+ *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
+ * @example
+ * // Basic merge with type safety
+ * const numbers = new Stream<number>();
+ * const strings = new Stream<string>();
+ * const merged = numbers.pipe(merge(strings));
+ * // Type: Stream<number | string>
+ *
+ * @example
+ * // Multiple streams
+ * const stream1 = new Stream<number>();
+ * const stream2 = new Stream<string>();
+ * const stream3 = new Stream<boolean>();
+ *
+ * const combined = stream1.pipe(merge(stream2, stream3));
+ * // Type: Stream<number | string | boolean>
+ *
+
+ */
+export declare function merge<VALUE, STREAMS extends [Stream<any>, ...Stream<any>[]]>(...streams: STREAMS): (stream: Stream<VALUE>) => Stream<VALUE | ValueOf<STREAMS[number]>>;
+export {};
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/transformers/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,KAAK,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAC1E,GAAG,OAAO,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CA0BrE"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soffinal/stream",
   "module": "./dist/index.js",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "A reactive event streaming library for TypeScript/JavaScript",
   "type": "module",
   "devDependencies": {
@@ -10,12 +10,6 @@
   "peerDependencies": {
     "typescript": "^5.9.2"
   },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "build": "bun run clean && bun build src/index.ts --outdir dist --target node --format esm --sourcemap --minify && bun run build:types",
-    "build:types": "tsc --emitDeclarationOnly --allowImportingTsExtensions --noEmit false",
-    "release": " git add . && git commit -m \"Release v$(node -p 'require(\"./package.json\").version')\" && git tag v$(node -p 'require(\"./package.json\").version')"
-  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -29,7 +23,8 @@
     "typescript",
     "event",
     "observable",
-    "emitter"
+    "emitter",
+    "adaptive constraints"
   ],
   "author": "Soffinal <smari.sofiane@gmail.com>",
   "license": "MIT",
@@ -41,7 +36,9 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "src/transformers/*.md",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ]
 }

package/src/transformers/filter.md

@@ -0,0 +1,202 @@
+# 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 }];
+  });
+```
+
+### 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];
+  });
+```
+
+### tap - The Observer Gatekeeper
+
+```typescript
+const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+  filter<T, {}>({}, async (_, value) => {
+    await fn(value);
+    return [true, {}]; // Always pass through
+  });
+
+// Usage: Side effects without changing the stream
+stream.pipe(tap((value) => console.log("Saw:", value)));
+stream.pipe(tap(async (value) => await logToDatabase(value)));
+```
+
+## 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.
+
+## Enhanced Pipe Integration
+
+The new pipe architecture enables seamless integration:
+
+```typescript
+// Filter integrates with any transformer
+const result = stream
+  .pipe(filter({}, (_, v) => [v > 0, {}])) // Returns Stream<T>
+  .pipe(map({}, (_, v) => [v.toString(), {}])) // Returns Stream<string>
+  .pipe(toState("0")); // Returns State<string>
+
+// Complex filtering chains
+const processed = source
+  .pipe(
+    filter({ seen: 0 }, (state, v) => {
+      if (state.seen >= 100) return; // Terminate after 100
+      return [v > 0, { seen: state.seen + 1 }];
+    })
+  )
+  .pipe(tap((v) => console.log("Positive:", v)))
+  .pipe(
+    filter({ count: 0 }, (state, v) => {
+      return [state.count % 2 === 0, { count: state.count + 1 }]; // Every other
+    })
+  );
+```
+
+**Note**: Filters compose naturally because they all speak the same language - **adaptive constraints** that can terminate, remember, and evolve.
+
+**Design insight**: Filtering State creates **conditional reactivity** - the derived state only reacts to values that pass the adaptive constraints.
+
+## 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,216 @@
+# 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.
+
+### tap - The Observer Gatekeeper
+
+```typescript
+const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+  map<T, {}, T>({}, async (_, value) => {
+    await fn(value);
+    return [value, {}]; // Always pass through
+  });
+
+// Usage: Side effects without changing the stream
+stream.pipe(tap((value) => console.log("Saw:", value)));
+stream.pipe(tap(async (value) => await logToDatabase(value)));
+```
+
+### scan - The Accumulating Alchemist
+
+```typescript
+const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>
+  map<T, { acc: U }, U>({ acc: initial }, (state, value) => {
+    const newAcc = fn(state.acc, value);
+    return [newAcc, { acc: newAcc }];
+  });
+
+// Usage: Accumulate values over time
+stream.pipe(scan((sum, value) => sum + value, 0)); // Running sum
+stream.pipe(scan((max, value) => Math.max(max, value), -Infinity)); // Running max
+```
+
+`scan` demonstrates **accumulative transformation** - each value builds upon all previous values, creating a growing understanding.
+
+## 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)
+- **Integrates** with reactive state (toState)
+- **Accumulates** knowledge over time (scan)

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"}