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

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`

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-KYMTQJIJ.mjs → chunk-DC2ZV7KQ.mjs}

@@ -7,4 +7,4 @@ function iteratorFrom(iteratorLike) {
 export {
   iteratorFrom
 };
-//# sourceMappingURL=chunk-KYMTQJIJ.mjs.map
+//# 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-TQCZXEK7.mjs → chunk-JVR6BUJA.mjs}

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

package/dist/chunk-JVR6BUJA.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\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-NLXKATXE.mjs

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

package/dist/chunk-NLXKATXE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorFrom.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport from from 'core-js-pure/full/async-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 asyncIteratorFrom<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): AsyncIterator<T> {\n  return from(asyncIteratorLike);\n}\n"],"mappings":";AACA,OAAO,UAAU;AASV,SAAS,kBAAqB,mBAAqE;AACxG,SAAO,KAAK,iBAAiB;AAC/B;","names":[]}

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

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

package/dist/chunk-RVIERPEV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readableStreamValues.ts"],"sourcesContent":["export function readableStreamValues<T>(readable: ReadableStream<T>): AsyncIterableIterator<T> {\n  const reader = readable.getReader();\n\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      // Break/throw inside for-loop will trigger return().\n      reader.releaseLock();\n\n      return { done: true, value: undefined };\n    }\n  };\n\n  return iterable;\n}\n"],"mappings":";AAAO,SAAS,qBAAwB,UAAuD;AAC7F,QAAM,SAAS,SAAS,UAAU;AAElC,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,YAAY;AAEnB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

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

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

package/dist/chunk-S2LECQKY.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\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":";AACA,OAAO,aAAa;AASb,SAAS,gBAAmB,cAA8C;AAC/E,SAAO,QAAQ,YAAY;AAC7B;","names":[]}

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

@@ -0,0 +1,10 @@
+/**
+ * `.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.
+ *
+ * @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 asyncIteratorFrom<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): AsyncIterator<T>;
+
+export { asyncIteratorFrom };

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

@@ -0,0 +1,10 @@
+/**
+ * `.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.
+ *
+ * @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 asyncIteratorFrom<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): AsyncIterator<T>;
+
+export { asyncIteratorFrom };

package/dist/iter-fest.asyncIteratorFrom.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asyncIteratorFrom.ts
+var asyncIteratorFrom_exports = {};
+__export(asyncIteratorFrom_exports, {
+  asyncIteratorFrom: () => asyncIteratorFrom
+});
+module.exports = __toCommonJS(asyncIteratorFrom_exports);
+var import_from = __toESM(require("core-js-pure/full/async-iterator/from"));
+function asyncIteratorFrom(asyncIteratorLike) {
+  return (0, import_from.default)(asyncIteratorLike);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asyncIteratorFrom
+});
+//# sourceMappingURL=iter-fest.asyncIteratorFrom.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asyncIteratorFrom.ts"],"sourcesContent":["// @ts-expect-error core-js-pure is not typed.\nimport from from 'core-js-pure/full/async-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 asyncIteratorFrom<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): AsyncIterator<T> {\n  return from(asyncIteratorLike);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAAiB;AASV,SAAS,kBAAqB,mBAAqE;AACxG,aAAO,YAAAA,SAAK,iBAAiB;AAC/B;","names":["from"]}

package/dist/iter-fest.asyncIteratorFrom.mjs

@@ -0,0 +1,7 @@
+import {
+  asyncIteratorFrom
+} from "./chunk-NLXKATXE.mjs";
+export {
+  asyncIteratorFrom
+};
+//# sourceMappingURL=iter-fest.asyncIteratorFrom.mjs.map

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

@@ -1,13 +1,10 @@
-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: AsyncIteratorLike<T>): Promise<T[]>;
+declare function asyncIteratorToArray<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): Promise<T[]>;
 
 export { asyncIteratorToArray };

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

@@ -1,13 +1,10 @@
-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: AsyncIteratorLike<T>): Promise<T[]>;
+declare function asyncIteratorToArray<T>(asyncIteratorLike: Pick<AsyncIterator<T>, 'next'>): 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\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"]}
+{"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"]}

package/dist/iter-fest.asyncIteratorToArray.mjs

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

package/dist/iter-fest.d.mts

@@ -7,6 +7,7 @@ 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';
@@ -44,6 +45,7 @@ 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 { readerValues } from './iter-fest.readerValues.mjs';
+export { readableStreamValues } from './iter-fest.readableStreamValues.mjs';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.d.ts

@@ -7,6 +7,7 @@ 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';
@@ -44,6 +45,7 @@ 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 { readerValues } from './iter-fest.readerValues.js';
+export { readableStreamValues } from './iter-fest.readableStreamValues.js';
 import 'core-js-pure/full/observable';

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

@@ -1,12 +1,10 @@
 /**
  * `.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: Iterator<T>): Iterator<T>;
+declare function iteratorFrom<T>(iteratorLike: Pick<Iterator<T>, 'next'>): Iterator<T>;
 
 export { iteratorFrom };

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

@@ -1,12 +1,10 @@
 /**
  * `.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: Iterator<T>): Iterator<T>;
+declare function iteratorFrom<T>(iteratorLike: Pick<Iterator<T>, 'next'>): 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 * @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"]}
+{"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"]}

package/dist/iter-fest.iteratorFrom.mjs

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

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

@@ -1,13 +1,10 @@
-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: IteratorLike<T>): T[];
+declare function iteratorToArray<T>(iteratorLike: Pick<Iterator<T>, 'next'>): T[];
 
 export { iteratorToArray };

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

@@ -1,13 +1,10 @@
-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: IteratorLike<T>): T[];
+declare function iteratorToArray<T>(iteratorLike: Pick<Iterator<T>, 'next'>): 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\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"]}
+{"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"]}

package/dist/iter-fest.iteratorToArray.mjs

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