iter-fest 0.1.1-main.dd552c2 → 0.1.1-main.edf2470

package/README.md

@@ -16,22 +16,38 @@ Iterables can contains infinite number of items, please use this package respons
 npm install iter-fest
 ```
 
+### `Array.prototype` ports
+
+We ported majority of functions from `Array.prototype.*` to `iterable*`.
+
+```ts
+import { iterableIncludes, iterableReduce } from 'iter-fest'; // Via default exports.
+import { iterableSome } from 'iter-fest/iterableSome'; // Via named exports.
+
+const iterable: Iterable<number> = [1, 2, 3, 4, 5].values();
+
+console.log(iterableIncludes(iterable, 3)); // Prints "true".
+console.log(iterableReduce(iterable, (sum, value) => sum + value, 0)); // Prints "15".
+console.log(iterableSome(iterable, value => value % 2)); // Prints "true".
+```
+
+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)                                                 |
-| `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)         |
+| 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>(iterable: AsyncIterable<T>): Observable<T>`](#converting-an-asynciterable-to-observable)                                |
+| `AsyncIterable`/`Iterable`    | `ReadableStream`        | [`iterableGetReadable<T>(iterable: 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).
 
 ### 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.
+`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.
 
 ```ts
 const iterate = (): Iterator<number> => {
@@ -43,7 +59,7 @@ const iterate = (): Iterator<number> => {
         return { value };
       }
 
-      return { done: true, value: undefined } satisfies IteratorResult<number>;
+      return { done: true, value: undefined };
     }
   };
 };
@@ -53,31 +69,28 @@ 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.
+Note: calling `[Symbol.iterator]` will not refresh the iteration.
 
 ### Converting an `Observable` to `AsyncIterableIterator`
 
-`ReadableStream` can be used as an intermediate format when converting an `Observable` to `AsyncIterableIterator`.
+`ReadableStream` can be used to 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
 const observable = Observable.from([1, 2, 3]);
 const readable = observableSubscribeAsReadable(observable);
-const iterable = readerValues(readable.getReader());
 
-for await (const value of iterable) {
+for await (const value of readerValues(readable.getReader())) {
   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]()`.
+`observableFromAsync` will convert `AsyncIterable` into `Observable`.
 
 ```ts
 async function* generate() {
@@ -92,11 +105,7 @@ const next = value => console.log(value);
 observable.subscribe({ next }); // Prints "1", "2", "3".
 ```
 
-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`
+## Converting an `Observable` to `ReadableStream`
 
 `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.
 
@@ -105,11 +114,12 @@ 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.
 ```
 
-### Converting a `ReadableStreamDefaultReader` to `AsyncIterableIterator`
+### Iterating `ReadableStreamDefaultReader`
 
 `readerValues` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
 
@@ -125,28 +135,20 @@ const readableStream = new ReadableStream({
   }
 });
 
-const iterable = readerValues(readableStream.getReader());
-
-for await (const value of iterable) {
+for await (const value of readerValues(readableStream.getReader())) {
   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.
-
-### Converting an `AsyncIterable`/`Iterable` to `ReadableStream`
-
-> Notes: this feature is part of [Streams Standard](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static).
+## Converting an `AsyncIterable`/`Iterable` to `ReadableStream`
 
 ```ts
 const iterable = [1, 2, 3].values();
-const readable = readableStreamFrom(iterable);
+const readable = iterableGetReadable(iterable);
 
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restart the iteration where possible.
-
 ## Others
 
 ### Typed `Observable`
@@ -155,18 +157,14 @@ Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restar
 
 ### Producer-consumer queue
 
-`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.
+`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` supports multiple consumers and continuation:
+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.
 
-- 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.
+For a full-featured producer-consumer queue that supports flow control, use `ReadableStream` instead.
 
 ```ts
-const iterable = new IterableWritableStream();
-const writer = iterable.getWriter();
+const iterable = new PushAsyncIterableIterator();
 
 (async function consumer() {
   for await (const value of iterable) {
@@ -177,10 +175,10 @@ const writer = iterable.getWriter();
 })();
 
 (async function producer() {
-  writer.write(1);
-  writer.write(2);
-  writer.write(3);
-  writer.close();
+  iterable.push(1);
+  iterable.push(2);
+  iterable.push(3);
+  iterable.close();
 })();
 
 // Prints "1", "2", "3", "Done".
@@ -197,11 +195,11 @@ The `generatorWithLastValue()` and `asyncGeneratorWithLastValue()` helps bridge
 ```ts
 const generator = generatorWithLastValue(
   (function* () {
-    yield 1; // { done: false, value: 1 }
-    yield 2; // { done: false, value: 2 }
-    yield 3; // { done: false, value: 3 }
+    yield 1;
+    yield 2;
+    yield 3;
 
-    return 'end'; // { done: true, value: 'end' }
+    return 'end';
   })()
 );
 
@@ -224,42 +222,6 @@ const generator = generatorWithLastValue(
 );
 ```
 
-## Adding types to `core-js-pure`
-
-We added types to 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)
-
-## `Array.prototype` ports
-
-> Note: we are working to move them from `iterable*` to `iterator*` to make them similar to TC39 proposals.
-
-We ported majority of functions from `Array.prototype.*` to `iterable*`.
-
-```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?
@@ -308,21 +270,18 @@ 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`. Sample function signature should looks below.
+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`.
 
 ```ts
-function myFunction<T>(input: Iterable<T>): IterableIterator<T>;
+function transform<T>(iterable: 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-5CRMPYKD.mjs

@@ -0,0 +1,19 @@
+// src/iterableEvery.ts
+function iterableEvery(iterable, predicate, thisArg = void 0) {
+  let index = 0;
+  if (typeof predicate !== "function") {
+    throw new TypeError(`${predicate} is not a function`);
+  }
+  const boundPredicate = predicate.bind(thisArg);
+  for (const value of iterable) {
+    if (!boundPredicate(value, index++, iterable)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export {
+  iterableEvery
+};
+//# sourceMappingURL=chunk-5CRMPYKD.mjs.map

package/dist/chunk-5CRMPYKD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableEvery.ts"],"sourcesContent":["/**\n * Determines whether all the members of an iterable satisfy the specified test.\n *\n * @param predicate A function that accepts up to three arguments. The every method calls\n * the predicate function for each element in the iterable until the predicate returns a value\n * which is coercible to the Boolean value false, or until the end of the iterable.\n *\n * @param thisArg An object to which the this keyword can refer in the predicate function.\n * If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableEvery<T, S extends T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => value is S,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): iterable is S[];\n\n/**\n * Determines whether all the members of an iterable satisfy the specified test.\n *\n * @param predicate A function that accepts up to three arguments. The every method calls\n * the predicate function for each element in the iterable until the predicate returns a value\n * which is coercible to the Boolean value false, or until the end of the iterable.\n *\n * @param thisArg An object to which the this keyword can refer in the predicate function.\n * If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableEvery<T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): boolean;\n\nexport function iterableEvery<T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg: any = undefined\n): boolean {\n  let index = 0;\n\n  if (typeof predicate !== 'function') {\n    throw new TypeError(`${predicate} is not a function`);\n  }\n\n  const boundPredicate = predicate.bind(thisArg);\n\n  for (const value of iterable) {\n    if (!boundPredicate(value, index++, iterable)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":";AAkCO,SAAS,cACd,UACA,WAEA,UAAe,QACN;AACT,MAAI,QAAQ;AAEZ,MAAI,OAAO,cAAc,YAAY;AACnC,UAAM,IAAI,UAAU,GAAG,SAAS,oBAAoB;AAAA,EACtD;AAEA,QAAM,iBAAiB,UAAU,KAAK,OAAO;AAE7C,aAAW,SAAS,UAAU;AAC5B,QAAI,CAAC,eAAe,OAAO,SAAS,QAAQ,GAAG;AAC7C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-6C3P4TNK.mjs

@@ -0,0 +1,19 @@
+// src/iterableSome.ts
+function iterableSome(iterable, predicate, thisArg = void 0) {
+  let index = 0;
+  if (typeof predicate !== "function") {
+    throw new TypeError(`${predicate} is not a function`);
+  }
+  const boundPredicate = predicate.bind(thisArg);
+  for (const value of iterable) {
+    if (boundPredicate(value, index++, iterable)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  iterableSome
+};
+//# sourceMappingURL=chunk-6C3P4TNK.mjs.map

package/dist/chunk-6C3P4TNK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableSome.ts"],"sourcesContent":["/**\n * Determines whether the specified callback function returns true for any element of an iterable.\n *\n * @param predicate\n * A function that accepts up to three arguments. The some method calls the predicate function for each element in the iterable until the predicate returns a value which is coercible to the Boolean value true, or until the end of the iterable.\n *\n * @param thisArg\n * An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableSome<T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg: any = undefined\n): boolean {\n  let index = 0;\n\n  if (typeof predicate !== 'function') {\n    throw new TypeError(`${predicate} is not a function`);\n  }\n\n  const boundPredicate = predicate.bind(thisArg);\n\n  for (const value of iterable) {\n    if (boundPredicate(value, index++, iterable)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";AASO,SAAS,aACd,UACA,WAEA,UAAe,QACN;AACT,MAAI,QAAQ;AAEZ,MAAI,OAAO,cAAc,YAAY;AACnC,UAAM,IAAI,UAAU,GAAG,SAAS,oBAAoB;AAAA,EACtD;AAEA,QAAM,iBAAiB,UAAU,KAAK,OAAO;AAE7C,aAAW,SAAS,UAAU;AAC5B,QAAI,eAAe,OAAO,SAAS,QAAQ,GAAG;AAC5C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-EZC33HE6.mjs

@@ -0,0 +1,15 @@
+// src/iterableMap.ts
+function* iterableMap(iterable, callbackfn, thisArg) {
+  let index = 0;
+  if (typeof callbackfn !== "function") {
+    throw new TypeError(`${callbackfn} is not a function`);
+  }
+  for (const value of iterable) {
+    yield callbackfn.call(thisArg, value, index++, iterable);
+  }
+}
+
+export {
+  iterableMap
+};
+//# sourceMappingURL=chunk-EZC33HE6.mjs.map

package/dist/chunk-EZC33HE6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableMap.ts"],"sourcesContent":["/**\n * Calls a defined callback function on each element of an array, and returns an array that contains the results.\n * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.\n * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.\n */\nexport function* iterableMap<T, U>(\n  iterable: Iterable<T>,\n  callbackfn: (value: T, index: number, array: Iterable<T>) => U,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): IterableIterator<U> {\n  let index = 0;\n\n  if (typeof callbackfn !== 'function') {\n    throw new TypeError(`${callbackfn} is not a function`);\n  }\n\n  for (const value of iterable) {\n    yield callbackfn.call(thisArg, value, index++, iterable);\n  }\n}\n"],"mappings":";AAKO,UAAU,YACf,UACA,YAEA,SACqB;AACrB,MAAI,QAAQ;AAEZ,MAAI,OAAO,eAAe,YAAY;AACpC,UAAM,IAAI,UAAU,GAAG,UAAU,oBAAoB;AAAA,EACvD;AAEA,aAAW,SAAS,UAAU;AAC5B,UAAM,WAAW,KAAK,SAAS,OAAO,SAAS,QAAQ;AAAA,EACzD;AACF;","names":[]}

package/dist/chunk-JU353VSE.mjs

@@ -0,0 +1,16 @@
+// src/iterableForEach.ts
+function iterableForEach(iterable, callbackfn, thisArg) {
+  let index = 0;
+  if (typeof callbackfn !== "function") {
+    throw new TypeError(`${callbackfn} is not a function`);
+  }
+  const boundCallbackfn = callbackfn.bind(thisArg);
+  for (const value of iterable) {
+    boundCallbackfn(value, index++, iterable);
+  }
+}
+
+export {
+  iterableForEach
+};
+//# sourceMappingURL=chunk-JU353VSE.mjs.map

package/dist/chunk-JU353VSE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableForEach.ts"],"sourcesContent":["/**\n * Performs the specified action for each element in an iterable.\n *\n * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the iterable.\n *\n * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableForEach<T>(\n  iterable: Iterable<T>,\n  callbackfn: (value: T, index: number, iterable: Iterable<T>) => void,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): void {\n  let index = 0;\n\n  if (typeof callbackfn !== 'function') {\n    throw new TypeError(`${callbackfn} is not a function`);\n  }\n\n  const boundCallbackfn = callbackfn.bind(thisArg);\n\n  for (const value of iterable) {\n    boundCallbackfn(value, index++, iterable);\n  }\n}\n"],"mappings":";AAOO,SAAS,gBACd,UACA,YAEA,SACM;AACN,MAAI,QAAQ;AAEZ,MAAI,OAAO,eAAe,YAAY;AACpC,UAAM,IAAI,UAAU,GAAG,UAAU,oBAAoB;AAAA,EACvD;AAEA,QAAM,kBAAkB,WAAW,KAAK,OAAO;AAE/C,aAAW,SAAS,UAAU;AAC5B,oBAAgB,OAAO,SAAS,QAAQ;AAAA,EAC1C;AACF;","names":[]}

package/dist/chunk-MNLOWKTC.mjs

@@ -0,0 +1,19 @@
+// src/iterableFind.ts
+function iterableFind(iterable, predicate, thisArg) {
+  let index = 0;
+  if (typeof predicate !== "function") {
+    throw new TypeError(`${predicate} is not a function`);
+  }
+  const boundPredicate = predicate.bind(thisArg);
+  for (const value of iterable) {
+    if (boundPredicate(value, index++, iterable)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+export {
+  iterableFind
+};
+//# sourceMappingURL=chunk-MNLOWKTC.mjs.map

package/dist/chunk-MNLOWKTC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableFind.ts"],"sourcesContent":["/**\n * Returns the value of the first element in the iterable where predicate is true, and undefined\n * otherwise.\n *\n * @param predicate find calls predicate once for each element of the iterable, 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 * @param thisArg If provided, it will be used as the this value for each invocation of\n * predicate. If it is not provided, undefined is used instead.\n */\nexport function iterableFind<T, S extends T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, obj: Iterable<T>) => value is S,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): S | undefined;\n\nexport function iterableFind<T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, obj: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): T | undefined;\n\nexport function iterableFind<T, S extends T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, obj: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): S | undefined {\n  let index = 0;\n\n  if (typeof predicate !== 'function') {\n    throw new TypeError(`${predicate} is not a function`);\n  }\n\n  const boundPredicate = predicate.bind(thisArg);\n\n  for (const value of iterable) {\n    if (boundPredicate(value, index++, iterable)) {\n      return value as S;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":";AAyBO,SAAS,aACd,UACA,WAEA,SACe;AACf,MAAI,QAAQ;AAEZ,MAAI,OAAO,cAAc,YAAY;AACnC,UAAM,IAAI,UAAU,GAAG,SAAS,oBAAoB;AAAA,EACtD;AAEA,QAAM,iBAAiB,UAAU,KAAK,OAAO;AAE7C,aAAW,SAAS,UAAU;AAC5B,QAAI,eAAe,OAAO,SAAS,QAAQ,GAAG;AAC5C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-YJSIVBF7.mjs → chunk-MOBXUTO5.mjs}

@@ -1,9 +1,9 @@
-// src/readableStreamFrom.ts
+// src/iterableGetReadable.ts
 function isIterable(iterable) {
   return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
 }
-function readableStreamFrom(anyIterable) {
-  const iterator = isIterable(anyIterable) ? anyIterable[Symbol.iterator]() : anyIterable[Symbol.asyncIterator]();
+function iterableGetReadable(iterable) {
+  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
   return new ReadableStream({
     async pull(controller) {
       const result = await iterator.next();
@@ -17,6 +17,6 @@ function readableStreamFrom(anyIterable) {
 }
 
 export {
-  readableStreamFrom
+  iterableGetReadable
 };
-//# sourceMappingURL=chunk-YJSIVBF7.mjs.map
+//# sourceMappingURL=chunk-MOBXUTO5.mjs.map

package/dist/chunk-MOBXUTO5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableGetReadable.ts"],"sourcesContent":["function isIterable(iterable: unknown): iterable is Iterable<unknown> {\n  return !!(iterable && typeof iterable === 'object' && Symbol.iterator in iterable);\n}\n\nexport function iterableGetReadable<T>(iterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T> {\n  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();\n\n  return new ReadableStream({\n    async pull(controller) {\n      const result = await iterator.next();\n\n      if (result.done) {\n        controller.close();\n      } else {\n        controller.enqueue(result.value);\n      }\n    }\n  });\n}\n"],"mappings":";AAAA,SAAS,WAAW,UAAkD;AACpE,SAAO,CAAC,EAAE,YAAY,OAAO,aAAa,YAAY,OAAO,YAAY;AAC3E;AAEO,SAAS,oBAAuB,UAA6D;AAClG,QAAM,WAAW,WAAW,QAAQ,IAAI,SAAS,OAAO,QAAQ,EAAE,IAAI,SAAS,OAAO,aAAa,EAAE;AAErG,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,KAAK,YAAY;AACrB,YAAM,SAAS,MAAM,SAAS,KAAK;AAEnC,UAAI,OAAO,MAAM;AACf,mBAAW,MAAM;AAAA,MACnB,OAAO;AACL,mBAAW,QAAQ,OAAO,KAAK;AAAA,MACjC;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-O5SQJUKB.mjs

@@ -0,0 +1,37 @@
+// src/private/withResolvers.ts
+import coreJSPromiseWithResolvers from "core-js-pure/full/promise/with-resolvers";
+function withResolvers() {
+  return coreJSPromiseWithResolvers();
+}
+
+// src/PushAsyncIterableIterator.ts
+var CLOSE = Symbol("close");
+var PushAsyncIterableIterator = class {
+  #closed = false;
+  #pushResolvers = withResolvers();
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  close() {
+    this.#closed = true;
+    this.#pushResolvers.resolve(CLOSE);
+  }
+  async next() {
+    const value = await this.#pushResolvers.promise;
+    if (value === CLOSE) {
+      return { done: true, value: void 0 };
+    }
+    return { done: false, value };
+  }
+  push(value) {
+    if (!this.#closed) {
+      this.#pushResolvers.resolve(value);
+      this.#pushResolvers = withResolvers();
+    }
+  }
+};
+
+export {
+  PushAsyncIterableIterator
+};
+//# sourceMappingURL=chunk-O5SQJUKB.mjs.map

package/dist/chunk-O5SQJUKB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/private/withResolvers.ts","../src/PushAsyncIterableIterator.ts"],"sourcesContent":["// @ts-expect-error \"core-js\" is not typed.\nimport coreJSPromiseWithResolvers from 'core-js-pure/full/promise/with-resolvers';\n\nexport default function withResolvers<T>(): PromiseWithResolvers<T> {\n  return coreJSPromiseWithResolvers();\n}\n","import withResolvers from './private/withResolvers';\n\nconst CLOSE = Symbol('close');\n\nexport class PushAsyncIterableIterator<T> implements AsyncIterableIterator<T> {\n  #closed: boolean = false;\n  #pushResolvers: PromiseWithResolvers<T | typeof CLOSE> = withResolvers();\n\n  [Symbol.asyncIterator]() {\n    return this;\n  }\n\n  close() {\n    this.#closed = true;\n    this.#pushResolvers.resolve(CLOSE);\n  }\n\n  async next(): Promise<IteratorResult<T>> {\n    const value = await this.#pushResolvers.promise;\n\n    if (value === CLOSE) {\n      return { done: true, value: undefined };\n    }\n\n    return { done: false, value };\n  }\n\n  push(value: T) {\n    if (!this.#closed) {\n      this.#pushResolvers.resolve(value);\n      this.#pushResolvers = withResolvers();\n    }\n  }\n}\n"],"mappings":";AACA,OAAO,gCAAgC;AAExB,SAAR,gBAA6D;AAClE,SAAO,2BAA2B;AACpC;;;ACHA,IAAM,QAAQ,OAAO,OAAO;AAErB,IAAM,4BAAN,MAAuE;AAAA,EAC5E,UAAmB;AAAA,EACnB,iBAAyD,cAAc;AAAA,EAEvE,CAAC,OAAO,aAAa,IAAI;AACvB,WAAO;AAAA,EACT;AAAA,EAEA,QAAQ;AACN,SAAK,UAAU;AACf,SAAK,eAAe,QAAQ,KAAK;AAAA,EACnC;AAAA,EAEA,MAAM,OAAmC;AACvC,UAAM,QAAQ,MAAM,KAAK,eAAe;AAExC,QAAI,UAAU,OAAO;AACnB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAEA,WAAO,EAAE,MAAM,OAAO,MAAM;AAAA,EAC9B;AAAA,EAEA,KAAK,OAAU;AACb,QAAI,CAAC,KAAK,SAAS;AACjB,WAAK,eAAe,QAAQ,KAAK;AACjC,WAAK,iBAAiB,cAAc;AAAA,IACtC;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-XW34KZRY.mjs

@@ -0,0 +1,17 @@
+// src/iterableReduce.ts
+function iterableReduce(iterable, callbackfn, initialValue) {
+  let index = 0;
+  let previousValue = initialValue;
+  if (typeof callbackfn !== "function") {
+    throw new TypeError(`${callbackfn} is not a function`);
+  }
+  for (const currentValue of iterable) {
+    previousValue = callbackfn(previousValue, currentValue, index++, iterable);
+  }
+  return previousValue;
+}
+
+export {
+  iterableReduce
+};
+//# sourceMappingURL=chunk-XW34KZRY.mjs.map

package/dist/chunk-XW34KZRY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableReduce.ts"],"sourcesContent":["/**\n * Calls the specified callback function for all the elements in an iterable. 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 iterable.\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 iterable value.\n */\nexport function iterableReduce<T>(\n  iterable: Iterable<T>,\n  callbackfn: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T\n): T;\n\nexport function iterableReduce<T>(\n  iterable: Iterable<T>,\n  callbackfn: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T,\n  initialValue: T\n): T;\n\n/**\n * Calls the specified callback function for all the elements in an iterable. 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 iterable.\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\nexport function iterableReduce<T, U>(\n  iterable: Iterable<T>,\n  callbackfn: (previousValue: U, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U,\n  initialValue: U\n): U;\n\nexport function iterableReduce<T, U = undefined>(\n  iterable: Iterable<T>,\n  callbackfn: (previousValue: U | undefined, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U,\n  initialValue?: U\n): U | undefined {\n  let index = 0;\n  let previousValue: U | undefined = initialValue;\n\n  if (typeof callbackfn !== 'function') {\n    throw new TypeError(`${callbackfn} is not a function`);\n  }\n\n  for (const currentValue of iterable) {\n    previousValue = callbackfn(previousValue, currentValue, index++, iterable);\n  }\n\n  return previousValue;\n}\n"],"mappings":";AAgCO,SAAS,eACd,UACA,YACA,cACe;AACf,MAAI,QAAQ;AACZ,MAAI,gBAA+B;AAEnC,MAAI,OAAO,eAAe,YAAY;AACpC,UAAM,IAAI,UAAU,GAAG,UAAU,oBAAoB;AAAA,EACvD;AAEA,aAAW,gBAAgB,UAAU;AACnC,oBAAgB,WAAW,eAAe,cAAc,SAAS,QAAQ;AAAA,EAC3E;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-ZUBHGSCW.mjs

@@ -0,0 +1,18 @@
+// src/iterableFilter.ts
+function* iterableFilter(iterable, predicate, thisArg) {
+  let index = 0;
+  if (typeof predicate !== "function") {
+    throw new TypeError(`${predicate} is not a function`);
+  }
+  const boundPredicate = predicate.bind(thisArg);
+  for (const value of iterable) {
+    if (boundPredicate(value, index++, iterable)) {
+      yield value;
+    }
+  }
+}
+
+export {
+  iterableFilter
+};
+//# sourceMappingURL=chunk-ZUBHGSCW.mjs.map

package/dist/chunk-ZUBHGSCW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableFilter.ts"],"sourcesContent":["/**\n * Returns the elements of an iterable that meet the condition specified in a callback function.\n *\n * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the iterable.\n * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableFilter<T, S extends T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => value is S,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: unknown\n): IterableIterator<S>;\n\n/**\n * Returns the elements of an iterable that meet the condition specified in a callback function.\n *\n * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the iterable.\n * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n */\nexport function iterableFilter<T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: any\n): IterableIterator<T>;\n\nexport function* iterableFilter<T, S extends T>(\n  iterable: Iterable<T>,\n  predicate: (value: T, index: number, iterable: Iterable<T>) => unknown,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisArg?: unknown\n): IterableIterator<S> {\n  let index = 0;\n\n  if (typeof predicate !== 'function') {\n    throw new TypeError(`${predicate} is not a function`);\n  }\n\n  const boundPredicate = predicate.bind(thisArg);\n\n  for (const value of iterable) {\n    if (boundPredicate(value, index++, iterable)) {\n      yield value as S;\n    }\n  }\n}\n"],"mappings":";AA0BO,UAAU,eACf,UACA,WAEA,SACqB;AACrB,MAAI,QAAQ;AAEZ,MAAI,OAAO,cAAc,YAAY;AACnC,UAAM,IAAI,UAAU,GAAG,SAAS,oBAAoB;AAAA,EACtD;AAEA,QAAM,iBAAiB,UAAU,KAAK,OAAO;AAE7C,aAAW,SAAS,UAAU;AAC5B,QAAI,eAAe,OAAO,SAAS,QAAQ,GAAG;AAC5C,YAAM;AAAA,IACR;AAAA,EACF;AACF;","names":[]}

package/dist/iter-fest.d.mts

@@ -1,37 +1,31 @@
 export { CompleteFunction, ErrorFunction, NextFunction, Observable, Observer, StartFunction, SubscriberFunction, Subscription, SubscriptionObserver } from './iter-fest.observable.mjs';
+export { PushAsyncIterableIterator } from './iter-fest.pushAsyncIterableIterator.mjs';
 export { SymbolObservable } from './iter-fest.symbolObservable.mjs';
 export { AsyncGeneratorWithLastValue, asyncGeneratorWithLastValue } from './iter-fest.asyncGeneratorWithLastValue.mjs';
-export { asyncIteratorToAsyncIterable } from './iter-fest.asyncIteratorToAsyncIterable.mjs';
 export { GeneratorWithLastValue, generatorWithLastValue } from './iter-fest.generatorWithLastValue.mjs';
 export { iterableAt } from './iter-fest.iterableAt.mjs';
 export { iterableConcat } from './iter-fest.iterableConcat.mjs';
 export { iterableEntries } from './iter-fest.iterableEntries.mjs';
+export { iterableEvery } from './iter-fest.iterableEvery.mjs';
+export { iterableFilter } from './iter-fest.iterableFilter.mjs';
+export { iterableFind } from './iter-fest.iterableFind.mjs';
 export { iterableFindIndex } from './iter-fest.iterableFindIndex.mjs';
 export { iterableFindLast } from './iter-fest.iterableFindLast.mjs';
 export { iterableFindLastIndex } from './iter-fest.iterableFindLastIndex.mjs';
+export { iterableForEach } from './iter-fest.iterableForEach.mjs';
+export { iterableGetReadable } from './iter-fest.iterableGetReadable.mjs';
 export { iterableIncludes } from './iter-fest.iterableIncludes.mjs';
 export { iterableIndexOf } from './iter-fest.iterableIndexOf.mjs';
 export { iterableJoin } from './iter-fest.iterableJoin.mjs';
 export { iterableKeys } from './iter-fest.iterableKeys.mjs';
+export { iterableMap } from './iter-fest.iterableMap.mjs';
+export { iterableReduce } from './iter-fest.iterableReduce.mjs';
 export { iterableSlice } from './iter-fest.iterableSlice.mjs';
+export { iterableSome } from './iter-fest.iterableSome.mjs';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.mjs';
 export { iterableToString } from './iter-fest.iterableToString.mjs';
-export { IterableWritableStream } from './iter-fest.iterableWritableStream.mjs';
-export { iteratorDrop } from './iter-fest.iteratorDrop.mjs';
-export { iteratorEvery } from './iter-fest.iteratorEvery.mjs';
-export { iteratorFilter } from './iter-fest.iteratorFilter.mjs';
-export { iteratorFind } from './iter-fest.iteratorFind.mjs';
-export { iteratorFlatMap } from './iter-fest.iteratorFlatMap.mjs';
-export { iteratorForEach } from './iter-fest.iteratorForEach.mjs';
-export { iteratorFrom } from './iter-fest.iteratorFrom.mjs';
-export { iteratorMap } from './iter-fest.iteratorMap.mjs';
-export { iteratorReduce } from './iter-fest.iteratorReduce.mjs';
-export { iteratorSome } from './iter-fest.iteratorSome.mjs';
-export { iteratorTake } from './iter-fest.iteratorTake.mjs';
-export { iteratorToArray } from './iter-fest.iteratorToArray.mjs';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.mjs';
 export { observableFromAsync } from './iter-fest.observableFromAsync.mjs';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.mjs';
-export { readableStreamFrom } from './iter-fest.readableStreamFrom.mjs';
 export { readerValues } from './iter-fest.readerValues.mjs';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.d.ts

@@ -1,37 +1,31 @@
 export { CompleteFunction, ErrorFunction, NextFunction, Observable, Observer, StartFunction, SubscriberFunction, Subscription, SubscriptionObserver } from './iter-fest.observable.js';
+export { PushAsyncIterableIterator } from './iter-fest.pushAsyncIterableIterator.js';
 export { SymbolObservable } from './iter-fest.symbolObservable.js';
 export { AsyncGeneratorWithLastValue, asyncGeneratorWithLastValue } from './iter-fest.asyncGeneratorWithLastValue.js';
-export { asyncIteratorToAsyncIterable } from './iter-fest.asyncIteratorToAsyncIterable.js';
 export { GeneratorWithLastValue, generatorWithLastValue } from './iter-fest.generatorWithLastValue.js';
 export { iterableAt } from './iter-fest.iterableAt.js';
 export { iterableConcat } from './iter-fest.iterableConcat.js';
 export { iterableEntries } from './iter-fest.iterableEntries.js';
+export { iterableEvery } from './iter-fest.iterableEvery.js';
+export { iterableFilter } from './iter-fest.iterableFilter.js';
+export { iterableFind } from './iter-fest.iterableFind.js';
 export { iterableFindIndex } from './iter-fest.iterableFindIndex.js';
 export { iterableFindLast } from './iter-fest.iterableFindLast.js';
 export { iterableFindLastIndex } from './iter-fest.iterableFindLastIndex.js';
+export { iterableForEach } from './iter-fest.iterableForEach.js';
+export { iterableGetReadable } from './iter-fest.iterableGetReadable.js';
 export { iterableIncludes } from './iter-fest.iterableIncludes.js';
 export { iterableIndexOf } from './iter-fest.iterableIndexOf.js';
 export { iterableJoin } from './iter-fest.iterableJoin.js';
 export { iterableKeys } from './iter-fest.iterableKeys.js';
+export { iterableMap } from './iter-fest.iterableMap.js';
+export { iterableReduce } from './iter-fest.iterableReduce.js';
 export { iterableSlice } from './iter-fest.iterableSlice.js';
+export { iterableSome } from './iter-fest.iterableSome.js';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.js';
 export { iterableToString } from './iter-fest.iterableToString.js';
-export { IterableWritableStream } from './iter-fest.iterableWritableStream.js';
-export { iteratorDrop } from './iter-fest.iteratorDrop.js';
-export { iteratorEvery } from './iter-fest.iteratorEvery.js';
-export { iteratorFilter } from './iter-fest.iteratorFilter.js';
-export { iteratorFind } from './iter-fest.iteratorFind.js';
-export { iteratorFlatMap } from './iter-fest.iteratorFlatMap.js';
-export { iteratorForEach } from './iter-fest.iteratorForEach.js';
-export { iteratorFrom } from './iter-fest.iteratorFrom.js';
-export { iteratorMap } from './iter-fest.iteratorMap.js';
-export { iteratorReduce } from './iter-fest.iteratorReduce.js';
-export { iteratorSome } from './iter-fest.iteratorSome.js';
-export { iteratorTake } from './iter-fest.iteratorTake.js';
-export { iteratorToArray } from './iter-fest.iteratorToArray.js';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.js';
 export { observableFromAsync } from './iter-fest.observableFromAsync.js';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.js';
-export { readableStreamFrom } from './iter-fest.readableStreamFrom.js';
 export { readerValues } from './iter-fest.readerValues.js';
 import 'core-js-pure/full/observable';