iter-fest 0.1.1-main.9193c0a → 0.1.1-main.b1e260f

package/dist/iter-fest.js

@@ -1,49 +1,314 @@
 "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, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from3, except, desc) => {
+  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
+    for (let key of __getOwnPropNames(from3))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, 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/index.ts
 var src_exports = {};
 __export(src_exports, {
-  iterableAt: () => iterableAt,
-  iterableConcat: () => iterableConcat,
-  iterableEntries: () => iterableEntries,
-  iterableEvery: () => iterableEvery,
-  iterableFilter: () => iterableFilter,
-  iterableFind: () => iterableFind,
-  iterableFindIndex: () => iterableFindIndex,
-  iterableFindLast: () => iterableFindLast,
-  iterableFindLastIndex: () => iterableFindLastIndex,
-  iterableForEach: () => iterableForEach,
-  iterableIncludes: () => iterableIncludes,
-  iterableIndexOf: () => iterableIndexOf,
-  iterableJoin: () => iterableJoin,
-  iterableKeys: () => iterableKeys,
-  iterableMap: () => iterableMap,
-  iterableReduce: () => iterableReduce,
-  iterableSlice: () => iterableSlice,
-  iterableSome: () => iterableSome,
-  iterableToSpliced: () => iterableToSpliced,
-  iterableToString: () => iterableToString,
-  iteratorToIterable: () => iteratorToIterable
+  IterableWritableStream: () => IterableWritableStream,
+  Observable: () => Observable,
+  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,
+  iteratorToIterable: () => iteratorToIterable,
+  iteratorToSpliced: () => iteratorToSpliced,
+  iteratorToString: () => iteratorToString,
+  observableFromAsync: () => observableFromAsync,
+  observableSubscribeAsReadable: () => observableSubscribeAsReadable,
+  observableValues: () => observableValues,
+  readableStreamFrom: () => readableStreamFrom,
+  readableStreamValues: () => readableStreamValues
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/Observable.ts
+var import_observable2 = __toESM(require("core-js-pure/full/observable"));
+
+// src/SymbolObservable.ts
+var import_observable = __toESM(require("core-js-pure/features/symbol/observable"));
+var SymbolObservable = import_observable.default;
+
+// src/Observable.ts
+var Observable = class extends import_observable2.default {
+  constructor(subscriber) {
+    super(subscriber);
+  }
+  subscribe(observerOrOnNext, onError, onComplete) {
+    return super.subscribe(observerOrOnNext, onError, onComplete);
+  }
+  /** Returns itself */
+  [SymbolObservable]() {
+    return this;
+  }
+  /** Converts items to an Observable */
+  static of(...items) {
+    return import_observable2.default.of(...items);
+  }
+  static from(iterableOrObservable) {
+    return import_observable2.default.from(iterableOrObservable);
+  }
+};
+
+// src/asyncGeneratorWithLastValue.ts
+var STILL_ITERATING = Symbol();
+function asyncGeneratorWithLastValue(generator) {
+  let lastValue = STILL_ITERATING;
+  const asyncGeneratorWithLastValue2 = {
+    [Symbol.asyncIterator]() {
+      return asyncGeneratorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    async next(next) {
+      const result = await generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
+    }
+  };
+  return asyncGeneratorWithLastValue2;
+}
+
+// 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 = {
+    [Symbol.asyncIterator]: () => asyncIterableIterator,
+    next: asyncIterator.next.bind(asyncIterator),
+    ...asyncIterator.return ? { return: asyncIterator.return.bind(asyncIterator) } : {},
+    ...asyncIterator.throw ? { throw: asyncIterator.throw.bind(asyncIterator) } : {}
+  };
+  return asyncIterableIterator;
+}
+
+// src/generatorWithLastValue.ts
+var STILL_ITERATING2 = Symbol();
+function generatorWithLastValue(generator) {
+  let lastValue = STILL_ITERATING2;
+  const generatorWithLastValue2 = {
+    [Symbol.iterator]() {
+      return generatorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING2) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    next(next) {
+      const result = generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
+    }
+  };
+  return generatorWithLastValue2;
+}
+
+// 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) {
@@ -52,8 +317,8 @@ function toIntegerOrInfinity(value) {
   return ~~value;
 }
 
-// src/iterableAt.ts
-function iterableAt(iterable, index) {
+// src/iteratorAt.ts
+function iteratorAt(iterator, index) {
   let currentIndex = 0;
   index = toIntegerOrInfinity(index);
   if (!isFinite(index)) {
@@ -62,7 +327,7 @@ function iterableAt(iterable, index) {
   if (index < 0) {
     throw new TypeError("index cannot be a negative finite number");
   }
-  for (const value of iterable) {
+  for (const value of iteratorToIterable(iterator)) {
     if (currentIndex++ === index) {
       return value;
     }
@@ -70,79 +335,62 @@ function iterableAt(iterable, index) {
   return void 0;
 }
 
-// src/iterableConcat.ts
-function* iterableConcat(iterable, ...items) {
-  yield* iterable;
+// src/iteratorConcat.ts
+function isIterator(value) {
+  return !!value && typeof value === "object" && Symbol.iterator in value;
+}
+function* iteratorConcat(iterator, ...items) {
+  yield* iteratorToIterable(iterator);
   for (const item of items) {
-    if (item && typeof item === "object" && Symbol.iterator in item) {
-      yield* item;
+    if (isIterator(item)) {
+      yield* iteratorToIterable(item);
     } else {
       yield item;
     }
   }
 }
 
-// src/iterableEntries.ts
-function* iterableEntries(iterable) {
+// 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) {
   let index = 0;
-  for (const value of iterable) {
+  for (const value of iteratorToIterable(iterator)) {
     yield [index++, value];
   }
 }
 
-// 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/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/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/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/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/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/iterableFindIndex.ts
-function iterableFindIndex(iterable, predicate, thisArg) {
+// src/iteratorFindIndex.ts
+function iteratorFindIndex(iterator, 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)) {
+  for (const value of iteratorToIterable(iterator)) {
+    if (boundPredicate(value, index, iterator)) {
       return index;
     }
     index++;
@@ -150,32 +398,32 @@ function iterableFindIndex(iterable, predicate, thisArg) {
   return -1;
 }
 
-// src/iterableFindLast.ts
-function iterableFindLast(iterable, predicate, thisArg) {
+// src/iteratorFindLast.ts
+function iteratorFindLast(iterator, 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 iterable) {
-    if (boundPredicate(value, index++, iterable)) {
+  for (const value of iteratorToIterable(iterator)) {
+    if (boundPredicate(value, index++, iterator)) {
       last = value;
     }
   }
   return last;
 }
 
-// src/iterableFindLastIndex.ts
-function iterableFindLastIndex(iterable, predicate, thisArg) {
+// src/iteratorFindLastIndex.ts
+function iteratorFindLastIndex(iterator, 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 iterable) {
-    if (boundPredicate(value, index, iterable)) {
+  for (const value of iteratorToIterable(iterator)) {
+    if (boundPredicate(value, index, iterator)) {
       lastIndex = index;
     }
     index++;
@@ -183,20 +431,26 @@ function iterableFindLastIndex(iterable, predicate, thisArg) {
   return lastIndex;
 }
 
-// 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/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/iterableIncludes.ts
-function iterableIncludes(iterable, searchElement, fromIndex = 0) {
+// 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/iteratorFrom.ts
+var import_from2 = __toESM(require("core-js-pure/full/iterator/from"));
+function iteratorFrom(iteratorLike) {
+  return (0, import_from2.default)(iteratorLike);
+}
+
+// src/iteratorIncludes.ts
+function iteratorIncludes(iterator, searchElement, fromIndex = 0) {
   let index = 0;
   fromIndex = toIntegerOrInfinity(fromIndex);
   if (fromIndex !== Infinity) {
@@ -204,7 +458,7 @@ function iterableIncludes(iterable, searchElement, fromIndex = 0) {
     if (fromIndex < 0) {
       throw new TypeError("fromIndex cannot be a negative finite number");
     }
-    for (const item of iterable) {
+    for (const item of iteratorToIterable(iterator)) {
       if (index++ >= fromIndex && Object.is(item, searchElement)) {
         return true;
       }
@@ -213,8 +467,8 @@ function iterableIncludes(iterable, searchElement, fromIndex = 0) {
   return false;
 }
 
-// src/iterableIndexOf.ts
-function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
+// src/iteratorIndexOf.ts
+function iteratorIndexOf(iterator, searchElement, fromIndex = 0) {
   let index = 0;
   fromIndex = toIntegerOrInfinity(fromIndex);
   if (fromIndex !== Infinity) {
@@ -222,7 +476,7 @@ function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
     if (fromIndex < 0) {
       throw new TypeError("fromIndex cannot be a negative finite number");
     }
-    for (const item of iterable) {
+    for (const item of iteratorToIterable(iterator)) {
       if (index >= fromIndex && Object.is(item, searchElement)) {
         return index;
       }
@@ -232,11 +486,11 @@ function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
   return -1;
 }
 
-// src/iterableJoin.ts
-function iterableJoin(iterable, separator = ",") {
+// src/iteratorJoin.ts
+function iteratorJoin(iterator, separator = ",") {
   let index = 0;
   let result = "";
-  for (const item of iterable) {
+  for (const item of iteratorToIterable(iterator)) {
     if (index) {
       result += separator;
     }
@@ -248,40 +502,28 @@ function iterableJoin(iterable, separator = ",") {
   return result;
 }
 
-// src/iterableKeys.ts
-function* iterableKeys(iterable) {
+// src/iteratorKeys.ts
+function* iteratorKeys(iterator) {
   let index = 0;
-  for (const _ of iterable) {
+  for (const _ of iteratorToIterable(iterator)) {
     yield index++;
   }
 }
 
-// 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/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/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/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/iterableSlice.ts
-function* iterableSlice(iterable, start = 0, end = Infinity) {
+// src/iteratorSlice.ts
+function* iteratorSlice(iterator, start = 0, end = Infinity) {
   let index = 0;
   start = toIntegerOrInfinity(start);
   start = start === -Infinity ? 0 : start;
@@ -296,7 +538,7 @@ function* iterableSlice(iterable, start = 0, end = Infinity) {
   if (start === Infinity) {
     return;
   }
-  for (const item of iterable) {
+  for (const item of iteratorToIterable(iterator)) {
     if (index >= start && index < end) {
       yield item;
     }
@@ -307,23 +549,32 @@ function* iterableSlice(iterable, start = 0, end = Infinity) {
   }
 }
 
-// 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/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/iterableToSpliced.ts
-function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
+// src/iteratorToSpliced.ts
+function* iteratorToSpliced(iterator, start = 0, deleteCount = 0, ...items) {
   let index = 0;
   start = toIntegerOrInfinity(start);
   start = start === -Infinity ? 0 : start;
@@ -331,7 +582,7 @@ function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
     throw new TypeError("start cannot be a negative finite number");
   }
   let inserted = false;
-  for (const item of iterable) {
+  for (const item of iteratorToIterable(iterator)) {
     if (index + 1 > start && !inserted) {
       yield* items;
       inserted = true;
@@ -346,43 +597,174 @@ function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
   }
 }
 
-// src/iterableToString.ts
-function iterableToString(iterable) {
-  return iterableJoin(iterable);
+// src/iteratorToString.ts
+function iteratorToString(iterator) {
+  return iteratorJoin(iterator);
 }
 
-// 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) } : {}
+// src/observableFromAsync.ts
+function observableFromAsync(iterable) {
+  return new Observable((subscriber) => {
+    let closed = false;
+    (async function() {
+      try {
+        for await (const value of iterable) {
+          if (closed) {
+            break;
+          }
+          subscriber.next(value);
+        }
+        subscriber.complete();
+      } catch (error) {
+        subscriber.error(error);
+      }
+    })();
+    return () => {
+      closed = true;
+    };
+  });
+}
+
+// src/observableSubscribeAsReadable.ts
+function observableSubscribeAsReadable(observable) {
+  let subscription;
+  return new ReadableStream({
+    cancel() {
+      subscription.unsubscribe();
+    },
+    start(controller) {
+      subscription = observable.subscribe({
+        complete() {
+          controller.close();
+        },
+        error(err) {
+          controller.error(err);
+        },
+        next(value) {
+          controller.enqueue(value);
+        }
+      });
+    }
+  });
+}
+
+// src/readableStreamValues.ts
+function readableStreamValues(readable) {
+  const reader = readable.getReader();
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return iterable;
+    },
+    async next() {
+      const result = await Promise.race([reader.read(), reader.closed]);
+      if (!result || result.done) {
+        return { done: true, value: void 0 };
+      }
+      return { value: result.value };
+    },
+    async return() {
+      reader.releaseLock();
+      return { done: true, value: void 0 };
+    }
   };
-  return iterableIterator;
+  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 = {
-  iterableAt,
-  iterableConcat,
-  iterableEntries,
-  iterableEvery,
-  iterableFilter,
-  iterableFind,
-  iterableFindIndex,
-  iterableFindLast,
-  iterableFindLastIndex,
-  iterableForEach,
-  iterableIncludes,
-  iterableIndexOf,
-  iterableJoin,
-  iterableKeys,
-  iterableMap,
-  iterableReduce,
-  iterableSlice,
-  iterableSome,
-  iterableToSpliced,
-  iterableToString,
-  iteratorToIterable
+  IterableWritableStream,
+  Observable,
+  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,
+  iteratorToIterable,
+  iteratorToSpliced,
+  iteratorToString,
+  observableFromAsync,
+  observableSubscribeAsReadable,
+  observableValues,
+  readableStreamFrom,
+  readableStreamValues
 });
 //# sourceMappingURL=iter-fest.js.map