iter-fest 0.1.1-main.f54555b → 0.2.0

package/README.md

@@ -18,19 +18,24 @@ npm install iter-fest
 
 ## Conversions
 
-| From                          | To                      | Function signature                                                                                                                                         |
-| ----------------------------- | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Iterator`                    | `IterableIterator`      | [`iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>`](#converting-an-iterator-to-iterable)                                                 |
-| `AsyncIterator`               | `AsyncIterableIterator` | [`asyncIteratorToAsyncIterable<T>(asyncIterator: AsyncIterator<T>): AsyncIterableIterator<T>`](#converting-an-iterator-to-iterable)                        |
-| `Observable`                  | `ReadableStream`        | [`observableSubscribeAsReadable<T>(observable: Observable<T>): ReadableStream<T>`](#converting-an-observable-to-readablestream)                            |
-| `ReadableStreamDefaultReader` | `AsyncIterableIterator` | [`readerValues`<T>(reader: ReadableStreamDefaultReader<T>): AsyncIterableIterator<T>`](#converting-a-readablestreamdefaultreader-to-asynciterableiterator) |
-| `AsyncIterable`               | `Observable`            | [`observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>`](#converting-an-asynciterable-to-observable)                                          |
-| `AsyncIterable`/`Iterable`    | `ReadableStream`        | [`readableStreamFrom<T>(anyIterable: AsyncIterable<T> \| Iterable<T>): ReadableStream<T>`](#converting-an-asynciterableiterable-to-readablestream)         |
-
-To convert `Observable` to `AsyncIterableIterator`, [use `ReadableStream` as intermediate format](#converting-an-observable-to-asynciterableiterator).
+| From                       | To                      | Function                                                                        |
+| -------------------------- | ----------------------- | ------------------------------------------------------------------------------- |
+| `Iterator`                 | `IterableIterator`      | [`iteratorToIterable`](#converting-an-iterator-to-iterable)                     |
+| `AsyncIterator`            | `AsyncIterableIterator` | [`asyncIteratorToAsyncIterable`](#converting-an-iterator-to-iterable)           |
+| `Observable`               | `ReadableStream`        | [`observableSubscribeAsReadable`](#converting-an-observable-to-readablestream)  |
+| `ReadableStream`           | `AsyncIterableIterator` | [`readableStreamValues`](#converting-a-readablestream-to-asynciterableiterator) |
+| `AsyncIterable`            | `Observable`            | [`observableFromAsync`](#converting-an-asynciterable-to-observable)             |
+| `AsyncIterable`/`Iterable` | `ReadableStream`        | [`readableStreamFrom`](#converting-an-asynciterableiterable-to-readablestream)  |
+| `Observable`               | `AsyncIterableIterator` | [`observableValues`](#converting-an-observable-to-asynciterableiterator)        |
 
 ### Converting an iterator to iterable
 
+```ts
+function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>
+
+function asyncIteratorToAsyncIterable<T>(asyncIterator: AsyncIterator<T>): AsyncIterableIterator<T>
+```
+
 `iteratorToIterable` and `asyncIteratorToAsyncIterable` enable a [pure iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator) to be iterable using a for-loop statement.
 
 ```ts
@@ -55,26 +60,12 @@ for (const value of iteratorToIterable(iterate())) {
 
 Note: calling `[Symbol.iterator]()` or `[Symbol.asyncIterator]()` will not restart the iteration. This is because iterator is an instance of iteration and is not restartable.
 
-### Converting an `Observable` to `AsyncIterableIterator`
-
-`ReadableStream` can be used as an intermediate format when converting an `Observable` to `AsyncIterableIterator`.
-
-Note: `Observable` is push-based and it does not support flow control. When converting to `AsyncIterableIteratorrr`, the internal buffer of `ReadableStream` could build up quickly.
+### Converting an `AsyncIterable` to `Observable`
 
 ```ts
-const observable = Observable.from([1, 2, 3]);
-const readable = observableSubscribeAsReadable(observable);
-const iterable = readerValues(readable.getReader());
-
-for await (const value of iterable) {
-  console.log(value); // Prints "1", "2", "3".
-}
+function observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>
 ```
 
-Note: calling `[Symbol.asyncIterator]()` will not resubscribe and read from the start of the observable. This is because the intermediate format does not support restart.
-
-### Converting an `AsyncIterable` to `Observable`
-
 `Observable.from` converts `Iterable` into `Observable`. However, it does not convert `AsyncIterable`.
 
 `observableFromAsync` will convert `AsyncIterable` into `Observable`. It will try to restart the iteration by calling `[Symbol.asyncIterator]()`.
@@ -98,6 +89,10 @@ Note: It is not recommended to convert `AsyncGenerator` to an `Observable`. `Asy
 
 ### Converting an `Observable` to `ReadableStream`
 
+```ts
+function observableSubscribeAsReadable<T>(observable: Observable<T>): ReadableStream<T>
+```
+
 `ReadableStream` is powerful for transforming and piping stream of data. It can be formed using data from both push-based and pull-based source with backpressuree.
 
 Note: `Observable` is push-based and it does not support flow control. When converting to `ReadableStream`, the internal buffer could build up quickly.
@@ -109,12 +104,16 @@ const readable = observableSubscribeAsReadable(observable);
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-### Converting a `ReadableStreamDefaultReader` to `AsyncIterableIterator`
+### Converting a `ReadableStream` to `AsyncIterableIterator`
+
+```ts
+function readableStreamValues`<T>(readable: ReadableStream<T>): AsyncIterableIterator<T>
+```
 
-`readerValues` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
+`readableStreamValues` allow iteration of `ReadableStream` as an `AsyncIterableIterator`.
 
 ```ts
-const readableStream = new ReadableStream({
+const readable = new ReadableStream({
   start(controller) {
     controller.enqueue(1);
     controller.enqueue(2);
@@ -125,17 +124,23 @@ const readableStream = new ReadableStream({
   }
 });
 
-const iterable = readerValues(readableStream.getReader());
+const iterable = readableStreamValues(readable);
 
 for await (const value of iterable) {
   console.log(value); // Prints "1", "2", "3".
 }
 ```
 
-Note: `[Symbol.asyncIterator]()` will not restart the reader and read from start of the stream. Reader is not restartable and streams are not seekable.
+Note: The stream will be locked as soon as the iterable is created. When using iterating outside of for-loop, make sure to call `AsyncIterator.return` when the iteration is done to release the lock on the stream.
+
+Note: `[Symbol.asyncIterator]()` will not restart the stream.
 
 ### Converting an `AsyncIterable`/`Iterable` to `ReadableStream`
 
+```ts
+function readableStreamFrom<T>(anyIterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T>
+```
+
 > Notes: this feature is part of [Streams Standard](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static).
 
 ```ts
@@ -147,6 +152,27 @@ readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 
 Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restart the iteration where possible.
 
+### Converting an `Observable` to `AsyncIterableIterator`
+
+```ts
+function observableValues<T>(observable: Observable<T>): AsyncIterableIterator<T>
+```
+
+`Observable` can be converted to `AsyncIterableIterator` for easier consumption.
+
+```ts
+const observable = Observable.from([1, 2, 3]);
+const iterable = observableValues(readable);
+
+for await (const value of iterable) {
+  console.log(value); // Prints "1", "2", "3".
+}
+```
+
+Note: `Observable` is push-based and it does not support flow control. When converting to `AsyncIterableIterator`, the internal buffer could build up quickly.
+
+Note: when the observable throw an exception via `observer.error()`, it will become rejection of `AsyncIterator.next()`. The exception will be hoisted back to the caller.
+
 ## Others
 
 ### Typed `Observable`
@@ -155,14 +181,18 @@ Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restar
 
 ### Producer-consumer queue
 
-`PushAsyncIterableIterator` is a simple push-based producer-consumer queue and designed to decouple the flow between a producer and consumer. The producer can push a new job at anytime. The consumer can pull a job at its own convenience via for-loop.
+`IterableWritableStream` is a push-based producer-consumer queue designed to decouple the flow between a producer and multiple consumers. The producer can push a new job at anytime. The consumer can pull a job at its own convenience via for-loop.
 
-Compare to pull-based queue, a push-based queue is very easy to use. However, pull-based queue offers better flow control as it will produce a job only if there is a consumer ready to consume.
+`IterableWritableStream` supports multiple consumers and continuation:
 
-For a full-featured producer-consumer queue that supports flow control, use `ReadableStream` instead.
+- Multiple consumers: when 2 or more consumers are active at the same time, jobs will be distributed across all consumers in a round robin fashion when possible
+- Continuation: when the last consumer disconnected while producer keep pushing new jobs, the next consumer will pick up where the last consumer left
+
+Compare to pull-based queue, a push-based queue is easy to use. However, pull-based queue offers better flow control as it will produce a job only if there is a consumer ready to consume.
 
 ```ts
-const iterable = new PushAsyncIterableIterator();
+const iterable = new IterableWritableStream();
+const writer = iterable.getWriter();
 
 (async function consumer() {
   for await (const value of iterable) {
@@ -173,10 +203,10 @@ const iterable = new PushAsyncIterableIterator();
 })();
 
 (async function producer() {
-  iterable.push(1);
-  iterable.push(2);
-  iterable.push(3);
-  iterable.close();
+  writer.write(1);
+  writer.write(2);
+  writer.write(3);
+  writer.close();
 })();
 
 // Prints "1", "2", "3", "Done".
@@ -220,22 +250,51 @@ const generator = generatorWithLastValue(
 );
 ```
 
+## Adding types to `core-js-pure`
+
+We added types to [Iterator Helpers](https://github.com/tc39/proposal-iterator-helpers) and [Async Iterator Helpers](https://github.com/tc39/proposal-async-iterator-helpers) implementation from `core-js-pure`:
+
+- [`Iterator.drop`](https://tc39.es/ecma262/#sec-array.prototype.drop)
+- [`Iterator.every`](https://tc39.es/ecma262/#sec-array.prototype.every)
+- [`Iterator.filter`](https://tc39.es/ecma262/#sec-array.prototype.filter)
+- [`Iterator.find`](https://tc39.es/ecma262/#sec-array.prototype.find)
+- [`Iterator.flatMap`](https://tc39.es/ecma262/#sec-array.prototype.flatmap)
+- [`Iterator.forEach`](https://tc39.es/ecma262/#sec-array.prototype.foreach)
+- [`Iterator.from`](https://tc39.es/ecma262/#sec-array.prototype.from)
+- [`Iterator.map`](https://tc39.es/ecma262/#sec-array.prototype.map)
+- [`Iterator.reduce`](https://tc39.es/ecma262/#sec-array.prototype.reduce)
+- [`Iterator.some`](https://tc39.es/ecma262/#sec-array.prototype.some)
+- [`Iterator.take`](https://tc39.es/ecma262/#sec-array.prototype.take)
+- [`Iterator.toArray`](https://tc39.es/ecma262/#sec-array.prototype.toarray)
+- [`AsyncIterator.drop`](https://tc39.es/ecma262/#sec-array.prototype.drop)
+- [`AsyncIterator.every`](https://tc39.es/ecma262/#sec-array.prototype.every)
+- [`AsyncIterator.filter`](https://tc39.es/ecma262/#sec-array.prototype.filter)
+- [`AsyncIterator.find`](https://tc39.es/ecma262/#sec-array.prototype.find)
+- [`AsyncIterator.flatMap`](https://tc39.es/ecma262/#sec-array.prototype.flatmap)
+- [`AsyncIterator.forEach`](https://tc39.es/ecma262/#sec-array.prototype.foreach)
+- [`AsyncIterator.from`](https://tc39.es/ecma262/#sec-array.prototype.from)
+- [`AsyncIterator.map`](https://tc39.es/ecma262/#sec-array.prototype.map)
+- [`AsyncIterator.reduce`](https://tc39.es/ecma262/#sec-array.prototype.reduce)
+- [`AsyncIterator.some`](https://tc39.es/ecma262/#sec-array.prototype.some)
+- [`AsyncIterator.take`](https://tc39.es/ecma262/#sec-array.prototype.take)
+- [`AsyncIterator.toArray`](https://tc39.es/ecma262/#sec-array.prototype.toarray)
+
 ## `Array.prototype` ports
 
-We ported majority of functions from `Array.prototype.*` to `iterable*`.
+We ported majority of functions from `Array.prototype.*` to `iterator*`.
 
 ```ts
-import { iterableIncludes, iterableReduce } from 'iter-fest'; // Via default exports.
-import { iterableSome } from 'iter-fest/iterableSome'; // Via named exports.
+import { iteratorIncludes, iteratorReduce } from 'iter-fest'; // Via default exports.
+import { iteratorSome } from 'iter-fest/iteratorSome'; // Via named exports.
 
-const iterable: Iterable<number> = [1, 2, 3, 4, 5].values();
+const iterator: iterator<number> = [1, 2, 3, 4, 5].values();
 
-console.log(iterableIncludes(iterable, 3)); // Prints "true".
-console.log(iterableReduce(iterable, (sum, value) => sum + value, 0)); // Prints "15".
-console.log(iterableSome(iterable, value => value % 2)); // Prints "true".
+console.log(iteratorIncludes(iterator, 3)); // Prints "true".
+console.log(iteratorReduce(iterator, (sum, value) => sum + value, 0)); // Prints "15".
+console.log(iteratorSome(iterator, value => value % 2)); // Prints "true".
 ```
 
-List of ported functions: [`at`](https://tc39.es/ecma262/#sec-array.prototype.at), [`concat`](https://tc39.es/ecma262/#sec-array.prototype.concat), [`entries`](https://tc39.es/ecma262/#sec-array.prototype.entries), [`every`](https://tc39.es/ecma262/#sec-array.prototype.every), [`filter`](https://tc39.es/ecma262/#sec-array.prototype.filter), [`find`](https://tc39.es/ecma262/#sec-array.prototype.find), [`findIndex`](https://tc39.es/ecma262/#sec-array.prototype.findindex), [`findLast`](https://tc39.es/ecma262/#sec-array.prototype.findlast), [`findLastIndex`](https://tc39.es/ecma262/#sec-array.prototype.findlastindex), [`forEach`](https://tc39.es/ecma262/#sec-array.prototype.foreach), [`includes`](https://tc39.es/ecma262/#sec-array.prototype.includes), [`indexOf`](https://tc39.es/ecma262/#sec-array.prototype.indexof), [`join`](https://tc39.es/ecma262/#sec-array.prototype.join), [`keys`](https://tc39.es/ecma262/#sec-array.prototype.keys), [`map`](https://tc39.es/ecma262/#sec-array.prototype.map), [`reduce`](https://tc39.es/ecma262/#sec-array.prototype.reduce), [`slice`](https://tc39.es/ecma262/#sec-array.prototype.slice), [`some`](https://tc39.es/ecma262/#sec-array.prototype.some), [`toSpliced`](https://tc39.es/ecma262/#sec-array.prototype.tospliced), and [`toString`](https://tc39.es/ecma262/#sec-array.prototype.tostring).
+List of ported functions: [`at`](https://tc39.es/ecma262/#sec-array.prototype.at), [`concat`](https://tc39.es/ecma262/#sec-array.prototype.concat), [`entries`](https://tc39.es/ecma262/#sec-array.prototype.entries), [`findIndex`](https://tc39.es/ecma262/#sec-array.prototype.findindex), [`findLast`](https://tc39.es/ecma262/#sec-array.prototype.findlast), [`findLastIndex`](https://tc39.es/ecma262/#sec-array.prototype.findlastindex), [`includes`](https://tc39.es/ecma262/#sec-array.prototype.includes), [`indexOf`](https://tc39.es/ecma262/#sec-array.prototype.indexof), [`join`](https://tc39.es/ecma262/#sec-array.prototype.join), [`keys`](https://tc39.es/ecma262/#sec-array.prototype.keys), [`slice`](https://tc39.es/ecma262/#sec-array.prototype.slice), [`toSpliced`](https://tc39.es/ecma262/#sec-array.prototype.tospliced), and [`toString`](https://tc39.es/ecma262/#sec-array.prototype.tostring).
 
 ## Behaviors
 
@@ -252,27 +311,27 @@ Majority of functions should work the same way with same complexity and performa
 There are minor differences on some functions:
 
 - `findLast` and `findLastIndex`
-  - Instead of iterating from the right side, iterables must start from left side
-  - Thus, with an iterable of 5 items, `predicate` will be called exactly 5 times with `O(N)` complexity
+  - Instead of iterating from the right side, iterators must start from left side
+  - Thus, with an iterator of 5 items, `predicate` will be called exactly 5 times with `O(N)` complexity
   - In contrast, its counterpart in `Array` will be called between 1 and 5 times with `O(log N)` complexity
 - `at`, `includes`, `indexOf`, `slice`, and `toSpliced`
   - Index arguments cannot be negative finite number
-    - Negative finite number means traversing from right side, which an iterator/iterable may not have an end
+    - Negative finite number means traversing from right side, which an iterator may not have an end
     - Infinites, zeroes, and positive numbers are supported
 
 ### Why `Array.prototype.push` is not ported?
 
-Some functions that modify the array are not ported, such as, `copyWithin`, `fill`, `pop`, `push`, `reverse`, `shift`, `splice`, `unshift`, etc. Iterables are read-only and we prefer to keep it that way.
+Some functions that modify the array are not ported, such as, `copyWithin`, `fill`, `pop`, `push`, `reverse`, `shift`, `splice`, `unshift`, etc. Iterators are read-only and we prefer to keep it that way.
 
-Some functions that do not have actual functionality in the iterable world are not ported, such as, `values`, etc.
+Some functions that do not have actual functionality in the iterator world are not ported, such as, `values`, etc.
 
 Some functions that cannot not retains their complexity or performance characteristics are not ported. These functions usually iterate from the other end or requires random access, such as, `lastIndexOf`, `reduceRight`, `sort`, `toReversed`, `toSorted`, etc.
 
 If you think a specific function should be ported, please submit a pull request to us.
 
-### How about asynchronous iterables?
+### How about asynchronous iterators?
 
-Yes, this is on our roadmap. This will enable traverse iterables [across domains/workers via `MessagePort`](https://npmjs.com/package/message-port-rpc). We welcome pull requests.
+Yes, this is on our roadmap. This will enable traverse iterators [across domains/workers via `MessagePort`](https://npmjs.com/package/message-port-rpc). We welcome pull requests.
 
 ### How about functions outside of `Array.prototype`?
 

package/dist/chunk-3S6LCGE6.mjs

@@ -0,0 +1,10 @@
+// src/iteratorSome.ts
+import some from "core-js-pure/full/iterator/some";
+function iteratorSome(iterator, predicate) {
+  return some(iterator, predicate);
+}
+
+export {
+  iteratorSome
+};
+//# sourceMappingURL=chunk-3S6LCGE6.mjs.map

package/dist/chunk-3S6LCGE6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorSome.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport some from 'core-js-pure/full/iterator/some';\n\n/**\n * Determines whether the specified callback function returns true for any element of an iterable.\n *\n * @param predicate A function that accepts up to three arguments. The some method calls the predicate function for each element in the iterable until the predicate returns a value which is coercible to the Boolean value true, or until the end of the iterable.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function iteratorSome<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => unknown): boolean {\n  return some(iterator, predicate);\n}\n"],"mappings":";AACA,OAAO,UAAU;AASV,SAAS,aAAgB,UAAuB,WAA0D;AAC/G,SAAO,KAAK,UAAU,SAAS;AACjC;","names":[]}

package/dist/chunk-4RT2FROS.mjs

@@ -0,0 +1,10 @@
+// src/asyncIteratorEvery.ts
+import every from "core-js-pure/full/async-iterator/every";
+function asyncIteratorEvery(iterator, predicate) {
+  return every(iterator, predicate);
+}
+
+export {
+  asyncIteratorEvery
+};
+//# sourceMappingURL=chunk-4RT2FROS.mjs.map

package/dist/chunk-4RT2FROS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorEvery.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport every from 'core-js-pure/full/async-iterator/every';\n\n/**\n * Determines whether all the members of an iterator satisfy the specified test.\n *\n * @param predicate A function that accepts up to three arguments. The every method calls\n * the predicate function for each element in the iterator until the predicate returns a value\n * which is coercible to the Boolean value false, or until the end of the iterator.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorEvery<T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<boolean>\n): Promise<boolean>;\n\n/**\n * Determines whether all the members of an iterator satisfy the specified test.\n *\n * @param predicate A function that accepts up to three arguments. The every method calls\n * the predicate function for each element in the iterator until the predicate returns a value\n * which is coercible to the Boolean value false, or until the end of the iterator.\n *\n * @param thisArg An object to which the this keyword can refer in the predicate function.\n * If thisArg is omitted, undefined is used as the this value.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorEvery<T>(\n  iterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<unknown>\n): Promise<boolean>;\n\nexport function asyncIteratorEvery<T>(\n  iterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<unknown>\n): Promise<boolean> {\n  return every(iterator, predicate);\n}\n"],"mappings":";AACA,OAAO,WAAW;AAiCX,SAAS,mBACd,UACA,WACkB;AAClB,SAAO,MAAM,UAAU,SAAS;AAClC;","names":[]}

package/dist/chunk-4ZBMXHD6.mjs

@@ -0,0 +1,10 @@
+// src/asyncIteratorFilter.ts
+import filter from "core-js-pure/full/async-iterator/filter";
+function asyncIteratorFilter(asyncIterator, predicate) {
+  return filter(asyncIterator, predicate);
+}
+
+export {
+  asyncIteratorFilter
+};
+//# sourceMappingURL=chunk-4ZBMXHD6.mjs.map

package/dist/chunk-4ZBMXHD6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorFilter.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport filter from 'core-js-pure/full/async-iterator/filter';\n\n/**\n * Returns the elements of an iterator that meet the condition specified in a callback function.\n *\n * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the iterator.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorFilter<T, S extends T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => value is S\n): AsyncIterableIterator<S>;\n\n/**\n * Returns the elements of an iterator that meet the condition specified in a callback function.\n *\n * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the iterator.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorFilter<T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => unknown\n): AsyncIterableIterator<T>;\n\nexport function asyncIteratorFilter<T, S extends T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => unknown\n): AsyncIterableIterator<S> {\n  return filter(asyncIterator, predicate);\n}\n"],"mappings":";AACA,OAAO,YAAY;AA0BZ,SAAS,oBACd,eACA,WAC0B;AAC1B,SAAO,OAAO,eAAe,SAAS;AACxC;","names":[]}

package/dist/chunk-72AEHTPQ.mjs

@@ -0,0 +1,38 @@
+import {
+  readableStreamValues
+} from "./chunk-RVIERPEV.mjs";
+import {
+  observableSubscribeAsReadable
+} from "./chunk-EIIP7YWB.mjs";
+
+// src/observableValues.ts
+function observableValues(observable) {
+  const readable = observableSubscribeAsReadable(observable);
+  const iterable = readableStreamValues(readable);
+  const cancellableIterable = {
+    [Symbol.asyncIterator]() {
+      return cancellableIterable;
+    },
+    next() {
+      return iterable.next();
+    },
+    return() {
+      var _a;
+      try {
+        return ((_a = iterable.return) == null ? void 0 : _a.call(iterable)) ?? Promise.resolve({ done: true, value: void 0 });
+      } finally {
+        readable.cancel();
+      }
+    },
+    throw(error) {
+      var _a;
+      return ((_a = iterable.throw) == null ? void 0 : _a.call(iterable, error)) ?? Promise.resolve({ done: true, value: void 0 });
+    }
+  };
+  return cancellableIterable;
+}
+
+export {
+  observableValues
+};
+//# sourceMappingURL=chunk-72AEHTPQ.mjs.map

package/dist/chunk-72AEHTPQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/observableValues.ts"],"sourcesContent":["import type { Observable } from './Observable';\nimport { observableSubscribeAsReadable } from './observableSubscribeAsReadable';\nimport { readableStreamValues } from './readableStreamValues';\n\nexport function observableValues<T>(observable: Observable<T>): AsyncIterableIterator<T> {\n  const readable = observableSubscribeAsReadable(observable);\n  const iterable = readableStreamValues(readable);\n\n  const cancellableIterable: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      return cancellableIterable;\n    },\n    next() {\n      return iterable.next();\n    },\n    return() {\n      try {\n        return iterable.return?.() ?? Promise.resolve({ done: true, value: undefined });\n      } finally {\n        readable.cancel();\n      }\n    },\n    throw(error) {\n      return iterable.throw?.(error) ?? Promise.resolve({ done: true, value: undefined });\n    }\n  };\n\n  return cancellableIterable;\n}\n"],"mappings":";;;;;;;;AAIO,SAAS,iBAAoB,YAAqD;AACvF,QAAM,WAAW,8BAA8B,UAAU;AACzD,QAAM,WAAW,qBAAqB,QAAQ;AAE9C,QAAM,sBAAgD;AAAA,IACpD,CAAC,OAAO,aAAa,IAAI;AACvB,aAAO;AAAA,IACT;AAAA,IACA,OAAO;AACL,aAAO,SAAS,KAAK;AAAA,IACvB;AAAA,IACA,SAAS;AAfb;AAgBM,UAAI;AACF,iBAAO,cAAS,WAAT,sCAAuB,QAAQ,QAAQ,EAAE,MAAM,MAAM,OAAO,OAAU,CAAC;AAAA,MAChF,UAAE;AACA,iBAAS,OAAO;AAAA,MAClB;AAAA,IACF;AAAA,IACA,MAAM,OAAO;AAtBjB;AAuBM,eAAO,cAAS,UAAT,kCAAiB,WAAU,QAAQ,QAAQ,EAAE,MAAM,MAAM,OAAO,OAAU,CAAC;AAAA,IACpF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-UIEKIMLW.mjs → chunk-AN54W42O.mjs}

@@ -1,9 +1,12 @@
 import {
   toIntegerOrInfinity
 } from "./chunk-W5NEOEVE.mjs";
+import {
+  iteratorToIterable
+} from "./chunk-MNDAEMYM.mjs";
 
-// src/iterableIndexOf.ts
-function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
+// src/iteratorIndexOf.ts
+function iteratorIndexOf(iterator, searchElement, fromIndex = 0) {
   let index = 0;
   fromIndex = toIntegerOrInfinity(fromIndex);
   if (fromIndex !== Infinity) {
@@ -11,7 +14,7 @@ function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
     if (fromIndex < 0) {
       throw new TypeError("fromIndex cannot be a negative finite number");
     }
-    for (const item of iterable) {
+    for (const item of iteratorToIterable(iterator)) {
       if (index >= fromIndex && Object.is(item, searchElement)) {
         return index;
       }
@@ -22,6 +25,6 @@ function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
 }
 
 export {
-  iterableIndexOf
+  iteratorIndexOf
 };
-//# sourceMappingURL=chunk-UIEKIMLW.mjs.map
+//# sourceMappingURL=chunk-AN54W42O.mjs.map

package/dist/chunk-AN54W42O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorIndexOf.ts"],"sourcesContent":["import { iteratorToIterable } from './iteratorToIterable';\nimport toIntegerOrInfinity from './private/toIntegerOrInfinity';\n\n/**\n * Returns the index of the first occurrence of a value in an iterator, or -1 if it is not present.\n *\n * @param searchElement The value to locate in the iterator.\n * @param fromIndex The iterator index at which to begin the search. If fromIndex is omitted, the search starts at index 0.\n */\nexport function iteratorIndexOf<T>(iterator: Iterator<T>, searchElement: T, fromIndex: number = 0): number {\n  let index = 0;\n\n  fromIndex = toIntegerOrInfinity(fromIndex);\n\n  if (fromIndex !== Infinity) {\n    fromIndex = fromIndex === -Infinity ? 0 : fromIndex;\n\n    if (fromIndex < 0) {\n      // TODO: Support negative fromIndex.\n      throw new TypeError('fromIndex cannot be a negative finite number');\n    }\n\n    for (const item of iteratorToIterable(iterator)) {\n      if (index >= fromIndex && Object.is(item, searchElement)) {\n        return index;\n      }\n\n      index++;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":";;;;;;;;AASO,SAAS,gBAAmB,UAAuB,eAAkB,YAAoB,GAAW;AACzG,MAAI,QAAQ;AAEZ,cAAY,oBAAoB,SAAS;AAEzC,MAAI,cAAc,UAAU;AAC1B,gBAAY,cAAc,YAAY,IAAI;AAE1C,QAAI,YAAY,GAAG;AAEjB,YAAM,IAAI,UAAU,8CAA8C;AAAA,IACpE;AAEA,eAAW,QAAQ,mBAAmB,QAAQ,GAAG;AAC/C,UAAI,SAAS,aAAa,OAAO,GAAG,MAAM,aAAa,GAAG;AACxD,eAAO;AAAA,MACT;AAEA;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-AOZVPHE4.mjs

@@ -0,0 +1,10 @@
+// src/asyncIteratorTake.ts
+import take from "core-js-pure/full/async-iterator/take";
+function asyncIteratorTake(asyncIterator, limit) {
+  return take(asyncIterator, limit);
+}
+
+export {
+  asyncIteratorTake
+};
+//# sourceMappingURL=chunk-AOZVPHE4.mjs.map

package/dist/chunk-AOZVPHE4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorTake.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport take from 'core-js-pure/full/async-iterator/take';\n\n/**\n * `take` takes an integer as an argument. It returns an iterator that produces, at most, the given number of elements produced by the underlying iterator.\n *\n * @param limit\n *\n * @return Returns an iterator with items from the original iterator from 0 until the limit.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorTake<T>(asyncIterator: AsyncIterator<T>, limit: number): AsyncIterator<T> {\n  return take(asyncIterator, limit);\n}\n"],"mappings":";AACA,OAAO,UAAU;AAWV,SAAS,kBAAqB,eAAiC,OAAiC;AACrG,SAAO,KAAK,eAAe,KAAK;AAClC;","names":[]}

package/dist/chunk-BSAPKNNZ.mjs

@@ -0,0 +1,16 @@
+import {
+  iteratorToIterable
+} from "./chunk-MNDAEMYM.mjs";
+
+// src/iteratorEntries.ts
+function* iteratorEntries(iterator) {
+  let index = 0;
+  for (const value of iteratorToIterable(iterator)) {
+    yield [index++, value];
+  }
+}
+
+export {
+  iteratorEntries
+};
+//# sourceMappingURL=chunk-BSAPKNNZ.mjs.map

package/dist/chunk-BSAPKNNZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorEntries.ts"],"sourcesContent":["import { iteratorToIterable } from './iteratorToIterable';\n\n/**\n * Returns an iterator of key, value pairs for every entry in the iterator\n */\nexport function* iteratorEntries<T>(iterator: Iterator<T>): IterableIterator<[number, T]> {\n  let index = 0;\n\n  for (const value of iteratorToIterable(iterator)) {\n    yield [index++, value];\n  }\n}\n"],"mappings":";;;;;AAKO,UAAU,gBAAmB,UAAsD;AACxF,MAAI,QAAQ;AAEZ,aAAW,SAAS,mBAAmB,QAAQ,GAAG;AAChD,UAAM,CAAC,SAAS,KAAK;AAAA,EACvB;AACF;","names":[]}

package/dist/chunk-BWMXKULC.mjs

@@ -0,0 +1,46 @@
+// src/private/withResolvers.ts
+import coreJSPromiseWithResolvers from "core-js-pure/full/promise/with-resolvers";
+function withResolvers() {
+  return coreJSPromiseWithResolvers();
+}
+
+// src/iterableWritableStream.ts
+var CLOSE = Symbol();
+var IterableWritableStream = class extends WritableStream {
+  constructor() {
+    super({
+      close: () => {
+        this.#buffer.push(CLOSE);
+        this.#writeResolvers.resolve();
+      },
+      write: (chunk) => {
+        this.#buffer.push(chunk);
+        this.#writeResolvers.resolve();
+        this.#writeResolvers = withResolvers();
+      }
+    });
+  }
+  #buffer = [];
+  #writeResolvers = withResolvers();
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        while (!this.#buffer.length) {
+          await this.#writeResolvers.promise;
+        }
+        const value = this.#buffer[0];
+        if (value === CLOSE) {
+          return { done: true, value: void 0 };
+        }
+        this.#buffer.shift();
+        await void 0;
+        return { done: false, value };
+      }
+    };
+  }
+};
+
+export {
+  IterableWritableStream
+};
+//# sourceMappingURL=chunk-BWMXKULC.mjs.map

package/dist/chunk-BWMXKULC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/private/withResolvers.ts","../src/iterableWritableStream.ts"],"sourcesContent":["// @ts-expect-error \"core-js\" is not typed.\nimport coreJSPromiseWithResolvers from 'core-js-pure/full/promise/with-resolvers';\n\nexport default function withResolvers<T>(): PromiseWithResolvers<T> {\n  return coreJSPromiseWithResolvers();\n}\n","import withResolvers from './private/withResolvers';\n\nconst CLOSE = Symbol();\n\nexport class IterableWritableStream<T> extends WritableStream<T> {\n  constructor() {\n    super({\n      close: () => {\n        this.#buffer.push(CLOSE);\n        this.#writeResolvers.resolve();\n      },\n      write: (chunk: T) => {\n        this.#buffer.push(chunk);\n        this.#writeResolvers.resolve();\n        this.#writeResolvers = withResolvers();\n      }\n    });\n  }\n\n  #buffer: (T | typeof CLOSE)[] = [];\n  #writeResolvers: PromiseWithResolvers<void> = withResolvers();\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return {\n      next: async () => {\n        while (!this.#buffer.length) {\n          await this.#writeResolvers.promise;\n        }\n\n        const value = this.#buffer[0] as T | typeof CLOSE;\n\n        if (value === CLOSE) {\n          return { done: true, value: undefined };\n        }\n\n        // If it is not CLOSE, remove it from the queue.\n        this.#buffer.shift();\n\n        // Idle here so concurrent iteration has a chance to pick up the next value in a round robin fashion.\n        await undefined;\n\n        return { done: false, value };\n      }\n    };\n  }\n}\n"],"mappings":";AACA,OAAO,gCAAgC;AAExB,SAAR,gBAA6D;AAClE,SAAO,2BAA2B;AACpC;;;ACHA,IAAM,QAAQ,OAAO;AAEd,IAAM,yBAAN,cAAwC,eAAkB;AAAA,EAC/D,cAAc;AACZ,UAAM;AAAA,MACJ,OAAO,MAAM;AACX,aAAK,QAAQ,KAAK,KAAK;AACvB,aAAK,gBAAgB,QAAQ;AAAA,MAC/B;AAAA,MACA,OAAO,CAAC,UAAa;AACnB,aAAK,QAAQ,KAAK,KAAK;AACvB,aAAK,gBAAgB,QAAQ;AAC7B,aAAK,kBAAkB,cAAc;AAAA,MACvC;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,UAAgC,CAAC;AAAA,EACjC,kBAA8C,cAAc;AAAA,EAE5D,CAAC,OAAO,aAAa,IAAsB;AACzC,WAAO;AAAA,MACL,MAAM,YAAY;AAChB,eAAO,CAAC,KAAK,QAAQ,QAAQ;AAC3B,gBAAM,KAAK,gBAAgB;AAAA,QAC7B;AAEA,cAAM,QAAQ,KAAK,QAAQ,CAAC;AAE5B,YAAI,UAAU,OAAO;AACnB,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,QACxC;AAGA,aAAK,QAAQ,MAAM;AAGnB,cAAM;AAEN,eAAO,EAAE,MAAM,OAAO,MAAM;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-CNCNQPK3.mjs

@@ -0,0 +1,16 @@
+import {
+  iteratorToIterable
+} from "./chunk-MNDAEMYM.mjs";
+
+// src/iteratorKeys.ts
+function* iteratorKeys(iterator) {
+  let index = 0;
+  for (const _ of iteratorToIterable(iterator)) {
+    yield index++;
+  }
+}
+
+export {
+  iteratorKeys
+};
+//# sourceMappingURL=chunk-CNCNQPK3.mjs.map

package/dist/chunk-CNCNQPK3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorKeys.ts"],"sourcesContent":["import { iteratorToIterable } from './iteratorToIterable';\n\n/**\n * Returns an iterator of keys in the iterator\n */\nexport function* iteratorKeys<T>(iterator: Iterator<T>): IterableIterator<number> {\n  let index = 0;\n\n  for (const _ of iteratorToIterable(iterator)) {\n    yield index++;\n  }\n}\n"],"mappings":";;;;;AAKO,UAAU,aAAgB,UAAiD;AAChF,MAAI,QAAQ;AAEZ,aAAW,KAAK,mBAAmB,QAAQ,GAAG;AAC5C,UAAM;AAAA,EACR;AACF;","names":[]}

package/dist/chunk-CNKIGQUS.mjs

@@ -0,0 +1,10 @@
+// src/asyncIteratorFind.ts
+import find from "core-js-pure/full/async-iterator/find";
+function asyncIteratorFind(asyncIterator, predicate) {
+  return find(asyncIterator, predicate);
+}
+
+export {
+  asyncIteratorFind
+};
+//# sourceMappingURL=chunk-CNKIGQUS.mjs.map

package/dist/chunk-CNKIGQUS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorFind.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport find from 'core-js-pure/full/async-iterator/find';\n\n/**\n * Returns the value of the first element in the iterator where predicate is true, and undefined\n * otherwise.\n *\n * @param predicate find calls predicate once for each element of the iterator, in ascending\n * order, until it finds one where predicate returns true. If such an element is found, find\n * immediately returns that element value. Otherwise, find returns undefined.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorFind<T, S extends T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<boolean>\n): Promise<S | undefined>;\n\nexport function asyncIteratorFind<T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<unknown>\n): Promise<T | undefined>;\n\nexport function asyncIteratorFind<T, S extends T>(\n  asyncIterator: AsyncIterator<T>,\n  predicate: (value: T, index: number) => Promise<unknown>\n): Promise<S | undefined> {\n  return find(asyncIterator, predicate);\n}\n"],"mappings":";AACA,OAAO,UAAU;AAsBV,SAAS,kBACd,eACA,WACwB;AACxB,SAAO,KAAK,eAAe,SAAS;AACtC;","names":[]}

package/dist/chunk-DC2ZV7KQ.mjs

@@ -0,0 +1,10 @@
+// src/iteratorFrom.ts
+import from from "core-js-pure/full/iterator/from";
+function iteratorFrom(iteratorLike) {
+  return from(iteratorLike);
+}
+
+export {
+  iteratorFrom
+};
+//# sourceMappingURL=chunk-DC2ZV7KQ.mjs.map

package/dist/chunk-DC2ZV7KQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorFrom.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport from from 'core-js-pure/full/iterator/from';\n\n/**\n * `.from` is a static method (unlike the others listed above) which takes an object as an argument. This method allows wrapping \"iterator-like\" objects with an iterator.\n *\n * @return Returns the object if it is already an iterator, returns a wrapping iterator if the passed object implements a callable @@iterator property.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function iteratorFrom<T>(iteratorLike: Pick<Iterator<T>, 'next'>): Iterator<T> {\n  return from(iteratorLike);\n}\n"],"mappings":";AACA,OAAO,UAAU;AASV,SAAS,aAAgB,cAAsD;AACpF,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/dist/{chunk-KONB7TV6.mjs → chunk-EQZQP6GW.mjs}

@@ -1,9 +1,12 @@
 import {
   toIntegerOrInfinity
 } from "./chunk-W5NEOEVE.mjs";
+import {
+  iteratorToIterable
+} from "./chunk-MNDAEMYM.mjs";
 
-// src/iterableSlice.ts
-function* iterableSlice(iterable, start = 0, end = Infinity) {
+// src/iteratorSlice.ts
+function* iteratorSlice(iterator, start = 0, end = Infinity) {
   let index = 0;
   start = toIntegerOrInfinity(start);
   start = start === -Infinity ? 0 : start;
@@ -18,7 +21,7 @@ function* iterableSlice(iterable, start = 0, end = Infinity) {
   if (start === Infinity) {
     return;
   }
-  for (const item of iterable) {
+  for (const item of iteratorToIterable(iterator)) {
     if (index >= start && index < end) {
       yield item;
     }
@@ -30,6 +33,6 @@ function* iterableSlice(iterable, start = 0, end = Infinity) {
 }
 
 export {
-  iterableSlice
+  iteratorSlice
 };
-//# sourceMappingURL=chunk-KONB7TV6.mjs.map
+//# sourceMappingURL=chunk-EQZQP6GW.mjs.map

package/dist/chunk-EQZQP6GW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorSlice.ts"],"sourcesContent":["import { iteratorToIterable } from './iteratorToIterable';\nimport toIntegerOrInfinity from './private/toIntegerOrInfinity';\n\n/**\n * Returns a copy of a section of an iterator.\n * For both start and end, a negative index can be used to indicate an offset from the end of the iterator.\n * For example, -2 refers to the second to last element of the iterator.\n *\n * @param start The beginning index of the specified portion of the iterator.\n * If start is undefined, then the slice begins at index 0.\n *\n * @param end The end index of the specified portion of the iterator. This is exclusive of the element at the index 'end'.\n * If end is undefined, then the slice extends to the end of the iterator.\n */\nexport function* iteratorSlice<T>(\n  iterator: Iterator<T>,\n  start: number = 0,\n  end: number = Infinity\n): IterableIterator<T> {\n  let index = 0;\n\n  start = toIntegerOrInfinity(start);\n  start = start === -Infinity ? 0 : start;\n  end = toIntegerOrInfinity(end);\n  end = end === -Infinity ? 0 : end;\n\n  if (start < 0) {\n    throw new TypeError('start cannot be a negative finite number');\n  }\n\n  if (end < 0) {\n    throw new TypeError('end cannot be a negative finite number');\n  }\n\n  if (start === Infinity) {\n    return;\n  }\n\n  for (const item of iteratorToIterable(iterator)) {\n    if (index >= start && index < end) {\n      yield item;\n    }\n\n    index++;\n\n    if (index > end) {\n      break;\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAcO,UAAU,cACf,UACA,QAAgB,GAChB,MAAc,UACO;AACrB,MAAI,QAAQ;AAEZ,UAAQ,oBAAoB,KAAK;AACjC,UAAQ,UAAU,YAAY,IAAI;AAClC,QAAM,oBAAoB,GAAG;AAC7B,QAAM,QAAQ,YAAY,IAAI;AAE9B,MAAI,QAAQ,GAAG;AACb,UAAM,IAAI,UAAU,0CAA0C;AAAA,EAChE;AAEA,MAAI,MAAM,GAAG;AACX,UAAM,IAAI,UAAU,wCAAwC;AAAA,EAC9D;AAEA,MAAI,UAAU,UAAU;AACtB;AAAA,EACF;AAEA,aAAW,QAAQ,mBAAmB,QAAQ,GAAG;AAC/C,QAAI,SAAS,SAAS,QAAQ,KAAK;AACjC,YAAM;AAAA,IACR;AAEA;AAEA,QAAI,QAAQ,KAAK;AACf;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-FBST4AUL.mjs

@@ -0,0 +1,10 @@
+// src/iteratorFind.ts
+import find from "core-js-pure/full/iterator/find";
+function iteratorFind(iterator, predicate) {
+  return find(iterator, predicate);
+}
+
+export {
+  iteratorFind
+};
+//# sourceMappingURL=chunk-FBST4AUL.mjs.map

package/dist/chunk-FBST4AUL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorFind.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport find from 'core-js-pure/full/iterator/find';\n\n/**\n * Returns the value of the first element in the iterator where predicate is true, and undefined\n * otherwise.\n *\n * @param predicate find calls predicate once for each element of the iterator, in ascending\n * order, until it finds one where predicate returns true. If such an element is found, find\n * immediately returns that element value. Otherwise, find returns undefined.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function iteratorFind<T, S extends T>(\n  iterator: Iterator<T>,\n  predicate: (value: T, index: number) => value is S\n): S | undefined;\n\nexport function iteratorFind<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => unknown): T | undefined;\n\nexport function iteratorFind<T, S extends T>(\n  iterator: Iterator<T>,\n  predicate: (value: T, index: number) => unknown\n): S | undefined {\n  return find(iterator, predicate);\n}\n"],"mappings":";AACA,OAAO,UAAU;AAmBV,SAAS,aACd,UACA,WACe;AACf,SAAO,KAAK,UAAU,SAAS;AACjC;","names":[]}