iter-fest 0.1.1-main.f9dfd27 → 0.2.1-main.25af1d2

package/README.md

@@ -16,37 +16,27 @@ Iterables can contains infinite number of items, please use this package respons
 npm install iter-fest
 ```
 
-### `Array.prototype` ports
+## Conversions
 
-We ported majority of functions from `Array.prototype.*` to `iterable*`.
+| 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)        |
 
-```ts
-import { iterableIncludes, iterableReduce } from 'iter-fest'; // Via default exports.
-import { iterableSome } from 'iter-fest/iterableSome'; // Via named exports.
+### Converting an iterator to iterable
 
-const iterable: Iterable<number> = [1, 2, 3, 4, 5].values();
+```ts
+function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>
 
-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".
+function asyncIteratorToAsyncIterable<T>(asyncIterator: AsyncIterator<T>): AsyncIterableIterator<T>
 ```
 
-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).
-
-## Conversions
-
-| From                          | To                      | Function signature                                                                                                              |
-| ----------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `Iterator`                    | `IterableIterator`      | [`iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<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>`](#iterating-readablestreamdefaultreader)  |
-| `AsyncIterable`               | `Observable`            | [`observableFromAsync<T>(iterator: AsyncIterableIterator<T>): Observable<T>`](#converting-an-asynciterable-to-observable)       |
-
-To convert `Observable` to `AsyncIterableIterator`, [use `ReadableStream` as intermediate format](#converting-an-observable-to-asynciterableiterator).
-
-### Converting an iterator to iterable
-
-`iteratorToIterable` 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.
+`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
 const iterate = (): Iterator<number> => {
@@ -58,7 +48,7 @@ const iterate = (): Iterator<number> => {
         return { value };
       }
 
-      return { done: true, value: undefined };
+      return { done: true, value: undefined } satisfies IteratorResult<number>;
     }
   };
 };
@@ -68,26 +58,17 @@ for (const value of iteratorToIterable(iterate())) {
 }
 ```
 
-### Converting an `Observable` to `AsyncIterableIterator`
-
-`ReadableStream` can be used to when converting an `Observable` to `AsyncIterableIterator`.
+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.
 
-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);
-
-for await (const value of readerValues(readable.getReader())) {
-  console.log(value); // Prints "1", "2", "3".
-}
+function observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>
 ```
 
-### Converting an `AsyncIterable` to `Observable`
-
 `Observable.from` converts `Iterable` into `Observable`. However, it does not convert `AsyncIterable`.
 
-`observableFromAsync` will convert `AsyncIterable` into `Observable`.
+`observableFromAsync` will convert `AsyncIterable` into `Observable`. It will try to restart the iteration by calling `[Symbol.asyncIterator]()`.
 
 ```ts
 async function* generate() {
@@ -102,7 +83,15 @@ const next = value => console.log(value);
 observable.subscribe({ next }); // Prints "1", "2", "3".
 ```
 
-## Converting an `Observable` to `ReadableStream`
+Note: `observableFromAsync` will call `[Symbol.asyncIterator]()` initially to restart the iteration where possible.
+
+Note: It is not recommended to convert `AsyncGenerator` to an `Observable`. `AsyncGenerator` has more functionalities and `Observable` does not support many of them.
+
+### 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.
 
@@ -111,17 +100,20 @@ Note: `Observable` is push-based and it does not support flow control. When conv
 ```ts
 const observable = Observable.from([1, 2, 3]);
 const readable = observableSubscribeAsReadable(observable);
-const reader = readable.getReader();
 
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-### Iterating `ReadableStreamDefaultReader`
+### Converting a `ReadableStream` to `AsyncIterableIterator`
 
-`readerValues` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
+```ts
+function readableStreamValues`<T>(readable: ReadableStream<T>): AsyncIterableIterator<T>
+```
+
+`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);
@@ -132,11 +124,55 @@ const readableStream = new ReadableStream({
   }
 });
 
-for await (const value of readerValues(readableStream.getReader())) {
+const iterable = readableStreamValues(readable);
+
+for await (const value of iterable) {
+  console.log(value); // Prints "1", "2", "3".
+}
+```
+
+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
+const iterable = [1, 2, 3].values();
+const readable = readableStreamFrom(iterable);
+
+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`
@@ -145,14 +181,18 @@ for await (const value of readerValues(readableStream.getReader())) {
 
 ### 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.
+`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 easier 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) {
@@ -163,15 +203,99 @@ 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".
 ```
 
+### Using for-loop with generator
+
+Compare to `Iterator`, `Generator` offers advanced capability.
+
+When using for-loop with generator, the last value return from the generator is lost.
+
+The `generatorWithLastValue()` and `asyncGeneratorWithLastValue()` helps bridge the for-loop usage by capturing the value returned as `{ done: true }` and make it accessible via `lastValue()`.
+
+```ts
+const generator = generatorWithLastValue(
+  (function* () {
+    yield 1; // { done: false, value: 1 }
+    yield 2; // { done: false, value: 2 }
+    yield 3; // { done: false, value: 3 }
+
+    return 'end'; // { done: true, value: 'end' }
+  })()
+);
+
+for (const value of generator) {
+  console.log(value); // Prints "1", "2", "3".
+}
+
+console.log(generator.lastValue()); // Prints "end".
+```
+
+Note: `lastValue()` will throw if it is being called before end of iteration. Also, excessive calls to `next()` will return `{ done: true, value: undefined }`, thus, `lastValue()` could become `undefined` if `next()` is called after the end of iteration.
+
+The value returned from `generatorWithLastValue()`/`asyncGeneratorWithLastValue()` will passthrough all function calls to original `Generator` with a minor difference. Calling `[Symbol.iterator]()`/`[Symbol.asyncIterator]()` on the returned generator will not start a fresh iteration. If a fresh iteration is required, create a new one before passing it to `generatorWithLastValue()`/`asyncGeneratorWithLastValue()`.
+
+```ts
+const generator = generatorWithLastValue(
+  (function* () {
+    // ...
+  })()[Symbol.iterator]() // Creates a fresh iteration.
+);
+```
+
+## 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 `iterator*`.
+
+```ts
+import { iteratorIncludes, iteratorReduce } from 'iter-fest'; // Via default exports.
+import { iteratorSome } from 'iter-fest/iteratorSome'; // Via named exports.
+
+const iterator: iterator<number> = [1, 2, 3, 4, 5].values();
+
+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), [`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
 
 ### How this compares to the TC39 proposals?
@@ -187,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`?
 
@@ -220,18 +344,21 @@ Generator has more functionalities than iterator and array. It is not recommende
 - Generator can define the return value
   - `return { done: true, value: 'the very last value' }`
   - Iterating generator using for-loop will not get any values from `{ done: true }`
+  - The `generatorWithLastValue()` will help capturing and retrieving the last return value
 - Generator can receive feedback values from its iterator
   - `generator.next('something')`, the feedback can be assigned to variable via `const feedback = yield;`
   - For-loop cannot send feedbacks to generator
 
 ### When should I use `Iterable`, `IterableIterator` and `Iterator`?
 
-For best compatibility, you should generally follow this API signature: use `Iterable` for inputs, and use `IterableIterator` for outputs. You should avoid exporting pure `Iterator`.
+For best compatibility, you should generally follow this API signature: use `Iterable` for inputs, and use `IterableIterator` for outputs. You should avoid exporting pure `Iterator`. Sample function signature should looks below.
 
 ```ts
-function transform<T>(iterable: Iterable<T>): IterableIterator<T>;
+function myFunction<T>(input: Iterable<T>): IterableIterator<T>;
 ```
 
+`IterableIterator` may opt to support restarting the iteration through `[Symbol.iterator]()`. When consuming an `IterableIterator`, you should call `[Symbol.iterator]()` to obtain a fresh iteration or use for-loop statement if possible. However, `[Symbol.iterator]()` is an opt-in feature and does not always guarantee a fresh iteration.
+
 ### What is on the roadmap?
 
 We are planning to bring iterables and its siblings together, including:

package/dist/chunk-2BBSIYMU.mjs

@@ -0,0 +1,10 @@
+// src/iteratorReduce.ts
+import reduce from "core-js-pure/full/iterator/reduce.js";
+function iteratorReduce(iterator, callbackfn, initialValue) {
+  return reduce(iterator, callbackfn, initialValue);
+}
+
+export {
+  iteratorReduce
+};
+//# sourceMappingURL=chunk-2BBSIYMU.mjs.map

package/dist/chunk-2BBSIYMU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorReduce.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport reduce from 'core-js-pure/full/iterator/reduce.js';\n\n/**\n * Calls the specified callback function for all the elements in an iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n *\n * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the iterator.\n *\n * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an iterator value.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function iteratorReduce<T>(\n  iterator: Iterator<T>,\n  callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T\n): T;\n\nexport function iteratorReduce<T>(\n  iterator: Iterator<T>,\n  callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T,\n  initialValue: T\n): T;\n\n/**\n * Calls the specified callback function for all the elements in an iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n *\n * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the iterator.\n *\n * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function iteratorReduce<T, U>(\n  iterator: Iterator<T>,\n  callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U,\n  initialValue: U\n): U;\n\nexport function iteratorReduce<T, U = undefined>(\n  iterator: Iterator<T>,\n  callbackfn: (previousValue: U | undefined, currentValue: T, currentIndex: number) => U,\n  initialValue?: U\n): U | undefined {\n  return reduce(iterator, callbackfn, initialValue);\n}\n"],"mappings":";AACA,OAAO,YAAY;AAqCZ,SAAS,eACd,UACA,YACA,cACe;AACf,SAAO,OAAO,UAAU,YAAY,YAAY;AAClD;","names":[]}

package/dist/chunk-2DE3J4J7.mjs

@@ -0,0 +1,35 @@
+// src/generatorWithLastValue.ts
+var STILL_ITERATING = Symbol();
+function generatorWithLastValue(generator) {
+  let lastValue = STILL_ITERATING;
+  const generatorWithLastValue2 = {
+    [Symbol.iterator]() {
+      return generatorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    next(next) {
+      const result = generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
+    }
+  };
+  return generatorWithLastValue2;
+}
+
+export {
+  generatorWithLastValue
+};
+//# sourceMappingURL=chunk-2DE3J4J7.mjs.map

package/dist/chunk-2DE3J4J7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generatorWithLastValue.ts"],"sourcesContent":["const STILL_ITERATING = Symbol();\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type GeneratorWithLastValue<T = unknown, TReturn = any, TNext = unknown> = Generator<T, TReturn, TNext> & {\n  lastValue(): TReturn;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function generatorWithLastValue<T = unknown, TReturn = any, TNext = unknown>(\n  generator: Generator<T, TReturn, TNext>\n): GeneratorWithLastValue<T, TReturn, TNext> {\n  let lastValue: typeof STILL_ITERATING | TReturn = STILL_ITERATING;\n\n  const generatorWithLastValue = {\n    [Symbol.iterator]() {\n      return generatorWithLastValue;\n    },\n    lastValue(): TReturn {\n      if (lastValue === STILL_ITERATING) {\n        throw new Error('Iteration has not complete yet, cannot get last value.');\n      }\n\n      return lastValue;\n    },\n    next(next: TNext) {\n      const result = generator.next(next);\n\n      if (result.done) {\n        lastValue = result.value;\n      }\n\n      return result;\n    },\n    return(value: TReturn) {\n      return generator.return(value);\n    },\n    throw(error: unknown) {\n      return generator.throw(error);\n    }\n  };\n\n  return generatorWithLastValue;\n}\n"],"mappings":";AAAA,IAAM,kBAAkB,OAAO;AAQxB,SAAS,uBACd,WAC2C;AAC3C,MAAI,YAA8C;AAElD,QAAMA,0BAAyB;AAAA,IAC7B,CAAC,OAAO,QAAQ,IAAI;AAClB,aAAOA;AAAA,IACT;AAAA,IACA,YAAqB;AACnB,UAAI,cAAc,iBAAiB;AACjC,cAAM,IAAI,MAAM,wDAAwD;AAAA,MAC1E;AAEA,aAAO;AAAA,IACT;AAAA,IACA,KAAK,MAAa;AAChB,YAAM,SAAS,UAAU,KAAK,IAAI;AAElC,UAAI,OAAO,MAAM;AACf,oBAAY,OAAO;AAAA,MACrB;AAEA,aAAO;AAAA,IACT;AAAA,IACA,OAAO,OAAgB;AACrB,aAAO,UAAU,OAAO,KAAK;AAAA,IAC/B;AAAA,IACA,MAAM,OAAgB;AACpB,aAAO,UAAU,MAAM,KAAK;AAAA,IAC9B;AAAA,EACF;AAEA,SAAOA;AACT;","names":["generatorWithLastValue"]}

package/dist/chunk-5LYB6HR7.mjs

@@ -0,0 +1,46 @@
+// src/private/withResolvers.ts
+import coreJSPromiseWithResolvers from "core-js-pure/full/promise/with-resolvers.js";
+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-5LYB6HR7.mjs.map

package/dist/chunk-5LYB6HR7.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.js';\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-745JDME6.mjs

@@ -0,0 +1,10 @@
+// src/asyncIteratorToArray.ts
+import toArray from "core-js-pure/full/async-iterator/to-array.js";
+function asyncIteratorToArray(asyncIteratorLike) {
+  return toArray(asyncIteratorLike);
+}
+
+export {
+  asyncIteratorToArray
+};
+//# sourceMappingURL=chunk-745JDME6.mjs.map

package/dist/chunk-745JDME6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorToArray.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport toArray from 'core-js-pure/full/async-iterator/to-array.js';\n\n/**\n * When you have a non-infinite iterator which you wish to transform into an array, you can do so with the builtin toArray method.\n *\n * @return Returns an Array containing the values from the iterator.\n *\n * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md\n */\nexport function asyncIteratorToArray<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): Promise<T[]> {\n  return toArray(asyncIteratorLike);\n}\n"],"mappings":";AACA,OAAO,aAAa;AASb,SAAS,qBAAwB,mBAAiE;AACvG,SAAO,QAAQ,iBAAiB;AAClC;","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-ANRVAYLW.mjs

@@ -0,0 +1,35 @@
+// src/asyncGeneratorWithLastValue.ts
+var STILL_ITERATING = Symbol();
+function asyncGeneratorWithLastValue(generator) {
+  let lastValue = STILL_ITERATING;
+  const asyncGeneratorWithLastValue2 = {
+    [Symbol.asyncIterator]() {
+      return asyncGeneratorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    async next(next) {
+      const result = await generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
+    }
+  };
+  return asyncGeneratorWithLastValue2;
+}
+
+export {
+  asyncGeneratorWithLastValue
+};
+//# sourceMappingURL=chunk-ANRVAYLW.mjs.map

package/dist/chunk-ANRVAYLW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncGeneratorWithLastValue.ts"],"sourcesContent":["const STILL_ITERATING = Symbol();\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AsyncGeneratorWithLastValue<T = unknown, TReturn = any, TNext = unknown> = AsyncGenerator<\n  T,\n  TReturn,\n  TNext\n> & {\n  lastValue(): TReturn;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function asyncGeneratorWithLastValue<T = unknown, TReturn = any, TNext = unknown>(\n  generator: AsyncGenerator<T, TReturn, TNext>\n): AsyncGeneratorWithLastValue<T, TReturn, TNext> {\n  let lastValue: typeof STILL_ITERATING | TReturn = STILL_ITERATING;\n\n  const asyncGeneratorWithLastValue = {\n    [Symbol.asyncIterator]() {\n      return asyncGeneratorWithLastValue;\n    },\n    lastValue(): TReturn {\n      if (lastValue === STILL_ITERATING) {\n        throw new Error('Iteration has not complete yet, cannot get last value.');\n      }\n\n      return lastValue;\n    },\n    async next(next: TNext) {\n      const result = await generator.next(next);\n\n      if (result.done) {\n        lastValue = result.value;\n      }\n\n      return result;\n    },\n    return(value: TReturn) {\n      return generator.return(value);\n    },\n    throw(error: unknown) {\n      return generator.throw(error);\n    }\n  };\n\n  return asyncGeneratorWithLastValue;\n}\n"],"mappings":";AAAA,IAAM,kBAAkB,OAAO;AAYxB,SAAS,4BACd,WACgD;AAChD,MAAI,YAA8C;AAElD,QAAMA,+BAA8B;AAAA,IAClC,CAAC,OAAO,aAAa,IAAI;AACvB,aAAOA;AAAA,IACT;AAAA,IACA,YAAqB;AACnB,UAAI,cAAc,iBAAiB;AACjC,cAAM,IAAI,MAAM,wDAAwD;AAAA,MAC1E;AAEA,aAAO;AAAA,IACT;AAAA,IACA,MAAM,KAAK,MAAa;AACtB,YAAM,SAAS,MAAM,UAAU,KAAK,IAAI;AAExC,UAAI,OAAO,MAAM;AACf,oBAAY,OAAO;AAAA,MACrB;AAEA,aAAO;AAAA,IACT;AAAA,IACA,OAAO,OAAgB;AACrB,aAAO,UAAU,OAAO,KAAK;AAAA,IAC/B;AAAA,IACA,MAAM,OAAgB;AACpB,aAAO,UAAU,MAAM,KAAK;AAAA,IAC9B;AAAA,EACF;AAEA,SAAOA;AACT;","names":["asyncGeneratorWithLastValue"]}

package/dist/chunk-AUWAPRBT.mjs

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

package/dist/chunk-AUWAPRBT.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.js';\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-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-OJMT4K3R.mjs → chunk-BZKIZ3TX.mjs}

@@ -1,8 +1,8 @@
 // src/SymbolObservable.ts
-import CoreJSSymbolObservable from "core-js-pure/features/symbol/observable";
+import CoreJSSymbolObservable from "core-js-pure/features/symbol/observable.js";
 var SymbolObservable = CoreJSSymbolObservable;
 
 export {
   SymbolObservable
 };
-//# sourceMappingURL=chunk-OJMT4K3R.mjs.map
+//# sourceMappingURL=chunk-BZKIZ3TX.mjs.map