iter-fest 0.0.0-main.9e231bf

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

@@ -0,0 +1,17 @@
+/**
+ * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.
+ * @param start The zero-based location in the array from which to start removing elements.
+ * @param deleteCount The number of elements to remove.
+ * @param items Elements to insert into the copied array in place of the deleted elements.
+ * @returns The copied array.
+ */
+declare function iterableToSpliced<T>(iterable: Iterable<T>, start?: number | undefined, deleteCount?: number | undefined, ...items: T[]): Iterable<T>;
+/**
+ * Copies an array and removes elements while returning the remaining elements.
+ * @param start The zero-based location in the array from which to start removing elements.
+ * @param deleteCount The number of elements to remove.
+ * @returns A copy of the original array with the remaining elements.
+ */
+declare function iterableToSpliced<T>(iterable: Iterable<T>, start?: number | undefined, deleteCount?: number | undefined): Iterable<T>;
+
+export { iterableToSpliced };

package/dist/iter-fest.iterableToSpliced.js

@@ -0,0 +1,62 @@
+"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/iterableToSpliced.ts
+var iterableToSpliced_exports = {};
+__export(iterableToSpliced_exports, {
+  iterableToSpliced: () => iterableToSpliced
+});
+module.exports = __toCommonJS(iterableToSpliced_exports);
+
+// src/private/toIntegerOrInfinity.ts
+function toIntegerOrInfinity(value) {
+  if (value === Infinity || value === -Infinity) {
+    return value;
+  }
+  return ~~value;
+}
+
+// src/iterableToSpliced.ts
+function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
+  let index = 0;
+  start = toIntegerOrInfinity(start);
+  start = start === -Infinity ? 0 : start;
+  if (start < 0) {
+    throw new TypeError("start cannot be a negative finite number");
+  }
+  let inserted = false;
+  for (const item of iterable) {
+    if (index + 1 > start && !inserted) {
+      yield* items;
+      inserted = true;
+    }
+    if (index < start || index >= start + deleteCount) {
+      yield item;
+    }
+    index++;
+  }
+  if (!inserted) {
+    yield* items;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  iterableToSpliced
+});
+//# sourceMappingURL=iter-fest.iterableToSpliced.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableToSpliced.ts","../src/private/toIntegerOrInfinity.ts"],"sourcesContent":["import toIntegerOrInfinity from './private/toIntegerOrInfinity';\n\n/**\n * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.\n * @param start The zero-based location in the array from which to start removing elements.\n * @param deleteCount The number of elements to remove.\n * @param items Elements to insert into the copied array in place of the deleted elements.\n * @returns The copied array.\n */\nexport function iterableToSpliced<T>(\n  iterable: Iterable<T>,\n  start?: number | undefined,\n  deleteCount?: number | undefined,\n  ...items: T[]\n): Iterable<T>;\n\n/**\n * Copies an array and removes elements while returning the remaining elements.\n * @param start The zero-based location in the array from which to start removing elements.\n * @param deleteCount The number of elements to remove.\n * @returns A copy of the original array with the remaining elements.\n */\nexport function iterableToSpliced<T>(\n  iterable: Iterable<T>,\n  start?: number | undefined,\n  deleteCount?: number | undefined\n): Iterable<T>;\n\nexport function* iterableToSpliced<T>(\n  iterable: Iterable<T>,\n  start: number = 0,\n  deleteCount: number = 0,\n  ...items: T[]\n): Iterable<T> {\n  let index = 0;\n\n  start = toIntegerOrInfinity(start);\n  start = start === -Infinity ? 0 : start;\n\n  if (start < 0) {\n    throw new TypeError('start cannot be a negative finite number');\n  }\n\n  let inserted = false;\n\n  for (const item of iterable) {\n    if (index + 1 > start && !inserted) {\n      yield* items;\n      inserted = true;\n    }\n\n    if (index < start || index >= start + deleteCount) {\n      yield item;\n    }\n\n    index++;\n  }\n\n  if (!inserted) {\n    yield* items;\n  }\n}\n","export default function toIntegerOrInfinity(value: number): number {\n  if (value === Infinity || value === -Infinity) {\n    return value;\n  }\n\n  return ~~value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAe,SAAR,oBAAqC,OAAuB;AACjE,MAAI,UAAU,YAAY,UAAU,WAAW;AAC7C,WAAO;AAAA,EACT;AAEA,SAAO,CAAC,CAAC;AACX;;;ADsBO,UAAU,kBACf,UACA,QAAgB,GAChB,cAAsB,MACnB,OACU;AACb,MAAI,QAAQ;AAEZ,UAAQ,oBAAoB,KAAK;AACjC,UAAQ,UAAU,YAAY,IAAI;AAElC,MAAI,QAAQ,GAAG;AACb,UAAM,IAAI,UAAU,0CAA0C;AAAA,EAChE;AAEA,MAAI,WAAW;AAEf,aAAW,QAAQ,UAAU;AAC3B,QAAI,QAAQ,IAAI,SAAS,CAAC,UAAU;AAClC,aAAO;AACP,iBAAW;AAAA,IACb;AAEA,QAAI,QAAQ,SAAS,SAAS,QAAQ,aAAa;AACjD,YAAM;AAAA,IACR;AAEA;AAAA,EACF;AAEA,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/iter-fest.iterableToSpliced.mjs

@@ -0,0 +1,8 @@
+import {
+  iterableToSpliced
+} from "./chunk-WKIRSZXX.mjs";
+import "./chunk-W5NEOEVE.mjs";
+export {
+  iterableToSpliced
+};
+//# sourceMappingURL=iter-fest.iterableToSpliced.mjs.map

package/dist/iter-fest.iterableToSpliced.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -0,0 +1,6 @@
+/**
+ * Returns a string representation of an iterable.
+ */
+declare function iterableToString<T>(iterable: Iterable<T>): string;
+
+export { iterableToString };

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

@@ -0,0 +1,6 @@
+/**
+ * Returns a string representation of an iterable.
+ */
+declare function iterableToString<T>(iterable: Iterable<T>): string;
+
+export { iterableToString };

package/dist/iter-fest.iterableToString.js

@@ -0,0 +1,51 @@
+"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/iterableToString.ts
+var iterableToString_exports = {};
+__export(iterableToString_exports, {
+  iterableToString: () => iterableToString
+});
+module.exports = __toCommonJS(iterableToString_exports);
+
+// src/iterableJoin.ts
+function iterableJoin(iterable, separator = ",") {
+  let index = 0;
+  let result = "";
+  for (const item of iterable) {
+    if (index) {
+      result += separator;
+    }
+    if (typeof item !== "undefined" && item !== null) {
+      result += item;
+    }
+    index++;
+  }
+  return result;
+}
+
+// src/iterableToString.ts
+function iterableToString(iterable) {
+  return iterableJoin(iterable);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  iterableToString
+});
+//# sourceMappingURL=iter-fest.iterableToString.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableToString.ts","../src/iterableJoin.ts"],"sourcesContent":["import { iterableJoin } from './iterableJoin';\n\n/**\n * Returns a string representation of an iterable.\n */\nexport function iterableToString<T>(iterable: Iterable<T>): string {\n  return iterableJoin(iterable);\n}\n","/**\n * Adds all the elements of an iterable into a string, separated by the specified separator string.\n *\n * @param separator A string used to separate one element of the iterable from the next in the resulting string. If omitted, the iterable elements are separated with a comma.\n */\nexport function iterableJoin<T>(iterable: Iterable<T>, separator: string = ','): string {\n  let index = 0;\n  let result = '';\n\n  for (const item of iterable) {\n    if (index) {\n      result += separator;\n    }\n\n    if (typeof item !== 'undefined' && item !== null) {\n      result += item;\n    }\n\n    index++;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKO,SAAS,aAAgB,UAAuB,YAAoB,KAAa;AACtF,MAAI,QAAQ;AACZ,MAAI,SAAS;AAEb,aAAW,QAAQ,UAAU;AAC3B,QAAI,OAAO;AACT,gBAAU;AAAA,IACZ;AAEA,QAAI,OAAO,SAAS,eAAe,SAAS,MAAM;AAChD,gBAAU;AAAA,IACZ;AAEA;AAAA,EACF;AAEA,SAAO;AACT;;;ADjBO,SAAS,iBAAoB,UAA+B;AACjE,SAAO,aAAa,QAAQ;AAC9B;","names":[]}

package/dist/iter-fest.iterableToString.mjs

@@ -0,0 +1,8 @@
+import {
+  iterableToString
+} from "./chunk-Y5M2C7NQ.mjs";
+import "./chunk-5CHMNKXJ.mjs";
+export {
+  iterableToString
+};
+//# sourceMappingURL=iter-fest.iterableToString.mjs.map

package/dist/iter-fest.iterableToString.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -0,0 +1,3 @@
+declare function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
+
+export { iteratorToIterable };

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

@@ -0,0 +1,3 @@
+declare function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
+
+export { iteratorToIterable };

package/dist/iter-fest.iteratorToIterable.js

@@ -0,0 +1,39 @@
+"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/iteratorToIterable.ts
+var iteratorToIterable_exports = {};
+__export(iteratorToIterable_exports, {
+  iteratorToIterable: () => iteratorToIterable
+});
+module.exports = __toCommonJS(iteratorToIterable_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  iteratorToIterable
+});
+//# sourceMappingURL=iter-fest.iteratorToIterable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iteratorToIterable.ts"],"sourcesContent":["export function iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T> {\n  const iterableIterator: IterableIterator<T> = {\n    [Symbol.iterator]: () => iterableIterator,\n    next: iterator.next.bind(iterator),\n    ...(iterator.return ? { return: iterator.return.bind(iterator) } : {}),\n    ...(iterator.throw ? { throw: iterator.throw.bind(iterator) } : {})\n  };\n\n  return iterableIterator;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,mBAAsB,UAA4C;AAChF,QAAM,mBAAwC;AAAA,IAC5C,CAAC,OAAO,QAAQ,GAAG,MAAM;AAAA,IACzB,MAAM,SAAS,KAAK,KAAK,QAAQ;AAAA,IACjC,GAAI,SAAS,SAAS,EAAE,QAAQ,SAAS,OAAO,KAAK,QAAQ,EAAE,IAAI,CAAC;AAAA,IACpE,GAAI,SAAS,QAAQ,EAAE,OAAO,SAAS,MAAM,KAAK,QAAQ,EAAE,IAAI,CAAC;AAAA,EACnE;AAEA,SAAO;AACT;","names":[]}

package/dist/iter-fest.iteratorToIterable.mjs

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

package/dist/iter-fest.iteratorToIterable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/iter-fest.js

@@ -0,0 +1,388 @@
+"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/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
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/private/toIntegerOrInfinity.ts
+function toIntegerOrInfinity(value) {
+  if (value === Infinity || value === -Infinity) {
+    return value;
+  }
+  return ~~value;
+}
+
+// src/iterableAt.ts
+function iterableAt(iterable, index) {
+  let currentIndex = 0;
+  index = toIntegerOrInfinity(index);
+  if (!isFinite(index)) {
+    return;
+  }
+  if (index < 0) {
+    throw new TypeError("index cannot be a negative finite number");
+  }
+  for (const value of iterable) {
+    if (currentIndex++ === index) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/iterableConcat.ts
+function* iterableConcat(iterable, ...items) {
+  yield* iterable;
+  for (const item of items) {
+    if (item && typeof item === "object" && Symbol.iterator in item) {
+      yield* item;
+    } else {
+      yield item;
+    }
+  }
+}
+
+// src/iterableEntries.ts
+function* iterableEntries(iterable) {
+  let index = 0;
+  for (const value of iterable) {
+    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/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;
+  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 index;
+    }
+    index++;
+  }
+  return -1;
+}
+
+// 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 iterable) {
+    if (boundPredicate(value, index++, iterable)) {
+      last = value;
+    }
+  }
+  return last;
+}
+
+// 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 iterable) {
+    if (boundPredicate(value, index, iterable)) {
+      lastIndex = index;
+    }
+    index++;
+  }
+  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/iterableIncludes.ts
+function iterableIncludes(iterable, searchElement, fromIndex = 0) {
+  let index = 0;
+  fromIndex = toIntegerOrInfinity(fromIndex);
+  if (fromIndex !== Infinity) {
+    fromIndex = fromIndex === -Infinity ? 0 : fromIndex;
+    if (fromIndex < 0) {
+      throw new TypeError("fromIndex cannot be a negative finite number");
+    }
+    for (const item of iterable) {
+      if (index++ >= fromIndex && Object.is(item, searchElement)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/iterableIndexOf.ts
+function iterableIndexOf(iterable, searchElement, fromIndex = 0) {
+  let index = 0;
+  fromIndex = toIntegerOrInfinity(fromIndex);
+  if (fromIndex !== Infinity) {
+    fromIndex = fromIndex === -Infinity ? 0 : fromIndex;
+    if (fromIndex < 0) {
+      throw new TypeError("fromIndex cannot be a negative finite number");
+    }
+    for (const item of iterable) {
+      if (index >= fromIndex && Object.is(item, searchElement)) {
+        return index;
+      }
+      index++;
+    }
+  }
+  return -1;
+}
+
+// src/iterableJoin.ts
+function iterableJoin(iterable, separator = ",") {
+  let index = 0;
+  let result = "";
+  for (const item of iterable) {
+    if (index) {
+      result += separator;
+    }
+    if (typeof item !== "undefined" && item !== null) {
+      result += item;
+    }
+    index++;
+  }
+  return result;
+}
+
+// src/iterableKeys.ts
+function* iterableKeys(iterable) {
+  let index = 0;
+  for (const _ of iterable) {
+    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/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;
+  start = toIntegerOrInfinity(start);
+  start = start === -Infinity ? 0 : start;
+  end = toIntegerOrInfinity(end);
+  end = end === -Infinity ? 0 : end;
+  if (start < 0) {
+    throw new TypeError("start cannot be a negative finite number");
+  }
+  if (end < 0) {
+    throw new TypeError("end cannot be a negative finite number");
+  }
+  if (start === Infinity) {
+    return;
+  }
+  for (const item of iterable) {
+    if (index >= start && index < end) {
+      yield item;
+    }
+    index++;
+    if (index > end) {
+      break;
+    }
+  }
+}
+
+// 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;
+  start = toIntegerOrInfinity(start);
+  start = start === -Infinity ? 0 : start;
+  if (start < 0) {
+    throw new TypeError("start cannot be a negative finite number");
+  }
+  let inserted = false;
+  for (const item of iterable) {
+    if (index + 1 > start && !inserted) {
+      yield* items;
+      inserted = true;
+    }
+    if (index < start || index >= start + deleteCount) {
+      yield item;
+    }
+    index++;
+  }
+  if (!inserted) {
+    yield* items;
+  }
+}
+
+// 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;
+}
+// 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
+});
+//# sourceMappingURL=iter-fest.js.map