@sapphire/iterator-utilities 1.1.0-next.63f6019b.0 → 2.0.0-next.1e7d2dec

package/dist/iife/index.global.js

@@ -4,6 +4,15 @@ var SapphireIteratorUtilities = (function (exports) {
   var __defProp = Object.defineProperty;
   var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+  // 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/from.ts
   function from(value) {
     if (typeof value === "object" && value !== null) {
@@ -42,6 +51,30 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(toIterableIterator, "toIterableIterator");
 
+  // 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/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/chain.ts
   function* chain(...iterables) {
     for (const iterable of iterables) {
@@ -100,12 +133,9 @@ var SapphireIteratorUtilities = (function (exports) {
   // 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;
+    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");
@@ -114,13 +144,10 @@ var SapphireIteratorUtilities = (function (exports) {
   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();
+    if (count2 === 0) return resolvedIterable;
+    if (count2 === Number.POSITIVE_INFINITY) return empty();
     for (let i = 0; i < count2; i++) {
-      if (resolvedIterable.next().done)
-        break;
+      if (resolvedIterable.next().done) break;
     }
     return resolvedIterable;
   }
@@ -139,15 +166,6 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __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);
@@ -182,12 +200,9 @@ var SapphireIteratorUtilities = (function (exports) {
   // 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");
+    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");
@@ -209,13 +224,27 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(chunk, "chunk");
 
+  // src/lib/toArray.ts
+  function toArray(iterable) {
+    return [...toIterableIterator(iterable)];
+  }
+  __name(toArray, "toArray");
+
+  // src/lib/collectInto.ts
+  function collectInto(iterable, output) {
+    for (const value of toIterableIterator(iterable)) {
+      output.push(value);
+    }
+    return output;
+  }
+  __name(collectInto, "collectInto");
+
   // 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;
+      if (callbackFn(value, index++)) yield value;
     }
   }
   __name(filter, "filter");
@@ -226,6 +255,69 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(compact, "compact");
 
+  // src/lib/shared/_compare.ts
+  function compareIteratorElements(x, y, comparator) {
+    if (typeof x === "undefined") {
+      if (typeof y === "undefined") return 0;
+      return 1;
+    }
+    if (typeof y === "undefined") {
+      return -1;
+    }
+    return comparator(x, y);
+  }
+  __name(compareIteratorElements, "compareIteratorElements");
+  function orderingIsLess(ordering) {
+    return ordering < 0;
+  }
+  __name(orderingIsLess, "orderingIsLess");
+  function orderingIsEqual(ordering) {
+    return ordering === 0;
+  }
+  __name(orderingIsEqual, "orderingIsEqual");
+  function orderingIsGreater(ordering) {
+    return ordering > 0;
+  }
+  __name(orderingIsGreater, "orderingIsGreater");
+
+  // src/lib/compareBy.ts
+  function compareBy(iterable, other, comparator) {
+    const iterator1 = from(other);
+    for (const x of toIterableIterator(iterable)) {
+      const result1 = iterator1.next();
+      if (result1.done) return 1;
+      const y = result1.value;
+      const comparison = compareIteratorElements(x, y, comparator);
+      if (!orderingIsEqual(comparison)) {
+        return orderingIsLess(comparison) ? -1 : 1;
+      }
+    }
+    return iterator1.next().done ? 0 : -1;
+  }
+  __name(compareBy, "compareBy");
+
+  // src/lib/shared/comparators.ts
+  function swap(cb) {
+    return (x, y) => 0 - cb(x, y);
+  }
+  __name(swap, "swap");
+  function defaultCompare(x, y) {
+    return ascNumber(String(x), String(y));
+  }
+  __name(defaultCompare, "defaultCompare");
+  var descString = swap(defaultCompare);
+  function ascNumber(x, y) {
+    return (x > y) - (x < y);
+  }
+  __name(ascNumber, "ascNumber");
+  var descNumber = swap(ascNumber);
+
+  // src/lib/compare.ts
+  function compare(iterable, other) {
+    return compareBy(iterable, other, defaultCompare);
+  }
+  __name(compare, "compare");
+
   // src/lib/compress.ts
   function* compress(iterable, selectors) {
     const resolvedSelectors = from(selectors);
@@ -244,8 +336,7 @@ var SapphireIteratorUtilities = (function (exports) {
   // src/lib/contains.ts
   function contains(iterable, value) {
     for (const element of toIterableIterator(iterable)) {
-      if (element === value)
-        return true;
+      if (element === value) return true;
     }
     return false;
   }
@@ -287,8 +378,7 @@ var SapphireIteratorUtilities = (function (exports) {
   // src/lib/take.ts
   function take(iterable, count2) {
     count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
-    if (count2 === 0)
-      return empty();
+    if (count2 === 0) return empty();
     let i = 0;
     const resolvedIterable = from(iterable);
     return makeIterableIterator(
@@ -297,18 +387,11 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __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();
+    if (array.length <= count2) return empty();
     return take(array.values(), array.length - count2);
   }
   __name(dropLast, "dropLast");
@@ -334,17 +417,23 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(enumerate, "enumerate");
 
-  // src/lib/every.ts
-  function every(iterable, callbackFn) {
+  // src/lib/equalBy.ts
+  function equalBy(iterable, other, callbackFn) {
     callbackFn = assertFunction(callbackFn);
-    let index = 0;
-    for (const value of toIterableIterator(iterable)) {
-      if (!callbackFn(value, index++))
-        return false;
+    const iterator1 = from(other);
+    for (const value0 of toIterableIterator(iterable)) {
+      const result1 = iterator1.next();
+      if (result1.done || !callbackFn(value0, result1.value)) return false;
     }
-    return true;
+    return iterator1.next().done === true;
   }
-  __name(every, "every");
+  __name(equalBy, "equalBy");
+
+  // src/lib/equal.ts
+  function equal(iterable, other) {
+    return equalBy(iterable, other, (a, b) => a === b);
+  }
+  __name(equal, "equal");
 
   // src/lib/find.ts
   function find(iterable, callbackFn) {
@@ -394,6 +483,37 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(forEach, "forEach");
 
+  // src/lib/fuse.ts
+  function fuse(iterable) {
+    let ended = false;
+    const iterator = toIterableIterator(iterable);
+    return makeIterableIterator(() => {
+      if (ended) {
+        return { done: true, value: void 0 };
+      }
+      const result = iterator.next();
+      if (result.done) {
+        ended = true;
+      }
+      return result;
+    });
+  }
+  __name(fuse, "fuse");
+
+  // src/lib/greaterOrEqualThan.ts
+  function greaterOrEqualThan(iterable, other) {
+    const result = compare(iterable, other);
+    return !orderingIsLess(result);
+  }
+  __name(greaterOrEqualThan, "greaterOrEqualThan");
+
+  // src/lib/greaterThan.ts
+  function greaterThan(iterable, other) {
+    const result = compare(iterable, other);
+    return orderingIsGreater(result);
+  }
+  __name(greaterThan, "greaterThan");
+
   // src/lib/indexOf.ts
   function indexOf(iterable, value) {
     let index = 0;
@@ -407,6 +527,21 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(indexOf, "indexOf");
 
+  // src/lib/inspect.ts
+  function inspect(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      const result = iterator.next();
+      if (!result.done) {
+        callbackFn(result.value, index++);
+      }
+      return result;
+    });
+  }
+  __name(inspect, "inspect");
+
   // src/lib/intersect.ts
   function intersect(first2, second) {
     const set = new Set(toIterableIterator(second));
@@ -414,12 +549,78 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(intersect, "intersect");
 
+  // src/lib/intersperse.ts
+  function intersperse(iterable, separator) {
+    let started = false;
+    let nextItem;
+    let nextItemTaken = false;
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      if (started) {
+        if (nextItemTaken) {
+          nextItemTaken = false;
+          return { done: false, value: nextItem };
+        }
+        const result = iterator.next();
+        if (result.done) {
+          return { done: true, value: void 0 };
+        }
+        nextItem = result.value;
+        nextItemTaken = true;
+        return { done: false, value: separator };
+      }
+      started = true;
+      return iterator.next();
+    });
+  }
+  __name(intersperse, "intersperse");
+
   // src/lib/isEmpty.ts
   function isEmpty(iterable) {
     return from(iterable).next().done ?? false;
   }
   __name(isEmpty, "isEmpty");
 
+  // src/lib/isSortedBy.ts
+  function isSortedBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const result = iterator.next();
+    if (result.done) return true;
+    let previous = result.value;
+    for (const current of iterator) {
+      const comparison = compareIteratorElements(previous, current, comparator);
+      if (orderingIsGreater(comparison)) return false;
+      previous = current;
+    }
+    return true;
+  }
+  __name(isSortedBy, "isSortedBy");
+
+  // src/lib/isSorted.ts
+  function isSorted(iterable) {
+    return isSortedBy(iterable, defaultCompare);
+  }
+  __name(isSorted, "isSorted");
+
+  // src/lib/isSortedByKey.ts
+  function isSortedByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const result = iterator.next();
+    if (result.done) return true;
+    let previousKey = callbackFn(result.value, 0);
+    let index = 1;
+    for (const current of iterator) {
+      const currentKey = callbackFn(current, index++);
+      const comparison = compareIteratorElements(previousKey, currentKey, comparator);
+      if (orderingIsGreater(comparison)) return false;
+      previousKey = currentKey;
+    }
+    return true;
+  }
+  __name(isSortedByKey, "isSortedByKey");
+
   // src/lib/last.ts
   function last(iterable) {
     let last2;
@@ -430,28 +631,114 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(last, "last");
 
+  // src/lib/lessOrEqualThan.ts
+  function lessOrEqualThan(iterable, other) {
+    const result = compare(iterable, other);
+    return !orderingIsGreater(result);
+  }
+  __name(lessOrEqualThan, "lessOrEqualThan");
+
+  // src/lib/lessThan.ts
+  function lessThan(iterable, other) {
+    const result = compare(iterable, other);
+    return orderingIsLess(result);
+  }
+  __name(lessThan, "lessThan");
+
+  // src/lib/maxBy.ts
+  function maxBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let maximum = first2.value;
+    for (const value of iterator) {
+      const comparison = compareIteratorElements(value, maximum, comparator);
+      if (!orderingIsLess(comparison)) {
+        maximum = value;
+      }
+    }
+    return maximum;
+  }
+  __name(maxBy, "maxBy");
+
   // 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;
+    return maxBy(iterable, defaultCompare);
   }
   __name(max, "max");
 
+  // src/lib/maxByKey.ts
+  function maxByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let maximum = first2.value;
+    let maximumKey = callbackFn(maximum, 0);
+    let index = 1;
+    for (const value of iterator) {
+      const key = callbackFn(value, index++);
+      const comparison = compareIteratorElements(maximumKey, key, comparator);
+      if (!orderingIsGreater(comparison)) {
+        maximum = value;
+        maximumKey = key;
+      }
+    }
+    return maximum;
+  }
+  __name(maxByKey, "maxByKey");
+
+  // src/lib/minBy.ts
+  function minBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let minimum = first2.value;
+    for (const value of iterator) {
+      const comparison = compareIteratorElements(value, minimum, comparator);
+      if (!orderingIsGreater(comparison)) {
+        minimum = value;
+      }
+    }
+    return minimum;
+  }
+  __name(minBy, "minBy");
+
   // 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;
+    return minBy(iterable, defaultCompare);
   }
   __name(min, "min");
 
+  // src/lib/minByKey.ts
+  function minByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let minimum = first2.value;
+    let minimumKey = callbackFn(minimum, 0);
+    let index = 1;
+    for (const value of iterator) {
+      const key = callbackFn(value, index++);
+      const comparison = compareIteratorElements(minimumKey, key, comparator);
+      if (!orderingIsLess(comparison)) {
+        minimum = value;
+        minimumKey = key;
+      }
+    }
+    return minimum;
+  }
+  __name(minByKey, "minByKey");
+
+  // src/lib/notEqual.ts
+  function notEqual(iterable, other) {
+    return !equal(iterable, other);
+  }
+  __name(notEqual, "notEqual");
+
   // src/lib/partition.ts
   function partition(iterable, predicate) {
     predicate = assertFunction(predicate);
@@ -483,8 +770,7 @@ var SapphireIteratorUtilities = (function (exports) {
         return resolvedIterable.next();
       },
       peek() {
-        peeked = peeked ?? resolvedIterable.next();
-        return peeked;
+        return peeked ??= resolvedIterable.next();
       },
       [Symbol.iterator]() {
         return this;
@@ -549,8 +835,7 @@ var SapphireIteratorUtilities = (function (exports) {
     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");
+      if (firstValue.done) throw new TypeError("Reduce of empty iterator with no initial value");
       index = 1;
       accumulator = firstValue.value;
     } else {
@@ -576,10 +861,7 @@ var SapphireIteratorUtilities = (function (exports) {
 
   // src/lib/reverse.ts
   function* reverse(iterable) {
-    const items = [];
-    for (const item of toIterableIterator(iterable)) {
-      items.push(item);
-    }
+    const items = toArray(iterable);
     for (let i = items.length - 1; i >= 0; i--) {
       yield items[i];
     }
@@ -589,10 +871,8 @@ var SapphireIteratorUtilities = (function (exports) {
   // 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);
+    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(() => {
@@ -629,25 +909,11 @@ var SapphireIteratorUtilities = (function (exports) {
       }
       return take(takeLast(iterable, -start), end - start);
     }
-    if (start >= end)
-      return empty();
+    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();
@@ -663,6 +929,24 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(starMap, "starMap");
 
+  // src/lib/stepBy.ts
+  function stepBy(iterable, step) {
+    step = assertPositive(toIntegerOrInfinityOrThrow(step), step);
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      const result = iterator.next();
+      if (result.done) {
+        return { done: true, value: void 0 };
+      }
+      for (let i = 0; i < step - 1; i++) {
+        const result2 = iterator.next();
+        if (result2.done) break;
+      }
+      return { done: false, value: result.value };
+    });
+  }
+  __name(stepBy, "stepBy");
+
   // src/lib/sum.ts
   function sum(iterable) {
     let sum2 = 0;
@@ -676,8 +960,7 @@ var SapphireIteratorUtilities = (function (exports) {
   // src/lib/tee.ts
   function tee(iterable, count2) {
     count2 = assertNotNegative(toIntegerOrThrow(count2), count2);
-    if (count2 === 0)
-      return [];
+    if (count2 === 0) return [];
     const entries = [];
     const indexes = toArray(repeat(0, count2));
     const resolvedIterable = from(iterable);
@@ -731,8 +1014,7 @@ var SapphireIteratorUtilities = (function (exports) {
     }
     const size = firstResult.value.length;
     const results = [];
-    for (let i = 0; i < size; i++)
-      results.push([firstResult.value[i]]);
+    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");
@@ -755,8 +1037,7 @@ var SapphireIteratorUtilities = (function (exports) {
       const results = [];
       for (const resolvedIterable of resolvedIterables) {
         const result = resolvedIterable.next();
-        if (result.done)
-          return;
+        if (result.done) return;
         results.push(result.value);
       }
       yield results;
@@ -764,23 +1045,38 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(zip, "zip");
 
+  exports.all = every;
+  exports.any = some;
   exports.append = append;
+  exports.ascNumber = ascNumber;
+  exports.ascString = defaultCompare;
   exports.at = at;
   exports.average = average;
   exports.chain = chain;
   exports.chunk = chunk;
+  exports.collect = toArray;
+  exports.collectInto = collectInto;
   exports.compact = compact;
+  exports.compare = compare;
+  exports.compareBy = compareBy;
   exports.compress = compress;
   exports.concat = append;
   exports.contains = contains;
   exports.count = count;
   exports.cycle = cycle;
+  exports.defaultCompare = defaultCompare;
+  exports.descNumber = descNumber;
+  exports.descString = descString;
   exports.difference = difference;
   exports.drop = drop;
   exports.dropLast = dropLast;
   exports.dropWhile = dropWhile;
   exports.empty = empty;
   exports.enumerate = enumerate;
+  exports.eq = equal;
+  exports.eqBy = equalBy;
+  exports.equal = equal;
+  exports.equalBy = equalBy;
   exports.every = every;
   exports.except = difference;
   exports.filter = filter;
@@ -791,13 +1087,34 @@ var SapphireIteratorUtilities = (function (exports) {
   exports.flatMap = flatMap;
   exports.forEach = forEach;
   exports.from = from;
+  exports.fuse = fuse;
+  exports.ge = greaterOrEqualThan;
+  exports.greaterOrEqualThan = greaterOrEqualThan;
+  exports.greaterThan = greaterThan;
+  exports.gt = greaterThan;
   exports.indexOf = indexOf;
+  exports.inspect = inspect;
   exports.intersect = intersect;
+  exports.intersperse = intersperse;
   exports.isEmpty = isEmpty;
+  exports.isSorted = isSorted;
+  exports.isSortedBy = isSortedBy;
+  exports.isSortedByKey = isSortedByKey;
   exports.last = last;
+  exports.le = lessOrEqualThan;
+  exports.lessOrEqualThan = lessOrEqualThan;
+  exports.lessThan = lessThan;
+  exports.lt = lessThan;
   exports.map = map;
   exports.max = max;
+  exports.maxBy = maxBy;
+  exports.maxByKey = maxByKey;
   exports.min = min;
+  exports.minBy = minBy;
+  exports.minByKey = minByKey;
+  exports.ne = notEqual;
+  exports.notEqual = notEqual;
+  exports.nth = at;
   exports.omit = difference;
   exports.partition = partition;
   exports.peekable = peekable;
@@ -815,6 +1132,7 @@ var SapphireIteratorUtilities = (function (exports) {
   exports.some = some;
   exports.sorted = sorted;
   exports.starMap = starMap;
+  exports.stepBy = stepBy;
   exports.sum = sum;
   exports.take = take;
   exports.takeLast = takeLast;
@@ -830,5 +1148,5 @@ var SapphireIteratorUtilities = (function (exports) {
   return exports;
 
 })({});
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.global.js.map
 //# sourceMappingURL=index.global.js.map