iter-fest 0.1.1-main.b1e260f → 0.1.1-main.cc53108

package/README.md

@@ -18,23 +18,18 @@ npm install iter-fest
 
 ## Conversions
 
-| 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)        |
+| 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)         |
 
-### Converting an iterator to iterable
-
-```ts
-function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>
+To convert `Observable` to `AsyncIterableIterator`, [use `ReadableStream` as intermediate format](#converting-an-observable-to-asynciterableiterator).
 
-function asyncIteratorToAsyncIterable<T>(asyncIterator: AsyncIterator<T>): AsyncIterableIterator<T>
-```
+### Converting an iterator to iterable
 
 `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.
 
@@ -60,12 +55,26 @@ 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 `AsyncIterable` to `Observable`
+### 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.
 
 ```ts
-function observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>
+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".
+}
 ```
 
+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]()`.
@@ -89,10 +98,6 @@ 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.
@@ -104,16 +109,12 @@ const readable = observableSubscribeAsReadable(observable);
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-### Converting a `ReadableStream` to `AsyncIterableIterator`
-
-```ts
-function readableStreamValues`<T>(readable: ReadableStream<T>): AsyncIterableIterator<T>
-```
+### Converting a `ReadableStreamDefaultReader` to `AsyncIterableIterator`
 
-`readableStreamValues` allow iteration of `ReadableStream` as an `AsyncIterableIterator`.
+`readerValues` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
 
 ```ts
-const readable = new ReadableStream({
+const readableStream = new ReadableStream({
   start(controller) {
     controller.enqueue(1);
     controller.enqueue(2);
@@ -124,23 +125,17 @@ const readable = new ReadableStream({
   }
 });
 
-const iterable = readableStreamValues(readable);
+const iterable = readerValues(readableStream.getReader());
 
 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.
+Note: `[Symbol.asyncIterator]()` will not restart the reader and read from start of the stream. Reader is not restartable and streams are not seekable.
 
 ### 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
@@ -152,27 +147,6 @@ 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`

package/dist/{chunk-RVIERPEV.mjs → chunk-EUVK4YM7.mjs}

@@ -1,6 +1,5 @@
-// src/readableStreamValues.ts
-function readableStreamValues(readable) {
-  const reader = readable.getReader();
+// src/readerValues.ts
+function readerValues(reader) {
   const iterable = {
     [Symbol.asyncIterator]() {
       return iterable;
@@ -13,7 +12,7 @@ function readableStreamValues(readable) {
       return { value: result.value };
     },
     async return() {
-      reader.releaseLock();
+      reader.cancel();
       return { done: true, value: void 0 };
     }
   };
@@ -21,6 +20,6 @@ function readableStreamValues(readable) {
 }
 
 export {
-  readableStreamValues
+  readerValues
 };
-//# sourceMappingURL=chunk-RVIERPEV.mjs.map
+//# sourceMappingURL=chunk-EUVK4YM7.mjs.map

package/dist/chunk-EUVK4YM7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readerValues.ts"],"sourcesContent":["export function readerValues<T>(reader: ReadableStreamDefaultReader<T>): AsyncIterableIterator<T> {\n  const iterable: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      return iterable;\n    },\n    async next(): Promise<IteratorResult<T>> {\n      const result = await Promise.race([reader.read(), reader.closed]);\n\n      if (!result || result.done) {\n        return { done: true, value: undefined };\n      }\n\n      return { value: result.value };\n    },\n    async return() {\n      // Throw inside for-loop is return().\n      reader.cancel();\n\n      return { done: true, value: undefined };\n    }\n  };\n\n  return iterable;\n}\n"],"mappings":";AAAO,SAAS,aAAgB,QAAkE;AAChG,QAAM,WAAqC;AAAA,IACzC,CAAC,OAAO,aAAa,IAAI;AACvB,aAAO;AAAA,IACT;AAAA,IACA,MAAM,OAAmC;AACvC,YAAM,SAAS,MAAM,QAAQ,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,MAAM,CAAC;AAEhE,UAAI,CAAC,UAAU,OAAO,MAAM;AAC1B,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAEA,aAAO,EAAE,OAAO,OAAO,MAAM;AAAA,IAC/B;AAAA,IACA,MAAM,SAAS;AAEb,aAAO,OAAO;AAEd,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-DC2ZV7KQ.mjs → chunk-KYMTQJIJ.mjs}

@@ -7,4 +7,4 @@ function iteratorFrom(iteratorLike) {
 export {
   iteratorFrom
 };
-//# sourceMappingURL=chunk-DC2ZV7KQ.mjs.map
+//# sourceMappingURL=chunk-KYMTQJIJ.mjs.map

package/dist/chunk-KYMTQJIJ.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 * @param limit\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: Iterator<T>): Iterator<T> {\n  return from(iteratorLike);\n}\n"],"mappings":";AACA,OAAO,UAAU;AAWV,SAAS,aAAgB,cAAwC;AACtE,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/dist/{chunk-JVR6BUJA.mjs → chunk-TQCZXEK7.mjs}

@@ -7,4 +7,4 @@ function asyncIteratorToArray(asyncIteratorLike) {
 export {
   asyncIteratorToArray
 };
-//# sourceMappingURL=chunk-JVR6BUJA.mjs.map
+//# sourceMappingURL=chunk-TQCZXEK7.mjs.map

package/dist/chunk-TQCZXEK7.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';\n\ntype AsyncIteratorLike<T> = Pick<AsyncIterator<T>, 'next'>;\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 * @param limit\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: AsyncIteratorLike<T>): Promise<T[]> {\n  return toArray(asyncIteratorLike);\n}\n"],"mappings":";AACA,OAAO,aAAa;AAab,SAAS,qBAAwB,mBAAuD;AAC7F,SAAO,QAAQ,iBAAiB;AAClC;","names":[]}

package/dist/{chunk-S2LECQKY.mjs → chunk-YLERARWI.mjs}

@@ -7,4 +7,4 @@ function iteratorToArray(iteratorLike) {
 export {
   iteratorToArray
 };
-//# sourceMappingURL=chunk-S2LECQKY.mjs.map
+//# sourceMappingURL=chunk-YLERARWI.mjs.map

package/dist/chunk-YLERARWI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorToArray.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport toArray from 'core-js-pure/full/iterator/to-array';\n\ntype IteratorLike<T> = Pick<Iterator<T>, 'next'>;\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 * @param limit\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 iteratorToArray<T>(iteratorLike: IteratorLike<T>): T[] {\n  return toArray(iteratorLike);\n}\n"],"mappings":";AACA,OAAO,aAAa;AAab,SAAS,gBAAmB,cAAoC;AACrE,SAAO,QAAQ,YAAY;AAC7B;","names":[]}

package/dist/iter-fest.asyncIteratorToArray.d.mts

@@ -1,10 +1,13 @@
+type AsyncIteratorLike<T> = Pick<AsyncIterator<T>, 'next'>;
 /**
  * When you have a non-infinite iterator which you wish to transform into an array, you can do so with the builtin toArray method.
  *
+ * @param limit
+ *
  * @return Returns an Array containing the values from the iterator.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function asyncIteratorToArray<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): Promise<T[]>;
+declare function asyncIteratorToArray<T>(asyncIteratorLike: AsyncIteratorLike<T>): Promise<T[]>;
 
 export { asyncIteratorToArray };

package/dist/iter-fest.asyncIteratorToArray.d.ts

@@ -1,10 +1,13 @@
+type AsyncIteratorLike<T> = Pick<AsyncIterator<T>, 'next'>;
 /**
  * When you have a non-infinite iterator which you wish to transform into an array, you can do so with the builtin toArray method.
  *
+ * @param limit
+ *
  * @return Returns an Array containing the values from the iterator.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function asyncIteratorToArray<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): Promise<T[]>;
+declare function asyncIteratorToArray<T>(asyncIteratorLike: AsyncIteratorLike<T>): Promise<T[]>;
 
 export { asyncIteratorToArray };

package/dist/iter-fest.asyncIteratorToArray.js.map

@@ -1 +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';\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sBAAoB;AASb,SAAS,qBAAwB,mBAAiE;AACvG,aAAO,gBAAAA,SAAQ,iBAAiB;AAClC;","names":["toArray"]}
+{"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';\n\ntype AsyncIteratorLike<T> = Pick<AsyncIterator<T>, 'next'>;\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 * @param limit\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: AsyncIteratorLike<T>): Promise<T[]> {\n  return toArray(asyncIteratorLike);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sBAAoB;AAab,SAAS,qBAAwB,mBAAuD;AAC7F,aAAO,gBAAAA,SAAQ,iBAAiB;AAClC;","names":["toArray"]}

package/dist/iter-fest.asyncIteratorToArray.mjs

@@ -1,6 +1,6 @@
 import {
   asyncIteratorToArray
-} from "./chunk-JVR6BUJA.mjs";
+} from "./chunk-TQCZXEK7.mjs";
 export {
   asyncIteratorToArray
 };

package/dist/iter-fest.d.mts

@@ -7,7 +7,6 @@ export { asyncIteratorFilter } from './iter-fest.asyncIteratorFilter.mjs';
 export { asyncIteratorFind } from './iter-fest.asyncIteratorFind.mjs';
 export { asyncIteratorFlatMap } from './iter-fest.asyncIteratorFlatMap.mjs';
 export { asyncIteratorForEach } from './iter-fest.asyncIteratorForEach.mjs';
-export { asyncIteratorFrom } from './iter-fest.asyncIteratorFrom.mjs';
 export { asyncIteratorMap } from './iter-fest.asyncIteratorMap.mjs';
 export { asyncIteratorReduce } from './iter-fest.asyncIteratorReduce.mjs';
 export { asyncIteratorSome } from './iter-fest.asyncIteratorSome.mjs';
@@ -45,7 +44,6 @@ export { iteratorToSpliced } from './iter-fest.iteratorToSpliced.mjs';
 export { iteratorToString } from './iter-fest.iteratorToString.mjs';
 export { observableFromAsync } from './iter-fest.observableFromAsync.mjs';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.mjs';
-export { observableValues } from './iter-fest.observableValues.mjs';
 export { readableStreamFrom } from './iter-fest.readableStreamFrom.mjs';
-export { readableStreamValues } from './iter-fest.readableStreamValues.mjs';
+export { readerValues } from './iter-fest.readerValues.mjs';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.d.ts

@@ -7,7 +7,6 @@ export { asyncIteratorFilter } from './iter-fest.asyncIteratorFilter.js';
 export { asyncIteratorFind } from './iter-fest.asyncIteratorFind.js';
 export { asyncIteratorFlatMap } from './iter-fest.asyncIteratorFlatMap.js';
 export { asyncIteratorForEach } from './iter-fest.asyncIteratorForEach.js';
-export { asyncIteratorFrom } from './iter-fest.asyncIteratorFrom.js';
 export { asyncIteratorMap } from './iter-fest.asyncIteratorMap.js';
 export { asyncIteratorReduce } from './iter-fest.asyncIteratorReduce.js';
 export { asyncIteratorSome } from './iter-fest.asyncIteratorSome.js';
@@ -45,7 +44,6 @@ export { iteratorToSpliced } from './iter-fest.iteratorToSpliced.js';
 export { iteratorToString } from './iter-fest.iteratorToString.js';
 export { observableFromAsync } from './iter-fest.observableFromAsync.js';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.js';
-export { observableValues } from './iter-fest.observableValues.js';
 export { readableStreamFrom } from './iter-fest.readableStreamFrom.js';
-export { readableStreamValues } from './iter-fest.readableStreamValues.js';
+export { readerValues } from './iter-fest.readerValues.js';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.iteratorFrom.d.mts

@@ -1,10 +1,12 @@
 /**
  * `.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.
  *
+ * @param limit
+ *
  * @return Returns the object if it is already an iterator, returns a wrapping iterator if the passed object implements a callable @@iterator property.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function iteratorFrom<T>(iteratorLike: Pick<Iterator<T>, 'next'>): Iterator<T>;
+declare function iteratorFrom<T>(iteratorLike: Iterator<T>): Iterator<T>;
 
 export { iteratorFrom };

package/dist/iter-fest.iteratorFrom.d.ts

@@ -1,10 +1,12 @@
 /**
  * `.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.
  *
+ * @param limit
+ *
  * @return Returns the object if it is already an iterator, returns a wrapping iterator if the passed object implements a callable @@iterator property.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function iteratorFrom<T>(iteratorLike: Pick<Iterator<T>, 'next'>): Iterator<T>;
+declare function iteratorFrom<T>(iteratorLike: Iterator<T>): Iterator<T>;
 
 export { iteratorFrom };

package/dist/iter-fest.iteratorFrom.js.map

@@ -1 +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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAAiB;AASV,SAAS,aAAgB,cAAsD;AACpF,aAAO,YAAAA,SAAK,YAAY;AAC1B;","names":["from"]}
+{"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 * @param limit\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: Iterator<T>): Iterator<T> {\n  return from(iteratorLike);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAAiB;AAWV,SAAS,aAAgB,cAAwC;AACtE,aAAO,YAAAA,SAAK,YAAY;AAC1B;","names":["from"]}

package/dist/iter-fest.iteratorFrom.mjs

@@ -1,6 +1,6 @@
 import {
   iteratorFrom
-} from "./chunk-DC2ZV7KQ.mjs";
+} from "./chunk-KYMTQJIJ.mjs";
 export {
   iteratorFrom
 };

package/dist/iter-fest.iteratorToArray.d.mts

@@ -1,10 +1,13 @@
+type IteratorLike<T> = Pick<Iterator<T>, 'next'>;
 /**
  * When you have a non-infinite iterator which you wish to transform into an array, you can do so with the builtin toArray method.
  *
+ * @param limit
+ *
  * @return Returns an Array containing the values from the iterator.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function iteratorToArray<T>(iteratorLike: Pick<Iterator<T>, 'next'>): T[];
+declare function iteratorToArray<T>(iteratorLike: IteratorLike<T>): T[];
 
 export { iteratorToArray };

package/dist/iter-fest.iteratorToArray.d.ts

@@ -1,10 +1,13 @@
+type IteratorLike<T> = Pick<Iterator<T>, 'next'>;
 /**
  * When you have a non-infinite iterator which you wish to transform into an array, you can do so with the builtin toArray method.
  *
+ * @param limit
+ *
  * @return Returns an Array containing the values from the iterator.
  *
  * @link https://github.com/tc39/proposal-iterator-helpers/blob/main/README.md
  */
-declare function iteratorToArray<T>(iteratorLike: Pick<Iterator<T>, 'next'>): T[];
+declare function iteratorToArray<T>(iteratorLike: IteratorLike<T>): T[];
 
 export { iteratorToArray };

package/dist/iter-fest.iteratorToArray.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iteratorToArray.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport toArray from 'core-js-pure/full/iterator/to-array';\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 iteratorToArray<T>(iteratorLike: Pick<Iterator<T>, 'next'>): T[] {\n  return toArray(iteratorLike);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sBAAoB;AASb,SAAS,gBAAmB,cAA8C;AAC/E,aAAO,gBAAAA,SAAQ,YAAY;AAC7B;","names":["toArray"]}
+{"version":3,"sources":["../src/iteratorToArray.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport toArray from 'core-js-pure/full/iterator/to-array';\n\ntype IteratorLike<T> = Pick<Iterator<T>, 'next'>;\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 * @param limit\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 iteratorToArray<T>(iteratorLike: IteratorLike<T>): T[] {\n  return toArray(iteratorLike);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sBAAoB;AAab,SAAS,gBAAmB,cAAoC;AACrE,aAAO,gBAAAA,SAAQ,YAAY;AAC7B;","names":["toArray"]}

package/dist/iter-fest.iteratorToArray.mjs

@@ -1,6 +1,6 @@
 import {
   iteratorToArray
-} from "./chunk-S2LECQKY.mjs";
+} from "./chunk-YLERARWI.mjs";
 export {
   iteratorToArray
 };

package/dist/iter-fest.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -40,7 +40,6 @@ __export(src_exports, {
   asyncIteratorFind: () => asyncIteratorFind,
   asyncIteratorFlatMap: () => asyncIteratorFlatMap,
   asyncIteratorForEach: () => asyncIteratorForEach,
-  asyncIteratorFrom: () => asyncIteratorFrom,
   asyncIteratorMap: () => asyncIteratorMap,
   asyncIteratorReduce: () => asyncIteratorReduce,
   asyncIteratorSome: () => asyncIteratorSome,
@@ -77,9 +76,8 @@ __export(src_exports, {
   iteratorToString: () => iteratorToString,
   observableFromAsync: () => observableFromAsync,
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
-  observableValues: () => observableValues,
   readableStreamFrom: () => readableStreamFrom,
-  readableStreamValues: () => readableStreamValues
+  readerValues: () => readerValues
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -178,12 +176,6 @@ function asyncIteratorForEach(asyncIterator, callbackfn) {
   return (0, import_for_each.default)(asyncIterator, callbackfn);
 }
 
-// src/asyncIteratorFrom.ts
-var import_from = __toESM(require("core-js-pure/full/async-iterator/from"));
-function asyncIteratorFrom(asyncIteratorLike) {
-  return (0, import_from.default)(asyncIteratorLike);
-}
-
 // src/asyncIteratorMap.ts
 var import_map = __toESM(require("core-js-pure/full/async-iterator/map"));
 function asyncIteratorMap(asyncIterator, callbackfn) {
@@ -444,9 +436,9 @@ function iteratorForEach(iterator, callbackfn) {
 }
 
 // src/iteratorFrom.ts
-var import_from2 = __toESM(require("core-js-pure/full/iterator/from"));
+var import_from = __toESM(require("core-js-pure/full/iterator/from"));
 function iteratorFrom(iteratorLike) {
-  return (0, import_from2.default)(iteratorLike);
+  return (0, import_from.default)(iteratorLike);
 }
 
 // src/iteratorIncludes.ts
@@ -648,55 +640,6 @@ function observableSubscribeAsReadable(observable) {
   });
 }
 
-// src/readableStreamValues.ts
-function readableStreamValues(readable) {
-  const reader = readable.getReader();
-  const iterable = {
-    [Symbol.asyncIterator]() {
-      return iterable;
-    },
-    async next() {
-      const result = await Promise.race([reader.read(), reader.closed]);
-      if (!result || result.done) {
-        return { done: true, value: void 0 };
-      }
-      return { value: result.value };
-    },
-    async return() {
-      reader.releaseLock();
-      return { done: true, value: void 0 };
-    }
-  };
-  return iterable;
-}
-
-// 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;
-}
-
 // src/readableStreamFrom.ts
 function isIterable(iterable) {
   return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
@@ -714,6 +657,27 @@ function readableStreamFrom(anyIterable) {
     }
   });
 }
+
+// src/readerValues.ts
+function readerValues(reader) {
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return iterable;
+    },
+    async next() {
+      const result = await Promise.race([reader.read(), reader.closed]);
+      if (!result || result.done) {
+        return { done: true, value: void 0 };
+      }
+      return { value: result.value };
+    },
+    async return() {
+      reader.cancel();
+      return { done: true, value: void 0 };
+    }
+  };
+  return iterable;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   IterableWritableStream,
@@ -726,7 +690,6 @@ function readableStreamFrom(anyIterable) {
   asyncIteratorFind,
   asyncIteratorFlatMap,
   asyncIteratorForEach,
-  asyncIteratorFrom,
   asyncIteratorMap,
   asyncIteratorReduce,
   asyncIteratorSome,
@@ -763,8 +726,7 @@ function readableStreamFrom(anyIterable) {
   iteratorToString,
   observableFromAsync,
   observableSubscribeAsReadable,
-  observableValues,
   readableStreamFrom,
-  readableStreamValues
+  readerValues
 });
 //# sourceMappingURL=iter-fest.js.map