evnty 5.3.3 → 5.4.1

package/build/event.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/event.ts"],"sourcesContent":["import { Callback, Listener, FilterFunction, Predicate, Mapper, Reducer, Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\nimport { Disposer } from './async.js';\nimport { Signal } from './signal.js';\nimport { ListenerRegistry } from './listener-registry.js';\nimport { DispatchResult } from './dispatch-result.js';\n\nexport type Unsubscribe = Action;\n\n/**\n * @internal\n */\nexport class EventIterator<T> implements AsyncIterator<T, void, void> {\n  #signal: Signal<T>;\n\n  constructor(signal: Signal<T>) {\n    this.#signal = signal;\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      const value = await this.#signal.receive();\n      return { value, done: false };\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    return { value: undefined, done: true };\n  }\n}\n\n/**\n * Multi-listener event emitter with async support.\n * All registered listeners are called for each emission, and their return\n * values are collected in a DispatchResult. Supports async iteration and\n * an `onDispose` callback for cleanup.\n *\n * Differs from:\n * - Signal: Event has persistent listeners; Signal is promise-based (receive per round)\n * - Sequence: Event broadcasts to all listeners; Sequence is a single-consumer queue\n *\n * @template T - The type of value emitted to listeners (event payload)\n * @template R - The return type of listener functions\n */\nexport class Event<T = unknown, R = unknown> implements Emitter<T, DispatchResult<void | R>>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {\n  #listeners = new ListenerRegistry<[T], R | void>();\n  #signal = new Signal<T>();\n  #disposer: Disposer;\n  #onDispose?: Callback;\n  #sink?: Fn<[T], DispatchResult<void | R>>;\n\n  readonly [Symbol.toStringTag] = 'Event';\n\n  /**\n   * Creates a new event.\n   *\n   * @param onDispose - A function to call on the event disposal.\n   *\n   * @example\n   * ```typescript\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on(([x, y]) => console.log(`Clicked at ${x}, ${y}`));\n   * clickEvent.emit([10, 20]);\n   * ```\n   */\n  constructor(onDispose?: Callback) {\n    this.#onDispose = onDispose;\n    this.#disposer = new Disposer(this);\n  }\n\n  /**\n   * Returns a bound emit function for use as a callback.\n   * Useful for passing to other APIs that expect a function.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string>();\n   * someApi.onMessage(event.sink);\n   * ```\n   */\n  get sink(): Fn<[T], DispatchResult<void | R>> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  /**\n   * DOM EventListener interface compatibility.\n   * Allows the event to be used directly with addEventListener.\n   */\n  handleEvent(event: T): void {\n    this.emit(event);\n  }\n\n  /**\n   * The number of listeners for the event.\n   */\n  get size(): number {\n    return this.#listeners.size;\n  }\n\n  /**\n   * Emits a value to all registered listeners.\n   * Each listener is called with the value and their return values are collected.\n   *\n   * @param value - The value to emit to all listeners.\n   * @returns A DispatchResult containing all listener return values.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string, number>();\n   * event.on(str => str.length);\n   * const result = event.emit('hello');\n   * await result.all(); // [5]\n   * ```\n   */\n  emit(value: T): DispatchResult<void | R> {\n    this.#signal.emit(value);\n    return new DispatchResult(this.#listeners.dispatch(value));\n  }\n\n  /**\n   * Checks if the given listener is NOT registered for this event.\n   *\n   * @param listener - The listener function to check against the registered listeners.\n   * @returns `true` if the listener is not already registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Check if a listener is not already added\n   * if (event.lacks(myListener)) {\n   *   event.on(myListener);\n   * }\n   * ```\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return !this.#listeners.has(listener);\n  }\n\n  /**\n   * Checks if the given listener is registered for this event.\n   *\n   * @param listener - The listener function to check.\n   * @returns `true` if the listener is currently registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Verify if a listener is registered\n   * if (event.has(myListener)) {\n   *   console.log('Listener is already registered');\n   * }\n   * ```\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.#listeners.has(listener);\n  }\n\n  /**\n   * Removes a specific listener from this event.\n   *\n   * @param listener - The listener to remove.\n   * @returns The event instance for chaining.\n   *\n   * @example\n   * ```typescript\n   * // Remove a listener\n   * event.off(myListener);\n   * ```\n   */\n  off(listener: Listener<T, R>): this {\n    this.#listeners.off(listener);\n    return this;\n  }\n\n  /**\n   * Registers a listener that is called on every emission.\n   *\n   * @param listener - The function to call when the event occurs.\n   * @returns A function that removes this listener when called.\n   *\n   * @example\n   * ```typescript\n   * const unsubscribe = event.on((data) => {\n   *   console.log('Event data:', data);\n   * });\n   * ```\n   */\n  on(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.on(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Registers a listener that is called only once on the next emission, then auto-removed.\n   *\n   * @param listener - The listener to trigger once.\n   * @returns A function that removes this listener when called (if it hasn't fired yet).\n   *\n   * @example\n   * ```typescript\n   * const cancel = event.once((data) => {\n   *   console.log('Received data once:', data);\n   * });\n   * ```\n   */\n  once(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.once(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   * Does not dispose the event - new listeners can still be added after clearing.\n   *\n   * @returns The event instance for chaining.\n   */\n  clear(): this {\n    this.#listeners.clear();\n    return this;\n  }\n\n  /**\n   * Waits for the next emission and returns the emitted value.\n   *\n   * @returns A promise that resolves with the next emitted value.\n   */\n  receive(): Promise<T> {\n    return this.#signal.receive();\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  /**\n   * Waits for the next emission via `receive()` and wraps the outcome in a\n   * `PromiseSettledResult` - always resolves, never rejects.\n   *\n   * @returns A promise that resolves with the settled result.\n   *\n   * @example\n   * ```typescript\n   * const result = await event.settle();\n   * if (result.status === 'fulfilled') {\n   *   console.log('Value:', result.value);\n   * } else {\n   *   console.error('Reason:', result.reason);\n   * }\n   * ```\n   */\n  settle(): Promise<PromiseSettledResult<T>> {\n    return this.receive().then(\n      (value) => ({ status: 'fulfilled', value }) as const,\n      (reason: unknown) => ({ status: 'rejected', reason }) as const,\n    );\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return new EventIterator(this.#signal);\n  }\n\n  dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#disposer[Symbol.dispose]()) {\n      this.#signal[Symbol.dispose]();\n      this.#listeners.clear();\n      void this.#onDispose?.();\n    }\n  }\n}\n\nexport type EventParameters<T> = T extends Event<infer P, any> ? P : never;\n\nexport type EventReturn<T> = T extends Event<any, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<any, any>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<any, any>[]> = { [K in keyof T]: EventReturn<T[K]> }[number];\n\n/**\n * Merges multiple events into a single event that triggers whenever any source triggers.\n * Disposing the merged event unsubscribes from all sources.\n *\n * @param events - The events to merge.\n * @returns A new Event that forwards emissions from all sources.\n *\n * @example\n * ```typescript\n * const mouseEvent = createEvent<MouseEvent>();\n * const keyboardEvent = createEvent<KeyboardEvent>();\n * const inputEvent = merge(mouseEvent, keyboardEvent);\n * inputEvent.on(event => console.log('Input event:', event));\n * ```\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<Events>>(() => {\n    for (const event of events) {\n      event.off(mergedEvent.sink);\n    }\n  });\n\n  for (const event of events) {\n    event.on(mergedEvent.sink);\n  }\n  return mergedEvent;\n};\n\n/**\n * Creates a periodic event that emits an incrementing counter (starting from 0) at a fixed interval.\n * Disposing the event clears the interval.\n *\n * @param interval - The interval in milliseconds.\n * @returns An Event that triggers at the specified interval.\n *\n * @example\n * ```typescript\n * const tickEvent = createInterval(1000);\n * tickEvent.on(tickNumber => console.log('Tick:', tickNumber));\n * ```\n */\nexport const createInterval = <R = unknown>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => {\n    intervalEvent.emit(counter++);\n  }, interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new Event instance for multi-listener event handling.\n *\n * @example\n * ```typescript\n * const messageEvent = createEvent<string>();\n * messageEvent.on(msg => console.log('Received:', msg));\n * messageEvent.emit('Hello'); // All listeners receive 'Hello'\n *\n * // Listeners can return values, collected via DispatchResult\n * const validateEvent = createEvent<string, boolean>();\n * validateEvent.on(str => str.length > 0);\n * validateEvent.on(str => str.length < 100);\n * const results = await validateEvent.emit('test').all(); // [true, true]\n * ```\n */\nexport const createEvent = <T = unknown, R = unknown>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * Extracts the listener function type from an Event type.\n * Useful for type-safe listener definitions.\n *\n * @template E - The Event type to extract the listener type from\n *\n * @example\n * ```typescript\n * type MyEvent = Event<string, boolean>;\n * type MyListener = EventHandler<MyEvent>; // (value: string) => boolean | Promise<boolean>\n * ```\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * Extracts a filter function type for an Event's parameters.\n * Used for creating type-safe event filters.\n *\n * @template E - The Event type to create a filter for\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * Extracts a predicate function type for an Event's parameters.\n * Used for type narrowing with event values.\n *\n * @template E - The Event type to create a predicate for\n * @template P - The narrowed type that the predicate validates\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * Extracts a mapper function type for transforming Event parameters.\n * Used for creating type-safe event value transformations.\n *\n * @template E - The Event type to create a mapper for\n * @template M - The target type to map event values to\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * Extracts a reducer function type for Event parameters.\n * Used for creating type-safe event value reducers.\n *\n * @template E - The Event type to create a reducer for\n * @template R - The accumulator type for the reduction\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["Disposer","Signal","ListenerRegistry","DispatchResult","EventIterator","signal","next","value","receive","done","undefined","return","Event","Symbol","toStringTag","onDispose","sink","emit","bind","handleEvent","event","size","dispatch","lacks","listener","has","off","on","once","clear","then","onfulfilled","onrejected","catch","finally","onfinally","settle","status","reason","asyncIterator","dispose","merge","events","mergedEvent","createInterval","interval","counter","intervalEvent","clearInterval","timerId","setInterval","createEvent"],"mappings":"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"}
+{"version":3,"sources":["../src/event.ts"],"sourcesContent":["import { Callback, Listener, FilterFunction, Predicate, Mapper, Reducer, Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\nimport { Disposer, ITERATOR_DONE, ITERATOR_DONE_PROMISE } from './async.js';\nimport { Signal } from './signal.js';\nimport { ListenerRegistry } from './listener-registry.js';\nimport { DispatchResult } from './dispatch-result.js';\n\nexport type Unsubscribe = Action;\n\n/**\n * @internal\n */\nexport class EventIterator<T> implements AsyncIterator<T, void, void> {\n  #signal: Signal<T>;\n\n  constructor(signal: Signal<T>) {\n    this.#signal = signal;\n  }\n\n  next(): Promise<IteratorResult<T, void>> {\n    return this.#signal.receive().then(\n      (value): IteratorResult<T, void> => ({ value, done: false }),\n      (): IteratorResult<T, void> => ITERATOR_DONE,\n    );\n  }\n\n  return(): Promise<IteratorResult<T, void>> {\n    return ITERATOR_DONE_PROMISE;\n  }\n}\n\n/**\n * Multi-listener event emitter with async support.\n * All registered listeners are called for each emission, and their return\n * values are collected in a DispatchResult. Supports async iteration and\n * an `onDispose` callback for cleanup.\n *\n * Differs from:\n * - Signal: Event has persistent listeners; Signal is promise-based (receive per round)\n * - Sequence: Event broadcasts to all listeners; Sequence is a single-consumer queue\n *\n * @template T - The type of value emitted to listeners (event payload)\n * @template R - The return type of listener functions\n */\nexport class Event<T = unknown, R = unknown> implements Emitter<T, DispatchResult<void | R>>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {\n  #listeners = new ListenerRegistry<[T], R | void>();\n  #signal = new Signal<T>();\n  #disposer: Disposer;\n  #onDispose?: Callback;\n  #sink?: Fn<[T], DispatchResult<void | R>>;\n\n  readonly [Symbol.toStringTag] = 'Event';\n\n  /**\n   * Creates a new event.\n   *\n   * @param onDispose - A function to call on the event disposal.\n   *\n   * @example\n   * ```typescript\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on(([x, y]) => console.log(`Clicked at ${x}, ${y}`));\n   * clickEvent.emit([10, 20]);\n   * ```\n   */\n  constructor(onDispose?: Callback) {\n    this.#onDispose = onDispose;\n    this.#disposer = new Disposer(this);\n  }\n\n  /**\n   * Returns a bound emit function for use as a callback.\n   * Useful for passing to other APIs that expect a function.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string>();\n   * someApi.onMessage(event.sink);\n   * ```\n   */\n  get sink(): Fn<[T], DispatchResult<void | R>> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  /**\n   * DOM EventListener interface compatibility.\n   * Allows the event to be used directly with addEventListener.\n   */\n  handleEvent(event: T): void {\n    this.emit(event);\n  }\n\n  /**\n   * The number of listeners for the event.\n   */\n  get size(): number {\n    return this.#listeners.size;\n  }\n\n  /**\n   * Emits a value to all registered listeners.\n   * Each listener is called with the value and their return values are collected.\n   *\n   * @param value - The value to emit to all listeners.\n   * @returns A DispatchResult containing all listener return values.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string, number>();\n   * event.on(str => str.length);\n   * const result = event.emit('hello');\n   * await result.all(); // [5]\n   * ```\n   */\n  emit(value: T): DispatchResult<void | R> {\n    this.#signal.emit(value);\n    return new DispatchResult(this.#listeners.dispatch(value));\n  }\n\n  /**\n   * Checks if the given listener is NOT registered for this event.\n   *\n   * @param listener - The listener function to check against the registered listeners.\n   * @returns `true` if the listener is not already registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Check if a listener is not already added\n   * if (event.lacks(myListener)) {\n   *   event.on(myListener);\n   * }\n   * ```\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return !this.#listeners.has(listener);\n  }\n\n  /**\n   * Checks if the given listener is registered for this event.\n   *\n   * @param listener - The listener function to check.\n   * @returns `true` if the listener is currently registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Verify if a listener is registered\n   * if (event.has(myListener)) {\n   *   console.log('Listener is already registered');\n   * }\n   * ```\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.#listeners.has(listener);\n  }\n\n  /**\n   * Removes a specific listener from this event.\n   *\n   * @param listener - The listener to remove.\n   * @returns The event instance for chaining.\n   *\n   * @example\n   * ```typescript\n   * // Remove a listener\n   * event.off(myListener);\n   * ```\n   */\n  off(listener: Listener<T, R>): this {\n    this.#listeners.off(listener);\n    return this;\n  }\n\n  /**\n   * Registers a listener that is called on every emission.\n   *\n   * @param listener - The function to call when the event occurs.\n   * @returns A function that removes this listener when called.\n   *\n   * @example\n   * ```typescript\n   * const unsubscribe = event.on((data) => {\n   *   console.log('Event data:', data);\n   * });\n   * ```\n   */\n  on(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.on(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Registers a listener that is called only once on the next emission, then auto-removed.\n   *\n   * @param listener - The listener to trigger once.\n   * @returns A function that removes this listener when called (if it hasn't fired yet).\n   *\n   * @example\n   * ```typescript\n   * const cancel = event.once((data) => {\n   *   console.log('Received data once:', data);\n   * });\n   * ```\n   */\n  once(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.once(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   * Does not dispose the event - new listeners can still be added after clearing.\n   *\n   * @returns The event instance for chaining.\n   */\n  clear(): this {\n    this.#listeners.clear();\n    return this;\n  }\n\n  /**\n   * Waits for the next emission and returns the emitted value.\n   *\n   * @returns A promise that resolves with the next emitted value.\n   */\n  receive(): Promise<T> {\n    return this.#signal.receive();\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  /**\n   * Waits for the next emission via `receive()` and wraps the outcome in a\n   * `PromiseSettledResult` - always resolves, never rejects.\n   *\n   * @returns A promise that resolves with the settled result.\n   *\n   * @example\n   * ```typescript\n   * const result = await event.settle();\n   * if (result.status === 'fulfilled') {\n   *   console.log('Value:', result.value);\n   * } else {\n   *   console.error('Reason:', result.reason);\n   * }\n   * ```\n   */\n  settle(): Promise<PromiseSettledResult<T>> {\n    return this.receive().then(\n      (value) => ({ status: 'fulfilled', value }) as const,\n      (reason: unknown) => ({ status: 'rejected', reason }) as const,\n    );\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return new EventIterator(this.#signal);\n  }\n\n  dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#disposer[Symbol.dispose]()) {\n      this.#signal[Symbol.dispose]();\n      this.#listeners.clear();\n      void this.#onDispose?.();\n    }\n  }\n}\n\nexport type EventParameters<T> = T extends Event<infer P, any> ? P : never;\n\nexport type EventReturn<T> = T extends Event<any, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<any, any>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<any, any>[]> = { [K in keyof T]: EventReturn<T[K]> }[number];\n\n/**\n * Merges multiple events into a single event that triggers whenever any source triggers.\n * Disposing the merged event unsubscribes from all sources.\n *\n * @param events - The events to merge.\n * @returns A new Event that forwards emissions from all sources.\n *\n * @example\n * ```typescript\n * const mouseEvent = createEvent<MouseEvent>();\n * const keyboardEvent = createEvent<KeyboardEvent>();\n * const inputEvent = merge(mouseEvent, keyboardEvent);\n * inputEvent.on(event => console.log('Input event:', event));\n * ```\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<Events>>(() => {\n    for (const event of events) {\n      event.off(mergedEvent.sink);\n    }\n  });\n\n  for (const event of events) {\n    event.on(mergedEvent.sink);\n  }\n  return mergedEvent;\n};\n\n/**\n * Creates a periodic event that emits an incrementing counter (starting from 0) at a fixed interval.\n * Disposing the event clears the interval.\n *\n * @param interval - The interval in milliseconds.\n * @returns An Event that triggers at the specified interval.\n *\n * @example\n * ```typescript\n * const tickEvent = createInterval(1000);\n * tickEvent.on(tickNumber => console.log('Tick:', tickNumber));\n * ```\n */\nexport const createInterval = <R = unknown>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => {\n    intervalEvent.emit(counter++);\n  }, interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new Event instance for multi-listener event handling.\n *\n * @example\n * ```typescript\n * const messageEvent = createEvent<string>();\n * messageEvent.on(msg => console.log('Received:', msg));\n * messageEvent.emit('Hello'); // All listeners receive 'Hello'\n *\n * // Listeners can return values, collected via DispatchResult\n * const validateEvent = createEvent<string, boolean>();\n * validateEvent.on(str => str.length > 0);\n * validateEvent.on(str => str.length < 100);\n * const results = await validateEvent.emit('test').all(); // [true, true]\n * ```\n */\nexport const createEvent = <T = unknown, R = unknown>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * Extracts the listener function type from an Event type.\n * Useful for type-safe listener definitions.\n *\n * @template E - The Event type to extract the listener type from\n *\n * @example\n * ```typescript\n * type MyEvent = Event<string, boolean>;\n * type MyListener = EventHandler<MyEvent>; // (value: string) => boolean | Promise<boolean>\n * ```\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * Extracts a filter function type for an Event's parameters.\n * Used for creating type-safe event filters.\n *\n * @template E - The Event type to create a filter for\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * Extracts a predicate function type for an Event's parameters.\n * Used for type narrowing with event values.\n *\n * @template E - The Event type to create a predicate for\n * @template P - The narrowed type that the predicate validates\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * Extracts a mapper function type for transforming Event parameters.\n * Used for creating type-safe event value transformations.\n *\n * @template E - The Event type to create a mapper for\n * @template M - The target type to map event values to\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * Extracts a reducer function type for Event parameters.\n * Used for creating type-safe event value reducers.\n *\n * @template E - The Event type to create a reducer for\n * @template R - The accumulator type for the reduction\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["Disposer","ITERATOR_DONE","ITERATOR_DONE_PROMISE","Signal","ListenerRegistry","DispatchResult","EventIterator","signal","next","receive","then","value","done","return","Event","Symbol","toStringTag","onDispose","sink","emit","bind","handleEvent","event","size","dispatch","lacks","listener","has","off","on","once","clear","onfulfilled","onrejected","catch","finally","onfinally","settle","status","reason","asyncIterator","dispose","merge","events","mergedEvent","createInterval","interval","counter","intervalEvent","clearInterval","timerId","setInterval","createEvent"],"mappings":"AACA,SAASA,QAAQ,EAAEC,aAAa,EAAEC,qBAAqB,QAAQ,aAAa;AAC5E,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,gBAAgB,QAAQ,yBAAyB;AAC1D,SAASC,cAAc,QAAQ,uBAAuB;AAOtD,OAAO,MAAMC;IACX,CAAA,MAAO,CAAY;IAEnB,YAAYC,MAAiB,CAAE;QAC7B,IAAI,CAAC,CAAA,MAAO,GAAGA;IACjB;IAEAC,OAAyC;QACvC,OAAO,IAAI,CAAC,CAAA,MAAO,CAACC,OAAO,GAAGC,IAAI,CAChC,CAACC,QAAoC,CAAA;gBAAEA;gBAAOC,MAAM;YAAM,CAAA,GAC1D,IAA+BX;IAEnC;IAEAY,SAA2C;QACzC,OAAOX;IACT;AACF;AAeA,OAAO,MAAMY;IACX,CAAA,SAAU,GAAG,IAAIV,mBAAkC;IACnD,CAAA,MAAO,GAAG,IAAID,SAAY;IAC1B,CAAA,QAAS,CAAW;IACpB,CAAA,SAAU,CAAY;IACtB,CAAA,IAAK,CAAqC;IAEjC,CAACY,OAAOC,WAAW,CAAC,GAAG,QAAQ;IAexC,YAAYC,SAAoB,CAAE;QAChC,IAAI,CAAC,CAAA,SAAU,GAAGA;QAClB,IAAI,CAAC,CAAA,QAAS,GAAG,IAAIjB,SAAS,IAAI;IACpC;IAYA,IAAIkB,OAA0C;QAC5C,OAAQ,IAAI,CAAC,CAAA,IAAK,KAAK,IAAI,CAACC,IAAI,CAACC,IAAI,CAAC,IAAI;IAC5C;IAMAC,YAAYC,KAAQ,EAAQ;QAC1B,IAAI,CAACH,IAAI,CAACG;IACZ;IAKA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,SAAU,CAACA,IAAI;IAC7B;IAiBAJ,KAAKR,KAAQ,EAA4B;QACvC,IAAI,CAAC,CAAA,MAAO,CAACQ,IAAI,CAACR;QAClB,OAAO,IAAIN,eAAe,IAAI,CAAC,CAAA,SAAU,CAACmB,QAAQ,CAACb;IACrD;IAgBAc,MAAMC,QAAwB,EAAW;QACvC,OAAO,CAAC,IAAI,CAAC,CAAA,SAAU,CAACC,GAAG,CAACD;IAC9B;IAgBAC,IAAID,QAAwB,EAAW;QACrC,OAAO,IAAI,CAAC,CAAA,SAAU,CAACC,GAAG,CAACD;IAC7B;IAcAE,IAAIF,QAAwB,EAAQ;QAClC,IAAI,CAAC,CAAA,SAAU,CAACE,GAAG,CAACF;QACpB,OAAO,IAAI;IACb;IAeAG,GAAGH,QAAwB,EAAe;QACxC,IAAI,CAAC,CAAA,SAAU,CAACG,EAAE,CAACH;QACnB,OAAO,IAAM,KAAK,IAAI,CAACE,GAAG,CAACF;IAC7B;IAeAI,KAAKJ,QAAwB,EAAe;QAC1C,IAAI,CAAC,CAAA,SAAU,CAACI,IAAI,CAACJ;QACrB,OAAO,IAAM,KAAK,IAAI,CAACE,GAAG,CAACF;IAC7B;IAQAK,QAAc;QACZ,IAAI,CAAC,CAAA,SAAU,CAACA,KAAK;QACrB,OAAO,IAAI;IACb;IAOAtB,UAAsB;QACpB,OAAO,IAAI,CAAC,CAAA,MAAO,CAACA,OAAO;IAC7B;IAEAC,KAA0BsB,WAA8C,EAAEC,UAAoD,EAAqB;QACjJ,OAAO,IAAI,CAACxB,OAAO,GAAGC,IAAI,CAACsB,aAAaC;IAC1C;IAEAC,MAAmBD,UAAoD,EAAoB;QACzF,OAAO,IAAI,CAACxB,OAAO,GAAGyB,KAAK,CAACD;IAC9B;IAEAE,QAAQC,SAAyB,EAAc;QAC7C,OAAO,IAAI,CAAC3B,OAAO,GAAG0B,OAAO,CAACC;IAChC;IAkBAC,SAA2C;QACzC,OAAO,IAAI,CAAC5B,OAAO,GAAGC,IAAI,CACxB,CAACC,QAAW,CAAA;gBAAE2B,QAAQ;gBAAa3B;YAAM,CAAA,GACzC,CAAC4B,SAAqB,CAAA;gBAAED,QAAQ;gBAAYC;YAAO,CAAA;IAEvD;IAEA,CAACxB,OAAOyB,aAAa,CAAC,GAAiC;QACrD,OAAO,IAAIlC,cAAc,IAAI,CAAC,CAAA,MAAO;IACvC;IAEAmC,UAAgB;QACd,IAAI,CAAC1B,OAAO0B,OAAO,CAAC;IACtB;IAEA,CAAC1B,OAAO0B,OAAO,CAAC,GAAS;QACvB,IAAI,IAAI,CAAC,CAAA,QAAS,CAAC1B,OAAO0B,OAAO,CAAC,IAAI;YACpC,IAAI,CAAC,CAAA,MAAO,CAAC1B,OAAO0B,OAAO,CAAC;YAC5B,IAAI,CAAC,CAAA,SAAU,CAACV,KAAK;YACrB,KAAK,IAAI,CAAC,CAAA,SAAU;QACtB;IACF;AACF;AAyBA,OAAO,MAAMW,QAAQ,CAAmC,GAAGC;IACzD,MAAMC,cAAc,IAAI9B,MAA6D;QACnF,KAAK,MAAMQ,SAASqB,OAAQ;YAC1BrB,MAAMM,GAAG,CAACgB,YAAY1B,IAAI;QAC5B;IACF;IAEA,KAAK,MAAMI,SAASqB,OAAQ;QAC1BrB,MAAMO,EAAE,CAACe,YAAY1B,IAAI;IAC3B;IACA,OAAO0B;AACT,EAAE;AAeF,OAAO,MAAMC,iBAAiB,CAAcC;IAC1C,IAAIC,UAAU;IACd,MAAMC,gBAAgB,IAAIlC,MAAiB,IAAMmC,cAAcC;IAC/D,MAAMA,UAA0CC,YAAY;QAC1DH,cAAc7B,IAAI,CAAC4B;IACrB,GAAGD;IACH,OAAOE;AACT,EAAE;AAkBF,OAAO,MAAMI,cAAc,IAA6C,IAAItC,QAAc;AAE1F,eAAesC,YAAY"}

package/build/iterator.cjs

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "AsyncIteratorObject", {
     }
 });
 const _utilscjs = require("./utils.cjs");
+const _asynccjs = require("./async.cjs");
 class OpState {
     index;
     remaining;
@@ -330,45 +331,30 @@ function createSimpleIterable(source, ops) {
                         if (checkTakeExhausted(takeStates)) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         const sourceResult = await iterator.next();
                         if (sourceResult.done) {
                             done = true;
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         const result = await processOpsSimple(sourceResult.value, ops, opStates);
                         if (result.done) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         if (result.shouldYield) return {
                             value: result.value,
                             done: false
                         };
                     }
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 async return (returnValue) {
                     done = true;
                     await iterator.return?.(returnValue);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 async throw (error) {
                     done = true;
@@ -402,10 +388,7 @@ function createExpandingIterable(source, ops) {
                     done = true;
                     await closeInnerIterators();
                     await iterator.return?.();
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 }
                 if (result.expandIterator) {
                     innerStack.push({
@@ -461,36 +444,24 @@ function createExpandingIterable(source, ops) {
                         if (checkTakeExhausted(takeStates)) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         const sourceResult = await iterator.next();
                         if (sourceResult.done) {
                             done = true;
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return _asynccjs.ITERATOR_DONE;
                         }
                         const result = await processOps(sourceResult.value, ops, opStates, 0);
                         const handled = await handleResult(result);
                         if (handled) return handled;
                     }
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 async return (returnValue) {
                     done = true;
                     await closeInnerIterators();
                     await iterator.return?.(returnValue);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return _asynccjs.ITERATOR_DONE;
                 },
                 async throw (error) {
                     done = true;

package/build/iterator.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iterator.ts"],"sourcesContent":["import { mergeIterables, toAsyncIterable, pipe, isThenable } from './utils.js';\nimport { AnyIterable } from './types.js';\n\nconst enum OpKind {\n  MAP,\n  FILTER,\n  FILTER_MAP,\n  AWAITED,\n  INSPECT,\n  ENUMERATE,\n  TAKE,\n  DROP,\n  TAKE_WHILE,\n  DROP_WHILE,\n  REDUCE,\n  FLAT_MAP,\n  EXPAND,\n}\n\n/**\n * @internal\n * Represents a fusible operation that can be combined with other operations.\n */\ntype FusedOp =\n  | { kind: OpKind.MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.FILTER_MAP; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.AWAITED }\n  | { kind: OpKind.INSPECT; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.ENUMERATE; start: number }\n  | { kind: OpKind.TAKE; limit: number }\n  | { kind: OpKind.DROP; count: number }\n  | { kind: OpKind.TAKE_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.DROP_WHILE; fn: (value: unknown, index: number) => unknown }\n  | { kind: OpKind.REDUCE; fn: (acc: unknown, value: unknown, index: number) => unknown; init: unknown; hasInit: boolean }\n  | { kind: OpKind.FLAT_MAP; fn: (value: unknown, index: number) => AsyncIterable<unknown, void, unknown> }\n  | { kind: OpKind.EXPAND; fn: (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>> };\n\nclass OpState {\n  initialized = false;\n\n  constructor(\n    public index: number,\n    public remaining: number,\n    public dropping: boolean,\n    public value: unknown,\n  ) {}\n\n  static from(this: void, op: FusedOp): OpState {\n    switch (op.kind) {\n      case OpKind.ENUMERATE:\n        return new OpState(op.start, 0, false, undefined);\n      case OpKind.TAKE:\n        return new OpState(0, op.limit, false, undefined);\n      case OpKind.DROP:\n        return new OpState(0, op.count, false, undefined);\n      case OpKind.DROP_WHILE:\n        return new OpState(0, 0, true, undefined);\n      case OpKind.REDUCE:\n        return new OpState(0, 0, false, op.init);\n      default:\n        return new OpState(0, 0, false, undefined);\n    }\n  }\n}\n\nclass ProcessResult {\n  constructor(\n    readonly value: unknown,\n    readonly shouldYield: boolean,\n    readonly done: boolean,\n    readonly expandIterator: Iterator<unknown> | null,\n    readonly expandOpIndex: number,\n    readonly flatMapIterator: AsyncIterator<unknown> | null,\n    readonly flatMapOpIndex: number,\n  ) {}\n\n  static yield(value: unknown): ProcessResult {\n    return new ProcessResult(value, true, false, null, -1, null, -1);\n  }\n\n  static expand(iterator: Iterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, iterator, opIndex, null, -1);\n  }\n\n  static flatMap(iterator: AsyncIterator<unknown>, opIndex: number): ProcessResult {\n    return new ProcessResult(undefined, false, false, null, -1, iterator, opIndex);\n  }\n}\n\nconst CONTINUE = Object.freeze(new ProcessResult(undefined, false, false, null, -1, null, -1));\nconst DONE = Object.freeze(new ProcessResult(undefined, false, true, null, -1, null, -1));\n\nfunction findTakeStates(ops: FusedOp[], opStates: OpState[]): OpState[] {\n  const takeStates: OpState[] = [];\n  for (let i = 0; i < ops.length; i++) {\n    if (ops[i].kind === OpKind.TAKE) takeStates.push(opStates[i]);\n  }\n  return takeStates;\n}\n\nfunction hasExpandingOps(ops: FusedOp[]): boolean {\n  for (let i = 0; i < ops.length; i++) {\n    const kind = ops[i].kind;\n    if (kind === OpKind.FLAT_MAP || kind === OpKind.EXPAND) return true;\n  }\n  return false;\n}\n\nfunction checkTakeExhausted(takeStates: OpState[]): boolean {\n  for (let i = 0; i < takeStates.length; i++) {\n    if (takeStates[i].remaining <= 0) return true;\n  }\n  return false;\n}\n\nasync function processOps(inputValue: unknown, ops: FusedOp[], opStates: OpState[], startIndex: number): Promise<ProcessResult> {\n  let value = inputValue;\n\n  for (let i = startIndex; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return CONTINUE;\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return CONTINUE;\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        if (state.remaining <= 0) return DONE;\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return DONE;\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return CONTINUE;\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return CONTINUE;\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if (op.hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return CONTINUE;\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n\n      case OpKind.FLAT_MAP: {\n        const iterable = op.fn(value, state.index++);\n        return ProcessResult.flatMap(iterable[Symbol.asyncIterator](), i);\n      }\n\n      case OpKind.EXPAND: {\n        const result = op.fn(value, state.index++);\n        const expanded = isThenable(result) ? await result : result;\n        return ProcessResult.expand(expanded[Symbol.iterator](), i);\n      }\n    }\n  }\n\n  return ProcessResult.yield(value);\n}\n\nasync function processOpsSimple(inputValue: unknown, ops: FusedOp[], opStates: OpState[]): Promise<{ value: unknown; shouldYield: boolean; done: boolean }> {\n  let value = inputValue;\n\n  for (let i = 0; i < ops.length; i++) {\n    const op = ops[i];\n    const state = opStates[i];\n\n    switch (op.kind) {\n      case OpKind.MAP:\n        value = op.fn(value, state.index++);\n        break;\n\n      case OpKind.FILTER: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: false };\n        break;\n      }\n\n      case OpKind.FILTER_MAP: {\n        const result = op.fn(value, state.index++);\n        const resolved = isThenable(result) ? await result : result;\n        if (resolved === undefined) return { value: undefined, shouldYield: false, done: false };\n        value = resolved;\n        break;\n      }\n\n      case OpKind.AWAITED:\n        value = await value;\n        break;\n\n      case OpKind.INSPECT: {\n        const result = op.fn(value, state.index++);\n        if (isThenable(result)) await result;\n        break;\n      }\n\n      case OpKind.ENUMERATE:\n        value = [state.index++, value];\n        break;\n\n      case OpKind.TAKE:\n        state.remaining--;\n        break;\n\n      case OpKind.TAKE_WHILE: {\n        const result = op.fn(value, state.index++);\n        const passed = isThenable(result) ? await result : result;\n        if (!passed) return { value: undefined, shouldYield: false, done: true };\n        break;\n      }\n\n      case OpKind.DROP:\n        if (state.remaining > 0) {\n          state.remaining--;\n          return { value: undefined, shouldYield: false, done: false };\n        }\n        break;\n\n      case OpKind.DROP_WHILE:\n        if (state.dropping) {\n          const result = op.fn(value, state.index++);\n          const passed = isThenable(result) ? await result : result;\n          if (passed) return { value: undefined, shouldYield: false, done: false };\n          state.dropping = false;\n        }\n        break;\n\n      case OpKind.REDUCE: {\n        if (!state.initialized) {\n          state.initialized = true;\n          if ((op as { hasInit: boolean }).hasInit) {\n            const result = op.fn(state.value, value, state.index++);\n            state.value = isThenable(result) ? await result : result;\n            value = state.value;\n          } else {\n            state.value = value;\n            return { value: undefined, shouldYield: false, done: false };\n          }\n        } else {\n          const result = op.fn(state.value, value, state.index++);\n          state.value = isThenable(result) ? await result : result;\n          value = state.value;\n        }\n        break;\n      }\n    }\n  }\n\n  return { value, shouldYield: true, done: false };\n}\n\nfunction collectOps(iter: AsyncIteratorObject<unknown, unknown, unknown>): FusedOp[] {\n  const ops: FusedOp[] = [];\n  let current: AsyncIteratorObject<unknown, unknown, unknown> | null = iter;\n  while (current) {\n    const op = current.op;\n    if (op) ops.push(op);\n    current = current.parent;\n  }\n  ops.reverse();\n  return ops;\n}\n\nfunction getSource(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, unknown, unknown> {\n  let current = iter;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current.iterable;\n}\n\nfunction createSimpleIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n      let done = false;\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOpsSimple(sourceResult.value, ops, opStates);\n            if (result.done) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n            if (result.shouldYield) return { value: result.value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\ntype InnerFrame = { type: 'expand'; iterator: Iterator<unknown>; opIndex: number } | { type: 'flatMap'; iterator: AsyncIterator<unknown>; opIndex: number };\n\nfunction createExpandingIterable(source: AsyncIterable<unknown, unknown, unknown>, ops: FusedOp[]): AsyncIterable<unknown, void, unknown> {\n  return {\n    [Symbol.asyncIterator]: () => {\n      const iterator = source[Symbol.asyncIterator]();\n      const opStates = ops.map(OpState.from);\n      const takeStates = findTakeStates(ops, opStates);\n\n      let done = false;\n      const innerStack: InnerFrame[] = [];\n\n      const closeInnerIterators = async () => {\n        for (const frame of innerStack) {\n          if (frame.type === 'flatMap') {\n            await frame.iterator.return?.();\n          }\n        }\n        innerStack.length = 0;\n      };\n\n      const handleResult = async (result: ProcessResult): Promise<IteratorResult<unknown, void> | null> => {\n        if (result.done) {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.();\n          return { value: undefined, done: true };\n        }\n        if (result.expandIterator) {\n          innerStack.push({ type: 'expand', iterator: result.expandIterator, opIndex: result.expandOpIndex });\n          return null;\n        }\n        if (result.flatMapIterator) {\n          innerStack.push({ type: 'flatMap', iterator: result.flatMapIterator, opIndex: result.flatMapOpIndex });\n          return null;\n        }\n        if (result.shouldYield) {\n          return { value: result.value, done: false };\n        }\n        return null;\n      };\n\n      return {\n        async next(): Promise<IteratorResult<unknown, void>> {\n          while (!done) {\n            if (innerStack.length > 0) {\n              const frame = innerStack[innerStack.length - 1];\n              if (frame.type === 'expand') {\n                const expandResult = frame.iterator.next();\n                if (!expandResult.done) {\n                  const result = await processOps(expandResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              } else {\n                const flatMapResult = await frame.iterator.next();\n                if (!flatMapResult.done) {\n                  const result = await processOps(flatMapResult.value, ops, opStates, frame.opIndex + 1);\n                  const handled = await handleResult(result);\n                  if (handled) return handled;\n                  continue;\n                }\n                innerStack.pop();\n                continue;\n              }\n            }\n\n            if (checkTakeExhausted(takeStates)) {\n              done = true;\n              await iterator.return?.();\n              return { value: undefined, done: true };\n            }\n\n            const sourceResult = await iterator.next();\n            if (sourceResult.done) {\n              done = true;\n              return { value: undefined, done: true };\n            }\n\n            const result = await processOps(sourceResult.value, ops, opStates, 0);\n            const handled = await handleResult(result);\n            if (handled) return handled;\n          }\n\n          return { value: undefined, done: true };\n        },\n\n        async return(returnValue?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          await iterator.return?.(returnValue);\n          return { value: undefined, done: true };\n        },\n\n        async throw(error?: unknown): Promise<IteratorResult<unknown, void>> {\n          done = true;\n          await closeInnerIterators();\n          if (iterator.throw) {\n            await iterator.throw(error);\n          }\n          throw error;\n        },\n      };\n    },\n  };\n}\n\nfunction createFusedIterable(iter: AsyncIteratorObject<unknown, unknown, unknown>): AsyncIterable<unknown, void, unknown> {\n  const source = getSource(iter);\n  const ops = iter.cachedOps ?? (iter.cachedOps = collectOps(iter));\n\n  if (ops.length === 0) {\n    return source as AsyncIterable<unknown, void, unknown>;\n  }\n\n  return hasExpandingOps(ops) ? createExpandingIterable(source, ops) : createSimpleIterable(source, ops);\n}\n\n/**\n * A wrapper class providing functional operations on async iterables.\n * Enables lazy evaluation and chainable transformations on async data streams.\n *\n * Key characteristics:\n * - Lazy evaluation - operations are not executed until iteration begins\n * - Chainable - all transformation methods return new AsyncIteratorObject instances\n * - Supports both sync and async transformation functions\n * - Memory efficient - processes values one at a time\n * - Operation fusion - chains execute in optimized passes\n *\n * @template T The type of values yielded by the iterator\n * @template TReturn The return type of the iterator\n * @template TNext The type of value that can be passed to next()\n *\n * @example\n * ```typescript\n * // Create from an async generator\n * async function* numbers() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const iterator = new AsyncIteratorObject(numbers())\n *   .map(x => x * 2)\n *   .filter(x => x > 2);\n *\n * for await (const value of iterator) {\n *   console.log(value); // 4, 6\n * }\n * ```\n */\nexport class AsyncIteratorObject<T, TReturn, TNext> {\n  /**\n   * Creates an AsyncIteratorObject from a synchronous iterable.\n   * Converts the sync iterable to async for uniform handling.\n   *\n   * @param iterable A synchronous iterable to convert\n   * @returns A new AsyncIteratorObject wrapping the converted iterable\n   *\n   * @example\n   * ```typescript\n   * const syncArray = [1, 2, 3, 4, 5];\n   * const asyncIterator = AsyncIteratorObject.from(syncArray);\n   *\n   * for await (const value of asyncIterator) {\n   *   console.log(value); // 1, 2, 3, 4, 5\n   * }\n   * ```\n   */\n  static from<T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIteratorObject<T, TReturn, TNext> {\n    const asyncIterable = toAsyncIterable(iterable);\n    return new AsyncIteratorObject<T, TReturn, TNext>(asyncIterable);\n  }\n\n  /**\n   * Merges multiple async iterables into a single stream.\n   * Values from all sources are interleaved as they become available.\n   * The merged iterator completes when all source iterators complete.\n   *\n   * @param iterables The async iterables to merge\n   * @returns A new AsyncIteratorObject yielding values from all sources\n   *\n   * @example\n   * ```typescript\n   * async function* source1() { yield 1; yield 3; }\n   * async function* source2() { yield 2; yield 4; }\n   *\n   * const merged = AsyncIteratorObject.merge(source1(), source2());\n   *\n   * for await (const value of merged) {\n   *   console.log(value); // Order depends on timing: 1, 2, 3, 4 or similar\n   * }\n   * ```\n   */\n  static merge<T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(mergeIterables(...iterables));\n  }\n\n  /** @internal */\n  iterable: AsyncIterable<unknown, unknown, unknown>;\n  /** @internal */\n  parent: AsyncIteratorObject<unknown, unknown, unknown> | null;\n  /** @internal */\n  op: FusedOp | null;\n  /** @internal */\n  cachedOps: FusedOp[] | null = null;\n\n  readonly [Symbol.toStringTag] = 'AsyncIteratorObject';\n\n  constructor(iterable: AsyncIterable<T, TReturn, TNext>, parent: AsyncIteratorObject<unknown, unknown, unknown> | null = null, op: FusedOp | null = null) {\n    this.iterable = iterable as AsyncIterable<unknown, unknown, unknown>;\n    this.parent = parent;\n    this.op = op;\n  }\n\n  /**\n   * Escape hatch for custom transformations not covered by the built-in operators.\n   * Materializes the fused operation chain, then applies a generator function to each value.\n   *\n   * @param generatorFactory A function that returns a generator function for transforming values\n   * @param signal Optional AbortSignal to cancel the operation\n   * @returns A new AsyncIteratorObject with transformed values\n   */\n  pipe<U>(generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>, signal?: AbortSignal): AsyncIteratorObject<U, void, unknown> {\n    const materialized = createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>);\n    const generator = pipe(materialized as AsyncIterable<T>, generatorFactory, signal);\n    return new AsyncIteratorObject<U, void, unknown>(generator);\n  }\n\n  /**\n   * Resolves promise-like values from the source iterator.\n   * Useful for normalizing values before applying type-guard predicates.\n   *\n   * @returns A new AsyncIteratorObject yielding awaited values\n   */\n  awaited(): AsyncIteratorObject<Awaited<T>, void, unknown> {\n    return new AsyncIteratorObject<Awaited<T>, void, unknown>(\n      this.iterable as AsyncIterable<Awaited<T>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.AWAITED },\n    );\n  }\n\n  /**\n   * Transforms each value using a mapping function.\n   * The callback can be synchronous or return a promise.\n   *\n   * @param callbackfn Function to transform each value\n   * @returns A new AsyncIteratorObject yielding transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const doubled = numbers.map(x => x * 2);\n   *\n   * for await (const value of doubled) {\n   *   console.log(value); // 2, 4, 6\n   * }\n   * ```\n   */\n  map<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.MAP,\n      fn: callbackfn as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Filters values based on a predicate function.\n   * Only values for which the predicate returns truthy are yielded.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding only values that pass the test\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const evens = numbers.filter(x => x % 2 === 0);\n   *\n   * for await (const value of evens) {\n   *   console.log(value); // 2, 4\n   * }\n   * ```\n   */\n  filter(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FILTER,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Combined filter and map operation. Returns undefined to skip a value.\n   * The callback result is awaited to check for undefined.\n   *\n   * @param callbackfn Function that returns a transformed value or undefined to skip\n   * @returns A new AsyncIteratorObject yielding non-undefined transformed values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const doubledEvens = numbers.filterMap(x => x % 2 === 0 ? x * 2 : undefined);\n   *\n   * for await (const value of doubledEvens) {\n   *   console.log(value); // 4, 8\n   * }\n   * ```\n   */\n  filterMap<U>(callbackfn: (value: T, index: number) => U): AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown> {\n    return new AsyncIteratorObject<Exclude<Awaited<U>, undefined>, void, unknown>(\n      this.iterable as AsyncIterable<Exclude<Awaited<U>, undefined>, void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.FILTER_MAP, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Executes a side-effect function for each value without modifying the stream.\n   * Useful for debugging or logging. The callback is awaited for proper sequencing.\n   *\n   * @param callbackfn Function to execute for each value\n   * @returns A new AsyncIteratorObject yielding the same values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const logged = numbers.inspect(x => console.log('value:', x)).map(x => x * 2);\n   * ```\n   */\n  inspect(callbackfn: (value: T, index: number) => unknown): AsyncIteratorObject<T, TReturn, TNext> {\n    return new AsyncIteratorObject<T, TReturn, TNext>(\n      this.iterable as AsyncIterable<T, TReturn, TNext>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.INSPECT, fn: callbackfn as (value: unknown, index: number) => unknown },\n    );\n  }\n\n  /**\n   * Wraps each value with its index as a tuple.\n   * Useful after filtering when original indices are lost.\n   *\n   * @param start Starting index (default: 0)\n   * @returns A new AsyncIteratorObject yielding [index, value] tuples\n   *\n   * @example\n   * ```typescript\n   * const letters = AsyncIteratorObject.from(['a', 'b', 'c']);\n   * const enumerated = letters.enumerate();\n   *\n   * for await (const [i, v] of enumerated) {\n   *   console.log(i, v); // 0 'a', 1 'b', 2 'c'\n   * }\n   * ```\n   */\n  enumerate(start: number = 0): AsyncIteratorObject<[number, T], void, unknown> {\n    return new AsyncIteratorObject<[number, T], void, unknown>(\n      this.iterable as AsyncIterable<[number, T], void, unknown>,\n      this as AsyncIteratorObject<unknown, unknown, unknown>,\n      { kind: OpKind.ENUMERATE, start },\n    );\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.\n   * @param limit The maximum number of values to yield.\n   */\n  take(limit: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE,\n      limit,\n    });\n  }\n\n  /**\n   * Takes values while the predicate returns truthy.\n   * Stops immediately when predicate returns falsy.\n   * Supports type guard predicates for type narrowing.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject yielding values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const small = numbers.takeWhile(x => x < 4);\n   *\n   * for await (const value of small) {\n   *   console.log(value); // 1, 2, 3\n   * }\n   * ```\n   */\n  takeWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown>;\n  takeWhile<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, void, unknown> {\n    return new AsyncIteratorObject<S, void, unknown>(this.iterable as AsyncIterable<S, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.TAKE_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the values from this iterator after skipping the provided count.\n   * @param count The number of values to drop.\n   */\n  drop(count: number): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP,\n      count,\n    });\n  }\n\n  /**\n   * Skips values while the predicate returns truthy.\n   * Yields all remaining values once predicate returns falsy.\n   *\n   * @param predicate Function to test each value\n   * @returns A new AsyncIteratorObject skipping values until predicate fails\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4, 5]);\n   * const afterSmall = numbers.dropWhile(x => x < 3);\n   *\n   * for await (const value of afterSmall) {\n   *   console.log(value); // 3, 4, 5\n   * }\n   * ```\n   */\n  dropWhile(predicate: (value: T, index: number) => unknown): AsyncIteratorObject<T, void, unknown> {\n    return new AsyncIteratorObject<T, void, unknown>(this.iterable as AsyncIterable<T, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.DROP_WHILE,\n      fn: predicate as (value: unknown, index: number) => unknown,\n    });\n  }\n\n  /**\n   * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.\n   * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.\n   */\n  flatMap<U>(callback: (value: T, index: number) => AsyncIterable<U, void, unknown>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.FLAT_MAP,\n      fn: callback as (value: unknown, index: number) => AsyncIterable<unknown, void, unknown>,\n    });\n  }\n\n  /**\n   * Creates an iterator of accumulated values by applying a reducer function.\n   * Unlike Array.reduce, this returns an iterator that yields each intermediate accumulated value,\n   * not just the final result. This allows observing the accumulation process.\n   *\n   * @param callbackfn Reducer function to accumulate values\n   * @param initialValue Optional initial value for the accumulation\n   * @returns A new AsyncIteratorObject yielding accumulated values at each step\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3, 4]);\n   * const sums = numbers.reduce((sum, x) => sum + x, 0);\n   *\n   * for await (const value of sums) {\n   *   console.log(value); // 1, 3, 6, 10 (running totals)\n   * }\n   * ```\n   */\n  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T | PromiseLike<T>): AsyncIteratorObject<T, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    initialValue: R,\n  ): AsyncIteratorObject<R, void, unknown>;\n  reduce<R>(\n    callbackfn: (previousValue: R, currentValue: T, currentIndex: number) => R | PromiseLike<R>,\n    ...args: unknown[]\n  ): AsyncIteratorObject<R, void, unknown> {\n    const hasInit = args.length > 0;\n    return new AsyncIteratorObject<R, void, unknown>(this.iterable as AsyncIterable<R, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.REDUCE,\n      fn: callbackfn as (acc: unknown, value: unknown, index: number) => unknown,\n      init: args[0],\n      hasInit,\n    });\n  }\n\n  /**\n   * Transforms each value into multiple values using an expander function.\n   * Each input value is expanded into zero or more output values.\n   * Like `flatMap` but takes sync Iterables (or Promises of Iterables) instead of AsyncIterables.\n   *\n   * @param callbackfn Function that returns an iterable of values for each input\n   * @returns A new AsyncIteratorObject yielding all expanded values\n   *\n   * @example\n   * ```typescript\n   * const numbers = AsyncIteratorObject.from([1, 2, 3]);\n   * const expanded = numbers.expand(x => [x, x * 10]);\n   *\n   * for await (const value of expanded) {\n   *   console.log(value); // 1, 10, 2, 20, 3, 30\n   * }\n   * ```\n   */\n  expand<U>(callbackfn: (value: T, index: number) => Promise<Iterable<U>> | Iterable<U>): AsyncIteratorObject<U, void, unknown> {\n    return new AsyncIteratorObject<U, void, unknown>(this.iterable as AsyncIterable<U, void, unknown>, this as AsyncIteratorObject<unknown, unknown, unknown>, {\n      kind: OpKind.EXPAND,\n      fn: callbackfn as (value: unknown, index: number) => Iterable<unknown> | Promise<Iterable<unknown>>,\n    });\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n    return createFusedIterable(this as AsyncIteratorObject<unknown, unknown, unknown>)[Symbol.asyncIterator]() as AsyncIterator<T, TReturn, TNext>;\n  }\n}\n"],"names":["AsyncIteratorObject","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","yield","expand","iterator","opIndex","flatMap","CONTINUE","Object","freeze","DONE","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","isThenable","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","asyncIterable","toAsyncIterable","merge","iterables","mergeIterables","toStringTag","pipe","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":"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"}
+{"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":["AsyncIteratorObject","OpState","initialized","index","remaining","dropping","value","from","op","kind","start","undefined","limit","count","init","ProcessResult","shouldYield","done","expandIterator","expandOpIndex","flatMapIterator","flatMapOpIndex","yield","expand","iterator","opIndex","flatMap","CONTINUE","Object","freeze","DONE","findTakeStates","ops","opStates","takeStates","i","length","push","hasExpandingOps","checkTakeExhausted","processOps","inputValue","startIndex","state","fn","result","passed","isThenable","resolved","hasInit","iterable","Symbol","asyncIterator","expanded","processOpsSimple","collectOps","iter","current","parent","reverse","getSource","createSimpleIterable","source","map","next","return","ITERATOR_DONE","sourceResult","returnValue","throw","error","createExpandingIterable","innerStack","closeInnerIterators","frame","type","handleResult","expandResult","handled","pop","flatMapResult","createFusedIterable","cachedOps","asyncIterable","toAsyncIterable","merge","iterables","mergeIterables","toStringTag","pipe","generatorFactory","signal","materialized","generator","awaited","callbackfn","filter","predicate","filterMap","inspect","enumerate","take","takeWhile","drop","dropWhile","callback","reduce","args"],"mappings":";;;;+BAyhBaA;;;eAAAA;;;0BAzhBqD;0BACpC;AAsC9B,MAAMC;;;;;IACJC,cAAc,MAAM;IAEpB,YACE,AAAOC,KAAa,EACpB,AAAOC,SAAiB,EACxB,AAAOC,QAAiB,EACxB,AAAOC,KAAc,CACrB;aAJOH,QAAAA;aACAC,YAAAA;aACAC,WAAAA;aACAC,QAAAA;IACN;IAEH,OAAOC,KAAiBC,EAAW,EAAW;QAC5C,OAAQA,GAAGC,IAAI;YACb;gBACE,OAAO,IAAIR,QAAQO,GAAGE,KAAK,EAAE,GAAG,OAAOC;YACzC;gBACE,OAAO,IAAIV,QAAQ,GAAGO,GAAGI,KAAK,EAAE,OAAOD;YACzC;gBACE,OAAO,IAAIV,QAAQ,GAAGO,GAAGK,KAAK,EAAE,OAAOF;YACzC;gBACE,OAAO,IAAIV,QAAQ,GAAG,GAAG,MAAMU;YACjC;gBACE,OAAO,IAAIV,QAAQ,GAAG,GAAG,OAAOO,GAAGM,IAAI;YACzC;gBACE,OAAO,IAAIb,QAAQ,GAAG,GAAG,OAAOU;QACpC;IACF;AACF;AAEA,MAAMI;;;;;;;;IACJ,YACE,AAAST,KAAc,EACvB,AAASU,WAAoB,EAC7B,AAASC,IAAa,EACtB,AAASC,cAAwC,EACjD,AAASC,aAAqB,EAC9B,AAASC,eAA8C,EACvD,AAASC,cAAsB,CAC/B;aAPSf,QAAAA;aACAU,cAAAA;aACAC,OAAAA;aACAC,iBAAAA;aACAC,gBAAAA;aACAC,kBAAAA;aACAC,iBAAAA;IACR;IAEH,OAAOC,MAAMhB,KAAc,EAAiB;QAC1C,OAAO,IAAIS,cAAcT,OAAO,MAAM,OAAO,MAAM,CAAC,GAAG,MAAM,CAAC;IAChE;IAEA,OAAOiB,OAAOC,QAA2B,EAAEC,OAAe,EAAiB;QACzE,OAAO,IAAIV,cAAcJ,WAAW,OAAO,OAAOa,UAAUC,SAAS,MAAM,CAAC;IAC9E;IAEA,OAAOC,QAAQF,QAAgC,EAAEC,OAAe,EAAiB;QAC/E,OAAO,IAAIV,cAAcJ,WAAW,OAAO,OAAO,MAAM,CAAC,GAAGa,UAAUC;IACxE;AACF;AAEA,MAAME,WAAWC,OAAOC,MAAM,CAAC,IAAId,cAAcJ,WAAW,OAAO,OAAO,MAAM,CAAC,GAAG,MAAM,CAAC;AAC3F,MAAMmB,OAAOF,OAAOC,MAAM,CAAC,IAAId,cAAcJ,WAAW,OAAO,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC;AAEtF,SAASoB,eAAeC,GAAc,EAAEC,QAAmB;IACzD,MAAMC,aAAwB,EAAE;IAChC,IAAK,IAAIC,IAAI,GAAGA,IAAIH,IAAII,MAAM,EAAED,IAAK;QACnC,IAAIH,GAAG,CAACG,EAAE,CAAC1B,IAAI,QAAkByB,WAAWG,IAAI,CAACJ,QAAQ,CAACE,EAAE;IAC9D;IACA,OAAOD;AACT;AAEA,SAASI,gBAAgBN,GAAc;IACrC,IAAK,IAAIG,IAAI,GAAGA,IAAIH,IAAII,MAAM,EAAED,IAAK;QACnC,MAAM1B,OAAOuB,GAAG,CAACG,EAAE,CAAC1B,IAAI;QACxB,IAAIA,eAA4BA,aAAwB,OAAO;IACjE;IACA,OAAO;AACT;AAEA,SAAS8B,mBAAmBL,UAAqB;IAC/C,IAAK,IAAIC,IAAI,GAAGA,IAAID,WAAWE,MAAM,EAAED,IAAK;QAC1C,IAAID,UAAU,CAACC,EAAE,CAAC/B,SAAS,IAAI,GAAG,OAAO;IAC3C;IACA,OAAO;AACT;AAEA,eAAeoC,WAAWC,UAAmB,EAAET,GAAc,EAAEC,QAAmB,EAAES,UAAkB;IACpG,IAAIpC,QAAQmC;IAEZ,IAAK,IAAIN,IAAIO,YAAYP,IAAIH,IAAII,MAAM,EAAED,IAAK;QAC5C,MAAM3B,KAAKwB,GAAG,CAACG,EAAE;QACjB,MAAMQ,QAAQV,QAAQ,CAACE,EAAE;QAEzB,OAAQ3B,GAAGC,IAAI;YACb;gBACEH,QAAQE,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;gBAChC;YAEF;gBAAoB;oBAClB,MAAM0C,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAI,CAACC,QAAQ,OAAOnB;oBACpB;gBACF;YAEA;gBAAwB;oBACtB,MAAMkB,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM6C,WAAWD,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACrD,IAAIG,aAAarC,WAAW,OAAOgB;oBACnCrB,QAAQ0C;oBACR;gBACF;YAEA;gBACE1C,QAAQ,MAAMA;gBACd;YAEF;gBAAqB;oBACnB,MAAMuC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,IAAI4C,IAAAA,oBAAU,EAACF,SAAS,MAAMA;oBAC9B;gBACF;YAEA;gBACEvC,QAAQ;oBAACqC,MAAMxC,KAAK;oBAAIG;iBAAM;gBAC9B;YAEF;gBACE,IAAIqC,MAAMvC,SAAS,IAAI,GAAG,OAAO0B;gBACjCa,MAAMvC,SAAS;gBACf;YAEF;gBAAwB;oBACtB,MAAMyC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAI,CAACC,QAAQ,OAAOhB;oBACpB;gBACF;YAEA;gBACE,IAAIa,MAAMvC,SAAS,GAAG,GAAG;oBACvBuC,MAAMvC,SAAS;oBACf,OAAOuB;gBACT;gBACA;YAEF;gBACE,IAAIgB,MAAMtC,QAAQ,EAAE;oBAClB,MAAMwC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAIC,QAAQ,OAAOnB;oBACnBgB,MAAMtC,QAAQ,GAAG;gBACnB;gBACA;YAEF;gBAAoB;oBAClB,IAAI,CAACsC,MAAMzC,WAAW,EAAE;wBACtByC,MAAMzC,WAAW,GAAG;wBACpB,IAAIM,GAAGyC,OAAO,EAAE;4BACd,MAAMJ,SAASrC,GAAGoC,EAAE,CAACD,MAAMrC,KAAK,EAAEA,OAAOqC,MAAMxC,KAAK;4BACpDwC,MAAMrC,KAAK,GAAGyC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;4BAClDvC,QAAQqC,MAAMrC,KAAK;wBACrB,OAAO;4BACLqC,MAAMrC,KAAK,GAAGA;4BACd,OAAOqB;wBACT;oBACF,OAAO;wBACL,MAAMkB,SAASrC,GAAGoC,EAAE,CAACD,MAAMrC,KAAK,EAAEA,OAAOqC,MAAMxC,KAAK;wBACpDwC,MAAMrC,KAAK,GAAGyC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;wBAClDvC,QAAQqC,MAAMrC,KAAK;oBACrB;oBACA;gBACF;YAEA;gBAAsB;oBACpB,MAAM4C,WAAW1C,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACzC,OAAOY,cAAcW,OAAO,CAACwB,QAAQ,CAACC,OAAOC,aAAa,CAAC,IAAIjB;gBACjE;YAEA;gBAAoB;oBAClB,MAAMU,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAMkD,WAAWN,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACrD,OAAO9B,cAAcQ,MAAM,CAAC8B,QAAQ,CAACF,OAAO3B,QAAQ,CAAC,IAAIW;gBAC3D;QACF;IACF;IAEA,OAAOpB,cAAcO,KAAK,CAAChB;AAC7B;AAEA,eAAegD,iBAAiBb,UAAmB,EAAET,GAAc,EAAEC,QAAmB;IACtF,IAAI3B,QAAQmC;IAEZ,IAAK,IAAIN,IAAI,GAAGA,IAAIH,IAAII,MAAM,EAAED,IAAK;QACnC,MAAM3B,KAAKwB,GAAG,CAACG,EAAE;QACjB,MAAMQ,QAAQV,QAAQ,CAACE,EAAE;QAEzB,OAAQ3B,GAAGC,IAAI;YACb;gBACEH,QAAQE,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;gBAChC;YAEF;gBAAoB;oBAClB,MAAM0C,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAI,CAACC,QAAQ,OAAO;wBAAExC,OAAOK;wBAAWK,aAAa;wBAAOC,MAAM;oBAAM;oBACxE;gBACF;YAEA;gBAAwB;oBACtB,MAAM4B,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM6C,WAAWD,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACrD,IAAIG,aAAarC,WAAW,OAAO;wBAAEL,OAAOK;wBAAWK,aAAa;wBAAOC,MAAM;oBAAM;oBACvFX,QAAQ0C;oBACR;gBACF;YAEA;gBACE1C,QAAQ,MAAMA;gBACd;YAEF;gBAAqB;oBACnB,MAAMuC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,IAAI4C,IAAAA,oBAAU,EAACF,SAAS,MAAMA;oBAC9B;gBACF;YAEA;gBACEvC,QAAQ;oBAACqC,MAAMxC,KAAK;oBAAIG;iBAAM;gBAC9B;YAEF;gBACEqC,MAAMvC,SAAS;gBACf;YAEF;gBAAwB;oBACtB,MAAMyC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAI,CAACC,QAAQ,OAAO;wBAAExC,OAAOK;wBAAWK,aAAa;wBAAOC,MAAM;oBAAK;oBACvE;gBACF;YAEA;gBACE,IAAI0B,MAAMvC,SAAS,GAAG,GAAG;oBACvBuC,MAAMvC,SAAS;oBACf,OAAO;wBAAEE,OAAOK;wBAAWK,aAAa;wBAAOC,MAAM;oBAAM;gBAC7D;gBACA;YAEF;gBACE,IAAI0B,MAAMtC,QAAQ,EAAE;oBAClB,MAAMwC,SAASrC,GAAGoC,EAAE,CAACtC,OAAOqC,MAAMxC,KAAK;oBACvC,MAAM2C,SAASC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;oBACnD,IAAIC,QAAQ,OAAO;wBAAExC,OAAOK;wBAAWK,aAAa;wBAAOC,MAAM;oBAAM;oBACvE0B,MAAMtC,QAAQ,GAAG;gBACnB;gBACA;YAEF;gBAAoB;oBAClB,IAAI,CAACsC,MAAMzC,WAAW,EAAE;wBACtByC,MAAMzC,WAAW,GAAG;wBACpB,IAAI,AAACM,GAA4ByC,OAAO,EAAE;4BACxC,MAAMJ,SAASrC,GAAGoC,EAAE,CAACD,MAAMrC,KAAK,EAAEA,OAAOqC,MAAMxC,KAAK;4BACpDwC,MAAMrC,KAAK,GAAGyC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;4BAClDvC,QAAQqC,MAAMrC,KAAK;wBACrB,OAAO;4BACLqC,MAAMrC,KAAK,GAAGA;4BACd,OAAO;gCAAEA,OAAOK;gCAAWK,aAAa;gCAAOC,MAAM;4BAAM;wBAC7D;oBACF,OAAO;wBACL,MAAM4B,SAASrC,GAAGoC,EAAE,CAACD,MAAMrC,KAAK,EAAEA,OAAOqC,MAAMxC,KAAK;wBACpDwC,MAAMrC,KAAK,GAAGyC,IAAAA,oBAAU,EAACF,UAAU,MAAMA,SAASA;wBAClDvC,QAAQqC,MAAMrC,KAAK;oBACrB;oBACA;gBACF;QACF;IACF;IAEA,OAAO;QAAEA;QAAOU,aAAa;QAAMC,MAAM;IAAM;AACjD;AAEA,SAASsC,WAAWC,IAAoD;IACtE,MAAMxB,MAAiB,EAAE;IACzB,IAAIyB,UAAiED;IACrE,MAAOC,QAAS;QACd,MAAMjD,KAAKiD,QAAQjD,EAAE;QACrB,IAAIA,IAAIwB,IAAIK,IAAI,CAAC7B;QACjBiD,UAAUA,QAAQC,MAAM;IAC1B;IACA1B,IAAI2B,OAAO;IACX,OAAO3B;AACT;AAEA,SAAS4B,UAAUJ,IAAoD;IACrE,IAAIC,UAAUD;IACd,MAAOC,QAAQC,MAAM,CAAE;QACrBD,UAAUA,QAAQC,MAAM;IAC1B;IACA,OAAOD,QAAQP,QAAQ;AACzB;AAEA,SAASW,qBAAqBC,MAAgD,EAAE9B,GAAc;IAC5F,OAAO;QACL,CAACmB,OAAOC,aAAa,CAAC,EAAE;YACtB,MAAM5B,WAAWsC,MAAM,CAACX,OAAOC,aAAa,CAAC;YAC7C,MAAMnB,WAAWD,IAAI+B,GAAG,CAAC9D,QAAQM,IAAI;YACrC,MAAM2B,aAAaH,eAAeC,KAAKC;YACvC,IAAIhB,OAAO;YAEX,OAAO;gBACL,MAAM+C;oBACJ,MAAO,CAAC/C,KAAM;wBACZ,IAAIsB,mBAAmBL,aAAa;4BAClCjB,OAAO;4BACP,MAAMO,SAASyC,MAAM;4BACrB,OAAOC,uBAAa;wBACtB;wBAEA,MAAMC,eAAe,MAAM3C,SAASwC,IAAI;wBACxC,IAAIG,aAAalD,IAAI,EAAE;4BACrBA,OAAO;4BACP,OAAOiD,uBAAa;wBACtB;wBAEA,MAAMrB,SAAS,MAAMS,iBAAiBa,aAAa7D,KAAK,EAAE0B,KAAKC;wBAC/D,IAAIY,OAAO5B,IAAI,EAAE;4BACfA,OAAO;4BACP,MAAMO,SAASyC,MAAM;4BACrB,OAAOC,uBAAa;wBACtB;wBACA,IAAIrB,OAAO7B,WAAW,EAAE,OAAO;4BAAEV,OAAOuC,OAAOvC,KAAK;4BAAEW,MAAM;wBAAM;oBACpE;oBACA,OAAOiD,uBAAa;gBACtB;gBAEA,MAAMD,QAAOG,WAAqB;oBAChCnD,OAAO;oBACP,MAAMO,SAASyC,MAAM,GAAGG;oBACxB,OAAOF,uBAAa;gBACtB;gBAEA,MAAMG,OAAMC,KAAe;oBACzBrD,OAAO;oBACP,IAAIO,SAAS6C,KAAK,EAAE;wBAClB,MAAM7C,SAAS6C,KAAK,CAACC;oBACvB;oBACA,MAAMA;gBACR;YACF;QACF;IACF;AACF;AAIA,SAASC,wBAAwBT,MAAgD,EAAE9B,GAAc;IAC/F,OAAO;QACL,CAACmB,OAAOC,aAAa,CAAC,EAAE;YACtB,MAAM5B,WAAWsC,MAAM,CAACX,OAAOC,aAAa,CAAC;YAC7C,MAAMnB,WAAWD,IAAI+B,GAAG,CAAC9D,QAAQM,IAAI;YACrC,MAAM2B,aAAaH,eAAeC,KAAKC;YAEvC,IAAIhB,OAAO;YACX,MAAMuD,aAA2B,EAAE;YAEnC,MAAMC,sBAAsB;gBAC1B,KAAK,MAAMC,SAASF,WAAY;oBAC9B,IAAIE,MAAMC,IAAI,KAAK,WAAW;wBAC5B,MAAMD,MAAMlD,QAAQ,CAACyC,MAAM;oBAC7B;gBACF;gBACAO,WAAWpC,MAAM,GAAG;YACtB;YAEA,MAAMwC,eAAe,OAAO/B;gBAC1B,IAAIA,OAAO5B,IAAI,EAAE;oBACfA,OAAO;oBACP,MAAMwD;oBACN,MAAMjD,SAASyC,MAAM;oBACrB,OAAOC,uBAAa;gBACtB;gBACA,IAAIrB,OAAO3B,cAAc,EAAE;oBACzBsD,WAAWnC,IAAI,CAAC;wBAAEsC,MAAM;wBAAUnD,UAAUqB,OAAO3B,cAAc;wBAAEO,SAASoB,OAAO1B,aAAa;oBAAC;oBACjG,OAAO;gBACT;gBACA,IAAI0B,OAAOzB,eAAe,EAAE;oBAC1BoD,WAAWnC,IAAI,CAAC;wBAAEsC,MAAM;wBAAWnD,UAAUqB,OAAOzB,eAAe;wBAAEK,SAASoB,OAAOxB,cAAc;oBAAC;oBACpG,OAAO;gBACT;gBACA,IAAIwB,OAAO7B,WAAW,EAAE;oBACtB,OAAO;wBAAEV,OAAOuC,OAAOvC,KAAK;wBAAEW,MAAM;oBAAM;gBAC5C;gBACA,OAAO;YACT;YAEA,OAAO;gBACL,MAAM+C;oBACJ,MAAO,CAAC/C,KAAM;wBACZ,IAAIuD,WAAWpC,MAAM,GAAG,GAAG;4BACzB,MAAMsC,QAAQF,UAAU,CAACA,WAAWpC,MAAM,GAAG,EAAE;4BAC/C,IAAIsC,MAAMC,IAAI,KAAK,UAAU;gCAC3B,MAAME,eAAeH,MAAMlD,QAAQ,CAACwC,IAAI;gCACxC,IAAI,CAACa,aAAa5D,IAAI,EAAE;oCACtB,MAAM4B,SAAS,MAAML,WAAWqC,aAAavE,KAAK,EAAE0B,KAAKC,UAAUyC,MAAMjD,OAAO,GAAG;oCACnF,MAAMqD,UAAU,MAAMF,aAAa/B;oCACnC,IAAIiC,SAAS,OAAOA;oCACpB;gCACF;gCACAN,WAAWO,GAAG;gCACd;4BACF,OAAO;gCACL,MAAMC,gBAAgB,MAAMN,MAAMlD,QAAQ,CAACwC,IAAI;gCAC/C,IAAI,CAACgB,cAAc/D,IAAI,EAAE;oCACvB,MAAM4B,SAAS,MAAML,WAAWwC,cAAc1E,KAAK,EAAE0B,KAAKC,UAAUyC,MAAMjD,OAAO,GAAG;oCACpF,MAAMqD,UAAU,MAAMF,aAAa/B;oCACnC,IAAIiC,SAAS,OAAOA;oCACpB;gCACF;gCACAN,WAAWO,GAAG;gCACd;4BACF;wBACF;wBAEA,IAAIxC,mBAAmBL,aAAa;4BAClCjB,OAAO;4BACP,MAAMO,SAASyC,MAAM;4BACrB,OAAOC,uBAAa;wBACtB;wBAEA,MAAMC,eAAe,MAAM3C,SAASwC,IAAI;wBACxC,IAAIG,aAAalD,IAAI,EAAE;4BACrBA,OAAO;4BACP,OAAOiD,uBAAa;wBACtB;wBAEA,MAAMrB,SAAS,MAAML,WAAW2B,aAAa7D,KAAK,EAAE0B,KAAKC,UAAU;wBACnE,MAAM6C,UAAU,MAAMF,aAAa/B;wBACnC,IAAIiC,SAAS,OAAOA;oBACtB;oBAEA,OAAOZ,uBAAa;gBACtB;gBAEA,MAAMD,QAAOG,WAAqB;oBAChCnD,OAAO;oBACP,MAAMwD;oBACN,MAAMjD,SAASyC,MAAM,GAAGG;oBACxB,OAAOF,uBAAa;gBACtB;gBAEA,MAAMG,OAAMC,KAAe;oBACzBrD,OAAO;oBACP,MAAMwD;oBACN,IAAIjD,SAAS6C,KAAK,EAAE;wBAClB,MAAM7C,SAAS6C,KAAK,CAACC;oBACvB;oBACA,MAAMA;gBACR;YACF;QACF;IACF;AACF;AAEA,SAASW,oBAAoBzB,IAAoD;IAC/E,MAAMM,SAASF,UAAUJ;IACzB,MAAMxB,MAAMwB,KAAK0B,SAAS,IAAK1B,CAAAA,KAAK0B,SAAS,GAAG3B,WAAWC,KAAI;IAE/D,IAAIxB,IAAII,MAAM,KAAK,GAAG;QACpB,OAAO0B;IACT;IAEA,OAAOxB,gBAAgBN,OAAOuC,wBAAwBT,QAAQ9B,OAAO6B,qBAAqBC,QAAQ9B;AACpG;AAiCO,MAAMhC;IAkBX,OAAOO,KAAwB2C,QAAqC,EAA0C;QAC5G,MAAMiC,gBAAgBC,IAAAA,yBAAe,EAAClC;QACtC,OAAO,IAAIlD,oBAAuCmF;IACpD;IAsBA,OAAOE,MAAS,GAAGC,SAA4C,EAAyC;QACtG,OAAO,IAAItF,oBAAsCuF,IAAAA,wBAAc,KAAID;IACrE;IAGApC,SAAmD;IAEnDQ,OAA8D;IAE9DlD,GAAmB;IAEnB0E,YAA8B,KAAK;IAE1B,CAAC/B,OAAOqC,WAAW,CAAC,GAAG,sBAAsB;IAEtD,YAAYtC,QAA0C,EAAEQ,SAAgE,IAAI,EAAElD,KAAqB,IAAI,CAAE;QACvJ,IAAI,CAAC0C,QAAQ,GAAGA;QAChB,IAAI,CAACQ,MAAM,GAAGA;QACd,IAAI,CAAClD,EAAE,GAAGA;IACZ;IAUAiF,KAAQC,gBAAmE,EAAEC,MAAoB,EAAyC;QACxI,MAAMC,eAAeX,oBAAoB,IAAI;QAC7C,MAAMY,YAAYJ,IAAAA,cAAI,EAACG,cAAkCF,kBAAkBC;QAC3E,OAAO,IAAI3F,oBAAsC6F;IACnD;IAQAC,UAA0D;QACxD,OAAO,IAAI9F,oBACT,IAAI,CAACkD,QAAQ,EACb,IAAI,EACJ;YAAEzC,IAAI;QAAiB;IAE3B;IAmBAsD,IAAOgC,UAA0C,EAAyC;QACxF,OAAO,IAAI/F,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAImD;QACN;IACF;IAsBAC,OAAoBC,SAAkD,EAAyC;QAC7G,OAAO,IAAIjG,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAIqD;QACN;IACF;IAmBAC,UAAaH,UAA0C,EAAsE;QAC3H,OAAO,IAAI/F,oBACT,IAAI,CAACkD,QAAQ,EACb,IAAI,EACJ;YAAEzC,IAAI;YAAqBmC,IAAImD;QAAyD;IAE5F;IAeAI,QAAQJ,UAAgD,EAA0C;QAChG,OAAO,IAAI/F,oBACT,IAAI,CAACkD,QAAQ,EACb,IAAI,EACJ;YAAEzC,IAAI;YAAkBmC,IAAImD;QAAyD;IAEzF;IAmBAK,UAAU1F,QAAgB,CAAC,EAAmD;QAC5E,OAAO,IAAIV,oBACT,IAAI,CAACkD,QAAQ,EACb,IAAI,EACJ;YAAEzC,IAAI;YAAoBC;QAAM;IAEpC;IAMA2F,KAAKzF,KAAa,EAAyC;QACzD,OAAO,IAAIZ,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJG;QACF;IACF;IAsBA0F,UAAuBL,SAAkD,EAAyC;QAChH,OAAO,IAAIjG,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAIqD;QACN;IACF;IAMAM,KAAK1F,KAAa,EAAyC;QACzD,OAAO,IAAIb,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJI;QACF;IACF;IAmBA2F,UAAUP,SAA+C,EAAyC;QAChG,OAAO,IAAIjG,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAIqD;QACN;IACF;IAMAvE,QAAW+E,QAAsE,EAAyC;QACxH,OAAO,IAAIzG,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAI6D;QACN;IACF;IA0BAC,OACEX,UAA2F,EAC3F,GAAGY,IAAe,EACqB;QACvC,MAAM1D,UAAU0D,KAAKvE,MAAM,GAAG;QAC9B,OAAO,IAAIpC,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAImD;YACJjF,MAAM6F,IAAI,CAAC,EAAE;YACb1D;QACF;IACF;IAoBA1B,OAAUwE,UAA2E,EAAyC;QAC5H,OAAO,IAAI/F,oBAAsC,IAAI,CAACkD,QAAQ,EAAqC,IAAI,EAAoD;YACzJzC,IAAI;YACJmC,IAAImD;QACN;IACF;IAEA,CAAC5C,OAAOC,aAAa,CAAC,GAAqC;QACzD,OAAO6B,oBAAoB,IAAI,CAAmD,CAAC9B,OAAOC,aAAa,CAAC;IAC1G;AACF"}

package/build/iterator.js

@@ -1,4 +1,5 @@
 import { mergeIterables, toAsyncIterable, pipe, isThenable } from "./utils.js";
+import { ITERATOR_DONE } from "./async.js";
 class OpState {
     index;
     remaining;
@@ -320,45 +321,30 @@ function createSimpleIterable(source, ops) {
                         if (checkTakeExhausted(takeStates)) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return ITERATOR_DONE;
                         }
                         const sourceResult = await iterator.next();
                         if (sourceResult.done) {
                             done = true;
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return ITERATOR_DONE;
                         }
                         const result = await processOpsSimple(sourceResult.value, ops, opStates);
                         if (result.done) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return ITERATOR_DONE;
                         }
                         if (result.shouldYield) return {
                             value: result.value,
                             done: false
                         };
                     }
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return ITERATOR_DONE;
                 },
                 async return (returnValue) {
                     done = true;
                     await iterator.return?.(returnValue);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return ITERATOR_DONE;
                 },
                 async throw (error) {
                     done = true;
@@ -392,10 +378,7 @@ function createExpandingIterable(source, ops) {
                     done = true;
                     await closeInnerIterators();
                     await iterator.return?.();
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return ITERATOR_DONE;
                 }
                 if (result.expandIterator) {
                     innerStack.push({
@@ -451,36 +434,24 @@ function createExpandingIterable(source, ops) {
                         if (checkTakeExhausted(takeStates)) {
                             done = true;
                             await iterator.return?.();
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return ITERATOR_DONE;
                         }
                         const sourceResult = await iterator.next();
                         if (sourceResult.done) {
                             done = true;
-                            return {
-                                value: undefined,
-                                done: true
-                            };
+                            return ITERATOR_DONE;
                         }
                         const result = await processOps(sourceResult.value, ops, opStates, 0);
                         const handled = await handleResult(result);
                         if (handled) return handled;
                     }
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return ITERATOR_DONE;
                 },
                 async return (returnValue) {
                     done = true;
                     await closeInnerIterators();
                     await iterator.return?.(returnValue);
-                    return {
-                        value: undefined,
-                        done: true
-                    };
+                    return ITERATOR_DONE;
                 },
                 async throw (error) {
                     done = true;