evnty 5.2.19 → 5.3.1

package/build/iterator.cjs

@@ -55,15 +55,9 @@ class ProcessResult {
         this.flatMapIterator = flatMapIterator;
         this.flatMapOpIndex = flatMapOpIndex;
     }
-    static continue() {
-        return new ProcessResult(undefined, false, false, null, -1, null, -1);
-    }
     static yield(value) {
         return new ProcessResult(value, true, false, null, -1, null, -1);
     }
-    static done() {
-        return new ProcessResult(undefined, false, true, null, -1, null, -1);
-    }
     static expand(iterator, opIndex) {
         return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);
     }
@@ -71,6 +65,8 @@ class ProcessResult {
         return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);
     }
 }
+const CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));
+const DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));
 function findTakeStates(ops, opStates) {
     const takeStates = [];
     for(let i = 0; i < ops.length; i++){
@@ -104,14 +100,14 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                 {
                     const result = op.fn(value, state.index++);
                     const passed = (0, _utilscjs.isThenable)(result) ? await result : result;
-                    if (!passed) return ProcessResult.continue();
+                    if (!passed) return CONTINUE;
                     break;
                 }
             case 2:
                 {
                     const result = op.fn(value, state.index++);
                     const resolved = (0, _utilscjs.isThenable)(result) ? await result : result;
-                    if (resolved === undefined) return ProcessResult.continue();
+                    if (resolved === undefined) return CONTINUE;
                     value = resolved;
                     break;
                 }
@@ -131,27 +127,27 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                 ];
                 break;
             case 6:
-                if (state.remaining <= 0) return ProcessResult.done();
+                if (state.remaining <= 0) return DONE;
                 state.remaining--;
                 break;
             case 8:
                 {
                     const result = op.fn(value, state.index++);
                     const passed = (0, _utilscjs.isThenable)(result) ? await result : result;
-                    if (!passed) return ProcessResult.done();
+                    if (!passed) return DONE;
                     break;
                 }
             case 7:
                 if (state.remaining > 0) {
                     state.remaining--;
-                    return ProcessResult.continue();
+                    return CONTINUE;
                 }
                 break;
             case 9:
                 if (state.dropping) {
                     const result = op.fn(value, state.index++);
                     const passed = (0, _utilscjs.isThenable)(result) ? await result : result;
-                    if (passed) return ProcessResult.continue();
+                    if (passed) return CONTINUE;
                     state.dropping = false;
                 }
                 break;
@@ -165,7 +161,7 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                             value = state.value;
                         } else {
                             state.value = value;
-                            return ProcessResult.continue();
+                            return CONTINUE;
                         }
                     } else {
                         const result = op.fn(state.value, value, state.index++);

package/build/iterator.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { AnyIterable } from './types.js';\n\nconst enum OpKind {\n  MAP,\n  FILTER,\n  FILTER_MAP,\n  AWAITED,\n  INSPECT,\n  ENUMERATE,\n  TAKE,\n  DROP,\n  TAKE_WHILE,\n  DROP_WHILE,\n  REDUCE,\n  FLAT_MAP,\n  EXPAND,\n}\n\n/**\n * @internal\n * Represents a fusible operation that can be combined with other operations.\n */\ntype FusedOp =\n  | { kind: OpKind.MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER_MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.AWAITED }\n  | { kind: OpKind.INSPECT; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.ENUMERATE; start: number }\n  | { kind: OpKind.TAKE; limit: number }\n  | { kind: OpKind.DROP; count: number }\n  | { kind: OpKind.TAKE_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.DROP_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.REDUCE; fn: (acc: unknown, value: unknown, index: number) => unknown; init: unknown; hasInit: boolean }\n  | { kind: OpKind.FLAT_MAP; fn: (value: unknown, index: number) => AsyncIterable<unknown, void, unknown> }\n  | { kind: OpKind.EXPAND; fn: (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>> };\n\nclass OpState {\n  initialized = false;\n\n  constructor(\n    public index: number,\n    public remaining: number,\n    public dropping: boolean,\n    public value: unknown,\n  ) {}\n\n  static from(this: void, op: FusedOp): OpState {\n    switch (op.kind) {\n      case OpKind.ENUMERATE:\n        return new OpState(op.start, 0, false, undefined);\n      case OpKind.TAKE:\n        return new OpState(0, op.limit, false, undefined);\n      case OpKind.DROP:\n        return new OpState(0, op.count, false, undefined);\n      case OpKind.DROP_WHILE:\n        return new OpState(0, 0, true, undefined);\n      case OpKind.REDUCE:\n        return new OpState(0, 0, false, op.init);\n      default:\n        return new OpState(0, 0, false, undefined);\n    }\n  }\n}\n\nclass ProcessResult {\n  constructor(\n    readonly value: unknown,\n    readonly shouldYield: boolean,\n    readonly done: boolean,\n    readonly expandIterator: Iterator<unknown> | null,\n    readonly expandOpIndex: number,\n    readonly flatMapIterator: AsyncIterator<unknown> | null,\n    readonly flatMapOpIndex: number,\n  ) {}\n\n  static continue(): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, null, -1);\n  }\n\n  static yield(value: unknown): ProcessResult {\n    return new ProcessResult(value, true, false, null, -1, null, -1);\n  }\n\n  static done(): ProcessResult {\n    return new ProcessResult(undefined, false, true, null, -1, null, -1);\n  }\n\n  static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);\n  }\n\n  static flatMap(iterator: AsyncIterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);\n  }\n}\n\nfunction findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {\n  const takeStates: OpState[] = [];\n  for (let i = 0; i < ops.length; i++) {\n    if (ops[i].kind === OpKind.TAKE) takeStates.push(opStates[i]);\n  }\n  return takeStates;\n}\n\nfunction hasExpandingOps(ops: FusedOp[]): boolean {\n  for (let i = 0; i < ops.length; i++) {\n    const kind = ops[i].kind;\n    if (kind === OpKind.FLAT_MAP || kind === OpKind.EXPAND) return true;\n  }\n  return false;\n}\n\nfunction checkTakeExhausted(takeStates: OpState[]): boolean {\n  for (let i = 0; i < takeStates.length; i++) {\n    if (takeStates[i].remaining <= 0) return true;\n  }\n  return false;\n}\n\nasync function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState[], startIndex: number): Promise<ProcessResult> {\n  let value = inputValue;\n\n  for (let i = startIndex; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return ProcessResult.continue();\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return ProcessResult.continue();\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        if (state.remaining <= 0) return ProcessResult.done();\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return ProcessResult.done();\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return ProcessResult.continue();\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return ProcessResult.continue();\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if (op.hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return ProcessResult.continue();\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n\n      case OpKind.FLAT_MAP: {\n        const iterable = op.fn(value, state.index++);\n        return ProcessResult.flatMap(iterable[Symbol.asyncIterator](), i);\n      }\n\n      case OpKind.EXPAND: {\n        const result = op.fn(value, state.index++);\n        const expanded = isThenable(result) ? await result : result;\n        return ProcessResult.expand(expanded[Symbol.iterator](), i);\n      }\n    }\n  }\n\n  return ProcessResult.yield(value);\n}\n\nasync function processOpsSimple(inputValue: unknown, ops: FusedOp[], opStates: OpState[]): Promise<{ value: unknown; shouldYield: boolean; done: boolean }> {\n  let value = inputValue;\n\n  for (let i = 0; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: false };\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return { value: undefined, shouldYield: false, done: false };\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: true };\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return { value: undefined, shouldYield: false, done: false };\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return { value: undefined, shouldYield: false, done: false };\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if ((op as { hasInit: boolean }).hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return { value: undefined, shouldYield: false, done: false };\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n    }\n  }\n\n  return { value, shouldYield: true, done: false };\n}\n\nfunction collectOps(iter: AsyncIteratorObject<unknown, unknown, unknown>): FusedOp[] {\n  const ops: FusedOp[] = [];\n  let current: AsyncIteratorObject<unknown, unknown, unknown> | null = iter;\n  while (current) {\n    const op = current.op;\n    if (op) ops.push(op);\n    current = current.parent;\n  }\n  ops.reverse();\n  return ops;\n}\n\nfunction getSource(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, unknown, unknown> {\n  let current = iter;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current.iterable;\n}\n\nfunction createSimpleIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n      let done = false;\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\ntype InnerFrame = { type: 'expand'; iterator: Iterator<unknown>; opIndex: number } | { type: 'flatMap'; iterator: AsyncIterator<unknown>; opIndex: number };\n\nfunction createExpandingIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n\n      let done = false;\n      const innerStack: InnerFrame[] = [];\n\n      const closeInnerIterators = async () => {\n        for (const frame of innerStack) {\n          if (frame.type === 'flatMap') {\n            await frame.iterator.return?.();\n          }\n        }\n        innerStack.length = 0;\n      };\n\n      const handleResult = async (result: ProcessResult): Promise<IteratorResult<unknown, void> | null> => {\n        if (result.done) {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.();\n          return { value: undefined, done: true };\n        }\n        if (result.expandIterator) {\n          innerStack.push({ type: 'expand', iterator: result.expandIterator, opIndex: result.expandOpIndex });\n          return null;\n        }\n        if (result.flatMapIterator) {\n          innerStack.push({ type: 'flatMap', iterator: result.flatMapIterator, opIndex: result.flatMapOpIndex });\n          return null;\n        }\n        if (result.shouldYield) {\n          return { value: result.value, done: false };\n        }\n        return null;\n      };\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (innerStack.length > 0) {\n              const frame = innerStack[innerStack.length - 1];\n              if (frame.type === 'expand') {\n                const expandResult = frame.iterator.next();\n                if (!expandResult.done) {\n                  const result = await processOps(expandResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              } else {\n                const flatMapResult = await frame.iterator.next();\n                if (!flatMapResult.done) {\n                  const result = await processOps(flatMapResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              }\n            }\n\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOps(sourceResult.value, ops, opStates, 0);\n            const handled = await handleResult(result);\n            if (handled) return handled;\n          }\n\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\nfunction createFusedIterable(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, void, unknown> {\n  const source = getSource(iter);\n  const ops = iter.cachedOps ?? (iter.cachedOps = collectOps(iter));\n\n  if (ops.length === 0) {\n    return source as AsyncIterable<unknown, void, unknown>;\n  }\n\n  return hasExpandingOps(ops) ? createExpandingIterable(source, ops) : createSimpleIterable(source, ops);\n}\n\n/**\n * A wrapper class providing functional operations on async iterables.\n * Enables lazy evaluation and chainable transformations on async data streams.\n *\n * Key characteristics:\n * - Lazy evaluation - operations are not executed until iteration begins\n * - Chainable - all transformation methods return new AsyncIteratorObject instances\n * - Supports both sync and async transformation functions\n * - Memory efficient - processes values one at a time\n * - Operation fusion - chains execute in optimized passes\n *\n * @template T The type of values yielded by the iterator\n * @template TReturn The return type of the iterator\n * @template TNext The type of value that can be passed to next()\n *\n * @example\n * ```typescript\n * // Create from an async generator\n * async function* numbers() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const iterator = new AsyncIteratorObject(numbers())\n *   .map(x => x * 2)\n *   .filter(x => x > 2);\n *\n * for await (const value of iterator) {\n *   console.log(value); // 4, 6\n * }\n * ```\n */\nexport class AsyncIteratorObject<T, TReturn, TNext> {\n  /**\n   * Creates an AsyncIteratorObject from a synchronous iterable.\n   * Converts the sync iterable to async for uniform handling.\n   *\n   * @param iterable A synchronous iterable to convert\n   * @returns A new AsyncIteratorObject wrapping the converted iterable\n   *\n   * @example\n   * ```typescript\n   * const syncArray = [1, 2, 3, 4, 5];\n   * const asyncIterator = AsyncIteratorObject.from(syncArray);\n   *\n   * for await (const value of asyncIterator) {\n   *   console.log(value); // 1, 2, 3, 4, 5\n   * }\n   * ```\n   */\n  static from<T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIteratorObject<T, TReturn, TNext> {\n    const asyncIterable = toAsyncIterable(iterable);\n    return new AsyncIteratorObject<T, TReturn, TNext>(asyncIterable);\n  }\n\n  /**\n   * Merges multiple async iterables into a single stream.\n   * Values from all sources are interleaved as they become available.\n   * The merged iterator completes when all source iterators complete.\n   *\n   * @param iterables The async iterables to merge\n   * @returns A new AsyncIteratorObject yielding values from all sources\n   *\n   * @example\n   * ```typescript\n   * async function* source1() { yield 1; yield 3; }\n   * async function* source2() { yield 2; yield 4; }\n   *\n   * const merged = AsyncIteratorObject.merge(source1(), source2());\n   *\n   * for await (const value of merged) {\n   *   console.log(value); // Order depends on timing: 1, 2, 3, 4 or similar\n   * }\n   * ```\n   */\n  static merge<T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(mergeIterables(...iterables));\n  }\n\n  /** @internal */\n  iterable: AsyncIterable<unknown, unknown, unknown>;\n  /** @internal */\n  parent: AsyncIteratorObject<unknown, unknown, unknown> | null;\n  /** @internal */\n  op: FusedOp | null;\n  /** @internal */\n  cachedOps: FusedOp[] | null = null;\n\n  readonly [Symbol.toStringTag] = 'AsyncIteratorObject';\n\n  constructor(iterable: AsyncIterable<T, TReturn, TNext>, parent: AsyncIteratorObject<unknown, unknown, unknown> | null = null, op: FusedOp | null = null) {\n    this.iterable = iterable as AsyncIterable<unknown, unknown, unknown>;\n    this.parent = parent;\n    this.op = op;\n  }\n\n  /**\n   * Escape hatch for custom transformations not covered by the built-in operators.\n   * Materializes the fused operation chain, then applies a generator function to each value.\n   *\n   * @param generatorFactory A function that returns a generator function for transforming values\n   * @param signal Optional AbortSignal to cancel the operation\n   * @returns A new AsyncIteratorObject with transformed values\n   */\n  pipe<U>(generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>, signal?: AbortSignal): AsyncIteratorObject<U, void, unknown> {\n    const materialized = createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>);\n    const generator = pipe(materialized as AsyncIterable<T>, generatorFactory, signal);\n    return new AsyncIteratorObject<U, void, unknown>(generator);\n  }\n\n  /**\n   * Resolves promise-like values from the source iterator.\n   * Useful for normalizing values before applying type-guard predicates.\n   *\n   * @returns A new AsyncIteratorObject yielding awaited values\n   */\n  awaited(): AsyncIteratorObject<Awaited<T>, void, unknown> {\n    return new AsyncIteratorObject<Awaited<T>, void, unknown>(\n      this.iterable as AsyncIterable<Awaited<T>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.AWAITED },\n    );\n  }\n\n  /**\n   * Transforms each value using a mapping function.\n   * The callback can be synchronous or return a promise.\n   *\n   * @param callbackfn Function to transform each value\n   * @returns A new AsyncIteratorObject yielding transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const doubled = numbers.map(x => x * 2);\n   *\n   * for await (const value of doubled) {\n   *   console.log(value); // 2, 4, 6\n   * }\n   * ```\n   */\n  map<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.MAP,\n      fn: callbackfn as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Filters values based on a predicate function.\n   * Only values for which the predicate returns truthy are yielded.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding only values that pass the test\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const evens = numbers.filter(x => x % 2 === 0);\n   *\n   * for await (const value of evens) {\n   *   console.log(value); // 2, 4\n   * }\n   * ```\n   */\n  filter(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FILTER,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Combined filter and map operation. Returns undefined to skip a value.\n   * The callback result is awaited to check for undefined.\n   *\n   * @param callbackfn Function that returns a transformed value or undefined to skip\n   * @returns A new AsyncIteratorObject yielding non-undefined transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const doubledEvens = numbers.filterMap(x => x % 2 === 0 ? x * 2 : undefined);\n   *\n   * for await (const value of doubledEvens) {\n   *   console.log(value); // 4, 8\n   * }\n   * ```\n   */\n  filterMap<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown> {\n    return new AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown>(\n      this.iterable as AsyncIterable<Exclude<Awaited<U>, undefined>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.FILTER_MAP, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Executes a side-effect function for each value without modifying the stream.\n   * Useful for debugging or logging. The callback is awaited for proper sequencing.\n   *\n   * @param callbackfn Function to execute for each value\n   * @returns A new AsyncIteratorObject yielding the same values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const logged = numbers.inspect(x => console.log('value:', x)).map(x => x * 2);\n   * ```\n   */\n  inspect(callbackfn: (value: T, index: number) => unknown): AsyncIteratorObject<T, TReturn, TNext> {\n    return new AsyncIteratorObject<T, TReturn, TNext>(\n      this.iterable as AsyncIterable<T, TReturn, TNext>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.INSPECT, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Wraps each value with its index as a tuple.\n   * Useful after filtering when original indices are lost.\n   *\n   * @param start Starting index (default: 0)\n   * @returns A new AsyncIteratorObject yielding [index, value] tuples\n   *\n   * @example\n   * ```typescript\n   * const letters = AsyncIteratorObject.from(['a', 'b', 'c']);\n   * const enumerated = letters.enumerate();\n   *\n   * for await (const [i, v] of enumerated) {\n   *   console.log(i, v); // 0 'a', 1 'b', 2 'c'\n   * }\n   * ```\n   */\n  enumerate(start: number = 0): AsyncIteratorObject<[number, T], void, unknown> {\n    return new AsyncIteratorObject<[number, T], void, unknown>(\n      this.iterable as AsyncIterable<[number, T], void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.ENUMERATE, start },\n    );\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.\n   * @param limit The maximum number of values to yield.\n   */\n  take(limit: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE,\n      limit,\n    });\n  }\n\n  /**\n   * Takes values while the predicate returns truthy.\n   * Stops immediately when predicate returns falsy.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const small = numbers.takeWhile(x => x < 4);\n   *\n   * for await (const value of small) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  takeWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator after skipping the provided count.\n   * @param count The number of values to drop.\n   */\n  drop(count: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP,\n      count,\n    });\n  }\n\n  /**\n   * Skips values while the predicate returns truthy.\n   * Yields all remaining values once predicate returns falsy.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject skipping values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const afterSmall = numbers.dropWhile(x => x < 3);\n   *\n   * for await (const value of afterSmall) {\n   *   console.log(value); // 3, 4, 5\n   * }\n   * ```\n   */\n  dropWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.\n   * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.\n   */\n  flatMap<U>(callback: (value: T, index: number) => AsyncIterable<U, void, unknown>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FLAT_MAP,\n      fn: callback as (value: unknown, index: number) => AsyncIterable<unknown, void, unknown>,\n    });\n  }\n\n  /**\n   * Creates an iterator of accumulated values by applying a reducer function.\n   * Unlike Array.reduce, this returns an iterator that yields each intermediate accumulated value,\n   * not just the final result. This allows observing the accumulation process.\n   *\n   * @param callbackfn Reducer function to accumulate values\n   * @param initialValue Optional initial value for the accumulation\n   * @returns A new AsyncIteratorObject yielding accumulated values at each step\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4]);\n   * const sums = numbers.reduce((sum, x) => sum + x, 0);\n   *\n   * for await (const value of sums) {\n   *   console.log(value); // 1, 3, 6, 10 (running totals)\n   * }\n   * ```\n   */\n  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): AsyncIteratorObject<T, void, unknown>;\n  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, initialValue: R): AsyncIteratorObject<R, void, unknown>;\n  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, ...args: unknown[]): AsyncIteratorObject<R, void, unknown> {\n    const hasInit = args.length > 0;\n    return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.REDUCE,\n      fn: callbackfn as (acc: unknown, value: unknown, index: number) => unknown,\n      init: args[0],\n      hasInit,\n    });\n  }\n\n  /**\n   * Transforms each value into multiple values using an expander function.\n   * Each input value is expanded into zero or more output values.\n   * Like `flatMap` but takes sync Iterables (or Promises of Iterables) instead of AsyncIterables.\n   *\n   * @param callbackfn Function that returns an iterable of values for each input\n   * @returns A new AsyncIteratorObject yielding all expanded values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const expanded = numbers.expand(x => [x, x * 10]);\n   *\n   * for await (const value of expanded) {\n   *   console.log(value); // 1, 10, 2, 20, 3, 30\n   * }\n   * ```\n   */\n  expand<U>(callbackfn: (value: T, index: number) => Promise<Iterable<U>> | Iterable<U>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.EXPAND,\n      fn: callbackfn as (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>>,\n    });\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n    return createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>)[Symbol.asyncIterator]() as AsyncIterator<T, TReturn, TNext>;\n  }\n}\n"],"names":["AsyncIteratorObject","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","continue","yield","expand","iterator","opIndex","flatMap","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","isThenable","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","asyncIterable","toAsyncIterable","merge","iterables","mergeIterables","toStringTag","pipe","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":"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"}
+{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { AnyIterable } from './types.js';\n\nconst enum OpKind {\n  MAP,\n  FILTER,\n  FILTER_MAP,\n  AWAITED,\n  INSPECT,\n  ENUMERATE,\n  TAKE,\n  DROP,\n  TAKE_WHILE,\n  DROP_WHILE,\n  REDUCE,\n  FLAT_MAP,\n  EXPAND,\n}\n\n/**\n * @internal\n * Represents a fusible operation that can be combined with other operations.\n */\ntype FusedOp =\n  | { kind: OpKind.MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER_MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.AWAITED }\n  | { kind: OpKind.INSPECT; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.ENUMERATE; start: number }\n  | { kind: OpKind.TAKE; limit: number }\n  | { kind: OpKind.DROP; count: number }\n  | { kind: OpKind.TAKE_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.DROP_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.REDUCE; fn: (acc: unknown, value: unknown, index: number) => unknown; init: unknown; hasInit: boolean }\n  | { kind: OpKind.FLAT_MAP; fn: (value: unknown, index: number) => AsyncIterable<unknown, void, unknown> }\n  | { kind: OpKind.EXPAND; fn: (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>> };\n\nclass OpState {\n  initialized = false;\n\n  constructor(\n    public index: number,\n    public remaining: number,\n    public dropping: boolean,\n    public value: unknown,\n  ) {}\n\n  static from(this: void, op: FusedOp): OpState {\n    switch (op.kind) {\n      case OpKind.ENUMERATE:\n        return new OpState(op.start, 0, false, undefined);\n      case OpKind.TAKE:\n        return new OpState(0, op.limit, false, undefined);\n      case OpKind.DROP:\n        return new OpState(0, op.count, false, undefined);\n      case OpKind.DROP_WHILE:\n        return new OpState(0, 0, true, undefined);\n      case OpKind.REDUCE:\n        return new OpState(0, 0, false, op.init);\n      default:\n        return new OpState(0, 0, false, undefined);\n    }\n  }\n}\n\nclass ProcessResult {\n  constructor(\n    readonly value: unknown,\n    readonly shouldYield: boolean,\n    readonly done: boolean,\n    readonly expandIterator: Iterator<unknown> | null,\n    readonly expandOpIndex: number,\n    readonly flatMapIterator: AsyncIterator<unknown> | null,\n    readonly flatMapOpIndex: number,\n  ) {}\n\n  static yield(value: unknown): ProcessResult {\n    return new ProcessResult(value, true, false, null, -1, null, -1);\n  }\n\n  static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);\n  }\n\n  static flatMap(iterator: AsyncIterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);\n  }\n}\n\nconst CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));\nconst DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));\n\nfunction findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {\n  const takeStates: OpState[] = [];\n  for (let i = 0; i < ops.length; i++) {\n    if (ops[i].kind === OpKind.TAKE) takeStates.push(opStates[i]);\n  }\n  return takeStates;\n}\n\nfunction hasExpandingOps(ops: FusedOp[]): boolean {\n  for (let i = 0; i < ops.length; i++) {\n    const kind = ops[i].kind;\n    if (kind === OpKind.FLAT_MAP || kind === OpKind.EXPAND) return true;\n  }\n  return false;\n}\n\nfunction checkTakeExhausted(takeStates: OpState[]): boolean {\n  for (let i = 0; i < takeStates.length; i++) {\n    if (takeStates[i].remaining <= 0) return true;\n  }\n  return false;\n}\n\nasync function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState[], startIndex: number): Promise<ProcessResult> {\n  let value = inputValue;\n\n  for (let i = startIndex; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return CONTINUE;\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return CONTINUE;\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        if (state.remaining <= 0) return DONE;\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return DONE;\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return CONTINUE;\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return CONTINUE;\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if (op.hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return CONTINUE;\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n\n      case OpKind.FLAT_MAP: {\n        const iterable = op.fn(value, state.index++);\n        return ProcessResult.flatMap(iterable[Symbol.asyncIterator](), i);\n      }\n\n      case OpKind.EXPAND: {\n        const result = op.fn(value, state.index++);\n        const expanded = isThenable(result) ? await result : result;\n        return ProcessResult.expand(expanded[Symbol.iterator](), i);\n      }\n    }\n  }\n\n  return ProcessResult.yield(value);\n}\n\nasync function processOpsSimple(inputValue: unknown, ops: FusedOp[], opStates: OpState[]): Promise<{ value: unknown; shouldYield: boolean; done: boolean }> {\n  let value = inputValue;\n\n  for (let i = 0; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: false };\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return { value: undefined, shouldYield: false, done: false };\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: true };\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return { value: undefined, shouldYield: false, done: false };\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return { value: undefined, shouldYield: false, done: false };\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if ((op as { hasInit: boolean }).hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return { value: undefined, shouldYield: false, done: false };\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n    }\n  }\n\n  return { value, shouldYield: true, done: false };\n}\n\nfunction collectOps(iter: AsyncIteratorObject<unknown, unknown, unknown>): FusedOp[] {\n  const ops: FusedOp[] = [];\n  let current: AsyncIteratorObject<unknown, unknown, unknown> | null = iter;\n  while (current) {\n    const op = current.op;\n    if (op) ops.push(op);\n    current = current.parent;\n  }\n  ops.reverse();\n  return ops;\n}\n\nfunction getSource(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, unknown, unknown> {\n  let current = iter;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current.iterable;\n}\n\nfunction createSimpleIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n      let done = false;\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\ntype InnerFrame = { type: 'expand'; iterator: Iterator<unknown>; opIndex: number } | { type: 'flatMap'; iterator: AsyncIterator<unknown>; opIndex: number };\n\nfunction createExpandingIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n\n      let done = false;\n      const innerStack: InnerFrame[] = [];\n\n      const closeInnerIterators = async () => {\n        for (const frame of innerStack) {\n          if (frame.type === 'flatMap') {\n            await frame.iterator.return?.();\n          }\n        }\n        innerStack.length = 0;\n      };\n\n      const handleResult = async (result: ProcessResult): Promise<IteratorResult<unknown, void> | null> => {\n        if (result.done) {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.();\n          return { value: undefined, done: true };\n        }\n        if (result.expandIterator) {\n          innerStack.push({ type: 'expand', iterator: result.expandIterator, opIndex: result.expandOpIndex });\n          return null;\n        }\n        if (result.flatMapIterator) {\n          innerStack.push({ type: 'flatMap', iterator: result.flatMapIterator, opIndex: result.flatMapOpIndex });\n          return null;\n        }\n        if (result.shouldYield) {\n          return { value: result.value, done: false };\n        }\n        return null;\n      };\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (innerStack.length > 0) {\n              const frame = innerStack[innerStack.length - 1];\n              if (frame.type === 'expand') {\n                const expandResult = frame.iterator.next();\n                if (!expandResult.done) {\n                  const result = await processOps(expandResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              } else {\n                const flatMapResult = await frame.iterator.next();\n                if (!flatMapResult.done) {\n                  const result = await processOps(flatMapResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              }\n            }\n\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOps(sourceResult.value, ops, opStates, 0);\n            const handled = await handleResult(result);\n            if (handled) return handled;\n          }\n\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\nfunction createFusedIterable(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, void, unknown> {\n  const source = getSource(iter);\n  const ops = iter.cachedOps ?? (iter.cachedOps = collectOps(iter));\n\n  if (ops.length === 0) {\n    return source as AsyncIterable<unknown, void, unknown>;\n  }\n\n  return hasExpandingOps(ops) ? createExpandingIterable(source, ops) : createSimpleIterable(source, ops);\n}\n\n/**\n * A wrapper class providing functional operations on async iterables.\n * Enables lazy evaluation and chainable transformations on async data streams.\n *\n * Key characteristics:\n * - Lazy evaluation - operations are not executed until iteration begins\n * - Chainable - all transformation methods return new AsyncIteratorObject instances\n * - Supports both sync and async transformation functions\n * - Memory efficient - processes values one at a time\n * - Operation fusion - chains execute in optimized passes\n *\n * @template T The type of values yielded by the iterator\n * @template TReturn The return type of the iterator\n * @template TNext The type of value that can be passed to next()\n *\n * @example\n * ```typescript\n * // Create from an async generator\n * async function* numbers() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const iterator = new AsyncIteratorObject(numbers())\n *   .map(x => x * 2)\n *   .filter(x => x > 2);\n *\n * for await (const value of iterator) {\n *   console.log(value); // 4, 6\n * }\n * ```\n */\nexport class AsyncIteratorObject<T, TReturn, TNext> {\n  /**\n   * Creates an AsyncIteratorObject from a synchronous iterable.\n   * Converts the sync iterable to async for uniform handling.\n   *\n   * @param iterable A synchronous iterable to convert\n   * @returns A new AsyncIteratorObject wrapping the converted iterable\n   *\n   * @example\n   * ```typescript\n   * const syncArray = [1, 2, 3, 4, 5];\n   * const asyncIterator = AsyncIteratorObject.from(syncArray);\n   *\n   * for await (const value of asyncIterator) {\n   *   console.log(value); // 1, 2, 3, 4, 5\n   * }\n   * ```\n   */\n  static from<T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIteratorObject<T, TReturn, TNext> {\n    const asyncIterable = toAsyncIterable(iterable);\n    return new AsyncIteratorObject<T, TReturn, TNext>(asyncIterable);\n  }\n\n  /**\n   * Merges multiple async iterables into a single stream.\n   * Values from all sources are interleaved as they become available.\n   * The merged iterator completes when all source iterators complete.\n   *\n   * @param iterables The async iterables to merge\n   * @returns A new AsyncIteratorObject yielding values from all sources\n   *\n   * @example\n   * ```typescript\n   * async function* source1() { yield 1; yield 3; }\n   * async function* source2() { yield 2; yield 4; }\n   *\n   * const merged = AsyncIteratorObject.merge(source1(), source2());\n   *\n   * for await (const value of merged) {\n   *   console.log(value); // Order depends on timing: 1, 2, 3, 4 or similar\n   * }\n   * ```\n   */\n  static merge<T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(mergeIterables(...iterables));\n  }\n\n  /** @internal */\n  iterable: AsyncIterable<unknown, unknown, unknown>;\n  /** @internal */\n  parent: AsyncIteratorObject<unknown, unknown, unknown> | null;\n  /** @internal */\n  op: FusedOp | null;\n  /** @internal */\n  cachedOps: FusedOp[] | null = null;\n\n  readonly [Symbol.toStringTag] = 'AsyncIteratorObject';\n\n  constructor(iterable: AsyncIterable<T, TReturn, TNext>, parent: AsyncIteratorObject<unknown, unknown, unknown> | null = null, op: FusedOp | null = null) {\n    this.iterable = iterable as AsyncIterable<unknown, unknown, unknown>;\n    this.parent = parent;\n    this.op = op;\n  }\n\n  /**\n   * Escape hatch for custom transformations not covered by the built-in operators.\n   * Materializes the fused operation chain, then applies a generator function to each value.\n   *\n   * @param generatorFactory A function that returns a generator function for transforming values\n   * @param signal Optional AbortSignal to cancel the operation\n   * @returns A new AsyncIteratorObject with transformed values\n   */\n  pipe<U>(generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>, signal?: AbortSignal): AsyncIteratorObject<U, void, unknown> {\n    const materialized = createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>);\n    const generator = pipe(materialized as AsyncIterable<T>, generatorFactory, signal);\n    return new AsyncIteratorObject<U, void, unknown>(generator);\n  }\n\n  /**\n   * Resolves promise-like values from the source iterator.\n   * Useful for normalizing values before applying type-guard predicates.\n   *\n   * @returns A new AsyncIteratorObject yielding awaited values\n   */\n  awaited(): AsyncIteratorObject<Awaited<T>, void, unknown> {\n    return new AsyncIteratorObject<Awaited<T>, void, unknown>(\n      this.iterable as AsyncIterable<Awaited<T>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.AWAITED },\n    );\n  }\n\n  /**\n   * Transforms each value using a mapping function.\n   * The callback can be synchronous or return a promise.\n   *\n   * @param callbackfn Function to transform each value\n   * @returns A new AsyncIteratorObject yielding transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const doubled = numbers.map(x => x * 2);\n   *\n   * for await (const value of doubled) {\n   *   console.log(value); // 2, 4, 6\n   * }\n   * ```\n   */\n  map<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.MAP,\n      fn: callbackfn as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Filters values based on a predicate function.\n   * Only values for which the predicate returns truthy are yielded.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding only values that pass the test\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const evens = numbers.filter(x => x % 2 === 0);\n   *\n   * for await (const value of evens) {\n   *   console.log(value); // 2, 4\n   * }\n   * ```\n   */\n  filter(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FILTER,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Combined filter and map operation. Returns undefined to skip a value.\n   * The callback result is awaited to check for undefined.\n   *\n   * @param callbackfn Function that returns a transformed value or undefined to skip\n   * @returns A new AsyncIteratorObject yielding non-undefined transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const doubledEvens = numbers.filterMap(x => x % 2 === 0 ? x * 2 : undefined);\n   *\n   * for await (const value of doubledEvens) {\n   *   console.log(value); // 4, 8\n   * }\n   * ```\n   */\n  filterMap<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown> {\n    return new AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown>(\n      this.iterable as AsyncIterable<Exclude<Awaited<U>, undefined>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.FILTER_MAP, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Executes a side-effect function for each value without modifying the stream.\n   * Useful for debugging or logging. The callback is awaited for proper sequencing.\n   *\n   * @param callbackfn Function to execute for each value\n   * @returns A new AsyncIteratorObject yielding the same values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const logged = numbers.inspect(x => console.log('value:', x)).map(x => x * 2);\n   * ```\n   */\n  inspect(callbackfn: (value: T, index: number) => unknown): AsyncIteratorObject<T, TReturn, TNext> {\n    return new AsyncIteratorObject<T, TReturn, TNext>(\n      this.iterable as AsyncIterable<T, TReturn, TNext>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.INSPECT, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Wraps each value with its index as a tuple.\n   * Useful after filtering when original indices are lost.\n   *\n   * @param start Starting index (default: 0)\n   * @returns A new AsyncIteratorObject yielding [index, value] tuples\n   *\n   * @example\n   * ```typescript\n   * const letters = AsyncIteratorObject.from(['a', 'b', 'c']);\n   * const enumerated = letters.enumerate();\n   *\n   * for await (const [i, v] of enumerated) {\n   *   console.log(i, v); // 0 'a', 1 'b', 2 'c'\n   * }\n   * ```\n   */\n  enumerate(start: number = 0): AsyncIteratorObject<[number, T], void, unknown> {\n    return new AsyncIteratorObject<[number, T], void, unknown>(\n      this.iterable as AsyncIterable<[number, T], void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.ENUMERATE, start },\n    );\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.\n   * @param limit The maximum number of values to yield.\n   */\n  take(limit: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE,\n      limit,\n    });\n  }\n\n  /**\n   * Takes values while the predicate returns truthy.\n   * Stops immediately when predicate returns falsy.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const small = numbers.takeWhile(x => x < 4);\n   *\n   * for await (const value of small) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  takeWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator after skipping the provided count.\n   * @param count The number of values to drop.\n   */\n  drop(count: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP,\n      count,\n    });\n  }\n\n  /**\n   * Skips values while the predicate returns truthy.\n   * Yields all remaining values once predicate returns falsy.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject skipping values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const afterSmall = numbers.dropWhile(x => x < 3);\n   *\n   * for await (const value of afterSmall) {\n   *   console.log(value); // 3, 4, 5\n   * }\n   * ```\n   */\n  dropWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.\n   * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.\n   */\n  flatMap<U>(callback: (value: T, index: number) => AsyncIterable<U, void, unknown>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FLAT_MAP,\n      fn: callback as (value: unknown, index: number) => AsyncIterable<unknown, void, unknown>,\n    });\n  }\n\n  /**\n   * Creates an iterator of accumulated values by applying a reducer function.\n   * Unlike Array.reduce, this returns an iterator that yields each intermediate accumulated value,\n   * not just the final result. This allows observing the accumulation process.\n   *\n   * @param callbackfn Reducer function to accumulate values\n   * @param initialValue Optional initial value for the accumulation\n   * @returns A new AsyncIteratorObject yielding accumulated values at each step\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4]);\n   * const sums = numbers.reduce((sum, x) => sum + x, 0);\n   *\n   * for await (const value of sums) {\n   *   console.log(value); // 1, 3, 6, 10 (running totals)\n   * }\n   * ```\n   */\n  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T | PromiseLike<T>): AsyncIteratorObject<T, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    initialValue: R,\n  ): AsyncIteratorObject<R, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    ...args: unknown[]\n  ): AsyncIteratorObject<R, void, unknown> {\n    const hasInit = args.length > 0;\n    return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.REDUCE,\n      fn: callbackfn as (acc: unknown, value: unknown, index: number) => unknown,\n      init: args[0],\n      hasInit,\n    });\n  }\n\n  /**\n   * Transforms each value into multiple values using an expander function.\n   * Each input value is expanded into zero or more output values.\n   * Like `flatMap` but takes sync Iterables (or Promises of Iterables) instead of AsyncIterables.\n   *\n   * @param callbackfn Function that returns an iterable of values for each input\n   * @returns A new AsyncIteratorObject yielding all expanded values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const expanded = numbers.expand(x => [x, x * 10]);\n   *\n   * for await (const value of expanded) {\n   *   console.log(value); // 1, 10, 2, 20, 3, 30\n   * }\n   * ```\n   */\n  expand<U>(callbackfn: (value: T, index: number) => Promise<Iterable<U>> | Iterable<U>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.EXPAND,\n      fn: callbackfn as (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>>,\n    });\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n    return createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>)[Symbol.asyncIterator]() as AsyncIterator<T, TReturn, TNext>;\n  }\n}\n"],"names":["AsyncIteratorObject","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","yield","expand","iterator","opIndex","flatMap","CONTINUE","Object","freeze","DONE","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","isThenable","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","asyncIterable","toAsyncIterable","merge","iterables","mergeIterables","toStringTag","pipe","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":"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"}

package/build/iterator.d.ts

@@ -316,8 +316,8 @@ export declare class AsyncIteratorObject<T, TReturn, TNext> {
      * }
      * ```
      */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): AsyncIteratorObject<T, void, unknown>;
-    reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, initialValue: R): AsyncIteratorObject<R, void, unknown>;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T | PromiseLike<T>): AsyncIteratorObject<T, void, unknown>;
+    reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>, initialValue: R): AsyncIteratorObject<R, void, unknown>;
     /**
      * Transforms each value into multiple values using an expander function.
      * Each input value is expanded into zero or more output values.

package/build/iterator.js

@@ -45,15 +45,9 @@ class ProcessResult {
         this.flatMapIterator = flatMapIterator;
         this.flatMapOpIndex = flatMapOpIndex;
     }
-    static continue() {
-        return new ProcessResult(undefined, false, false, null, -1, null, -1);
-    }
     static yield(value) {
         return new ProcessResult(value, true, false, null, -1, null, -1);
     }
-    static done() {
-        return new ProcessResult(undefined, false, true, null, -1, null, -1);
-    }
     static expand(iterator, opIndex) {
         return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);
     }
@@ -61,6 +55,8 @@ class ProcessResult {
         return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);
     }
 }
+const CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));
+const DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));
 function findTakeStates(ops, opStates) {
     const takeStates = [];
     for(let i = 0; i < ops.length; i++){
@@ -94,14 +90,14 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                 {
                     const result = op.fn(value, state.index++);
                     const passed = isThenable(result) ? await result : result;
-                    if (!passed) return ProcessResult.continue();
+                    if (!passed) return CONTINUE;
                     break;
                 }
             case 2:
                 {
                     const result = op.fn(value, state.index++);
                     const resolved = isThenable(result) ? await result : result;
-                    if (resolved === undefined) return ProcessResult.continue();
+                    if (resolved === undefined) return CONTINUE;
                     value = resolved;
                     break;
                 }
@@ -121,27 +117,27 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                 ];
                 break;
             case 6:
-                if (state.remaining <= 0) return ProcessResult.done();
+                if (state.remaining <= 0) return DONE;
                 state.remaining--;
                 break;
             case 8:
                 {
                     const result = op.fn(value, state.index++);
                     const passed = isThenable(result) ? await result : result;
-                    if (!passed) return ProcessResult.done();
+                    if (!passed) return DONE;
                     break;
                 }
             case 7:
                 if (state.remaining > 0) {
                     state.remaining--;
-                    return ProcessResult.continue();
+                    return CONTINUE;
                 }
                 break;
             case 9:
                 if (state.dropping) {
                     const result = op.fn(value, state.index++);
                     const passed = isThenable(result) ? await result : result;
-                    if (passed) return ProcessResult.continue();
+                    if (passed) return CONTINUE;
                     state.dropping = false;
                 }
                 break;
@@ -155,7 +151,7 @@ async function processOps(inputValue, ops, opStates, startIndex) {
                             value = state.value;
                         } else {
                             state.value = value;
-                            return ProcessResult.continue();
+                            return CONTINUE;
                         }
                     } else {
                         const result = op.fn(state.value, value, state.index++);

package/build/iterator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { AnyIterable } from './types.js';\n\nconst enum OpKind {\n  MAP,\n  FILTER,\n  FILTER_MAP,\n  AWAITED,\n  INSPECT,\n  ENUMERATE,\n  TAKE,\n  DROP,\n  TAKE_WHILE,\n  DROP_WHILE,\n  REDUCE,\n  FLAT_MAP,\n  EXPAND,\n}\n\n/**\n * @internal\n * Represents a fusible operation that can be combined with other operations.\n */\ntype FusedOp =\n  | { kind: OpKind.MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER_MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.AWAITED }\n  | { kind: OpKind.INSPECT; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.ENUMERATE; start: number }\n  | { kind: OpKind.TAKE; limit: number }\n  | { kind: OpKind.DROP; count: number }\n  | { kind: OpKind.TAKE_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.DROP_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.REDUCE; fn: (acc: unknown, value: unknown, index: number) => unknown; init: unknown; hasInit: boolean }\n  | { kind: OpKind.FLAT_MAP; fn: (value: unknown, index: number) => AsyncIterable<unknown, void, unknown> }\n  | { kind: OpKind.EXPAND; fn: (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>> };\n\nclass OpState {\n  initialized = false;\n\n  constructor(\n    public index: number,\n    public remaining: number,\n    public dropping: boolean,\n    public value: unknown,\n  ) {}\n\n  static from(this: void, op: FusedOp): OpState {\n    switch (op.kind) {\n      case OpKind.ENUMERATE:\n        return new OpState(op.start, 0, false, undefined);\n      case OpKind.TAKE:\n        return new OpState(0, op.limit, false, undefined);\n      case OpKind.DROP:\n        return new OpState(0, op.count, false, undefined);\n      case OpKind.DROP_WHILE:\n        return new OpState(0, 0, true, undefined);\n      case OpKind.REDUCE:\n        return new OpState(0, 0, false, op.init);\n      default:\n        return new OpState(0, 0, false, undefined);\n    }\n  }\n}\n\nclass ProcessResult {\n  constructor(\n    readonly value: unknown,\n    readonly shouldYield: boolean,\n    readonly done: boolean,\n    readonly expandIterator: Iterator<unknown> | null,\n    readonly expandOpIndex: number,\n    readonly flatMapIterator: AsyncIterator<unknown> | null,\n    readonly flatMapOpIndex: number,\n  ) {}\n\n  static continue(): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, null, -1);\n  }\n\n  static yield(value: unknown): ProcessResult {\n    return new ProcessResult(value, true, false, null, -1, null, -1);\n  }\n\n  static done(): ProcessResult {\n    return new ProcessResult(undefined, false, true, null, -1, null, -1);\n  }\n\n  static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);\n  }\n\n  static flatMap(iterator: AsyncIterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);\n  }\n}\n\nfunction findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {\n  const takeStates: OpState[] = [];\n  for (let i = 0; i < ops.length; i++) {\n    if (ops[i].kind === OpKind.TAKE) takeStates.push(opStates[i]);\n  }\n  return takeStates;\n}\n\nfunction hasExpandingOps(ops: FusedOp[]): boolean {\n  for (let i = 0; i < ops.length; i++) {\n    const kind = ops[i].kind;\n    if (kind === OpKind.FLAT_MAP || kind === OpKind.EXPAND) return true;\n  }\n  return false;\n}\n\nfunction checkTakeExhausted(takeStates: OpState[]): boolean {\n  for (let i = 0; i < takeStates.length; i++) {\n    if (takeStates[i].remaining <= 0) return true;\n  }\n  return false;\n}\n\nasync function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState[], startIndex: number): Promise<ProcessResult> {\n  let value = inputValue;\n\n  for (let i = startIndex; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return ProcessResult.continue();\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return ProcessResult.continue();\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        if (state.remaining <= 0) return ProcessResult.done();\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return ProcessResult.done();\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return ProcessResult.continue();\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return ProcessResult.continue();\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if (op.hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return ProcessResult.continue();\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n\n      case OpKind.FLAT_MAP: {\n        const iterable = op.fn(value, state.index++);\n        return ProcessResult.flatMap(iterable[Symbol.asyncIterator](), i);\n      }\n\n      case OpKind.EXPAND: {\n        const result = op.fn(value, state.index++);\n        const expanded = isThenable(result) ? await result : result;\n        return ProcessResult.expand(expanded[Symbol.iterator](), i);\n      }\n    }\n  }\n\n  return ProcessResult.yield(value);\n}\n\nasync function processOpsSimple(inputValue: unknown, ops: FusedOp[], opStates: OpState[]): Promise<{ value: unknown; shouldYield: boolean; done: boolean }> {\n  let value = inputValue;\n\n  for (let i = 0; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: false };\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return { value: undefined, shouldYield: false, done: false };\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: true };\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return { value: undefined, shouldYield: false, done: false };\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return { value: undefined, shouldYield: false, done: false };\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if ((op as { hasInit: boolean }).hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return { value: undefined, shouldYield: false, done: false };\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n    }\n  }\n\n  return { value, shouldYield: true, done: false };\n}\n\nfunction collectOps(iter: AsyncIteratorObject<unknown, unknown, unknown>): FusedOp[] {\n  const ops: FusedOp[] = [];\n  let current: AsyncIteratorObject<unknown, unknown, unknown> | null = iter;\n  while (current) {\n    const op = current.op;\n    if (op) ops.push(op);\n    current = current.parent;\n  }\n  ops.reverse();\n  return ops;\n}\n\nfunction getSource(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, unknown, unknown> {\n  let current = iter;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current.iterable;\n}\n\nfunction createSimpleIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n      let done = false;\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\ntype InnerFrame = { type: 'expand'; iterator: Iterator<unknown>; opIndex: number } | { type: 'flatMap'; iterator: AsyncIterator<unknown>; opIndex: number };\n\nfunction createExpandingIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n\n      let done = false;\n      const innerStack: InnerFrame[] = [];\n\n      const closeInnerIterators = async () => {\n        for (const frame of innerStack) {\n          if (frame.type === 'flatMap') {\n            await frame.iterator.return?.();\n          }\n        }\n        innerStack.length = 0;\n      };\n\n      const handleResult = async (result: ProcessResult): Promise<IteratorResult<unknown, void> | null> => {\n        if (result.done) {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.();\n          return { value: undefined, done: true };\n        }\n        if (result.expandIterator) {\n          innerStack.push({ type: 'expand', iterator: result.expandIterator, opIndex: result.expandOpIndex });\n          return null;\n        }\n        if (result.flatMapIterator) {\n          innerStack.push({ type: 'flatMap', iterator: result.flatMapIterator, opIndex: result.flatMapOpIndex });\n          return null;\n        }\n        if (result.shouldYield) {\n          return { value: result.value, done: false };\n        }\n        return null;\n      };\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (innerStack.length > 0) {\n              const frame = innerStack[innerStack.length - 1];\n              if (frame.type === 'expand') {\n                const expandResult = frame.iterator.next();\n                if (!expandResult.done) {\n                  const result = await processOps(expandResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              } else {\n                const flatMapResult = await frame.iterator.next();\n                if (!flatMapResult.done) {\n                  const result = await processOps(flatMapResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              }\n            }\n\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOps(sourceResult.value, ops, opStates, 0);\n            const handled = await handleResult(result);\n            if (handled) return handled;\n          }\n\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\nfunction createFusedIterable(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, void, unknown> {\n  const source = getSource(iter);\n  const ops = iter.cachedOps ?? (iter.cachedOps = collectOps(iter));\n\n  if (ops.length === 0) {\n    return source as AsyncIterable<unknown, void, unknown>;\n  }\n\n  return hasExpandingOps(ops) ? createExpandingIterable(source, ops) : createSimpleIterable(source, ops);\n}\n\n/**\n * A wrapper class providing functional operations on async iterables.\n * Enables lazy evaluation and chainable transformations on async data streams.\n *\n * Key characteristics:\n * - Lazy evaluation - operations are not executed until iteration begins\n * - Chainable - all transformation methods return new AsyncIteratorObject instances\n * - Supports both sync and async transformation functions\n * - Memory efficient - processes values one at a time\n * - Operation fusion - chains execute in optimized passes\n *\n * @template T The type of values yielded by the iterator\n * @template TReturn The return type of the iterator\n * @template TNext The type of value that can be passed to next()\n *\n * @example\n * ```typescript\n * // Create from an async generator\n * async function* numbers() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const iterator = new AsyncIteratorObject(numbers())\n *   .map(x => x * 2)\n *   .filter(x => x > 2);\n *\n * for await (const value of iterator) {\n *   console.log(value); // 4, 6\n * }\n * ```\n */\nexport class AsyncIteratorObject<T, TReturn, TNext> {\n  /**\n   * Creates an AsyncIteratorObject from a synchronous iterable.\n   * Converts the sync iterable to async for uniform handling.\n   *\n   * @param iterable A synchronous iterable to convert\n   * @returns A new AsyncIteratorObject wrapping the converted iterable\n   *\n   * @example\n   * ```typescript\n   * const syncArray = [1, 2, 3, 4, 5];\n   * const asyncIterator = AsyncIteratorObject.from(syncArray);\n   *\n   * for await (const value of asyncIterator) {\n   *   console.log(value); // 1, 2, 3, 4, 5\n   * }\n   * ```\n   */\n  static from<T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIteratorObject<T, TReturn, TNext> {\n    const asyncIterable = toAsyncIterable(iterable);\n    return new AsyncIteratorObject<T, TReturn, TNext>(asyncIterable);\n  }\n\n  /**\n   * Merges multiple async iterables into a single stream.\n   * Values from all sources are interleaved as they become available.\n   * The merged iterator completes when all source iterators complete.\n   *\n   * @param iterables The async iterables to merge\n   * @returns A new AsyncIteratorObject yielding values from all sources\n   *\n   * @example\n   * ```typescript\n   * async function* source1() { yield 1; yield 3; }\n   * async function* source2() { yield 2; yield 4; }\n   *\n   * const merged = AsyncIteratorObject.merge(source1(), source2());\n   *\n   * for await (const value of merged) {\n   *   console.log(value); // Order depends on timing: 1, 2, 3, 4 or similar\n   * }\n   * ```\n   */\n  static merge<T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(mergeIterables(...iterables));\n  }\n\n  /** @internal */\n  iterable: AsyncIterable<unknown, unknown, unknown>;\n  /** @internal */\n  parent: AsyncIteratorObject<unknown, unknown, unknown> | null;\n  /** @internal */\n  op: FusedOp | null;\n  /** @internal */\n  cachedOps: FusedOp[] | null = null;\n\n  readonly [Symbol.toStringTag] = 'AsyncIteratorObject';\n\n  constructor(iterable: AsyncIterable<T, TReturn, TNext>, parent: AsyncIteratorObject<unknown, unknown, unknown> | null = null, op: FusedOp | null = null) {\n    this.iterable = iterable as AsyncIterable<unknown, unknown, unknown>;\n    this.parent = parent;\n    this.op = op;\n  }\n\n  /**\n   * Escape hatch for custom transformations not covered by the built-in operators.\n   * Materializes the fused operation chain, then applies a generator function to each value.\n   *\n   * @param generatorFactory A function that returns a generator function for transforming values\n   * @param signal Optional AbortSignal to cancel the operation\n   * @returns A new AsyncIteratorObject with transformed values\n   */\n  pipe<U>(generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>, signal?: AbortSignal): AsyncIteratorObject<U, void, unknown> {\n    const materialized = createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>);\n    const generator = pipe(materialized as AsyncIterable<T>, generatorFactory, signal);\n    return new AsyncIteratorObject<U, void, unknown>(generator);\n  }\n\n  /**\n   * Resolves promise-like values from the source iterator.\n   * Useful for normalizing values before applying type-guard predicates.\n   *\n   * @returns A new AsyncIteratorObject yielding awaited values\n   */\n  awaited(): AsyncIteratorObject<Awaited<T>, void, unknown> {\n    return new AsyncIteratorObject<Awaited<T>, void, unknown>(\n      this.iterable as AsyncIterable<Awaited<T>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.AWAITED },\n    );\n  }\n\n  /**\n   * Transforms each value using a mapping function.\n   * The callback can be synchronous or return a promise.\n   *\n   * @param callbackfn Function to transform each value\n   * @returns A new AsyncIteratorObject yielding transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const doubled = numbers.map(x => x * 2);\n   *\n   * for await (const value of doubled) {\n   *   console.log(value); // 2, 4, 6\n   * }\n   * ```\n   */\n  map<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.MAP,\n      fn: callbackfn as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Filters values based on a predicate function.\n   * Only values for which the predicate returns truthy are yielded.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding only values that pass the test\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const evens = numbers.filter(x => x % 2 === 0);\n   *\n   * for await (const value of evens) {\n   *   console.log(value); // 2, 4\n   * }\n   * ```\n   */\n  filter(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FILTER,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Combined filter and map operation. Returns undefined to skip a value.\n   * The callback result is awaited to check for undefined.\n   *\n   * @param callbackfn Function that returns a transformed value or undefined to skip\n   * @returns A new AsyncIteratorObject yielding non-undefined transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const doubledEvens = numbers.filterMap(x => x % 2 === 0 ? x * 2 : undefined);\n   *\n   * for await (const value of doubledEvens) {\n   *   console.log(value); // 4, 8\n   * }\n   * ```\n   */\n  filterMap<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown> {\n    return new AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown>(\n      this.iterable as AsyncIterable<Exclude<Awaited<U>, undefined>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.FILTER_MAP, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Executes a side-effect function for each value without modifying the stream.\n   * Useful for debugging or logging. The callback is awaited for proper sequencing.\n   *\n   * @param callbackfn Function to execute for each value\n   * @returns A new AsyncIteratorObject yielding the same values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const logged = numbers.inspect(x => console.log('value:', x)).map(x => x * 2);\n   * ```\n   */\n  inspect(callbackfn: (value: T, index: number) => unknown): AsyncIteratorObject<T, TReturn, TNext> {\n    return new AsyncIteratorObject<T, TReturn, TNext>(\n      this.iterable as AsyncIterable<T, TReturn, TNext>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.INSPECT, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Wraps each value with its index as a tuple.\n   * Useful after filtering when original indices are lost.\n   *\n   * @param start Starting index (default: 0)\n   * @returns A new AsyncIteratorObject yielding [index, value] tuples\n   *\n   * @example\n   * ```typescript\n   * const letters = AsyncIteratorObject.from(['a', 'b', 'c']);\n   * const enumerated = letters.enumerate();\n   *\n   * for await (const [i, v] of enumerated) {\n   *   console.log(i, v); // 0 'a', 1 'b', 2 'c'\n   * }\n   * ```\n   */\n  enumerate(start: number = 0): AsyncIteratorObject<[number, T], void, unknown> {\n    return new AsyncIteratorObject<[number, T], void, unknown>(\n      this.iterable as AsyncIterable<[number, T], void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.ENUMERATE, start },\n    );\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.\n   * @param limit The maximum number of values to yield.\n   */\n  take(limit: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE,\n      limit,\n    });\n  }\n\n  /**\n   * Takes values while the predicate returns truthy.\n   * Stops immediately when predicate returns falsy.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const small = numbers.takeWhile(x => x < 4);\n   *\n   * for await (const value of small) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  takeWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator after skipping the provided count.\n   * @param count The number of values to drop.\n   */\n  drop(count: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP,\n      count,\n    });\n  }\n\n  /**\n   * Skips values while the predicate returns truthy.\n   * Yields all remaining values once predicate returns falsy.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject skipping values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const afterSmall = numbers.dropWhile(x => x < 3);\n   *\n   * for await (const value of afterSmall) {\n   *   console.log(value); // 3, 4, 5\n   * }\n   * ```\n   */\n  dropWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.\n   * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.\n   */\n  flatMap<U>(callback: (value: T, index: number) => AsyncIterable<U, void, unknown>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FLAT_MAP,\n      fn: callback as (value: unknown, index: number) => AsyncIterable<unknown, void, unknown>,\n    });\n  }\n\n  /**\n   * Creates an iterator of accumulated values by applying a reducer function.\n   * Unlike Array.reduce, this returns an iterator that yields each intermediate accumulated value,\n   * not just the final result. This allows observing the accumulation process.\n   *\n   * @param callbackfn Reducer function to accumulate values\n   * @param initialValue Optional initial value for the accumulation\n   * @returns A new AsyncIteratorObject yielding accumulated values at each step\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4]);\n   * const sums = numbers.reduce((sum, x) => sum + x, 0);\n   *\n   * for await (const value of sums) {\n   *   console.log(value); // 1, 3, 6, 10 (running totals)\n   * }\n   * ```\n   */\n  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): AsyncIteratorObject<T, void, unknown>;\n  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, initialValue: R): AsyncIteratorObject<R, void, unknown>;\n  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, ...args: unknown[]): AsyncIteratorObject<R, void, unknown> {\n    const hasInit = args.length > 0;\n    return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.REDUCE,\n      fn: callbackfn as (acc: unknown, value: unknown, index: number) => unknown,\n      init: args[0],\n      hasInit,\n    });\n  }\n\n  /**\n   * Transforms each value into multiple values using an expander function.\n   * Each input value is expanded into zero or more output values.\n   * Like `flatMap` but takes sync Iterables (or Promises of Iterables) instead of AsyncIterables.\n   *\n   * @param callbackfn Function that returns an iterable of values for each input\n   * @returns A new AsyncIteratorObject yielding all expanded values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const expanded = numbers.expand(x => [x, x * 10]);\n   *\n   * for await (const value of expanded) {\n   *   console.log(value); // 1, 10, 2, 20, 3, 30\n   * }\n   * ```\n   */\n  expand<U>(callbackfn: (value: T, index: number) => Promise<Iterable<U>> | Iterable<U>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.EXPAND,\n      fn: callbackfn as (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>>,\n    });\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n    return createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>)[Symbol.asyncIterator]() as AsyncIterator<T, TReturn, TNext>;\n  }\n}\n"],"names":["mergeIterables","toAsyncIterable","pipe","isThenable","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","continue","yield","expand","iterator","opIndex","flatMap","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","AsyncIteratorObject","asyncIterable","merge","iterables","toStringTag","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":"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"}
+{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { AnyIterable } from './types.js';\n\nconst enum OpKind {\n  MAP,\n  FILTER,\n  FILTER_MAP,\n  AWAITED,\n  INSPECT,\n  ENUMERATE,\n  TAKE,\n  DROP,\n  TAKE_WHILE,\n  DROP_WHILE,\n  REDUCE,\n  FLAT_MAP,\n  EXPAND,\n}\n\n/**\n * @internal\n * Represents a fusible operation that can be combined with other operations.\n */\ntype FusedOp =\n  | { kind: OpKind.MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER_MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.AWAITED }\n  | { kind: OpKind.INSPECT; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.ENUMERATE; start: number }\n  | { kind: OpKind.TAKE; limit: number }\n  | { kind: OpKind.DROP; count: number }\n  | { kind: OpKind.TAKE_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.DROP_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.REDUCE; fn: (acc: unknown, value: unknown, index: number) => unknown; init: unknown; hasInit: boolean }\n  | { kind: OpKind.FLAT_MAP; fn: (value: unknown, index: number) => AsyncIterable<unknown, void, unknown> }\n  | { kind: OpKind.EXPAND; fn: (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>> };\n\nclass OpState {\n  initialized = false;\n\n  constructor(\n    public index: number,\n    public remaining: number,\n    public dropping: boolean,\n    public value: unknown,\n  ) {}\n\n  static from(this: void, op: FusedOp): OpState {\n    switch (op.kind) {\n      case OpKind.ENUMERATE:\n        return new OpState(op.start, 0, false, undefined);\n      case OpKind.TAKE:\n        return new OpState(0, op.limit, false, undefined);\n      case OpKind.DROP:\n        return new OpState(0, op.count, false, undefined);\n      case OpKind.DROP_WHILE:\n        return new OpState(0, 0, true, undefined);\n      case OpKind.REDUCE:\n        return new OpState(0, 0, false, op.init);\n      default:\n        return new OpState(0, 0, false, undefined);\n    }\n  }\n}\n\nclass ProcessResult {\n  constructor(\n    readonly value: unknown,\n    readonly shouldYield: boolean,\n    readonly done: boolean,\n    readonly expandIterator: Iterator<unknown> | null,\n    readonly expandOpIndex: number,\n    readonly flatMapIterator: AsyncIterator<unknown> | null,\n    readonly flatMapOpIndex: number,\n  ) {}\n\n  static yield(value: unknown): ProcessResult {\n    return new ProcessResult(value, true, false, null, -1, null, -1);\n  }\n\n  static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);\n  }\n\n  static flatMap(iterator: AsyncIterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);\n  }\n}\n\nconst CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));\nconst DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));\n\nfunction findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {\n  const takeStates: OpState[] = [];\n  for (let i = 0; i < ops.length; i++) {\n    if (ops[i].kind === OpKind.TAKE) takeStates.push(opStates[i]);\n  }\n  return takeStates;\n}\n\nfunction hasExpandingOps(ops: FusedOp[]): boolean {\n  for (let i = 0; i < ops.length; i++) {\n    const kind = ops[i].kind;\n    if (kind === OpKind.FLAT_MAP || kind === OpKind.EXPAND) return true;\n  }\n  return false;\n}\n\nfunction checkTakeExhausted(takeStates: OpState[]): boolean {\n  for (let i = 0; i < takeStates.length; i++) {\n    if (takeStates[i].remaining <= 0) return true;\n  }\n  return false;\n}\n\nasync function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState[], startIndex: number): Promise<ProcessResult> {\n  let value = inputValue;\n\n  for (let i = startIndex; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return CONTINUE;\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return CONTINUE;\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        if (state.remaining <= 0) return DONE;\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return DONE;\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return CONTINUE;\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return CONTINUE;\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if (op.hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return CONTINUE;\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n\n      case OpKind.FLAT_MAP: {\n        const iterable = op.fn(value, state.index++);\n        return ProcessResult.flatMap(iterable[Symbol.asyncIterator](), i);\n      }\n\n      case OpKind.EXPAND: {\n        const result = op.fn(value, state.index++);\n        const expanded = isThenable(result) ? await result : result;\n        return ProcessResult.expand(expanded[Symbol.iterator](), i);\n      }\n    }\n  }\n\n  return ProcessResult.yield(value);\n}\n\nasync function processOpsSimple(inputValue: unknown, ops: FusedOp[], opStates: OpState[]): Promise<{ value: unknown; shouldYield: boolean; done: boolean }> {\n  let value = inputValue;\n\n  for (let i = 0; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: false };\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return { value: undefined, shouldYield: false, done: false };\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: true };\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return { value: undefined, shouldYield: false, done: false };\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return { value: undefined, shouldYield: false, done: false };\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if ((op as { hasInit: boolean }).hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return { value: undefined, shouldYield: false, done: false };\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n    }\n  }\n\n  return { value, shouldYield: true, done: false };\n}\n\nfunction collectOps(iter: AsyncIteratorObject<unknown, unknown, unknown>): FusedOp[] {\n  const ops: FusedOp[] = [];\n  let current: AsyncIteratorObject<unknown, unknown, unknown> | null = iter;\n  while (current) {\n    const op = current.op;\n    if (op) ops.push(op);\n    current = current.parent;\n  }\n  ops.reverse();\n  return ops;\n}\n\nfunction getSource(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, unknown, unknown> {\n  let current = iter;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current.iterable;\n}\n\nfunction createSimpleIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n      let done = false;\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\ntype InnerFrame = { type: 'expand'; iterator: Iterator<unknown>; opIndex: number } | { type: 'flatMap'; iterator: AsyncIterator<unknown>; opIndex: number };\n\nfunction createExpandingIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n\n      let done = false;\n      const innerStack: InnerFrame[] = [];\n\n      const closeInnerIterators = async () => {\n        for (const frame of innerStack) {\n          if (frame.type === 'flatMap') {\n            await frame.iterator.return?.();\n          }\n        }\n        innerStack.length = 0;\n      };\n\n      const handleResult = async (result: ProcessResult): Promise<IteratorResult<unknown, void> | null> => {\n        if (result.done) {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.();\n          return { value: undefined, done: true };\n        }\n        if (result.expandIterator) {\n          innerStack.push({ type: 'expand', iterator: result.expandIterator, opIndex: result.expandOpIndex });\n          return null;\n        }\n        if (result.flatMapIterator) {\n          innerStack.push({ type: 'flatMap', iterator: result.flatMapIterator, opIndex: result.flatMapOpIndex });\n          return null;\n        }\n        if (result.shouldYield) {\n          return { value: result.value, done: false };\n        }\n        return null;\n      };\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (innerStack.length > 0) {\n              const frame = innerStack[innerStack.length - 1];\n              if (frame.type === 'expand') {\n                const expandResult = frame.iterator.next();\n                if (!expandResult.done) {\n                  const result = await processOps(expandResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              } else {\n                const flatMapResult = await frame.iterator.next();\n                if (!flatMapResult.done) {\n                  const result = await processOps(flatMapResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              }\n            }\n\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOps(sourceResult.value, ops, opStates, 0);\n            const handled = await handleResult(result);\n            if (handled) return handled;\n          }\n\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\nfunction createFusedIterable(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, void, unknown> {\n  const source = getSource(iter);\n  const ops = iter.cachedOps ?? (iter.cachedOps = collectOps(iter));\n\n  if (ops.length === 0) {\n    return source as AsyncIterable<unknown, void, unknown>;\n  }\n\n  return hasExpandingOps(ops) ? createExpandingIterable(source, ops) : createSimpleIterable(source, ops);\n}\n\n/**\n * A wrapper class providing functional operations on async iterables.\n * Enables lazy evaluation and chainable transformations on async data streams.\n *\n * Key characteristics:\n * - Lazy evaluation - operations are not executed until iteration begins\n * - Chainable - all transformation methods return new AsyncIteratorObject instances\n * - Supports both sync and async transformation functions\n * - Memory efficient - processes values one at a time\n * - Operation fusion - chains execute in optimized passes\n *\n * @template T The type of values yielded by the iterator\n * @template TReturn The return type of the iterator\n * @template TNext The type of value that can be passed to next()\n *\n * @example\n * ```typescript\n * // Create from an async generator\n * async function* numbers() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const iterator = new AsyncIteratorObject(numbers())\n *   .map(x => x * 2)\n *   .filter(x => x > 2);\n *\n * for await (const value of iterator) {\n *   console.log(value); // 4, 6\n * }\n * ```\n */\nexport class AsyncIteratorObject<T, TReturn, TNext> {\n  /**\n   * Creates an AsyncIteratorObject from a synchronous iterable.\n   * Converts the sync iterable to async for uniform handling.\n   *\n   * @param iterable A synchronous iterable to convert\n   * @returns A new AsyncIteratorObject wrapping the converted iterable\n   *\n   * @example\n   * ```typescript\n   * const syncArray = [1, 2, 3, 4, 5];\n   * const asyncIterator = AsyncIteratorObject.from(syncArray);\n   *\n   * for await (const value of asyncIterator) {\n   *   console.log(value); // 1, 2, 3, 4, 5\n   * }\n   * ```\n   */\n  static from<T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIteratorObject<T, TReturn, TNext> {\n    const asyncIterable = toAsyncIterable(iterable);\n    return new AsyncIteratorObject<T, TReturn, TNext>(asyncIterable);\n  }\n\n  /**\n   * Merges multiple async iterables into a single stream.\n   * Values from all sources are interleaved as they become available.\n   * The merged iterator completes when all source iterators complete.\n   *\n   * @param iterables The async iterables to merge\n   * @returns A new AsyncIteratorObject yielding values from all sources\n   *\n   * @example\n   * ```typescript\n   * async function* source1() { yield 1; yield 3; }\n   * async function* source2() { yield 2; yield 4; }\n   *\n   * const merged = AsyncIteratorObject.merge(source1(), source2());\n   *\n   * for await (const value of merged) {\n   *   console.log(value); // Order depends on timing: 1, 2, 3, 4 or similar\n   * }\n   * ```\n   */\n  static merge<T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(mergeIterables(...iterables));\n  }\n\n  /** @internal */\n  iterable: AsyncIterable<unknown, unknown, unknown>;\n  /** @internal */\n  parent: AsyncIteratorObject<unknown, unknown, unknown> | null;\n  /** @internal */\n  op: FusedOp | null;\n  /** @internal */\n  cachedOps: FusedOp[] | null = null;\n\n  readonly [Symbol.toStringTag] = 'AsyncIteratorObject';\n\n  constructor(iterable: AsyncIterable<T, TReturn, TNext>, parent: AsyncIteratorObject<unknown, unknown, unknown> | null = null, op: FusedOp | null = null) {\n    this.iterable = iterable as AsyncIterable<unknown, unknown, unknown>;\n    this.parent = parent;\n    this.op = op;\n  }\n\n  /**\n   * Escape hatch for custom transformations not covered by the built-in operators.\n   * Materializes the fused operation chain, then applies a generator function to each value.\n   *\n   * @param generatorFactory A function that returns a generator function for transforming values\n   * @param signal Optional AbortSignal to cancel the operation\n   * @returns A new AsyncIteratorObject with transformed values\n   */\n  pipe<U>(generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>, signal?: AbortSignal): AsyncIteratorObject<U, void, unknown> {\n    const materialized = createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>);\n    const generator = pipe(materialized as AsyncIterable<T>, generatorFactory, signal);\n    return new AsyncIteratorObject<U, void, unknown>(generator);\n  }\n\n  /**\n   * Resolves promise-like values from the source iterator.\n   * Useful for normalizing values before applying type-guard predicates.\n   *\n   * @returns A new AsyncIteratorObject yielding awaited values\n   */\n  awaited(): AsyncIteratorObject<Awaited<T>, void, unknown> {\n    return new AsyncIteratorObject<Awaited<T>, void, unknown>(\n      this.iterable as AsyncIterable<Awaited<T>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.AWAITED },\n    );\n  }\n\n  /**\n   * Transforms each value using a mapping function.\n   * The callback can be synchronous or return a promise.\n   *\n   * @param callbackfn Function to transform each value\n   * @returns A new AsyncIteratorObject yielding transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const doubled = numbers.map(x => x * 2);\n   *\n   * for await (const value of doubled) {\n   *   console.log(value); // 2, 4, 6\n   * }\n   * ```\n   */\n  map<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.MAP,\n      fn: callbackfn as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Filters values based on a predicate function.\n   * Only values for which the predicate returns truthy are yielded.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding only values that pass the test\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const evens = numbers.filter(x => x % 2 === 0);\n   *\n   * for await (const value of evens) {\n   *   console.log(value); // 2, 4\n   * }\n   * ```\n   */\n  filter(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FILTER,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Combined filter and map operation. Returns undefined to skip a value.\n   * The callback result is awaited to check for undefined.\n   *\n   * @param callbackfn Function that returns a transformed value or undefined to skip\n   * @returns A new AsyncIteratorObject yielding non-undefined transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const doubledEvens = numbers.filterMap(x => x % 2 === 0 ? x * 2 : undefined);\n   *\n   * for await (const value of doubledEvens) {\n   *   console.log(value); // 4, 8\n   * }\n   * ```\n   */\n  filterMap<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown> {\n    return new AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown>(\n      this.iterable as AsyncIterable<Exclude<Awaited<U>, undefined>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.FILTER_MAP, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Executes a side-effect function for each value without modifying the stream.\n   * Useful for debugging or logging. The callback is awaited for proper sequencing.\n   *\n   * @param callbackfn Function to execute for each value\n   * @returns A new AsyncIteratorObject yielding the same values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const logged = numbers.inspect(x => console.log('value:', x)).map(x => x * 2);\n   * ```\n   */\n  inspect(callbackfn: (value: T, index: number) => unknown): AsyncIteratorObject<T, TReturn, TNext> {\n    return new AsyncIteratorObject<T, TReturn, TNext>(\n      this.iterable as AsyncIterable<T, TReturn, TNext>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.INSPECT, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Wraps each value with its index as a tuple.\n   * Useful after filtering when original indices are lost.\n   *\n   * @param start Starting index (default: 0)\n   * @returns A new AsyncIteratorObject yielding [index, value] tuples\n   *\n   * @example\n   * ```typescript\n   * const letters = AsyncIteratorObject.from(['a', 'b', 'c']);\n   * const enumerated = letters.enumerate();\n   *\n   * for await (const [i, v] of enumerated) {\n   *   console.log(i, v); // 0 'a', 1 'b', 2 'c'\n   * }\n   * ```\n   */\n  enumerate(start: number = 0): AsyncIteratorObject<[number, T], void, unknown> {\n    return new AsyncIteratorObject<[number, T], void, unknown>(\n      this.iterable as AsyncIterable<[number, T], void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.ENUMERATE, start },\n    );\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.\n   * @param limit The maximum number of values to yield.\n   */\n  take(limit: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE,\n      limit,\n    });\n  }\n\n  /**\n   * Takes values while the predicate returns truthy.\n   * Stops immediately when predicate returns falsy.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const small = numbers.takeWhile(x => x < 4);\n   *\n   * for await (const value of small) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  takeWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator after skipping the provided count.\n   * @param count The number of values to drop.\n   */\n  drop(count: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP,\n      count,\n    });\n  }\n\n  /**\n   * Skips values while the predicate returns truthy.\n   * Yields all remaining values once predicate returns falsy.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject skipping values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const afterSmall = numbers.dropWhile(x => x < 3);\n   *\n   * for await (const value of afterSmall) {\n   *   console.log(value); // 3, 4, 5\n   * }\n   * ```\n   */\n  dropWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.\n   * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.\n   */\n  flatMap<U>(callback: (value: T, index: number) => AsyncIterable<U, void, unknown>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FLAT_MAP,\n      fn: callback as (value: unknown, index: number) => AsyncIterable<unknown, void, unknown>,\n    });\n  }\n\n  /**\n   * Creates an iterator of accumulated values by applying a reducer function.\n   * Unlike Array.reduce, this returns an iterator that yields each intermediate accumulated value,\n   * not just the final result. This allows observing the accumulation process.\n   *\n   * @param callbackfn Reducer function to accumulate values\n   * @param initialValue Optional initial value for the accumulation\n   * @returns A new AsyncIteratorObject yielding accumulated values at each step\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4]);\n   * const sums = numbers.reduce((sum, x) => sum + x, 0);\n   *\n   * for await (const value of sums) {\n   *   console.log(value); // 1, 3, 6, 10 (running totals)\n   * }\n   * ```\n   */\n  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T | PromiseLike<T>): AsyncIteratorObject<T, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    initialValue: R,\n  ): AsyncIteratorObject<R, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    ...args: unknown[]\n  ): AsyncIteratorObject<R, void, unknown> {\n    const hasInit = args.length > 0;\n    return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.REDUCE,\n      fn: callbackfn as (acc: unknown, value: unknown, index: number) => unknown,\n      init: args[0],\n      hasInit,\n    });\n  }\n\n  /**\n   * Transforms each value into multiple values using an expander function.\n   * Each input value is expanded into zero or more output values.\n   * Like `flatMap` but takes sync Iterables (or Promises of Iterables) instead of AsyncIterables.\n   *\n   * @param callbackfn Function that returns an iterable of values for each input\n   * @returns A new AsyncIteratorObject yielding all expanded values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const expanded = numbers.expand(x => [x, x * 10]);\n   *\n   * for await (const value of expanded) {\n   *   console.log(value); // 1, 10, 2, 20, 3, 30\n   * }\n   * ```\n   */\n  expand<U>(callbackfn: (value: T, index: number) => Promise<Iterable<U>> | Iterable<U>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.EXPAND,\n      fn: callbackfn as (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>>,\n    });\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n    return createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>)[Symbol.asyncIterator]() as AsyncIterator<T, TReturn, TNext>;\n  }\n}\n"],"names":["mergeIterables","toAsyncIterable","pipe","isThenable","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","yield","expand","iterator","opIndex","flatMap","CONTINUE","Object","freeze","DONE","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","AsyncIteratorObject","asyncIterable","merge","iterables","toStringTag","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evnty",
   "description": "Async-first, reactive event handling library for complex event flows in browser and Node.js",
-  "version": "5.2.19",
+  "version": "5.3.1",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -58,13 +58,13 @@
     "@typescript-eslint/eslint-plugin": "^8.58.0",
     "@typescript-eslint/parser": "^8.58.0",
     "@typescript-eslint/typescript-estree": "^8.58.0",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@vitest/coverage-v8": "^4.1.3",
     "@vuepress/bundler-vite": "2.0.0-rc.28",
     "@vuepress/theme-default": "2.0.0-rc.128",
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
-    "evnty-release": "npm:evnty@^5.2.18",
+    "evnty-release": "npm:evnty@^5.3.0",
     "inop": "^0.9.0",
     "overtake": "2.1.1",
     "prettier": "^3.8.1",
@@ -72,7 +72,7 @@
     "sass-embedded": "^1.99.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",
-    "vitest": "^4.1.2",
+    "vitest": "^4.1.3",
     "vue": "^3.5.32",
     "vuepress": "2.0.0-rc.28"
   },

package/src/iterator.ts

@@ -75,18 +75,10 @@ class ProcessResult {
     readonly flatMapOpIndex: number,
   ) {}
 
-  static continue(): ProcessResult {
-    return new ProcessResult(undefined, false, false, null, -1, null, -1);
-  }
-
   static yield(value: unknown): ProcessResult {
     return new ProcessResult(value, true, false, null, -1, null, -1);
   }
 
-  static done(): ProcessResult {
-    return new ProcessResult(undefined, false, true, null, -1, null, -1);
-  }
-
   static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {
     return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);
   }
@@ -96,6 +88,9 @@ class ProcessResult {
   }
 }
 
+const CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));
+const DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));
+
 function findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {
   const takeStates: OpState[] = [];
   for (let i = 0; i < ops.length; i++) {
@@ -134,14 +129,14 @@ async function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState
       case OpKind.FILTER: {
         const result = op.fn(value, state.index++);
         const passed = isThenable(result) ? await result : result;
-        if (!passed) return ProcessResult.continue();
+        if (!passed) return CONTINUE;
         break;
       }
 
       case OpKind.FILTER_MAP: {
         const result = op.fn(value, state.index++);
         const resolved = isThenable(result) ? await result : result;
-        if (resolved === undefined) return ProcessResult.continue();
+        if (resolved === undefined) return CONTINUE;
         value = resolved;
         break;
       }
@@ -161,21 +156,21 @@ async function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState
         break;
 
       case OpKind.TAKE:
-        if (state.remaining <= 0) return ProcessResult.done();
+        if (state.remaining <= 0) return DONE;
         state.remaining--;
         break;
 
       case OpKind.TAKE_WHILE: {
         const result = op.fn(value, state.index++);
         const passed = isThenable(result) ? await result : result;
-        if (!passed) return ProcessResult.done();
+        if (!passed) return DONE;
         break;
       }
 
       case OpKind.DROP:
         if (state.remaining > 0) {
           state.remaining--;
-          return ProcessResult.continue();
+          return CONTINUE;
         }
         break;
 
@@ -183,7 +178,7 @@ async function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState
         if (state.dropping) {
           const result = op.fn(value, state.index++);
           const passed = isThenable(result) ? await result : result;
-          if (passed) return ProcessResult.continue();
+          if (passed) return CONTINUE;
           state.dropping = false;
         }
         break;
@@ -197,7 +192,7 @@ async function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState
             value = state.value;
           } else {
             state.value = value;
-            return ProcessResult.continue();
+            return CONTINUE;
           }
         } else {
           const result = op.fn(state.value, value, state.index++);
@@ -856,9 +851,15 @@ export class AsyncIteratorObject<T, TReturn, TNext> {
    * }
    * ```
    */
-  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): AsyncIteratorObject<T, void, unknown>;
-  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, initialValue: R): AsyncIteratorObject<R, void, unknown>;
-  reduce<R>(callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R, ...args: unknown[]): AsyncIteratorObject<R, void, unknown> {
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T | PromiseLike<T>): AsyncIteratorObject<T, void, unknown>;
+  reduce<R>(
+    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,
+    initialValue: R,
+  ): AsyncIteratorObject<R, void, unknown>;
+  reduce<R>(
+    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,
+    ...args: unknown[]
+  ): AsyncIteratorObject<R, void, unknown> {
     const hasInit = args.length > 0;
     return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {
       kind: OpKind.REDUCE,