evnty 5.3.3 → 5.4.0

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 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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"}
+{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { ITERATOR_DONE } from './async.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 ITERATOR_DONE;\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return ITERATOR_DONE;\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return ITERATOR_DONE;\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return ITERATOR_DONE;\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return ITERATOR_DONE;\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 ITERATOR_DONE;\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 ITERATOR_DONE;\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return ITERATOR_DONE;\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 ITERATOR_DONE;\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return ITERATOR_DONE;\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","ITERATOR_DONE","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/build/sequence.cjs

@@ -39,10 +39,9 @@ class Sequence extends _asynccjs.Async {
     get size() {
         return this.#queue.length;
     }
-    async reserve(capacity) {
-        while(this.#queue.length > capacity){
-            await this.#sendSignal;
-        }
+    reserve(capacity) {
+        if (this.#queue.length <= capacity) return Promise.resolve();
+        return this.#sendSignal.receive().then(()=>this.reserve(capacity));
     }
     emit(value) {
         const ok = !this.disposed;
@@ -52,12 +51,12 @@ class Sequence extends _asynccjs.Async {
         this.#nextSignal.emit();
         return ok;
     }
-    async receive() {
-        while(!this.#queue.length){
-            await this.#nextSignal;
+    receive() {
+        if (this.#queue.length) {
+            this.#sendSignal.emit();
+            return Promise.resolve(this.#queue.shift());
         }
-        this.#sendSignal.emit();
-        return this.#queue.shift();
+        return this.#nextSignal.receive().then(()=>this.receive());
     }
     dispose() {
         this.#sendSignal[Symbol.dispose]();

package/build/sequence.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { Async } from './async.js';\nimport { Signal } from './signal.js';\nimport { RingBuffer } from './ring-buffer.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * @example\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks.emit('task1');\n * tasks.emit('task2');\n * tasks.emit('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.receive(); // 'task1'\n * const task2 = await tasks.receive(); // 'task2'\n * const task3 = await tasks.receive(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends Async<T, boolean> {\n  #queue: RingBuffer<T>;\n  #nextSignal: Signal<void>;\n  #sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1.emit(1);\n   * source2.emit(2);\n   * source1.emit(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.receive(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        if (!target.disposed)\n          try {\n            const sink = target.sink;\n            for await (const value of source) {\n              if (!sink(value)) {\n                return;\n              }\n            }\n          } catch {\n            // sequence is disposed\n          }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Sequence instance.\n   * @param abortSignal - Optional AbortSignal to cancel pending operations\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n    this.#queue = new RingBuffer();\n    this.#nextSignal = new Signal(abortSignal);\n    this.#sendSignal = new Signal(abortSignal);\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.#queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * @example\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence.emit('new item'); // Safe to add, queue has space\n   * ```\n   */\n  async reserve(capacity: number): Promise<void> {\n    while (this.#queue.length > capacity) {\n      await this.#sendSignal;\n    }\n  }\n\n  /**\n   * Pushes a value onto the queue. Wakes any pending `receive()` waiter.\n   *\n   * @param value - The value to enqueue.\n   * @returns `true` if the sequence is still active.\n   */\n  emit(value: T): boolean {\n    const ok = !this.disposed;\n    if (ok) {\n      this.#queue.push(value);\n    }\n    this.#nextSignal.emit();\n    return ok;\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * @example\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.receive();\n   *\n   * // Producer adds value\n   * sequence.emit(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  async receive(): Promise<T> {\n    while (!this.#queue.length) {\n      await this.#nextSignal;\n    }\n    this.#sendSignal.emit();\n    return this.#queue.shift()!;\n  }\n\n  /**\n   * Disposes of the sequence, rejecting any pending `receive()` waiters.\n   * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.\n   */\n  dispose(): void {\n    this.#sendSignal[Symbol.dispose]();\n    this.#nextSignal[Symbol.dispose]();\n  }\n}\n"],"names":["Sequence","Async","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","RingBuffer","Signal","size","length","reserve","capacity","emit","ok","push","receive","shift","dispose"],"mappings":";;;;+BAmCaA;;;eAAAA;;;0BAnCS;2BACC;+BACI;AAiCpB,MAAMA,iBAAoBC,eAAK;IACpC,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACC,OAAOC,WAAW,CAAC,GAAG,WAAW;IA6B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI,CAACH,OAAOI,QAAQ,EAClB,IAAI;oBACF,MAAMC,OAAOL,OAAOK,IAAI;oBACxB,WAAW,MAAMC,SAASJ,OAAQ;wBAChC,IAAI,CAACG,KAAKC,QAAQ;4BAChB;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACJ;QACF;IACF;IAMA,YAAYC,WAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAAC,CAAA,KAAM,GAAG,IAAIC,yBAAU;QAC5B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIC,iBAAM,CAACF;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIE,iBAAM,CAACF;IAChC;IAOA,IAAIG,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACC,MAAM;IAC3B;IAmBA,MAAMC,QAAQC,QAAgB,EAAiB;QAC7C,MAAO,IAAI,CAAC,CAAA,KAAM,CAACF,MAAM,GAAGE,SAAU;YACpC,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;IACF;IAQAC,KAAKR,KAAQ,EAAW;QACtB,MAAMS,KAAK,CAAC,IAAI,CAACX,QAAQ;QACzB,IAAIW,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACV;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACQ,IAAI;QACrB,OAAOC;IACT;IAwBA,MAAME,UAAsB;QAC1B,MAAO,CAAC,IAAI,CAAC,CAAA,KAAM,CAACN,MAAM,CAAE;YAC1B,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;QACA,IAAI,CAAC,CAAA,UAAW,CAACG,IAAI;QACrB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACI,KAAK;IAC1B;IAMAC,UAAgB;QACd,IAAI,CAAC,CAAA,UAAW,CAACtB,OAAOsB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACtB,OAAOsB,OAAO,CAAC;IAClC;AACF"}
+{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { Async } from './async.js';\nimport { Signal } from './signal.js';\nimport { RingBuffer } from './ring-buffer.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * @example\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks.emit('task1');\n * tasks.emit('task2');\n * tasks.emit('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.receive(); // 'task1'\n * const task2 = await tasks.receive(); // 'task2'\n * const task3 = await tasks.receive(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends Async<T, boolean> {\n  #queue: RingBuffer<T>;\n  #nextSignal: Signal<void>;\n  #sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1.emit(1);\n   * source2.emit(2);\n   * source1.emit(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.receive(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        if (!target.disposed)\n          try {\n            const sink = target.sink;\n            for await (const value of source) {\n              if (!sink(value)) {\n                return;\n              }\n            }\n          } catch {\n            // sequence is disposed\n          }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Sequence instance.\n   * @param abortSignal - Optional AbortSignal to cancel pending operations\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n    this.#queue = new RingBuffer();\n    this.#nextSignal = new Signal(abortSignal);\n    this.#sendSignal = new Signal(abortSignal);\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.#queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * @example\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence.emit('new item'); // Safe to add, queue has space\n   * ```\n   */\n  reserve(capacity: number): Promise<void> {\n    if (this.#queue.length <= capacity) return Promise.resolve();\n    return this.#sendSignal.receive().then(() => this.reserve(capacity));\n  }\n\n  /**\n   * Pushes a value onto the queue. Wakes any pending `receive()` waiter.\n   *\n   * @param value - The value to enqueue.\n   * @returns `true` if the sequence is still active.\n   */\n  emit(value: T): boolean {\n    const ok = !this.disposed;\n    if (ok) {\n      this.#queue.push(value);\n    }\n    this.#nextSignal.emit();\n    return ok;\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * @example\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.receive();\n   *\n   * // Producer adds value\n   * sequence.emit(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  receive(): Promise<T> {\n    if (this.#queue.length) {\n      this.#sendSignal.emit();\n      return Promise.resolve(this.#queue.shift()!);\n    }\n    return this.#nextSignal.receive().then(() => this.receive());\n  }\n\n  /**\n   * Disposes of the sequence, rejecting any pending `receive()` waiters.\n   * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.\n   */\n  dispose(): void {\n    this.#sendSignal[Symbol.dispose]();\n    this.#nextSignal[Symbol.dispose]();\n  }\n}\n"],"names":["Sequence","Async","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","RingBuffer","Signal","size","length","reserve","capacity","Promise","resolve","receive","then","emit","ok","push","shift","dispose"],"mappings":";;;;+BAmCaA;;;eAAAA;;;0BAnCS;2BACC;+BACI;AAiCpB,MAAMA,iBAAoBC,eAAK;IACpC,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACC,OAAOC,WAAW,CAAC,GAAG,WAAW;IA6B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI,CAACH,OAAOI,QAAQ,EAClB,IAAI;oBACF,MAAMC,OAAOL,OAAOK,IAAI;oBACxB,WAAW,MAAMC,SAASJ,OAAQ;wBAChC,IAAI,CAACG,KAAKC,QAAQ;4BAChB;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACJ;QACF;IACF;IAMA,YAAYC,WAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAAC,CAAA,KAAM,GAAG,IAAIC,yBAAU;QAC5B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIC,iBAAM,CAACF;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIE,iBAAM,CAACF;IAChC;IAOA,IAAIG,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACC,MAAM;IAC3B;IAmBAC,QAAQC,QAAgB,EAAiB;QACvC,IAAI,IAAI,CAAC,CAAA,KAAM,CAACF,MAAM,IAAIE,UAAU,OAAOC,QAAQC,OAAO;QAC1D,OAAO,IAAI,CAAC,CAAA,UAAW,CAACC,OAAO,GAAGC,IAAI,CAAC,IAAM,IAAI,CAACL,OAAO,CAACC;IAC5D;IAQAK,KAAKZ,KAAQ,EAAW;QACtB,MAAMa,KAAK,CAAC,IAAI,CAACf,QAAQ;QACzB,IAAIe,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACd;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACY,IAAI;QACrB,OAAOC;IACT;IAwBAH,UAAsB;QACpB,IAAI,IAAI,CAAC,CAAA,KAAM,CAACL,MAAM,EAAE;YACtB,IAAI,CAAC,CAAA,UAAW,CAACO,IAAI;YACrB,OAAOJ,QAAQC,OAAO,CAAC,IAAI,CAAC,CAAA,KAAM,CAACM,KAAK;QAC1C;QACA,OAAO,IAAI,CAAC,CAAA,UAAW,CAACL,OAAO,GAAGC,IAAI,CAAC,IAAM,IAAI,CAACD,OAAO;IAC3D;IAMAM,UAAgB;QACd,IAAI,CAAC,CAAA,UAAW,CAACzB,OAAOyB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACzB,OAAOyB,OAAO,CAAC;IAClC;AACF"}

package/build/sequence.js

@@ -29,10 +29,9 @@ export class Sequence extends Async {
     get size() {
         return this.#queue.length;
     }
-    async reserve(capacity) {
-        while(this.#queue.length > capacity){
-            await this.#sendSignal;
-        }
+    reserve(capacity) {
+        if (this.#queue.length <= capacity) return Promise.resolve();
+        return this.#sendSignal.receive().then(()=>this.reserve(capacity));
     }
     emit(value) {
         const ok = !this.disposed;
@@ -42,12 +41,12 @@ export class Sequence extends Async {
         this.#nextSignal.emit();
         return ok;
     }
-    async receive() {
-        while(!this.#queue.length){
-            await this.#nextSignal;
+    receive() {
+        if (this.#queue.length) {
+            this.#sendSignal.emit();
+            return Promise.resolve(this.#queue.shift());
         }
-        this.#sendSignal.emit();
-        return this.#queue.shift();
+        return this.#nextSignal.receive().then(()=>this.receive());
     }
     dispose() {
         this.#sendSignal[Symbol.dispose]();

package/build/sequence.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { Async } from './async.js';\nimport { Signal } from './signal.js';\nimport { RingBuffer } from './ring-buffer.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * @example\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks.emit('task1');\n * tasks.emit('task2');\n * tasks.emit('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.receive(); // 'task1'\n * const task2 = await tasks.receive(); // 'task2'\n * const task3 = await tasks.receive(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends Async<T, boolean> {\n  #queue: RingBuffer<T>;\n  #nextSignal: Signal<void>;\n  #sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1.emit(1);\n   * source2.emit(2);\n   * source1.emit(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.receive(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        if (!target.disposed)\n          try {\n            const sink = target.sink;\n            for await (const value of source) {\n              if (!sink(value)) {\n                return;\n              }\n            }\n          } catch {\n            // sequence is disposed\n          }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Sequence instance.\n   * @param abortSignal - Optional AbortSignal to cancel pending operations\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n    this.#queue = new RingBuffer();\n    this.#nextSignal = new Signal(abortSignal);\n    this.#sendSignal = new Signal(abortSignal);\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.#queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * @example\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence.emit('new item'); // Safe to add, queue has space\n   * ```\n   */\n  async reserve(capacity: number): Promise<void> {\n    while (this.#queue.length > capacity) {\n      await this.#sendSignal;\n    }\n  }\n\n  /**\n   * Pushes a value onto the queue. Wakes any pending `receive()` waiter.\n   *\n   * @param value - The value to enqueue.\n   * @returns `true` if the sequence is still active.\n   */\n  emit(value: T): boolean {\n    const ok = !this.disposed;\n    if (ok) {\n      this.#queue.push(value);\n    }\n    this.#nextSignal.emit();\n    return ok;\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * @example\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.receive();\n   *\n   * // Producer adds value\n   * sequence.emit(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  async receive(): Promise<T> {\n    while (!this.#queue.length) {\n      await this.#nextSignal;\n    }\n    this.#sendSignal.emit();\n    return this.#queue.shift()!;\n  }\n\n  /**\n   * Disposes of the sequence, rejecting any pending `receive()` waiters.\n   * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.\n   */\n  dispose(): void {\n    this.#sendSignal[Symbol.dispose]();\n    this.#nextSignal[Symbol.dispose]();\n  }\n}\n"],"names":["Async","Signal","RingBuffer","Sequence","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","size","length","reserve","capacity","emit","ok","push","receive","shift","dispose"],"mappings":"AAAA,SAASA,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,UAAU,QAAQ,mBAAmB;AAiC9C,OAAO,MAAMC,iBAAoBH;IAC/B,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACI,OAAOC,WAAW,CAAC,GAAG,WAAW;IA6B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI,CAACH,OAAOI,QAAQ,EAClB,IAAI;oBACF,MAAMC,OAAOL,OAAOK,IAAI;oBACxB,WAAW,MAAMC,SAASJ,OAAQ;wBAChC,IAAI,CAACG,KAAKC,QAAQ;4BAChB;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACJ;QACF;IACF;IAMA,YAAYC,WAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAAC,CAAA,KAAM,GAAG,IAAIZ;QAClB,IAAI,CAAC,CAAA,UAAW,GAAG,IAAID,OAAOa;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIb,OAAOa;IAChC;IAOA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACC,MAAM;IAC3B;IAmBA,MAAMC,QAAQC,QAAgB,EAAiB;QAC7C,MAAO,IAAI,CAAC,CAAA,KAAM,CAACF,MAAM,GAAGE,SAAU;YACpC,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;IACF;IAQAC,KAAKN,KAAQ,EAAW;QACtB,MAAMO,KAAK,CAAC,IAAI,CAACT,QAAQ;QACzB,IAAIS,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACR;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACM,IAAI;QACrB,OAAOC;IACT;IAwBA,MAAME,UAAsB;QAC1B,MAAO,CAAC,IAAI,CAAC,CAAA,KAAM,CAACN,MAAM,CAAE;YAC1B,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;QACA,IAAI,CAAC,CAAA,UAAW,CAACG,IAAI;QACrB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACI,KAAK;IAC1B;IAMAC,UAAgB;QACd,IAAI,CAAC,CAAA,UAAW,CAACpB,OAAOoB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACpB,OAAOoB,OAAO,CAAC;IAClC;AACF"}
+{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { Async } from './async.js';\nimport { Signal } from './signal.js';\nimport { RingBuffer } from './ring-buffer.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * @example\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks.emit('task1');\n * tasks.emit('task2');\n * tasks.emit('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.receive(); // 'task1'\n * const task2 = await tasks.receive(); // 'task2'\n * const task3 = await tasks.receive(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends Async<T, boolean> {\n  #queue: RingBuffer<T>;\n  #nextSignal: Signal<void>;\n  #sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1.emit(1);\n   * source2.emit(2);\n   * source1.emit(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.receive(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        if (!target.disposed)\n          try {\n            const sink = target.sink;\n            for await (const value of source) {\n              if (!sink(value)) {\n                return;\n              }\n            }\n          } catch {\n            // sequence is disposed\n          }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Sequence instance.\n   * @param abortSignal - Optional AbortSignal to cancel pending operations\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n    this.#queue = new RingBuffer();\n    this.#nextSignal = new Signal(abortSignal);\n    this.#sendSignal = new Signal(abortSignal);\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.#queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * @example\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence.emit('new item'); // Safe to add, queue has space\n   * ```\n   */\n  reserve(capacity: number): Promise<void> {\n    if (this.#queue.length <= capacity) return Promise.resolve();\n    return this.#sendSignal.receive().then(() => this.reserve(capacity));\n  }\n\n  /**\n   * Pushes a value onto the queue. Wakes any pending `receive()` waiter.\n   *\n   * @param value - The value to enqueue.\n   * @returns `true` if the sequence is still active.\n   */\n  emit(value: T): boolean {\n    const ok = !this.disposed;\n    if (ok) {\n      this.#queue.push(value);\n    }\n    this.#nextSignal.emit();\n    return ok;\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * @example\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.receive();\n   *\n   * // Producer adds value\n   * sequence.emit(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  receive(): Promise<T> {\n    if (this.#queue.length) {\n      this.#sendSignal.emit();\n      return Promise.resolve(this.#queue.shift()!);\n    }\n    return this.#nextSignal.receive().then(() => this.receive());\n  }\n\n  /**\n   * Disposes of the sequence, rejecting any pending `receive()` waiters.\n   * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.\n   */\n  dispose(): void {\n    this.#sendSignal[Symbol.dispose]();\n    this.#nextSignal[Symbol.dispose]();\n  }\n}\n"],"names":["Async","Signal","RingBuffer","Sequence","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","size","length","reserve","capacity","Promise","resolve","receive","then","emit","ok","push","shift","dispose"],"mappings":"AAAA,SAASA,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,UAAU,QAAQ,mBAAmB;AAiC9C,OAAO,MAAMC,iBAAoBH;IAC/B,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACI,OAAOC,WAAW,CAAC,GAAG,WAAW;IA6B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI,CAACH,OAAOI,QAAQ,EAClB,IAAI;oBACF,MAAMC,OAAOL,OAAOK,IAAI;oBACxB,WAAW,MAAMC,SAASJ,OAAQ;wBAChC,IAAI,CAACG,KAAKC,QAAQ;4BAChB;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACJ;QACF;IACF;IAMA,YAAYC,WAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAAC,CAAA,KAAM,GAAG,IAAIZ;QAClB,IAAI,CAAC,CAAA,UAAW,GAAG,IAAID,OAAOa;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIb,OAAOa;IAChC;IAOA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACC,MAAM;IAC3B;IAmBAC,QAAQC,QAAgB,EAAiB;QACvC,IAAI,IAAI,CAAC,CAAA,KAAM,CAACF,MAAM,IAAIE,UAAU,OAAOC,QAAQC,OAAO;QAC1D,OAAO,IAAI,CAAC,CAAA,UAAW,CAACC,OAAO,GAAGC,IAAI,CAAC,IAAM,IAAI,CAACL,OAAO,CAACC;IAC5D;IAQAK,KAAKV,KAAQ,EAAW;QACtB,MAAMW,KAAK,CAAC,IAAI,CAACb,QAAQ;QACzB,IAAIa,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACZ;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACU,IAAI;QACrB,OAAOC;IACT;IAwBAH,UAAsB;QACpB,IAAI,IAAI,CAAC,CAAA,KAAM,CAACL,MAAM,EAAE;YACtB,IAAI,CAAC,CAAA,UAAW,CAACO,IAAI;YACrB,OAAOJ,QAAQC,OAAO,CAAC,IAAI,CAAC,CAAA,KAAM,CAACM,KAAK;QAC1C;QACA,OAAO,IAAI,CAAC,CAAA,UAAW,CAACL,OAAO,GAAGC,IAAI,CAAC,IAAM,IAAI,CAACD,OAAO;IAC3D;IAMAM,UAAgB;QACd,IAAI,CAAC,CAAA,UAAW,CAACvB,OAAOuB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACvB,OAAOuB,OAAO,CAAC;IAClC;AACF"}

package/build/utils.cjs

@@ -44,6 +44,7 @@ _export(exports, {
     }
 });
 const _sequencecjs = require("./sequence.cjs");
+const _asynccjs = require("./async.cjs");
 function isThenable(value) {
     return value !== null && typeof value === 'object' && typeof value.then === 'function';
 }
@@ -120,23 +121,24 @@ function abortableIterable(iterable, signal) {
                 undefined
             ];
             return {
-                async next (...args) {
+                next (...args) {
                     race[1] = iterator.next(...args);
-                    const result = await Promise.race(race);
-                    if (result === undefined) {
-                        void finish();
-                        return {
-                            done: true,
-                            value: undefined
-                        };
-                    }
-                    if (result.done) {
-                        closed = true;
-                        signal.removeEventListener('abort', onAbort);
-                    }
-                    return result;
+                    return Promise.race(race).then((result)=>{
+                        if (result === undefined) {
+                            void finish();
+                            return {
+                                done: true,
+                                value: undefined
+                            };
+                        }
+                        if (result.done) {
+                            closed = true;
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        return result;
+                    });
                 },
-                async return (value) {
+                return (value) {
                     return finish(value);
                 }
             };
@@ -162,10 +164,7 @@ const iterate = (startOrCount, countWhenTwoArgs, step = 1)=>{
                             done: false
                         };
                     }
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 return (value) {
                     idx = count;
@@ -200,21 +199,20 @@ const toAsyncIterable = (iterable)=>{
         [Symbol.asyncIterator] () {
             const iterator = iterable[Symbol.iterator]();
             return {
-                async next (...args) {
-                    return iterator.next(...args);
+                next (...args) {
+                    return Promise.resolve(iterator.next(...args));
                 },
-                async return (maybeValue) {
-                    const value = await maybeValue;
-                    return iterator.return?.(value) ?? {
-                        value,
-                        done: true
-                    };
+                return (maybeValue) {
+                    return Promise.resolve(maybeValue).then((value)=>iterator.return?.(value) ?? {
+                            value,
+                            done: true
+                        });
                 },
-                async throw (error) {
+                throw (error) {
                     if (iterator.throw) {
-                        return iterator.throw(error);
+                        return Promise.resolve(iterator.throw(error));
                     }
-                    throw error;
+                    return Promise.reject(error);
                 }
             };
         }
@@ -240,10 +238,7 @@ const mergeIterables = (...iterables)=>{
         [Symbol.asyncIterator] () {
             if (iterables.length === 0) {
                 return {
-                    next: async ()=>({
-                            value: undefined,
-                            done: true
-                        })
+                    next: ()=>Promise.resolve(_asynccjs.ITERATOR_DONE)
                 };
             }
             const exit = Symbol('mergeIterables.exit');
@@ -279,27 +274,18 @@ const mergeIterables = (...iterables)=>{
                         };
                     } catch  {
                         if (ctrl.signal.aborted && ctrl.signal.reason === exit) {
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         throw ctrl.signal.reason;
                     }
                 },
                 return: async ()=>{
                     ctrl.abort(exit);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 throw: async (error)=>{
                     ctrl.abort(error);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 }
             };
         }