evnty 5.0.0 → 5.1.0

package/build/utils.js

@@ -1,22 +1,107 @@
-export const iterate = (...args)=>{
-    let start, count, step;
-    if (args.length === 0) {
-        start = 0;
-        count = Infinity;
-        step = 1;
-    } else if (args.length === 1) {
-        start = 0;
-        count = args[0];
-        step = 1;
-    } else if (args.length === 2) {
-        start = args[0];
-        count = args[1];
-        step = 1;
+import { Sequence } from "./sequence.js";
+export function isThenable(value) {
+    return value !== null && typeof value === 'object' && typeof value.then === 'function';
+}
+export const noop = ()=>{};
+export function min(values, fallback) {
+    let result = Infinity;
+    for (const value of values){
+        if (value < result) result = value;
+    }
+    return result === Infinity ? fallback : result;
+}
+export var MapIteratorType = /*#__PURE__*/ function(MapIteratorType) {
+    MapIteratorType[MapIteratorType["NEXT"] = 0] = "NEXT";
+    MapIteratorType[MapIteratorType["RETURN"] = 1] = "RETURN";
+    MapIteratorType[MapIteratorType["THROW"] = 2] = "THROW";
+    return MapIteratorType;
+}({});
+export const mapIterator = (iterator, map)=>{
+    const subIterator = {
+        next: async (...args)=>{
+            const result = await iterator.next(...args);
+            return map(result, 0);
+        }
+    };
+    if (iterator.return) {
+        subIterator.return = async (...args)=>{
+            const result = await iterator.return(...args);
+            return map(result, 1);
+        };
     } else {
-        start = args[0];
-        count = args[1];
-        step = args[2];
+        subIterator.return = async (value)=>{
+            return map({
+                done: true,
+                value
+            }, 1);
+        };
+    }
+    if (iterator.throw) {
+        subIterator.throw = async (...args)=>{
+            const result = await iterator.throw(...args);
+            return map(result, 2);
+        };
     }
+    return subIterator;
+};
+export function abortableIterable(iterable, signal) {
+    return {
+        [Symbol.asyncIterator] () {
+            const iterator = iterable[Symbol.asyncIterator]();
+            const { promise, resolve } = Promise.withResolvers();
+            const onAbort = ()=>resolve();
+            let closed = false;
+            const finish = (value)=>{
+                if (closed) {
+                    return Promise.resolve({
+                        done: true,
+                        value: value
+                    });
+                }
+                closed = true;
+                signal.removeEventListener('abort', onAbort);
+                return iterator.return?.(value) ?? Promise.resolve({
+                    done: true,
+                    value: value
+                });
+            };
+            if (signal.aborted) {
+                onAbort();
+            } else {
+                signal.addEventListener('abort', onAbort);
+            }
+            const race = [
+                promise,
+                undefined
+            ];
+            return {
+                async next (...args) {
+                    race[1] = iterator.next(...args);
+                    const result = await Promise.race(race);
+                    if (result === undefined) {
+                        void finish();
+                        return {
+                            done: true,
+                            value: undefined
+                        };
+                    }
+                    if (result.done) {
+                        closed = true;
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    return result;
+                },
+                async return (value) {
+                    return finish(value);
+                }
+            };
+        }
+    };
+}
+export const iterate = (startOrCount, countWhenTwoArgs, step = 1)=>{
+    const hasStartArg = countWhenTwoArgs !== undefined;
+    const start = hasStartArg ? startOrCount : 0;
+    const count = startOrCount === undefined ? Infinity : hasStartArg ? countWhenTwoArgs : startOrCount;
     return {
         [Symbol.iterator] () {
             let idx = 0;
@@ -90,16 +175,90 @@ export const toAsyncIterable = (iterable)=>{
         }
     };
 };
+const isAsyncIterable = (value)=>{
+    return typeof value[Symbol.asyncIterator] === 'function';
+};
 export async function* pipe(iterable, generatorFactory, signal) {
+    const source = signal ? abortableIterable(iterable, signal) : iterable;
     const generator = generatorFactory();
-    for await (const value of iterable){
-        if (signal?.aborted) return;
-        for await (const subValue of generator(value)){
+    for await (const value of source){
+        const produced = generator(value);
+        const subIterable = isAsyncIterable(produced) ? produced : toAsyncIterable(produced);
+        const abortableSub = signal ? abortableIterable(subIterable, signal) : subIterable;
+        for await (const subValue of abortableSub){
             yield subValue;
-            if (signal?.aborted) return;
         }
-        if (signal?.aborted) return;
     }
 }
+export const mergeIterables = (...iterables)=>{
+    return {
+        [Symbol.asyncIterator] () {
+            if (iterables.length === 0) {
+                return {
+                    next: async ()=>({
+                            value: undefined,
+                            done: true
+                        })
+                };
+            }
+            const exit = Symbol('mergeIterables.exit');
+            const ctrl = new AbortController();
+            const sequence = new Sequence(ctrl.signal);
+            let remaining = iterables.length;
+            const pump = async (iterable)=>{
+                try {
+                    for await (const value of abortableIterable(iterable, ctrl.signal)){
+                        if (!sequence.emit(value)) {
+                            break;
+                        }
+                    }
+                } catch (error) {
+                    ctrl.abort(error);
+                } finally{
+                    remaining -= 1;
+                    if (remaining === 0 && !ctrl.signal.aborted) {
+                        ctrl.abort(exit);
+                    }
+                }
+            };
+            for (const iterable of iterables){
+                void pump(iterable);
+            }
+            return {
+                next: async ()=>{
+                    try {
+                        const value = await sequence.receive();
+                        return {
+                            value,
+                            done: false
+                        };
+                    } catch  {
+                        if (ctrl.signal.aborted && ctrl.signal.reason === exit) {
+                            return {
+                                value: undefined,
+                                done: true
+                            };
+                        }
+                        throw ctrl.signal.reason;
+                    }
+                },
+                return: async ()=>{
+                    ctrl.abort(exit);
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                },
+                throw: async (error)=>{
+                    ctrl.abort(error);
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                }
+            };
+        }
+    };
+};
 
 //# sourceMappingURL=utils.js.map

package/build/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["/**\n * Interface for creating iterable number sequences with various parameter combinations.\n * Supports infinite sequences, counted sequences, and sequences with custom start and step values.\n */\nexport interface Iterate {\n  (): Iterable<number, void, unknown>;\n  (count: number): Iterable<number, void, unknown>;\n  (start: number, count: number): Iterable<number, void, unknown>;\n  (start: number, count: number, step: number): Iterable<number, void, unknown>;\n}\n\n/**\n * Creates an iterable sequence of numbers with flexible parameters.\n * Can generate infinite sequences, finite sequences, or sequences with custom start and step values.\n *\n * @param args Variable arguments to configure the sequence:\n *   - No args: Infinite sequence starting at 0 with step 1\n *   - 1 arg (count): Sequence from 0 to count-1\n *   - 2 args (start, count): Sequence starting at 'start' for 'count' iterations\n *   - 3 args (start, count, step): Custom start, count, and step value\n * @returns An iterable that generates numbers according to the parameters\n *\n * @example\n * ```typescript\n * // Infinite sequence: 0, 1, 2, 3, ...\n * for (const n of iterate()) { }\n *\n * // Count only: 0, 1, 2, 3, 4\n * for (const n of iterate(5)) { }\n *\n * // Start and count: 10, 11, 12, 13, 14\n * for (const n of iterate(10, 5)) { }\n *\n * // Start, count, and step: 0, 2, 4, 6, 8\n * for (const n of iterate(0, 5, 2)) { }\n * ```\n */\nexport const iterate: Iterate = (...args: number[]): Iterable<number, void, unknown> => {\n  let start: number, count: number, step: number;\n\n  if (args.length === 0) {\n    start = 0;\n    count = Infinity;\n    step = 1;\n  } else if (args.length === 1) {\n    start = 0;\n    count = args[0]!;\n    step = 1;\n  } else if (args.length === 2) {\n    start = args[0]!;\n    count = args[1]!;\n    step = 1;\n  } else {\n    start = args[0]!;\n    count = args[1]!;\n    step = args[2]!;\n  }\n\n  return {\n    [Symbol.iterator]() {\n      let idx = 0;\n      let current = start;\n      return {\n        next() {\n          if (idx < count) {\n            const value = current;\n            current += step;\n            idx++;\n            return { value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n        return(value) {\n          idx = count;\n          return { value, done: true };\n        },\n        throw(error?: unknown) {\n          idx = count;\n          throw error;\n        },\n      } satisfies Iterator<number, void, unknown>;\n    },\n  };\n};\n\n/**\n * @internal\n * Creates a promise that resolves after a specified timeout. If an `AbortSignal` is provided and triggered,\n * the timeout is cleared, and the promise resolves to `false`.\n *\n * @param {number} timeout - The time in milliseconds to wait before resolving the promise.\n * @param {AbortSignal} [signal] - An optional `AbortSignal` that can abort the timeout.\n * @returns {Promise<boolean>} A promise that resolves to `true` if the timeout completed, or `false` if it was aborted.\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * setTimeout(() => controller.abort(), 500);\n * const result = await setTimeoutAsync(1000, controller.signal);\n * console.log(result); // false\n * ```\n */\nexport const setTimeoutAsync = async (timeout: number, signal?: AbortSignal): Promise<boolean> => {\n  if (signal?.aborted) {\n    return false;\n  }\n  const { promise, resolve } = Promise.withResolvers<boolean>();\n  const timerId = setTimeout(resolve, timeout, true);\n  const onAbort = () => {\n    clearTimeout(timerId);\n    resolve(false);\n  };\n  signal?.addEventListener('abort', onAbort);\n\n  return promise.finally(() => signal?.removeEventListener('abort', onAbort));\n};\n\n/**\n * Converts a synchronous iterable to an asynchronous iterable.\n * Wraps the sync iterator methods to return promises, enabling uniform async handling.\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 * @param iterable A synchronous iterable to convert\n * @returns An async iterable that yields the same values as the input\n *\n * @example\n * ```typescript\n * const syncArray = [1, 2, 3, 4, 5];\n * const asyncIterable = toAsyncIterable(syncArray);\n *\n * for await (const value of asyncIterable) {\n *   console.log(value); // 1, 2, 3, 4, 5\n * }\n * ```\n */\nexport const toAsyncIterable = <T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIterable<T, TReturn, TNext> => {\n  return {\n    [Symbol.asyncIterator]() {\n      const iterator = iterable[Symbol.iterator]();\n      return {\n        async next(...args: [TNext] | []) {\n          return iterator.next(...args);\n        },\n        async return(maybeValue) {\n          const value = await maybeValue;\n          return iterator.return?.(value) ?? ({ value, done: true } as IteratorResult<T, TReturn>);\n        },\n        async throw(error) {\n          if (iterator.throw) {\n            return iterator.throw(error);\n          }\n          throw error;\n        },\n      } satisfies AsyncIterator<T, TReturn, TNext>;\n    },\n  };\n};\n\n/**\n * Pipes values from an async iterable through a generator transformation.\n * Applies a generator function to each value, yielding all resulting values.\n * Supports cancellation via AbortSignal for early termination.\n *\n * @template T The input value type\n * @template U The output value type\n * @param iterable The source async iterable\n * @param generatorFactory A factory that returns a generator function for transforming values\n * @param signal Optional AbortSignal to cancel the operation\n * @returns An async generator yielding transformed values\n *\n * @example\n * ```typescript\n * async function* source() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const doubled = pipe(source(), () => async function*(n) {\n *   yield n * 2;\n * });\n *\n * for await (const value of doubled) {\n *   console.log(value); // 2, 4, 6\n * }\n * ```\n */\nexport async function* pipe<T, U>(\n  iterable: AsyncIterable<T>,\n  generatorFactory: () => (value: T) => AsyncIterable<U>,\n  signal?: AbortSignal,\n): AsyncGenerator<Awaited<U>, void, unknown> {\n  const generator = generatorFactory();\n  for await (const value of iterable) {\n    if (signal?.aborted) return;\n    for await (const subValue of generator(value)) {\n      yield subValue;\n      if (signal?.aborted) return;\n    }\n    if (signal?.aborted) return;\n  }\n}\n"],"names":["iterate","args","start","count","step","length","Infinity","Symbol","iterator","idx","current","next","value","done","undefined","return","throw","error","setTimeoutAsync","timeout","signal","aborted","promise","resolve","Promise","withResolvers","timerId","setTimeout","onAbort","clearTimeout","addEventListener","finally","removeEventListener","toAsyncIterable","iterable","asyncIterator","maybeValue","pipe","generatorFactory","generator","subValue"],"mappings":"AAqCA,OAAO,MAAMA,UAAmB,CAAC,GAAGC;IAClC,IAAIC,OAAeC,OAAeC;IAElC,IAAIH,KAAKI,MAAM,KAAK,GAAG;QACrBH,QAAQ;QACRC,QAAQG;QACRF,OAAO;IACT,OAAO,IAAIH,KAAKI,MAAM,KAAK,GAAG;QAC5BH,QAAQ;QACRC,QAAQF,IAAI,CAAC,EAAE;QACfG,OAAO;IACT,OAAO,IAAIH,KAAKI,MAAM,KAAK,GAAG;QAC5BH,QAAQD,IAAI,CAAC,EAAE;QACfE,QAAQF,IAAI,CAAC,EAAE;QACfG,OAAO;IACT,OAAO;QACLF,QAAQD,IAAI,CAAC,EAAE;QACfE,QAAQF,IAAI,CAAC,EAAE;QACfG,OAAOH,IAAI,CAAC,EAAE;IAChB;IAEA,OAAO;QACL,CAACM,OAAOC,QAAQ,CAAC;YACf,IAAIC,MAAM;YACV,IAAIC,UAAUR;YACd,OAAO;gBACLS;oBACE,IAAIF,MAAMN,OAAO;wBACf,MAAMS,QAAQF;wBACdA,WAAWN;wBACXK;wBACA,OAAO;4BAAEG;4BAAOC,MAAM;wBAAM;oBAC9B;oBACA,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;gBACAE,QAAOH,KAAK;oBACVH,MAAMN;oBACN,OAAO;wBAAES;wBAAOC,MAAM;oBAAK;gBAC7B;gBACAG,OAAMC,KAAe;oBACnBR,MAAMN;oBACN,MAAMc;gBACR;YACF;QACF;IACF;AACF,EAAE;AAmBF,OAAO,MAAMC,kBAAkB,OAAOC,SAAiBC;IACrD,IAAIA,QAAQC,SAAS;QACnB,OAAO;IACT;IACA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAE,GAAGC,QAAQC,aAAa;IAClD,MAAMC,UAAUC,WAAWJ,SAASJ,SAAS;IAC7C,MAAMS,UAAU;QACdC,aAAaH;QACbH,QAAQ;IACV;IACAH,QAAQU,iBAAiB,SAASF;IAElC,OAAON,QAAQS,OAAO,CAAC,IAAMX,QAAQY,oBAAoB,SAASJ;AACpE,EAAE;AAsBF,OAAO,MAAMK,kBAAkB,CAAoBC;IACjD,OAAO;QACL,CAAC3B,OAAO4B,aAAa,CAAC;YACpB,MAAM3B,WAAW0B,QAAQ,CAAC3B,OAAOC,QAAQ,CAAC;YAC1C,OAAO;gBACL,MAAMG,MAAK,GAAGV,IAAkB;oBAC9B,OAAOO,SAASG,IAAI,IAAIV;gBAC1B;gBACA,MAAMc,QAAOqB,UAAU;oBACrB,MAAMxB,QAAQ,MAAMwB;oBACpB,OAAO5B,SAASO,MAAM,GAAGH,UAAW;wBAAEA;wBAAOC,MAAM;oBAAK;gBAC1D;gBACA,MAAMG,OAAMC,KAAK;oBACf,IAAIT,SAASQ,KAAK,EAAE;wBAClB,OAAOR,SAASQ,KAAK,CAACC;oBACxB;oBACA,MAAMA;gBACR;YACF;QACF;IACF;AACF,EAAE;AA6BF,OAAO,gBAAgBoB,KACrBH,QAA0B,EAC1BI,gBAAsD,EACtDlB,MAAoB;IAEpB,MAAMmB,YAAYD;IAClB,WAAW,MAAM1B,SAASsB,SAAU;QAClC,IAAId,QAAQC,SAAS;QACrB,WAAW,MAAMmB,YAAYD,UAAU3B,OAAQ;YAC7C,MAAM4B;YACN,IAAIpB,QAAQC,SAAS;QACvB;QACA,IAAID,QAAQC,SAAS;IACvB;AACF"}
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { Sequence } from './sequence.js';\nimport { AnyIterator, AnyIterable, MaybePromise } from './types.js';\n\n/**\n * @internal\n */\nexport function isThenable(value: unknown): value is PromiseLike<unknown> {\n  return value !== null && typeof value === 'object' && typeof (value as PromiseLike<unknown>).then === 'function';\n}\n\n/**\n * @internal\n * A no-operation function. Useful as a default callback or placeholder.\n */\nexport const noop = () => {};\n\n/**\n * @internal\n * Returns the minimum value from an iterable, or a fallback if empty.\n */\nexport function min(values: Iterable<number>, fallback: number): number {\n  let result = Infinity;\n  for (const value of values) {\n    if (value < result) result = value;\n  }\n  return result === Infinity ? fallback : result;\n}\n\n/**\n * @internal\n * Indicates which iterator method triggered a mapping operation.\n */\nexport enum MapIteratorType {\n  /** The next() method was called */\n  NEXT,\n  /** The return() method was called */\n  RETURN,\n  /** The throw() method was called */\n  THROW,\n}\n\n/**\n * @internal\n * A mapping function for transforming iterator results.\n * @template T - The input value type\n * @template U - The output value type\n * @template TReturn - The iterator return type\n */\nexport interface MapNext<T, U, TReturn> {\n  (result: MaybePromise<IteratorResult<T, TReturn>>, type: MapIteratorType): MaybePromise<IteratorResult<U, TReturn>>;\n}\n\n/**\n * @internal\n * Wraps an iterator with a mapping function applied to each result.\n * @template U - The output value type\n * @template T - The input value type\n * @template TReturn - The iterator return type\n * @template TNext - The type passed to next()\n * @param iterator - The source iterator to wrap\n * @param map - The mapping function to apply to each result\n * @returns An async iterator with mapped results\n */\nexport const mapIterator = <U, T, TReturn, TNext>(iterator: AnyIterator<T, TReturn, TNext>, map: MapNext<T, U, TReturn>): AsyncIterator<U, TReturn, TNext> => {\n  const subIterator: AsyncIterator<U, TReturn, TNext> = {\n    next: async (...args: [] | [TNext]) => {\n      const result = await iterator.next(...args);\n      return map(result, MapIteratorType.NEXT);\n    },\n  };\n  if (iterator.return) {\n    subIterator.return = async (...args: [] | [TReturn]) => {\n      const result = await iterator.return!(...args);\n      return map(result, MapIteratorType.RETURN);\n    };\n  } else {\n    subIterator.return = async (value: TReturn) => {\n      return map({ done: true, value }, MapIteratorType.RETURN);\n    };\n  }\n  if (iterator.throw) {\n    subIterator.throw = async (...args: [] | [unknown]) => {\n      const result = await iterator.throw!(...args);\n      return map(result, MapIteratorType.THROW);\n    };\n  }\n\n  return subIterator;\n};\n\n/**\n * Wraps an async iterable with abort signal support.\n * Each iteration creates a fresh iterator with scoped abort handling.\n * Listener is added at iteration start and removed on completion/abort/return.\n *\n * @template T - The yielded value type\n * @template TReturn - The return value type\n * @template TNext - The type passed to next()\n * @param iterable - The source async iterable to wrap\n * @param signal - AbortSignal to cancel iteration\n * @returns An async iterable with abort support\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const source = async function*() { yield 1; yield 2; yield 3; };\n *\n * for await (const value of abortableIterable(source(), controller.signal)) {\n *   console.log(value);\n *   if (value === 2) controller.abort();\n * }\n * ```\n */\nexport function abortableIterable<T, TReturn, TNext>(iterable: AsyncIterable<T, TReturn, TNext>, signal: AbortSignal): AsyncIterable<T, TReturn, TNext> {\n  return {\n    [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext> {\n      const iterator = iterable[Symbol.asyncIterator]();\n      const { promise, resolve } = Promise.withResolvers<void>();\n      const onAbort = () => resolve();\n      let closed = false;\n\n      const finish = (value?: TReturn): Promise<IteratorResult<T, TReturn>> => {\n        if (closed) {\n          return Promise.resolve({ done: true, value: value as TReturn });\n        }\n        closed = true;\n        signal.removeEventListener('abort', onAbort);\n        return iterator.return?.(value) ?? Promise.resolve({ done: true, value: value as TReturn });\n      };\n\n      if (signal.aborted) {\n        onAbort();\n      } else {\n        signal.addEventListener('abort', onAbort);\n      }\n\n      const race = [promise, undefined] as unknown as [Promise<void>, Promise<IteratorResult<T, TReturn>>];\n\n      return {\n        async next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>> {\n          race[1] = iterator.next(...args);\n          const result = await Promise.race(race);\n          if (result === undefined) {\n            void finish();\n            return { done: true, value: undefined as TReturn };\n          }\n          if (result.done) {\n            closed = true;\n            signal.removeEventListener('abort', onAbort);\n          }\n          return result;\n        },\n        async return(value?: TReturn): Promise<IteratorResult<T, TReturn>> {\n          return finish(value);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Interface for creating iterable number sequences with various parameter combinations.\n * Supports infinite sequences, counted sequences, and sequences with custom start and step values.\n */\nexport interface Iterate {\n  (): Iterable<number, void, unknown>;\n  (count: number): Iterable<number, void, unknown>;\n  (start: number, count: number): Iterable<number, void, unknown>;\n  (start: number, count: number, step: number): Iterable<number, void, unknown>;\n}\n\n/**\n * Creates an iterable sequence of numbers with flexible parameters.\n * Can generate infinite sequences, finite sequences, or sequences with custom start and step values.\n *\n * @param args Variable arguments to configure the sequence:\n *   - No args: Infinite sequence starting at 0 with step 1\n *   - 1 arg (count): Sequence from 0 to count-1\n *   - 2 args (start, count): Sequence starting at 'start' for 'count' iterations\n *   - 3 args (start, count, step): Custom start, count, and step value\n * @returns An iterable that generates numbers according to the parameters\n *\n * @example\n * ```typescript\n * // Infinite sequence: 0, 1, 2, 3, ...\n * for (const n of iterate()) { }\n *\n * // Count only: 0, 1, 2, 3, 4\n * for (const n of iterate(5)) { }\n *\n * // Start and count: 10, 11, 12, 13, 14\n * for (const n of iterate(10, 5)) { }\n *\n * // Start, count, and step: 0, 2, 4, 6, 8\n * for (const n of iterate(0, 5, 2)) { }\n * ```\n */\nexport const iterate: Iterate = (startOrCount?: number, countWhenTwoArgs?: number, step: number = 1): Iterable<number, void, unknown> => {\n  const hasStartArg = countWhenTwoArgs !== undefined;\n  const start = hasStartArg ? startOrCount! : 0;\n  const count = startOrCount === undefined ? Infinity : hasStartArg ? countWhenTwoArgs : startOrCount;\n\n  return {\n    [Symbol.iterator]() {\n      let idx = 0;\n      let current = start;\n      return {\n        next() {\n          if (idx < count) {\n            const value = current;\n            current += step;\n            idx++;\n            return { value, done: false };\n          }\n          return { value: undefined, done: true };\n        },\n        return(value) {\n          idx = count;\n          return { value, done: true };\n        },\n        throw(error?: unknown) {\n          idx = count;\n          throw error;\n        },\n      } satisfies Iterator<number, void, unknown>;\n    },\n  };\n};\n\n/**\n * @internal\n * Creates a promise that resolves after a specified timeout. If an `AbortSignal` is provided and triggered,\n * the timeout is cleared, and the promise resolves to `false`.\n *\n * @param {number} timeout - The time in milliseconds to wait before resolving the promise.\n * @param {AbortSignal} [signal] - An optional `AbortSignal` that can abort the timeout.\n * @returns {Promise<boolean>} A promise that resolves to `true` if the timeout completed, or `false` if it was aborted.\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * setTimeout(() => controller.abort(), 500);\n * const result = await setTimeoutAsync(1000, controller.signal);\n * console.log(result); // false\n * ```\n */\nexport const setTimeoutAsync = async (timeout: number, signal?: AbortSignal): Promise<boolean> => {\n  if (signal?.aborted) {\n    return false;\n  }\n  const { promise, resolve } = Promise.withResolvers<boolean>();\n  const timerId = setTimeout(resolve, timeout, true);\n  const onAbort = () => {\n    clearTimeout(timerId);\n    resolve(false);\n  };\n  signal?.addEventListener('abort', onAbort);\n\n  return promise.finally(() => signal?.removeEventListener('abort', onAbort));\n};\n\n/**\n * Converts a synchronous iterable to an asynchronous iterable.\n * Wraps the sync iterator methods to return promises, enabling uniform async handling.\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 * @param iterable A synchronous iterable to convert\n * @returns An async iterable that yields the same values as the input\n *\n * @example\n * ```typescript\n * const syncArray = [1, 2, 3, 4, 5];\n * const asyncIterable = toAsyncIterable(syncArray);\n *\n * for await (const value of asyncIterable) {\n *   console.log(value); // 1, 2, 3, 4, 5\n * }\n * ```\n */\nexport const toAsyncIterable = <T, TReturn, TNext>(iterable: Iterable<T, TReturn, TNext>): AsyncIterable<T, TReturn, TNext> => {\n  return {\n    [Symbol.asyncIterator]() {\n      const iterator = iterable[Symbol.iterator]();\n      return {\n        async next(...args: [TNext] | []) {\n          return iterator.next(...args);\n        },\n        async return(maybeValue) {\n          const value = await maybeValue;\n          return iterator.return?.(value) ?? ({ value, done: true } as IteratorResult<T, TReturn>);\n        },\n        async throw(error) {\n          if (iterator.throw) {\n            return iterator.throw(error);\n          }\n          throw error;\n        },\n      } satisfies AsyncIterator<T, TReturn, TNext>;\n    },\n  };\n};\n\n/**\n * @internal\n * Pipes values from an async iterable through a generator transformation.\n * Applies a generator function to each value, yielding all resulting values.\n * Supports cancellation via AbortSignal for early termination.\n *\n * @template T The input value type\n * @template U The output value type\n * @param iterable The source async iterable\n * @param generatorFactory A factory that returns a generator function for transforming values\n * @param signal Optional AbortSignal to cancel the operation\n * @returns An async generator yielding transformed values\n *\n * @example\n * ```typescript\n * async function* source() {\n *   yield 1; yield 2; yield 3;\n * }\n *\n * const doubled = pipe(source(), () => async function*(n) {\n *   yield n * 2;\n * });\n *\n * for await (const value of doubled) {\n *   console.log(value); // 2, 4, 6\n * }\n * ```\n */\nconst isAsyncIterable = <T, TReturn, TNext>(value: AnyIterable<T, TReturn, TNext>): value is AsyncIterable<T, TReturn, TNext> => {\n  return typeof (value as AsyncIterable<T, TReturn, TNext>)[Symbol.asyncIterator] === 'function';\n};\n\n/**\n * @internal\n */\nexport async function* pipe<T, U>(\n  iterable: AsyncIterable<T>,\n  generatorFactory: () => (value: T) => AnyIterable<U, void, unknown>,\n  signal?: AbortSignal,\n): AsyncGenerator<Awaited<U>, void, unknown> {\n  const source = signal ? abortableIterable(iterable, signal) : iterable;\n  const generator = generatorFactory();\n\n  for await (const value of source) {\n    const produced = generator(value);\n    const subIterable = isAsyncIterable(produced) ? produced : toAsyncIterable(produced);\n    const abortableSub = signal ? abortableIterable(subIterable, signal) : subIterable;\n\n    for await (const subValue of abortableSub) {\n      yield subValue;\n    }\n  }\n}\n\n/**\n * @internal\n * Merges multiple async iterables into a single stream.\n * Values are yielded as they become available from any source.\n * Completes when all sources complete; aborts all on error.\n * @template T - The value type yielded by all iterables\n * @param iterables - The async iterables to merge\n * @returns A merged async iterable\n */\nexport const mergeIterables = <T>(...iterables: AsyncIterable<T, void, unknown>[]): AsyncIterable<T, void, unknown> => {\n  return {\n    [Symbol.asyncIterator]() {\n      if (iterables.length === 0) {\n        return {\n          next: async () => ({ value: undefined, done: true }),\n        };\n      }\n\n      const exit = Symbol('mergeIterables.exit');\n      const ctrl = new AbortController();\n      const sequence = new Sequence<T>(ctrl.signal);\n      let remaining = iterables.length;\n\n      const pump = async (iterable: AsyncIterable<T, void, unknown>) => {\n        try {\n          for await (const value of abortableIterable(iterable, ctrl.signal)) {\n            if (!sequence.emit(value)) {\n              break;\n            }\n          }\n        } catch (error) {\n          ctrl.abort(error);\n        } finally {\n          remaining -= 1;\n          if (remaining === 0 && !ctrl.signal.aborted) {\n            ctrl.abort(exit);\n          }\n        }\n      };\n\n      for (const iterable of iterables) {\n        void pump(iterable);\n      }\n\n      return {\n        next: async () => {\n          try {\n            const value = await sequence.receive();\n            return { value, done: false };\n          } catch {\n            if (ctrl.signal.aborted && ctrl.signal.reason === exit) {\n              return { value: undefined, done: true };\n            }\n            throw ctrl.signal.reason;\n          }\n        },\n        return: async () => {\n          ctrl.abort(exit);\n          return { value: undefined, done: true };\n        },\n        throw: async (error?: unknown) => {\n          ctrl.abort(error);\n          return { value: undefined, done: true };\n        },\n      };\n    },\n  };\n};\n"],"names":["Sequence","isThenable","value","then","noop","min","values","fallback","result","Infinity","MapIteratorType","mapIterator","iterator","map","subIterator","next","args","return","done","throw","abortableIterable","iterable","signal","Symbol","asyncIterator","promise","resolve","Promise","withResolvers","onAbort","closed","finish","removeEventListener","aborted","addEventListener","race","undefined","iterate","startOrCount","countWhenTwoArgs","step","hasStartArg","start","count","idx","current","error","setTimeoutAsync","timeout","timerId","setTimeout","clearTimeout","finally","toAsyncIterable","maybeValue","isAsyncIterable","pipe","generatorFactory","source","generator","produced","subIterable","abortableSub","subValue","mergeIterables","iterables","length","exit","ctrl","AbortController","sequence","remaining","pump","emit","abort","receive","reason"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evnty",
   "description": "Async-first, reactive event handling library for complex event flows in browser and Node.js",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -48,43 +48,45 @@
     "url": "https://github.com/3axap4eHko/evnty/issues"
   },
   "homepage": "https://github.com/3axap4eHko/evnty#readme",
-  "dependencies": {
-    "fastds": "0.0.5"
-  },
   "devDependencies": {
-    "@eslint/js": "^9.34.0",
-    "@types/node": "^24.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.40.0",
-    "@typescript-eslint/parser": "^8.40.0",
-    "@typescript-eslint/typescript-estree": "^8.40.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@eslint/js": "^10.0.1",
+    "@fast-check/vitest": "^0.2.4",
+    "@stryker-mutator/core": "^9.5.1",
+    "@stryker-mutator/typescript-checker": "^9.5.1",
+    "@stryker-mutator/vitest-runner": "^9.5.1",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@typescript-eslint/typescript-estree": "^8.56.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "@vuepress/bundler-vite": "2.0.0-rc.23",
     "@vuepress/theme-default": "2.0.0-rc.105",
-    "eslint": "^9.34.0",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.5",
+    "evnty": "^5.0.0",
     "husky": "^9.1.7",
-    "inop": "^0.7.8",
-    "overtake": "1.0.2",
-    "prettier": "^3.6.2",
+    "inop": "^0.9.0",
+    "overtake": "1.3.2",
+    "prettier": "^3.8.1",
     "recast": "^0.23.11",
-    "sass-embedded": "^1.90.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.40.0",
-    "vitest": "^3.2.4",
-    "vue": "^3.5.19",
+    "sass-embedded": "^1.97.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18",
+    "vue": "^3.5.29",
     "vuepress": "2.0.0-rc.23"
   },
   "scripts": {
-    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
+    "build": "rm -rf build && inop src build -i __tests__ -i __bench__ -i *.tmp.ts && tsc -p tsconfig.build.json --declaration --emitDeclarationOnly",
     "test": "vitest run",
-    "test:build": "node src/__tests__/index.cjs && node src/__tests__/index.mjs",
     "lint": "eslint src",
+    "check": "stryker run",
     "docs:build": "vuepress build docs",
     "docs:clean-dev": "vuepress dev docs --clean-cache",
     "docs:dev": "vuepress dev docs",
-    "docs:gen": "rm -f docs/*.tmp.md && for file in src/*.ts; do node --loader ts-node/esm ./scripts/docgen.ts $file; done",
-    "docs:update-package": "pnpm dlx vp-update"
+    "docs:gen": "node ./scripts/docgen.ts src/*.ts",
+    "docs:update-package": "pnpm dlx vp-update",
+    "bench": "overtake src/__bench__/event.ts"
   }
 }

package/src/__tests__/example.js

@@ -1,4 +1,4 @@
-const { createEvent, merge, once } = require('evnty');
+import { createEvent, merge } from 'evnty';
 
 // Creates a click event
 const clickEvent = createEvent();
@@ -11,35 +11,30 @@ const handleKeyPress = ({ key }) => console.log('Key pressed', key);
 const unsubscribeKeyPress = keyPressEvent.on(handleKeyPress);
 
 // Merges click and key press events into input event
-const handleInput = (input) => console.log('Input', input);;
+const handleInput = (input) => console.log('Input', input);
 const inputEvent = merge(clickEvent, keyPressEvent);
 inputEvent.on(handleInput);
 
-// Filters a click event to only include left-click events.
-const handleLeftClick = () => console.log('Left button is clicked');
-const leftClickEvent = clickEvent.filter(({ button }) => button === 'left');
-leftClickEvent.on(handleLeftClick);
+// One-time listener for left clicks only
+clickEvent.once(({ button }) => {
+  if (button === 'left') {
+    console.log('First left click detected!');
+  }
+});
 
-// Will press Enter after one second
-setTimeout(keyPressEvent, 1000, { key: 'Enter' });
-// Waits once the first Enter key press event occurs
-await once(keyPressEvent.first(({ key }) => key === 'Enter'));
+// Emit some events
+keyPressEvent.emit({ key: 'W' });
+keyPressEvent.emit({ key: 'A' });
+keyPressEvent.emit({ key: 'S' });
+keyPressEvent.emit({ key: 'D' });
 
-keyPressEvent({ key: 'W' });
-keyPressEvent({ key: 'A' });
-keyPressEvent({ key: 'S' });
-keyPressEvent({ key: 'D' });
-
-clickEvent({ button: 'right' });
-clickEvent({ button: 'left' });
-clickEvent({ button: 'middle' });
+clickEvent.emit({ button: 'right' });
+clickEvent.emit({ button: 'left' });
+clickEvent.emit({ button: 'middle' });
 
 // Unsubscribe click listener
 unsubscribeClick();
-// It does not log anything because of click listener is unsubscribed
-leftClickEvent.off(handleLeftClick);
 
-// Unsubscribe key press listener once first Esc key press occur
-unsubscribeKeyPress.after(() => once(keyPressEvent.first(({ key }) => key === 'Esc')));
-// Press Esc to unsubscribe key press listener
-keyPressEvent({ key: 'Esc' });
+// Unsubscribe with a follow-up action
+unsubscribeKeyPress();
+console.log('Key press listener has been removed');

package/src/index.ts

@@ -1,7 +1,9 @@
 export * from './types.js';
-export * from './callable.js';
 export * from './utils.js';
 export * from './iterator.js';
 export * from './signal.js';
 export * from './sequence.js';
+export * from './broadcast.js';
 export * from './event.js';
+export * from './listener-registry.js';
+export * from './dispatch-result.js';

package/build/callable.cjs

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get AsyncCallable () {
-        return AsyncCallable;
-    },
-    get Callable () {
-        return Callable;
-    },
-    get CallableAsyncIterator () {
-        return CallableAsyncIterator;
-    }
-});
-class Callable {
-    static{
-        Object.setPrototypeOf(Callable.prototype, Function.prototype);
-    }
-    constructor(func){
-        return Object.setPrototypeOf(func, new.target.prototype);
-    }
-}
-class AsyncCallable extends Callable {
-    constructor(func){
-        super(func);
-    }
-    catch(onrejected) {
-        return this.next().catch(onrejected);
-    }
-    finally(onfinally) {
-        return this.next().finally(onfinally);
-    }
-    then(onfulfilled, onrejected) {
-        return this.next().then(onfulfilled, onrejected);
-    }
-}
-class CallableAsyncIterator extends AsyncCallable {
-    [Symbol.asyncIterator]() {
-        return {
-            next: async ()=>{
-                try {
-                    const value = await this.next();
-                    return {
-                        value,
-                        done: false
-                    };
-                } catch  {
-                    return {
-                        value: undefined,
-                        done: true
-                    };
-                }
-            },
-            return: ()=>{
-                this[Symbol.dispose]();
-                return Promise.resolve({
-                    value: undefined,
-                    done: true
-                });
-            }
-        };
-    }
-}
-
-//# sourceMappingURL=callable.cjs.map

package/build/callable.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n/**\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: () => {\n        this[Symbol.dispose]();\n        return Promise.resolve({ value: undefined, done: true });\n      },\n    };\n  }\n  abstract [Symbol.dispose](): void;\n}\n"],"names":["AsyncCallable","Callable","CallableAsyncIterator","Object","setPrototypeOf","prototype","Function","func","catch","onrejected","next","finally","onfinally","then","onfulfilled","Symbol","asyncIterator","value","done","undefined","return","dispose","Promise","resolve"],"mappings":";;;;;;;;;;;QA6BsBA;eAAAA;;QAdAC;eAAAA;;QAyCAC;eAAAA;;;AAzCf,MAAeD;IACpB,MAAO;QACLE,OAAOC,cAAc,CAACH,SAASI,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAKO,MAAeL,sBAA4BC;IAChD,YAAYM,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAC,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAKO,MAAeP,8BAAoCF;IACxD,CAACe,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLN,MAAM;gBACJ,IAAI;oBACF,MAAMO,QAAQ,MAAM,IAAI,CAACP,IAAI;oBAC7B,OAAO;wBAAEO;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,IAAI,CAACL,OAAOM,OAAO,CAAC;gBACpB,OAAOC,QAAQC,OAAO,CAAC;oBAAEN,OAAOE;oBAAWD,MAAM;gBAAK;YACxD;QACF;IACF;AAEF"}

package/build/callable.d.ts

@@ -1,34 +0,0 @@
-import { Fn, Promiseable } from './types.js';
-/**
- * @internal
- */
-export interface Callable<T extends unknown[], R> {
-    (...args: T): R;
-}
-/**
- * An abstract class that extends the built-in Function class. It allows instances of the class
- * to be called as functions. When an instance of Callable is called as a function, it will
- * call the function passed to its constructor with the same arguments.
- * @internal
- */
-export declare abstract class Callable<T, R> {
-    constructor(func: Fn<T, R>);
-}
-/**
- * @internal
- */
-export declare abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {
-    constructor(func: Fn<[T], R>);
-    abstract [Symbol.toStringTag]: string;
-    abstract next(): Promise<T>;
-    catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK>;
-    finally(onfinally?: (() => void) | null): Promise<T>;
-    then<OK = T, ERR = never>(onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null, onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null): Promise<OK | ERR>;
-}
-/**
- * @internal
- */
-export declare abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {
-    [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
-    abstract [Symbol.dispose](): void;
-}

package/build/callable.js

@@ -1,51 +0,0 @@
-export class Callable {
-    static{
-        Object.setPrototypeOf(Callable.prototype, Function.prototype);
-    }
-    constructor(func){
-        return Object.setPrototypeOf(func, new.target.prototype);
-    }
-}
-export class AsyncCallable extends Callable {
-    constructor(func){
-        super(func);
-    }
-    catch(onrejected) {
-        return this.next().catch(onrejected);
-    }
-    finally(onfinally) {
-        return this.next().finally(onfinally);
-    }
-    then(onfulfilled, onrejected) {
-        return this.next().then(onfulfilled, onrejected);
-    }
-}
-export class CallableAsyncIterator extends AsyncCallable {
-    [Symbol.asyncIterator]() {
-        return {
-            next: async ()=>{
-                try {
-                    const value = await this.next();
-                    return {
-                        value,
-                        done: false
-                    };
-                } catch  {
-                    return {
-                        value: undefined,
-                        done: true
-                    };
-                }
-            },
-            return: ()=>{
-                this[Symbol.dispose]();
-                return Promise.resolve({
-                    value: undefined,
-                    done: true
-                });
-            }
-        };
-    }
-}
-
-//# sourceMappingURL=callable.js.map

package/build/callable.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n/**\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: () => {\n        this[Symbol.dispose]();\n        return Promise.resolve({ value: undefined, done: true });\n      },\n    };\n  }\n  abstract [Symbol.dispose](): void;\n}\n"],"names":["Callable","Object","setPrototypeOf","prototype","Function","func","AsyncCallable","catch","onrejected","next","finally","onfinally","then","onfulfilled","CallableAsyncIterator","Symbol","asyncIterator","value","done","undefined","return","dispose","Promise","resolve"],"mappings":"AAeA,OAAO,MAAeA;IACpB,MAAO;QACLC,OAAOC,cAAc,CAACF,SAASG,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAKA,OAAO,MAAeG,sBAA4BN;IAChD,YAAYK,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAE,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAKA,OAAO,MAAeM,8BAAoCR;IACxD,CAACS,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLP,MAAM;gBACJ,IAAI;oBACF,MAAMQ,QAAQ,MAAM,IAAI,CAACR,IAAI;oBAC7B,OAAO;wBAAEQ;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,IAAI,CAACL,OAAOM,OAAO,CAAC;gBACpB,OAAOC,QAAQC,OAAO,CAAC;oBAAEN,OAAOE;oBAAWD,MAAM;gBAAK;YACxD;QACF;IACF;AAEF"}