@sapphire/iterator-utilities 1.0.0

package/dist/iife/index.global.js

@@ -0,0 +1,834 @@
+var SapphireIteratorUtilities = (function (exports) {
+  'use strict';
+
+  var __defProp = Object.defineProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+  // src/lib/from.ts
+  function from(value) {
+    if (typeof value === "object" && value !== null) {
+      if (typeof value[Symbol.iterator] === "function") {
+        return value[Symbol.iterator]();
+      }
+      if (typeof value.next === "function") {
+        return value;
+      }
+    }
+    if (typeof value === "string") {
+      return value[Symbol.iterator]();
+    }
+    throw new TypeError(`${String(value)} cannot be converted to an iterable`);
+  }
+  __name(from, "from");
+
+  // src/lib/shared/_makeIterableIterator.ts
+  function makeIterableIterator(next) {
+    return {
+      next,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  __name(makeIterableIterator, "makeIterableIterator");
+
+  // src/lib/toIterableIterator.ts
+  function toIterableIterator(iterable) {
+    const resolvedIterable = from(iterable);
+    if (Symbol.iterator in resolvedIterable) {
+      return resolvedIterable;
+    }
+    return makeIterableIterator(() => resolvedIterable.next());
+  }
+  __name(toIterableIterator, "toIterableIterator");
+
+  // src/lib/chain.ts
+  function* chain(...iterables) {
+    for (const iterable of iterables) {
+      yield* toIterableIterator(iterable);
+    }
+  }
+  __name(chain, "chain");
+
+  // src/lib/append.ts
+  function append(iterable, ...iterables) {
+    return chain(iterable, ...iterables);
+  }
+  __name(append, "append");
+
+  // src/lib/empty.ts
+  function empty() {
+    return makeIterableIterator(() => ({ done: true, value: void 0 }));
+  }
+  __name(empty, "empty");
+
+  // src/lib/shared/_assertNotNegative.ts
+  function assertNotNegative(value, original) {
+    if (value < 0) {
+      throw new RangeError(`${original} must be a non-negative number`);
+    }
+    return value;
+  }
+  __name(assertNotNegative, "assertNotNegative");
+
+  // src/lib/shared/_toNumberOrThrow.ts
+  function toNumberOrThrow(value) {
+    switch (typeof value) {
+      case "bigint":
+        throw new TypeError("Cannot convert a BigInt value to a number");
+      case "symbol":
+        throw new TypeError("Cannot convert a Symbol value to a number");
+      case "boolean":
+        return value ? 1 : 0;
+      case "number":
+        return assertNumber(value, value);
+      case "undefined":
+        throw new TypeError("Cannot convert an undefined value to a number");
+      default:
+        return assertNumber(Number(value), value);
+    }
+  }
+  __name(toNumberOrThrow, "toNumberOrThrow");
+  function assertNumber(value, original) {
+    if (Number.isNaN(value)) {
+      throw new RangeError(`${original} must be a non-NaN number`);
+    }
+    return value;
+  }
+  __name(assertNumber, "assertNumber");
+
+  // src/lib/shared/_toIntegerOrInfinityOrThrow.ts
+  function toIntegerOrInfinityOrThrow(value) {
+    const number = toNumberOrThrow(value);
+    if (Number.isNaN(number) || number === 0)
+      return 0;
+    if (number === Number.POSITIVE_INFINITY)
+      return Number.POSITIVE_INFINITY;
+    if (number === Number.NEGATIVE_INFINITY)
+      return Number.NEGATIVE_INFINITY;
+    return Math.trunc(number);
+  }
+  __name(toIntegerOrInfinityOrThrow, "toIntegerOrInfinityOrThrow");
+
+  // src/lib/drop.ts
+  function drop(iterable, count2) {
+    count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
+    const resolvedIterable = toIterableIterator(iterable);
+    if (count2 === 0)
+      return resolvedIterable;
+    if (count2 === Number.POSITIVE_INFINITY)
+      return empty();
+    for (let i = 0; i < count2; i++) {
+      if (resolvedIterable.next().done)
+        break;
+    }
+    return resolvedIterable;
+  }
+  __name(drop, "drop");
+
+  // src/lib/first.ts
+  function first(iterable) {
+    return from(iterable).next().value;
+  }
+  __name(first, "first");
+
+  // src/lib/at.ts
+  function at(iterable, index) {
+    index = assertNotNegative(toIntegerOrInfinityOrThrow(index), index);
+    return first(index === 0 ? iterable : drop(iterable, index));
+  }
+  __name(at, "at");
+
+  // src/lib/shared/_assertFunction.ts
+  function assertFunction(value) {
+    if (typeof value !== "function") {
+      throw new TypeError(`${value} must be a function`);
+    }
+    return value;
+  }
+  __name(assertFunction, "assertFunction");
+
+  // src/lib/map.ts
+  function* map(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const element of toIterableIterator(iterable)) {
+      yield callbackFn(element, index++);
+    }
+  }
+  __name(map, "map");
+
+  // src/lib/average.ts
+  function average(iterable) {
+    let sum2 = 0;
+    let total = 0;
+    for (const value of map(iterable, toNumberOrThrow)) {
+      sum2 += value;
+      total++;
+    }
+    return total === 0 ? null : sum2 / total;
+  }
+  __name(average, "average");
+
+  // src/lib/shared/_assertPositive.ts
+  function assertPositive(value, original) {
+    if (value <= 0) {
+      throw new RangeError(`${original} must be a positive number`);
+    }
+    return value;
+  }
+  __name(assertPositive, "assertPositive");
+
+  // src/lib/shared/_toIntegerOrThrow.ts
+  function toIntegerOrThrow(value) {
+    const number = toNumberOrThrow(value);
+    if (Number.isNaN(number) || number === 0)
+      return 0;
+    if (number === Number.POSITIVE_INFINITY)
+      throw new RangeError("+Infinity cannot be represented as an integer");
+    if (number === Number.NEGATIVE_INFINITY)
+      throw new RangeError("-Infinity cannot be represented as an integer");
+    return Math.trunc(number);
+  }
+  __name(toIntegerOrThrow, "toIntegerOrThrow");
+
+  // src/lib/chunk.ts
+  function* chunk(iterable, size) {
+    size = assertPositive(toIntegerOrThrow(size), size);
+    let buffer = [];
+    for (const element of toIterableIterator(iterable)) {
+      buffer.push(element);
+      if (buffer.length === size) {
+        yield buffer;
+        buffer = [];
+      }
+    }
+    if (buffer.length) {
+      yield buffer;
+    }
+  }
+  __name(chunk, "chunk");
+
+  // src/lib/filter.ts
+  function* filter(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (callbackFn(value, index++))
+        yield value;
+    }
+  }
+  __name(filter, "filter");
+
+  // src/lib/compact.ts
+  function compact(iterable) {
+    return filter(iterable, (value) => value !== null && value !== void 0);
+  }
+  __name(compact, "compact");
+
+  // src/lib/compress.ts
+  function* compress(iterable, selectors) {
+    const resolvedSelectors = from(selectors);
+    for (const resolvedIterableResult of toIterableIterator(iterable)) {
+      const selectorResult = resolvedSelectors.next();
+      if (selectorResult.done) {
+        return;
+      }
+      if (selectorResult.value) {
+        yield resolvedIterableResult;
+      }
+    }
+  }
+  __name(compress, "compress");
+
+  // src/lib/contains.ts
+  function contains(iterable, value) {
+    for (const element of toIterableIterator(iterable)) {
+      if (element === value)
+        return true;
+    }
+    return false;
+  }
+  __name(contains, "contains");
+
+  // src/lib/count.ts
+  function count(iterable) {
+    let count2 = 0;
+    const resolvedIterable = from(iterable);
+    while (!resolvedIterable.next().done) {
+      count2++;
+    }
+    return count2;
+  }
+  __name(count, "count");
+
+  // src/lib/cycle.ts
+  function* cycle(iterable) {
+    const results = [];
+    for (const element of toIterableIterator(iterable)) {
+      yield element;
+      results.push(element);
+    }
+    while (results.length > 0) {
+      for (const element of results) {
+        yield element;
+      }
+    }
+  }
+  __name(cycle, "cycle");
+
+  // src/lib/difference.ts
+  function difference(first2, second) {
+    const set = new Set(toIterableIterator(second));
+    return filter(first2, (value) => !set.has(value));
+  }
+  __name(difference, "difference");
+
+  // src/lib/take.ts
+  function take(iterable, count2) {
+    count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
+    if (count2 === 0)
+      return empty();
+    let i = 0;
+    const resolvedIterable = from(iterable);
+    return makeIterableIterator(
+      () => i >= count2 ? { done: true, value: void 0 } : (i++, resolvedIterable.next())
+    );
+  }
+  __name(take, "take");
+
+  // src/lib/toArray.ts
+  function toArray(iterable) {
+    return [...toIterableIterator(iterable)];
+  }
+  __name(toArray, "toArray");
+
+  // src/lib/dropLast.ts
+  function dropLast(iterable, count2) {
+    count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
+    const array = toArray(iterable);
+    if (array.length <= count2)
+      return empty();
+    return take(array.values(), array.length - count2);
+  }
+  __name(dropLast, "dropLast");
+
+  // src/lib/dropWhile.ts
+  function* dropWhile(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (!callbackFn(value, index++)) {
+        yield value;
+      }
+    }
+  }
+  __name(dropWhile, "dropWhile");
+
+  // src/lib/enumerate.ts
+  function* enumerate(iterable) {
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      yield [index++, value];
+    }
+  }
+  __name(enumerate, "enumerate");
+
+  // src/lib/every.ts
+  function every(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (!callbackFn(value, index++))
+        return false;
+    }
+    return true;
+  }
+  __name(every, "every");
+
+  // src/lib/find.ts
+  function find(iterable, callbackFn) {
+    return first(filter(iterable, callbackFn));
+  }
+  __name(find, "find");
+
+  // src/lib/findIndex.ts
+  function findIndex(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const element of toIterableIterator(iterable)) {
+      if (callbackFn(element, index)) {
+        return index;
+      }
+      index++;
+    }
+    return -1;
+  }
+  __name(findIndex, "findIndex");
+
+  // src/lib/flat.ts
+  function* flat(iterables) {
+    for (const value of toIterableIterator(iterables)) {
+      yield* toIterableIterator(value);
+    }
+  }
+  __name(flat, "flat");
+
+  // src/lib/flatMap.ts
+  function* flatMap(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      yield* toIterableIterator(callbackFn(value, index++));
+    }
+  }
+  __name(flatMap, "flatMap");
+
+  // src/lib/forEach.ts
+  function forEach(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const element of toIterableIterator(iterable)) {
+      callbackFn(element, index++);
+    }
+  }
+  __name(forEach, "forEach");
+
+  // src/lib/indexOf.ts
+  function indexOf(iterable, value) {
+    let index = 0;
+    for (const element of toIterableIterator(iterable)) {
+      if (element === value) {
+        return index;
+      }
+      index++;
+    }
+    return -1;
+  }
+  __name(indexOf, "indexOf");
+
+  // src/lib/intersect.ts
+  function intersect(first2, second) {
+    const set = new Set(toIterableIterator(second));
+    return filter(first2, (value) => set.has(value));
+  }
+  __name(intersect, "intersect");
+
+  // src/lib/isEmpty.ts
+  function isEmpty(iterable) {
+    return from(iterable).next().done ?? false;
+  }
+  __name(isEmpty, "isEmpty");
+
+  // src/lib/last.ts
+  function last(iterable) {
+    let last2;
+    for (const value of toIterableIterator(iterable)) {
+      last2 = value;
+    }
+    return last2;
+  }
+  __name(last, "last");
+
+  // src/lib/max.ts
+  function max(iterable) {
+    let max2 = null;
+    for (const value of map(iterable, toNumberOrThrow)) {
+      if (max2 === null || value > max2)
+        max2 = value;
+    }
+    return max2;
+  }
+  __name(max, "max");
+
+  // src/lib/min.ts
+  function min(iterable) {
+    let min2 = null;
+    for (const value of map(iterable, toNumberOrThrow)) {
+      if (min2 === null || value < min2)
+        min2 = value;
+    }
+    return min2;
+  }
+  __name(min, "min");
+
+  // src/lib/partition.ts
+  function partition(iterable, predicate) {
+    predicate = assertFunction(predicate);
+    const bufferLeft = [];
+    const bufferRight = [];
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (predicate(value, index++)) {
+        bufferLeft.push(value);
+      } else {
+        bufferRight.push(value);
+      }
+    }
+    return [bufferLeft, bufferRight];
+  }
+  __name(partition, "partition");
+
+  // src/lib/peekable.ts
+  function peekable(iterable) {
+    const resolvedIterable = from(iterable);
+    let peeked;
+    return {
+      next() {
+        if (peeked) {
+          const value = peeked;
+          peeked = void 0;
+          return value;
+        }
+        return resolvedIterable.next();
+      },
+      peek() {
+        peeked = peeked ?? resolvedIterable.next();
+        return peeked;
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  __name(peekable, "peekable");
+
+  // src/lib/prepend.ts
+  function* prepend(iterable, ...iterables) {
+    for (const iterable2 of iterables) {
+      yield* toIterableIterator(iterable2);
+    }
+    yield* toIterableIterator(iterable);
+  }
+  __name(prepend, "prepend");
+
+  // src/lib/product.ts
+  function product(iterable) {
+    let result = 1;
+    for (const value of map(iterable, toNumberOrThrow)) {
+      result *= value;
+    }
+    return result;
+  }
+  __name(product, "product");
+
+  // src/lib/range.ts
+  function* range(start, end, step) {
+    start = toNumberOrThrow(start);
+    end = toNumberOrThrow(end);
+    if (step === void 0) {
+      step = start < end ? 1 : -1;
+    } else {
+      step = toNumberOrThrow(step);
+      if (step === 0) {
+        throw new RangeError("Step cannot be zero");
+      }
+      if (step > 0 && start > end) {
+        throw new RangeError("Start must be less than end when step is positive");
+      } else if (step < 0 && start < end) {
+        throw new RangeError("Start must be greater than end when step is negative");
+      }
+    }
+    if (start < end) {
+      for (let i = start; i < end; i += step) {
+        yield i;
+      }
+    } else {
+      for (let i = start; i > end; i += step) {
+        yield i;
+      }
+    }
+  }
+  __name(range, "range");
+
+  // src/lib/reduce.ts
+  function reduce(iterable, callbackFn, initialValue) {
+    callbackFn = assertFunction(callbackFn);
+    let index;
+    let accumulator;
+    const resolvedIterable = toIterableIterator(iterable);
+    if (arguments.length < 3) {
+      const firstValue = resolvedIterable.next();
+      if (firstValue.done)
+        throw new TypeError("Reduce of empty iterator with no initial value");
+      index = 1;
+      accumulator = firstValue.value;
+    } else {
+      index = 0;
+      accumulator = initialValue;
+    }
+    for (const value of resolvedIterable) {
+      accumulator = callbackFn(accumulator, value, index++);
+    }
+    return accumulator;
+  }
+  __name(reduce, "reduce");
+
+  // src/lib/repeat.ts
+  function repeat(value, count2) {
+    count2 = assertNotNegative(toNumberOrThrow(count2), count2);
+    let i = 0;
+    return makeIterableIterator(
+      () => i >= count2 ? { done: true, value: void 0 } : (i++, { done: false, value })
+    );
+  }
+  __name(repeat, "repeat");
+
+  // src/lib/reverse.ts
+  function* reverse(iterable) {
+    const items = [];
+    for (const item of toIterableIterator(iterable)) {
+      items.push(item);
+    }
+    for (let i = items.length - 1; i >= 0; i--) {
+      yield items[i];
+    }
+  }
+  __name(reverse, "reverse");
+
+  // src/lib/takeLast.ts
+  function takeLast(iterable, count2) {
+    count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
+    if (count2 === 0)
+      return empty();
+    if (count2 === Number.POSITIVE_INFINITY)
+      return toIterableIterator(iterable);
+    const array = toArray(iterable);
+    let i = Math.max(0, array.length - count2);
+    return makeIterableIterator(() => {
+      if (i >= array.length) {
+        return { done: true, value: void 0 };
+      }
+      return { done: false, value: array[i++] };
+    });
+  }
+  __name(takeLast, "takeLast");
+
+  // src/lib/slice.ts
+  function slice(iterable, start, end) {
+    start = toIntegerOrInfinityOrThrow(start ?? 0);
+    if (start === Number.NEGATIVE_INFINITY) {
+      start = 0;
+    }
+    if (end === void 0) {
+      return start >= 0 ? drop(iterable, start) : takeLast(iterable, -start);
+    }
+    end = toIntegerOrInfinityOrThrow(end);
+    if (end < 0) {
+      if (end === Number.NEGATIVE_INFINITY) {
+        return empty();
+      }
+      if (start === 0) {
+        return dropLast(iterable, -end);
+      }
+      if (start >= 0) {
+        return dropLast(drop(iterable, start), -end);
+      }
+      if (start >= end) {
+        return empty();
+      }
+      return take(takeLast(iterable, -start), end - start);
+    }
+    if (start >= end)
+      return empty();
+    return end === Number.POSITIVE_INFINITY ? drop(iterable, start) : take(drop(iterable, start), end - start);
+  }
+  __name(slice, "slice");
+
+  // src/lib/some.ts
+  function some(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (callbackFn(value, index++)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  __name(some, "some");
+
+  // src/lib/sorted.ts
+  function sorted(iterable, compareFn) {
+    return toArray(iterable).sort(compareFn).values();
+  }
+  __name(sorted, "sorted");
+
+  // src/lib/starMap.ts
+  function* starMap(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    for (const value of toIterableIterator(iterable)) {
+      yield callbackFn(...toIterableIterator(value));
+    }
+  }
+  __name(starMap, "starMap");
+
+  // src/lib/sum.ts
+  function sum(iterable) {
+    let sum2 = 0;
+    for (const value of map(iterable, toNumberOrThrow)) {
+      sum2 += value;
+    }
+    return sum2;
+  }
+  __name(sum, "sum");
+
+  // src/lib/tee.ts
+  function tee(iterable, count2) {
+    count2 = assertNotNegative(toIntegerOrThrow(count2), count2);
+    if (count2 === 0)
+      return [];
+    const entries = [];
+    const indexes = toArray(repeat(0, count2));
+    const resolvedIterable = from(iterable);
+    const iterables = [];
+    for (let i = 0; i < count2; i++) {
+      const iterable2 = makeIterableIterator(() => {
+        if (indexes[i] >= entries.length) {
+          const result = resolvedIterable.next();
+          if (result.done) {
+            return { done: true, value: void 0 };
+          }
+          entries.push(result.value);
+        }
+        return { done: false, value: entries[indexes[i]++] };
+      });
+      iterables.push(iterable2);
+    }
+    return iterables;
+  }
+  __name(tee, "tee");
+
+  // src/lib/union.ts
+  function* union(...iterables) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const iterator of iterables) {
+      for (const value of toIterableIterator(iterator)) {
+        if (!seen.has(value)) {
+          seen.add(value);
+          yield value;
+        }
+      }
+    }
+  }
+  __name(union, "union");
+
+  // src/lib/unique.ts
+  function unique(iterable) {
+    return union(iterable);
+  }
+  __name(unique, "unique");
+
+  // src/lib/unzip.ts
+  function unzip(iterable) {
+    const resolvedIterable = toIterableIterator(iterable);
+    const firstResult = resolvedIterable.next();
+    if (firstResult.done) {
+      throw new Error("Cannot unzip an empty iterable");
+    }
+    if (!Array.isArray(firstResult.value)) {
+      throw new Error("Cannot unzip an iterable that does not yield an array");
+    }
+    const size = firstResult.value.length;
+    const results = [];
+    for (let i = 0; i < size; i++)
+      results.push([firstResult.value[i]]);
+    for (const entries of resolvedIterable) {
+      if (!Array.isArray(entries)) {
+        throw new Error("Cannot unzip an iterable that does not yield an array");
+      }
+      if (entries.length !== size) {
+        throw new Error("Cannot unzip an iterable that yields arrays of different sizes");
+      }
+      for (let i = 0; i < size; i++) {
+        results[i].push(entries[i]);
+      }
+    }
+    return results;
+  }
+  __name(unzip, "unzip");
+
+  // src/lib/zip.ts
+  function* zip(...iterables) {
+    const resolvedIterables = iterables.map((iterable) => from(iterable));
+    while (true) {
+      const results = [];
+      for (const resolvedIterable of resolvedIterables) {
+        const result = resolvedIterable.next();
+        if (result.done)
+          return;
+        results.push(result.value);
+      }
+      yield results;
+    }
+  }
+  __name(zip, "zip");
+
+  exports.append = append;
+  exports.at = at;
+  exports.average = average;
+  exports.chain = chain;
+  exports.chunk = chunk;
+  exports.compact = compact;
+  exports.compress = compress;
+  exports.concat = append;
+  exports.contains = contains;
+  exports.count = count;
+  exports.cycle = cycle;
+  exports.difference = difference;
+  exports.drop = drop;
+  exports.dropLast = dropLast;
+  exports.dropWhile = dropWhile;
+  exports.empty = empty;
+  exports.enumerate = enumerate;
+  exports.every = every;
+  exports.except = difference;
+  exports.filter = filter;
+  exports.find = find;
+  exports.findIndex = findIndex;
+  exports.first = first;
+  exports.flat = flat;
+  exports.flatMap = flatMap;
+  exports.forEach = forEach;
+  exports.from = from;
+  exports.indexOf = indexOf;
+  exports.intersect = intersect;
+  exports.isEmpty = isEmpty;
+  exports.last = last;
+  exports.map = map;
+  exports.max = max;
+  exports.min = min;
+  exports.omit = difference;
+  exports.partition = partition;
+  exports.peekable = peekable;
+  exports.position = indexOf;
+  exports.prepend = prepend;
+  exports.product = product;
+  exports.range = range;
+  exports.reduce = reduce;
+  exports.repeat = repeat;
+  exports.reverse = reverse;
+  exports.skip = drop;
+  exports.skipLast = dropLast;
+  exports.skipWhile = dropWhile;
+  exports.slice = slice;
+  exports.some = some;
+  exports.sorted = sorted;
+  exports.starMap = starMap;
+  exports.sum = sum;
+  exports.take = take;
+  exports.takeLast = takeLast;
+  exports.takeWhile = filter;
+  exports.tee = tee;
+  exports.toArray = toArray;
+  exports.toIterableIterator = toIterableIterator;
+  exports.union = union;
+  exports.unique = unique;
+  exports.unzip = unzip;
+  exports.zip = zip;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.global.js.map