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

package/dist/iter-fest.iterableReduce.js.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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/iter-fest.iterableReduce.mjs

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

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

@@ -0,0 +1,12 @@
+/**
+ * Determines whether the specified callback function returns true for any element of an iterable.
+ *
+ * @param predicate
+ * 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.
+ *
+ * @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.
+ */
+declare function iterableSome<T>(iterable: Iterable<T>, predicate: (value: T, index: number, iterable: Iterable<T>) => unknown, thisArg?: any): boolean;
+
+export { iterableSome };

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

@@ -0,0 +1,12 @@
+/**
+ * Determines whether the specified callback function returns true for any element of an iterable.
+ *
+ * @param predicate
+ * 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.
+ *
+ * @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.
+ */
+declare function iterableSome<T>(iterable: Iterable<T>, predicate: (value: T, index: number, iterable: Iterable<T>) => unknown, thisArg?: any): boolean;
+
+export { iterableSome };

package/dist/iter-fest.iterableSome.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/iterableSome.ts
+var iterableSome_exports = {};
+__export(iterableSome_exports, {
+  iterableSome: () => iterableSome
+});
+module.exports = __toCommonJS(iterableSome_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  iterableSome
+});
+//# sourceMappingURL=iter-fest.iterableSome.js.map

package/dist/iter-fest.iterableSome.js.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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/iter-fest.iterableSome.mjs

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

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, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+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: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -30,41 +30,35 @@ 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,
-  asyncIteratorToAsyncIterable: () => asyncIteratorToAsyncIterable,
   generatorWithLastValue: () => generatorWithLastValue,
   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,
-  iteratorDrop: () => iteratorDrop,
-  iteratorEvery: () => iteratorEvery,
-  iteratorFilter: () => iteratorFilter,
-  iteratorFind: () => iteratorFind,
-  iteratorFlatMap: () => iteratorFlatMap,
-  iteratorForEach: () => iteratorForEach,
-  iteratorFrom: () => iteratorFrom,
-  iteratorMap: () => iteratorMap,
-  iteratorReduce: () => iteratorReduce,
-  iteratorSome: () => iteratorSome,
-  iteratorTake: () => iteratorTake,
-  iteratorToArray: () => iteratorToArray,
   iteratorToIterable: () => iteratorToIterable,
   observableFromAsync: () => observableFromAsync,
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
-  readableStreamFrom: () => readableStreamFrom,
   readerValues: () => readerValues
 });
 module.exports = __toCommonJS(src_exports);
@@ -97,6 +91,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) {
@@ -128,17 +155,6 @@ function asyncGeneratorWithLastValue(generator) {
   return asyncGeneratorWithLastValue2;
 }
 
-// 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) {
@@ -216,6 +232,50 @@ function* iterableEntries(iterable) {
   }
 }
 
+// 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/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/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/iterableFindIndex.ts
 function iterableFindIndex(iterable, predicate, thisArg) {
   let index = 0;
@@ -265,6 +325,36 @@ 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/iterableGetReadable.ts
+function isIterable(iterable) {
+  return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
+}
+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/iterableIncludes.ts
 function iterableIncludes(iterable, searchElement, fromIndex = 0) {
   let index = 0;
@@ -326,6 +416,30 @@ function* iterableKeys(iterable) {
   }
 }
 
+// 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/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/iterableSlice.ts
 function* iterableSlice(iterable, start = 0, end = Infinity) {
   let index = 0;
@@ -353,6 +467,21 @@ 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/iterableToSpliced.ts
 function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
   let index = 0;
@@ -382,120 +511,6 @@ function iterableToString(iterable) {
   return iterableJoin(iterable);
 }
 
-// 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/iteratorDrop.ts
-var import_drop = __toESM(require("core-js-pure/full/iterator/drop"));
-function iteratorDrop(iterator, limit) {
-  return (0, import_drop.default)(iterator, limit);
-}
-
-// src/iteratorEvery.ts
-var import_every = __toESM(require("core-js-pure/full/iterator/every"));
-function iteratorEvery(iterator, predicate) {
-  return (0, import_every.default)(iterator, predicate);
-}
-
-// src/iteratorFilter.ts
-var import_filter = __toESM(require("core-js-pure/full/iterator/filter"));
-function iteratorFilter(iterator, predicate) {
-  return (0, import_filter.default)(iterator, predicate);
-}
-
-// src/iteratorFind.ts
-var import_find = __toESM(require("core-js-pure/full/iterator/find"));
-function iteratorFind(iterator, predicate) {
-  return (0, import_find.default)(iterator, predicate);
-}
-
-// src/iteratorFlatMap.ts
-var import_flat_map = __toESM(require("core-js-pure/full/iterator/flat-map"));
-function iteratorFlatMap(iterable, mapperFn) {
-  return (0, import_flat_map.default)(iterable, mapperFn);
-}
-
-// src/iteratorForEach.ts
-var import_for_each = __toESM(require("core-js-pure/full/iterator/for-each"));
-function iteratorForEach(iterator, callbackfn) {
-  (0, import_for_each.default)(iterator, callbackfn);
-}
-
-// src/iteratorFrom.ts
-var import_from = __toESM(require("core-js-pure/full/iterator/from"));
-function iteratorFrom(iteratorLike) {
-  return (0, import_from.default)(iteratorLike);
-}
-
-// src/iteratorMap.ts
-var import_map = __toESM(require("core-js-pure/full/iterator/map"));
-function iteratorMap(iterator, callbackfn) {
-  return (0, import_map.default)(iterator, callbackfn);
-}
-
-// src/iteratorReduce.ts
-var import_reduce = __toESM(require("core-js-pure/full/iterator/reduce"));
-function iteratorReduce(iterator, callbackfn, initialValue) {
-  return (0, import_reduce.default)(iterator, callbackfn, initialValue);
-}
-
-// src/iteratorSome.ts
-var import_some = __toESM(require("core-js-pure/full/iterator/some"));
-function iteratorSome(iterator, predicate) {
-  return (0, import_some.default)(iterator, predicate);
-}
-
-// src/iteratorTake.ts
-var import_take = __toESM(require("core-js-pure/full/iterator/take"));
-function iteratorTake(iterator, limit) {
-  return (0, import_take.default)(iterator, limit);
-}
-
-// src/iteratorToArray.ts
-var import_to_array = __toESM(require("core-js-pure/full/iterator/to-array"));
-function iteratorToArray(iteratorLike) {
-  return (0, import_to_array.default)(iteratorLike);
-}
-
 // src/iteratorToIterable.ts
 function iteratorToIterable(iterator) {
   const iterableIterator = {
@@ -553,24 +568,6 @@ function observableSubscribeAsReadable(observable) {
   });
 }
 
-// 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);
-      }
-    }
-  });
-}
-
 // src/readerValues.ts
 function readerValues(reader) {
   const iterable = {
@@ -593,41 +590,35 @@ function readerValues(reader) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  IterableWritableStream,
   Observable,
+  PushAsyncIterableIterator,
   SymbolObservable,
   asyncGeneratorWithLastValue,
-  asyncIteratorToAsyncIterable,
   generatorWithLastValue,
   iterableAt,
   iterableConcat,
   iterableEntries,
+  iterableEvery,
+  iterableFilter,
+  iterableFind,
   iterableFindIndex,
   iterableFindLast,
   iterableFindLastIndex,
+  iterableForEach,
+  iterableGetReadable,
   iterableIncludes,
   iterableIndexOf,
   iterableJoin,
   iterableKeys,
+  iterableMap,
+  iterableReduce,
   iterableSlice,
+  iterableSome,
   iterableToSpliced,
   iterableToString,
-  iteratorDrop,
-  iteratorEvery,
-  iteratorFilter,
-  iteratorFind,
-  iteratorFlatMap,
-  iteratorForEach,
-  iteratorFrom,
-  iteratorMap,
-  iteratorReduce,
-  iteratorSome,
-  iteratorTake,
-  iteratorToArray,
   iteratorToIterable,
   observableFromAsync,
   observableSubscribeAsReadable,
-  readableStreamFrom,
   readerValues
 });
 //# sourceMappingURL=iter-fest.js.map