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

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, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -30,56 +30,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  IterableWritableStream: () => IterableWritableStream,
   Observable: () => Observable,
+  PushAsyncIterableIterator: () => PushAsyncIterableIterator,
   SymbolObservable: () => SymbolObservable,
   asyncGeneratorWithLastValue: () => asyncGeneratorWithLastValue,
-  asyncIteratorDrop: () => asyncIteratorDrop,
-  asyncIteratorEvery: () => asyncIteratorEvery,
-  asyncIteratorFilter: () => asyncIteratorFilter,
-  asyncIteratorFind: () => asyncIteratorFind,
-  asyncIteratorFlatMap: () => asyncIteratorFlatMap,
-  asyncIteratorForEach: () => asyncIteratorForEach,
-  asyncIteratorFrom: () => asyncIteratorFrom,
-  asyncIteratorMap: () => asyncIteratorMap,
-  asyncIteratorReduce: () => asyncIteratorReduce,
-  asyncIteratorSome: () => asyncIteratorSome,
-  asyncIteratorTake: () => asyncIteratorTake,
-  asyncIteratorToArray: () => asyncIteratorToArray,
   asyncIteratorToAsyncIterable: () => asyncIteratorToAsyncIterable,
   generatorWithLastValue: () => generatorWithLastValue,
-  iteratorAt: () => iteratorAt,
-  iteratorConcat: () => iteratorConcat,
-  iteratorDrop: () => iteratorDrop,
-  iteratorEntries: () => iteratorEntries,
-  iteratorEvery: () => iteratorEvery,
-  iteratorFilter: () => iteratorFilter,
-  iteratorFind: () => iteratorFind,
-  iteratorFindIndex: () => iteratorFindIndex,
-  iteratorFindLast: () => iteratorFindLast,
-  iteratorFindLastIndex: () => iteratorFindLastIndex,
-  iteratorFlatMap: () => iteratorFlatMap,
-  iteratorForEach: () => iteratorForEach,
-  iteratorFrom: () => iteratorFrom,
-  iteratorIncludes: () => iteratorIncludes,
-  iteratorIndexOf: () => iteratorIndexOf,
-  iteratorJoin: () => iteratorJoin,
-  iteratorKeys: () => iteratorKeys,
-  iteratorMap: () => iteratorMap,
-  iteratorReduce: () => iteratorReduce,
-  iteratorSlice: () => iteratorSlice,
-  iteratorSome: () => iteratorSome,
-  iteratorTake: () => iteratorTake,
-  iteratorToArray: () => iteratorToArray,
-  iteratorToAsync: () => iteratorToAsync,
+  iterableAt: () => iterableAt,
+  iterableConcat: () => iterableConcat,
+  iterableEntries: () => iterableEntries,
+  iterableEvery: () => iterableEvery,
+  iterableFilter: () => iterableFilter,
+  iterableFind: () => iterableFind,
+  iterableFindIndex: () => iterableFindIndex,
+  iterableFindLast: () => iterableFindLast,
+  iterableFindLastIndex: () => iterableFindLastIndex,
+  iterableForEach: () => iterableForEach,
+  iterableGetReadable: () => iterableGetReadable,
+  iterableIncludes: () => iterableIncludes,
+  iterableIndexOf: () => iterableIndexOf,
+  iterableJoin: () => iterableJoin,
+  iterableKeys: () => iterableKeys,
+  iterableMap: () => iterableMap,
+  iterableReduce: () => iterableReduce,
+  iterableSlice: () => iterableSlice,
+  iterableSome: () => iterableSome,
+  iterableToSpliced: () => iterableToSpliced,
+  iterableToString: () => iterableToString,
   iteratorToIterable: () => iteratorToIterable,
-  iteratorToSpliced: () => iteratorToSpliced,
-  iteratorToString: () => iteratorToString,
   observableFromAsync: () => observableFromAsync,
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
-  observableValues: () => observableValues,
-  readableStreamFrom: () => readableStreamFrom,
-  readableStreamValues: () => readableStreamValues
+  readerValues: () => readerValues
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -111,6 +92,39 @@ var Observable = class extends import_observable2.default {
   }
 };
 
+// src/private/withResolvers.ts
+var import_with_resolvers = __toESM(require("core-js-pure/full/promise/with-resolvers"));
+function withResolvers() {
+  return (0, import_with_resolvers.default)();
+}
+
+// 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();
+    }
+  }
+};
+
 // src/asyncGeneratorWithLastValue.ts
 var STILL_ITERATING = Symbol();
 function asyncGeneratorWithLastValue(generator) {
@@ -142,78 +156,6 @@ function asyncGeneratorWithLastValue(generator) {
   return asyncGeneratorWithLastValue2;
 }
 
-// src/asyncIteratorDrop.ts
-var import_drop = __toESM(require("core-js-pure/full/async-iterator/drop"));
-function asyncIteratorDrop(asyncIterator, limit) {
-  return (0, import_drop.default)(asyncIterator, limit);
-}
-
-// src/asyncIteratorEvery.ts
-var import_every = __toESM(require("core-js-pure/full/async-iterator/every"));
-function asyncIteratorEvery(iterator, predicate) {
-  return (0, import_every.default)(iterator, predicate);
-}
-
-// src/asyncIteratorFilter.ts
-var import_filter = __toESM(require("core-js-pure/full/async-iterator/filter"));
-function asyncIteratorFilter(asyncIterator, predicate) {
-  return (0, import_filter.default)(asyncIterator, predicate);
-}
-
-// src/asyncIteratorFind.ts
-var import_find = __toESM(require("core-js-pure/full/async-iterator/find"));
-function asyncIteratorFind(asyncIterator, predicate) {
-  return (0, import_find.default)(asyncIterator, predicate);
-}
-
-// src/asyncIteratorFlatMap.ts
-var import_flat_map = __toESM(require("core-js-pure/full/async-iterator/flat-map"));
-function asyncIteratorFlatMap(asyncIterator, mapperFn) {
-  return (0, import_flat_map.default)(asyncIterator, mapperFn);
-}
-
-// src/asyncIteratorForEach.ts
-var import_for_each = __toESM(require("core-js-pure/full/async-iterator/for-each"));
-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) {
-  return (0, import_map.default)(asyncIterator, callbackfn);
-}
-
-// src/asyncIteratorReduce.ts
-var import_reduce = __toESM(require("core-js-pure/full/async-iterator/reduce"));
-function asyncIteratorReduce(asyncIterator, callbackfn, initialValue) {
-  return (0, import_reduce.default)(asyncIterator, callbackfn, initialValue);
-}
-
-// src/asyncIteratorSome.ts
-var import_some = __toESM(require("core-js-pure/full/async-iterator/some"));
-function asyncIteratorSome(asyncIterator, predicate) {
-  return (0, import_some.default)(asyncIterator, predicate);
-}
-
-// src/asyncIteratorTake.ts
-var import_take = __toESM(require("core-js-pure/full/async-iterator/take"));
-function asyncIteratorTake(asyncIterator, limit) {
-  return (0, import_take.default)(asyncIterator, limit);
-}
-
-// src/asyncIteratorToArray.ts
-var import_to_array = __toESM(require("core-js-pure/full/async-iterator/to-array"));
-function asyncIteratorToArray(asyncIteratorLike) {
-  return (0, import_to_array.default)(asyncIteratorLike);
-}
-
 // src/asyncIteratorToAsyncIterable.ts
 function asyncIteratorToAsyncIterable(asyncIterator) {
   const asyncIterableIterator = {
@@ -256,59 +198,6 @@ function generatorWithLastValue(generator) {
   return generatorWithLastValue2;
 }
 
-// src/private/withResolvers.ts
-var import_with_resolvers = __toESM(require("core-js-pure/full/promise/with-resolvers"));
-function withResolvers() {
-  return (0, import_with_resolvers.default)();
-}
-
-// src/iterableWritableStream.ts
-var CLOSE = Symbol();
-var IterableWritableStream = class extends WritableStream {
-  constructor() {
-    super({
-      close: () => {
-        this.#buffer.push(CLOSE);
-        this.#writeResolvers.resolve();
-      },
-      write: (chunk) => {
-        this.#buffer.push(chunk);
-        this.#writeResolvers.resolve();
-        this.#writeResolvers = withResolvers();
-      }
-    });
-  }
-  #buffer = [];
-  #writeResolvers = withResolvers();
-  [Symbol.asyncIterator]() {
-    return {
-      next: async () => {
-        while (!this.#buffer.length) {
-          await this.#writeResolvers.promise;
-        }
-        const value = this.#buffer[0];
-        if (value === CLOSE) {
-          return { done: true, value: void 0 };
-        }
-        this.#buffer.shift();
-        await void 0;
-        return { done: false, value };
-      }
-    };
-  }
-};
-
-// src/iteratorToIterable.ts
-function iteratorToIterable(iterator) {
-  const iterableIterator = {
-    [Symbol.iterator]: () => iterableIterator,
-    next: iterator.next.bind(iterator),
-    ...iterator.return ? { return: iterator.return.bind(iterator) } : {},
-    ...iterator.throw ? { throw: iterator.throw.bind(iterator) } : {}
-  };
-  return iterableIterator;
-}
-
 // src/private/toIntegerOrInfinity.ts
 function toIntegerOrInfinity(value) {
   if (value === Infinity || value === -Infinity) {
@@ -317,8 +206,8 @@ function toIntegerOrInfinity(value) {
   return ~~value;
 }
 
-// src/iteratorAt.ts
-function iteratorAt(iterator, index) {
+// src/iterableAt.ts
+function iterableAt(iterable, index) {
   let currentIndex = 0;
   index = toIntegerOrInfinity(index);
   if (!isFinite(index)) {
@@ -327,7 +216,7 @@ function iteratorAt(iterator, index) {
   if (index < 0) {
     throw new TypeError("index cannot be a negative finite number");
   }
-  for (const value of iteratorToIterable(iterator)) {
+  for (const value of iterable) {
     if (currentIndex++ === index) {
       return value;
     }
@@ -335,62 +224,79 @@ function iteratorAt(iterator, index) {
   return void 0;
 }
 
-// src/iteratorConcat.ts
-function isIterator(value) {
-  return !!value && typeof value === "object" && Symbol.iterator in value;
-}
-function* iteratorConcat(iterator, ...items) {
-  yield* iteratorToIterable(iterator);
+// src/iterableConcat.ts
+function* iterableConcat(iterable, ...items) {
+  yield* iterable;
   for (const item of items) {
-    if (isIterator(item)) {
-      yield* iteratorToIterable(item);
+    if (item && typeof item === "object" && Symbol.iterator in item) {
+      yield* item;
     } else {
       yield item;
     }
   }
 }
 
-// src/iteratorDrop.ts
-var import_drop2 = __toESM(require("core-js-pure/full/iterator/drop"));
-function iteratorDrop(iterator, limit) {
-  return (0, import_drop2.default)(iterator, limit);
-}
-
-// src/iteratorEntries.ts
-function* iteratorEntries(iterator) {
+// src/iterableEntries.ts
+function* iterableEntries(iterable) {
   let index = 0;
-  for (const value of iteratorToIterable(iterator)) {
+  for (const value of iterable) {
     yield [index++, value];
   }
 }
 
-// src/iteratorEvery.ts
-var import_every2 = __toESM(require("core-js-pure/full/iterator/every"));
-function iteratorEvery(iterator, predicate) {
-  return (0, import_every2.default)(iterator, predicate);
+// 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;
 }
 
-// src/iteratorFilter.ts
-var import_filter2 = __toESM(require("core-js-pure/full/iterator/filter"));
-function iteratorFilter(iterator, predicate) {
-  return (0, import_filter2.default)(iterator, predicate);
+// 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;
+    }
+  }
 }
 
-// src/iteratorFind.ts
-var import_find2 = __toESM(require("core-js-pure/full/iterator/find"));
-function iteratorFind(iterator, predicate) {
-  return (0, import_find2.default)(iterator, predicate);
+// 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;
 }
 
-// src/iteratorFindIndex.ts
-function iteratorFindIndex(iterator, predicate, thisArg) {
+// src/iterableFindIndex.ts
+function iterableFindIndex(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 iteratorToIterable(iterator)) {
-    if (boundPredicate(value, index, iterator)) {
+  for (const value of iterable) {
+    if (boundPredicate(value, index, iterable)) {
       return index;
     }
     index++;
@@ -398,32 +304,32 @@ function iteratorFindIndex(iterator, predicate, thisArg) {
   return -1;
 }
 
-// src/iteratorFindLast.ts
-function iteratorFindLast(iterator, predicate, thisArg) {
+// src/iterableFindLast.ts
+function iterableFindLast(iterable, predicate, thisArg) {
   let index = 0;
   let last;
   if (typeof predicate !== "function") {
     throw new TypeError(`${predicate} is not a function`);
   }
   const boundPredicate = predicate.bind(thisArg);
-  for (const value of iteratorToIterable(iterator)) {
-    if (boundPredicate(value, index++, iterator)) {
+  for (const value of iterable) {
+    if (boundPredicate(value, index++, iterable)) {
       last = value;
     }
   }
   return last;
 }
 
-// src/iteratorFindLastIndex.ts
-function iteratorFindLastIndex(iterator, predicate, thisArg) {
+// src/iterableFindLastIndex.ts
+function iterableFindLastIndex(iterable, predicate, thisArg) {
   let index = 0;
   let lastIndex = -1;
   if (typeof predicate !== "function") {
     throw new TypeError(`${predicate} is not a function`);
   }
   const boundPredicate = predicate.bind(thisArg);
-  for (const value of iteratorToIterable(iterator)) {
-    if (boundPredicate(value, index, iterator)) {
+  for (const value of iterable) {
+    if (boundPredicate(value, index, iterable)) {
       lastIndex = index;
     }
     index++;
@@ -431,26 +337,38 @@ function iteratorFindLastIndex(iterator, predicate, thisArg) {
   return lastIndex;
 }
 
-// src/iteratorFlatMap.ts
-var import_flat_map2 = __toESM(require("core-js-pure/full/iterator/flat-map"));
-function iteratorFlatMap(iterator, mapperFn) {
-  return (0, import_flat_map2.default)(iterator, mapperFn);
+// 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);
+  }
 }
 
-// src/iteratorForEach.ts
-var import_for_each2 = __toESM(require("core-js-pure/full/iterator/for-each"));
-function iteratorForEach(iterator, callbackfn) {
-  (0, import_for_each2.default)(iterator, callbackfn);
+// src/iterableGetReadable.ts
+function isIterable(iterable) {
+  return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
 }
-
-// src/iteratorFrom.ts
-var import_from2 = __toESM(require("core-js-pure/full/iterator/from"));
-function iteratorFrom(iteratorLike) {
-  return (0, import_from2.default)(iteratorLike);
+function iterableGetReadable(iterable) {
+  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const result = await iterator.next();
+      if (result.done) {
+        controller.close();
+      } else {
+        controller.enqueue(result.value);
+      }
+    }
+  });
 }
 
-// src/iteratorIncludes.ts
-function iteratorIncludes(iterator, searchElement, fromIndex = 0) {
+// src/iterableIncludes.ts
+function iterableIncludes(iterable, searchElement, fromIndex = 0) {
   let index = 0;
   fromIndex = toIntegerOrInfinity(fromIndex);
   if (fromIndex !== Infinity) {
@@ -458,7 +376,7 @@ function iteratorIncludes(iterator, searchElement, fromIndex = 0) {
     if (fromIndex < 0) {
       throw new TypeError("fromIndex cannot be a negative finite number");
     }
-    for (const item of iteratorToIterable(iterator)) {
+    for (const item of iterable) {
       if (index++ >= fromIndex && Object.is(item, searchElement)) {
         return true;
       }
@@ -467,8 +385,8 @@ function iteratorIncludes(iterator, searchElement, fromIndex = 0) {
   return false;
 }
 
-// src/iteratorIndexOf.ts
-function iteratorIndexOf(iterator, searchElement, fromIndex = 0) {
+// src/iterableIndexOf.ts
+function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
   let index = 0;
   fromIndex = toIntegerOrInfinity(fromIndex);
   if (fromIndex !== Infinity) {
@@ -476,7 +394,7 @@ function iteratorIndexOf(iterator, searchElement, fromIndex = 0) {
     if (fromIndex < 0) {
       throw new TypeError("fromIndex cannot be a negative finite number");
     }
-    for (const item of iteratorToIterable(iterator)) {
+    for (const item of iterable) {
       if (index >= fromIndex && Object.is(item, searchElement)) {
         return index;
       }
@@ -486,11 +404,11 @@ function iteratorIndexOf(iterator, searchElement, fromIndex = 0) {
   return -1;
 }
 
-// src/iteratorJoin.ts
-function iteratorJoin(iterator, separator = ",") {
+// src/iterableJoin.ts
+function iterableJoin(iterable, separator = ",") {
   let index = 0;
   let result = "";
-  for (const item of iteratorToIterable(iterator)) {
+  for (const item of iterable) {
     if (index) {
       result += separator;
     }
@@ -502,28 +420,40 @@ function iteratorJoin(iterator, separator = ",") {
   return result;
 }
 
-// src/iteratorKeys.ts
-function* iteratorKeys(iterator) {
+// src/iterableKeys.ts
+function* iterableKeys(iterable) {
   let index = 0;
-  for (const _ of iteratorToIterable(iterator)) {
+  for (const _ of iterable) {
     yield index++;
   }
 }
 
-// src/iteratorMap.ts
-var import_map2 = __toESM(require("core-js-pure/full/iterator/map"));
-function iteratorMap(iterator, callbackfn) {
-  return (0, import_map2.default)(iterator, callbackfn);
+// 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);
+  }
 }
 
-// src/iteratorReduce.ts
-var import_reduce2 = __toESM(require("core-js-pure/full/iterator/reduce"));
-function iteratorReduce(iterator, callbackfn, initialValue) {
-  return (0, import_reduce2.default)(iterator, callbackfn, initialValue);
+// 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;
 }
 
-// src/iteratorSlice.ts
-function* iteratorSlice(iterator, start = 0, end = Infinity) {
+// src/iterableSlice.ts
+function* iterableSlice(iterable, start = 0, end = Infinity) {
   let index = 0;
   start = toIntegerOrInfinity(start);
   start = start === -Infinity ? 0 : start;
@@ -538,7 +468,7 @@ function* iteratorSlice(iterator, start = 0, end = Infinity) {
   if (start === Infinity) {
     return;
   }
-  for (const item of iteratorToIterable(iterator)) {
+  for (const item of iterable) {
     if (index >= start && index < end) {
       yield item;
     }
@@ -549,32 +479,23 @@ function* iteratorSlice(iterator, start = 0, end = Infinity) {
   }
 }
 
-// src/iteratorSome.ts
-var import_some2 = __toESM(require("core-js-pure/full/iterator/some"));
-function iteratorSome(iterator, predicate) {
-  return (0, import_some2.default)(iterator, predicate);
-}
-
-// src/iteratorTake.ts
-var import_take2 = __toESM(require("core-js-pure/full/iterator/take"));
-function iteratorTake(iterator, limit) {
-  return (0, import_take2.default)(iterator, limit);
-}
-
-// src/iteratorToArray.ts
-var import_to_array2 = __toESM(require("core-js-pure/full/iterator/to-array"));
-function iteratorToArray(iteratorLike) {
-  return (0, import_to_array2.default)(iteratorLike);
-}
-
-// src/iteratorToAsync.ts
-var import_to_async = __toESM(require("core-js-pure/full/iterator/to-async"));
-function iteratorToAsync(iterator) {
-  return (0, import_to_async.default)(iterator);
+// 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;
 }
 
-// src/iteratorToSpliced.ts
-function* iteratorToSpliced(iterator, start = 0, deleteCount = 0, ...items) {
+// src/iterableToSpliced.ts
+function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
   let index = 0;
   start = toIntegerOrInfinity(start);
   start = start === -Infinity ? 0 : start;
@@ -582,7 +503,7 @@ function* iteratorToSpliced(iterator, start = 0, deleteCount = 0, ...items) {
     throw new TypeError("start cannot be a negative finite number");
   }
   let inserted = false;
-  for (const item of iteratorToIterable(iterator)) {
+  for (const item of iterable) {
     if (index + 1 > start && !inserted) {
       yield* items;
       inserted = true;
@@ -597,9 +518,20 @@ function* iteratorToSpliced(iterator, start = 0, deleteCount = 0, ...items) {
   }
 }
 
-// src/iteratorToString.ts
-function iteratorToString(iterator) {
-  return iteratorJoin(iterator);
+// src/iterableToString.ts
+function iterableToString(iterable) {
+  return iterableJoin(iterable);
+}
+
+// src/iteratorToIterable.ts
+function iteratorToIterable(iterator) {
+  const iterableIterator = {
+    [Symbol.iterator]: () => iterableIterator,
+    next: iterator.next.bind(iterator),
+    ...iterator.return ? { return: iterator.return.bind(iterator) } : {},
+    ...iterator.throw ? { throw: iterator.throw.bind(iterator) } : {}
+  };
+  return iterableIterator;
 }
 
 // src/observableFromAsync.ts
@@ -648,9 +580,8 @@ function observableSubscribeAsReadable(observable) {
   });
 }
 
-// src/readableStreamValues.ts
-function readableStreamValues(readable) {
-  const reader = readable.getReader();
+// src/readerValues.ts
+function readerValues(reader) {
   const iterable = {
     [Symbol.asyncIterator]() {
       return iterable;
@@ -663,108 +594,44 @@ function readableStreamValues(readable) {
       return { value: result.value };
     },
     async return() {
-      reader.releaseLock();
+      reader.cancel();
       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);
-}
-function readableStreamFrom(anyIterable) {
-  const iterator = isIterable(anyIterable) ? anyIterable[Symbol.iterator]() : anyIterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const result = await iterator.next();
-      if (result.done) {
-        controller.close();
-      } else {
-        controller.enqueue(result.value);
-      }
-    }
-  });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  IterableWritableStream,
   Observable,
+  PushAsyncIterableIterator,
   SymbolObservable,
   asyncGeneratorWithLastValue,
-  asyncIteratorDrop,
-  asyncIteratorEvery,
-  asyncIteratorFilter,
-  asyncIteratorFind,
-  asyncIteratorFlatMap,
-  asyncIteratorForEach,
-  asyncIteratorFrom,
-  asyncIteratorMap,
-  asyncIteratorReduce,
-  asyncIteratorSome,
-  asyncIteratorTake,
-  asyncIteratorToArray,
   asyncIteratorToAsyncIterable,
   generatorWithLastValue,
-  iteratorAt,
-  iteratorConcat,
-  iteratorDrop,
-  iteratorEntries,
-  iteratorEvery,
-  iteratorFilter,
-  iteratorFind,
-  iteratorFindIndex,
-  iteratorFindLast,
-  iteratorFindLastIndex,
-  iteratorFlatMap,
-  iteratorForEach,
-  iteratorFrom,
-  iteratorIncludes,
-  iteratorIndexOf,
-  iteratorJoin,
-  iteratorKeys,
-  iteratorMap,
-  iteratorReduce,
-  iteratorSlice,
-  iteratorSome,
-  iteratorTake,
-  iteratorToArray,
-  iteratorToAsync,
+  iterableAt,
+  iterableConcat,
+  iterableEntries,
+  iterableEvery,
+  iterableFilter,
+  iterableFind,
+  iterableFindIndex,
+  iterableFindLast,
+  iterableFindLastIndex,
+  iterableForEach,
+  iterableGetReadable,
+  iterableIncludes,
+  iterableIndexOf,
+  iterableJoin,
+  iterableKeys,
+  iterableMap,
+  iterableReduce,
+  iterableSlice,
+  iterableSome,
+  iterableToSpliced,
+  iterableToString,
   iteratorToIterable,
-  iteratorToSpliced,
-  iteratorToString,
   observableFromAsync,
   observableSubscribeAsReadable,
-  observableValues,
-  readableStreamFrom,
-  readableStreamValues
+  readerValues
 });
 //# sourceMappingURL=iter-fest.js.map