evnty/build/iterator.cjs.map

Async-first, reactive event handling library for complex event flows in browser and Node.js

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