itertools 2.5.0-0 → 2.6.0-0

package/README.md

@@ -45,15 +45,15 @@ function bodies can span multiple lines, in which case the following block will
 remain aesthetically pleasing:
 
 ```ts
-import { map } from 'itertools';
+import { map } from "itertools";
 
 const numbers = [1, 2, 3];
 const squares = map(numbers, (n) => {
-    //
-    // Do something wild with these numbers here
-    //
-    // ...
-    return n * n;
+  //
+  // Do something wild with these numbers here
+  //
+  // ...
+  return n * n;
 });
 ```
 
@@ -61,30 +61,31 @@ const squares = map(numbers, (n) => {
 
 The `itertools` package consists of a few building blocks:
 
--   [Ports of builtins](#ports-of-builtins)
--   [Ports of itertools](#ports-of-itertools)
--   [Ports of more-itertools](#ports-of-more-itertools)
--   [Additions](#additions)
+- [Ports of builtins](#ports-of-builtins)
+- [Ports of itertools](#ports-of-itertools)
+- [Ports of more-itertools](#ports-of-more-itertools)
+- [Additions](#additions)
 
 ### Ports of builtins
 
--   [every](#every)
--   [some](#some)
--   [contains](#contains)
--   [enumerate](#enumerate)
--   [filter](#filter)
--   [iter](#iter)
--   [map](#map)
--   [max](#max)
--   [min](#min)
--   [range](#range)
--   [reduce](#reduce)
--   [sorted](#sorted)
--   [sum](#sum)
--   [zip](#zip)
--   [zip3](#zip3)
-
-<a name="every" href="#every">#</a> <b>every</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+- [every](#every)
+- [some](#some)
+- [contains](#contains)
+- [enumerate](#enumerate)
+- [filter](#filter)
+- [iter](#iter)
+- [map](#map)
+- [max](#max)
+- [min](#min)
+- [range](#range)
+- [reduce](#reduce)
+- [sorted](#sorted)
+- [xrange](#xrange)
+- [sum](#sum)
+- [zip](#zip)
+- [zip3](#zip3)
+
+<a name="every" href="#every">#</a> <b>every</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns true when every of the items in iterable are truthy. An optional key
 function can be used to define what truthiness means for this specific
@@ -106,7 +107,7 @@ every([2, 4, 6], (n) => n % 2 === 0); // => true
 every([2, 4, 5], (n) => n % 2 === 0); // => false
 ```
 
-<a name="some" href="#some">#</a> <b>some</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="some" href="#some">#</a> <b>some</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns true when some of the items in iterable are truthy. An optional key
 function can be used to define what truthiness means for this specific
@@ -124,10 +125,10 @@ Examples with using a key function:
 
 ```ts
 some([1, 4, 5], (n) => n % 2 === 0); // => true
-some([{ name: 'Bob' }, { name: 'Alice' }], (person) => person.name.startsWith('C')); // => false
+some([{ name: "Bob" }, { name: "Alice" }], (person) => person.name.startsWith("C")); // => false
 ```
 
-<a name="contains" href="#contains">#</a> <b>contains</b>(haystack: <i>Iterable&lt;T&gt;</i>, needle: <i>T</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="contains" href="#contains">#</a> <b>contains</b>(haystack: <i>Iterable&lt;T&gt;</i>, needle: <i>T</i>): <i>boolean</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns true when some of the items in the iterable are equal to the target
 object.
@@ -135,13 +136,13 @@ object.
 Examples:
 
 ```ts
-contains([], 'whatever'); // => false
+contains([], "whatever"); // => false
 contains([3], 42); // => false
 contains([3], 3); // => true
 contains([0, 1, 2], 2); // => true
 ```
 
-<a name="enumerate" href="#enumerate">#</a> <b>enumerate</b>(iterable: <i>Iterable&lt;T&gt;</i>, start: <i>number = 0</i>): <i>Iterable&lt;[number, T]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="enumerate" href="#enumerate">#</a> <b>enumerate</b>(iterable: <i>Iterable&lt;T&gt;</i>, start: <i>number = 0</i>): <i>Iterable&lt;[number, T]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns an iterable of enumeration pairs. Iterable must be a sequence, an
 iterator, or some other object which supports iteration. The elements produced
@@ -151,28 +152,28 @@ the values obtained from iterating over given iterable.
 Example:
 
 ```ts
-import { enumerate } from 'itertools';
+import { enumerate } from "itertools";
 
-console.log([...enumerate(['hello', 'world'])]);
+console.log([...enumerate(["hello", "world"])]);
 // [0, 'hello'], [1, 'world']]
 ```
 
-<a name="filter" href="#filter">#</a> <b>filter</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="filter" href="#filter">#</a> <b>filter</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Eager version of [ifilter](#ifilter).
 
-<a name="iter" href="#iter">#</a> <b>iter</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterator&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="iter" href="#iter">#</a> <b>iter</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterator&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns an iterator object for the given iterable. This can be used to
 manually get an iterator for any iterable datastructure. The purpose and main
 use case of this function is to get a single iterator (a thing with state,
 think of it as a "cursor") which can only be consumed once.
 
-<a name="map" href="#map">#</a> <b>map</b>(iterable: _Iterable&lt;T&gt;_, mapper: _(item: T) =&gt; V_): _V[]_ [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="map" href="#map">#</a> <b>map</b>(iterable: _Iterable&lt;T&gt;_, mapper: _(item: T) =&gt; V_): _V[]_ [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Eager version of [imap](#imap).
 
-<a name="max" href="#max">#</a> <b>max</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; number</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="max" href="#max">#</a> <b>max</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; number</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Return the largest item in an iterable. Only works for numbers, as ordering is
 pretty poorly defined on any other data type in JS. The optional `keyFn`
@@ -184,7 +185,7 @@ If the iterable is empty, `undefined` is returned.
 If multiple items are maximal, the function returns either one of them, but
 which one is not defined.
 
-<a name="min" href="#min">#</a> <b>min</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; number</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="min" href="#min">#</a> <b>min</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; number</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Return the smallest item in an iterable. Only works for numbers, as ordering
 is pretty poorly defined on any other data type in JS. The optional `keyFn`
@@ -196,8 +197,8 @@ If the iterable is empty, `undefined` is returned.
 If multiple items are minimal, the function returns either one of them, but
 which one is not defined.
 
-<a name="range" href="#range">#</a> <b>range</b>(stop: <i>number</i>): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')<br />
-<a name="range" href="#range">#</a> <b>range</b>(start: <i>number</i>, stop: <i>number</i>, step: <i>number</i> = 1): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="range" href="#range">#</a> <b>range</b>(stop: <i>number</i>): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")<br />
+<a name="range" href="#range">#</a> <b>range</b>(start: <i>number</i>, stop: <i>number</i>, step: <i>number</i> = 1): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Returns an iterator producing all the numbers in the given range one by one,
 starting from `start` (default 0), as long as `i < stop`, in increments of
@@ -207,11 +208,12 @@ starting from `start` (default 0), as long as `i < stop`, in increments of
 
 Various valid invocations:
 
-    range(5)           // [0, 1, 2, 3, 4]
-    range(0, 5)        // [0, 1, 2, 3, 4]
-    range(0, 5, 2)     // [0, 2, 4]
-    range(5, 0, -1)    // [5, 4, 3, 2, 1]
-    range(-3)          // []
+    range(5)           // 0, 1, 2, 3, 4
+    range(0, 5)        // 0, 1, 2, 3, 4
+    range(0, 5, 2)     // 0, 2, 4
+    range(5, 0, -1)    // 5, 4, 3, 2, 1
+    range(5, 0)        // (empty)
+    range(-3)          // (empty)
 
 For a positive `step`, the iterator will keep producing values `n` as long as
 the stop condition `n < stop` is satisfied.
@@ -222,8 +224,37 @@ the stop condition `n > stop` is satisfied.
 The produced range will be empty if the first value to produce already does not
 meet the value constraint.
 
-<a name="reduce" href="#reduce">#</a> <b>reduce</b>(iterable: <i>Iterable&lt;T&gt;</i>, reducer: <i>(O, T, number) =&gt; O</i>, start: <i>O</i>): <i>O</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')<br />
-<a name="reduce" href="#reduce">#</a> <b>reduce</b>(iterable: <i>Iterable&lt;T&gt;</i>, reducer: <i>(T, T, number) =&gt; T</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="xrange" href="#xrange">#</a> <b>xrange</b>(stop: <i>number</i>): <i>number[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")<br />
+<a name="xrange" href="#xrange">#</a> <b>xrange</b>(start: <i>number</i>, stop: <i>number</i>, step: <i>number</i> = 1): <i>number[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
+
+Returns an array with all the numbers in the given range, starting from
+`start` (default 0), as long as `i < stop`, in increments of `step`
+(default 1).
+
+`xrange(5)` is a convenient shorthand for `Array.from(range(5))`.
+
+Various valid invocations:
+
+    xrange(5)           // [0, 1, 2, 3, 4]
+    xrange(2, 5)        // [2, 3, 4]
+    xrange(0, 5, 2)     // [0, 2, 4]
+    xrange(5, 0, -1)    // [5, 4, 3, 2, 1]
+    xrange(5, 0)        // []
+
+For a positive `step`, the iterator will keep producing values `n` as long as
+the stop condition `n < stop` is satisfied.
+
+For a negative `step`, the iterator will keep producing values `n` as long as
+the stop condition `n > stop` is satisfied.
+
+The produced range will be empty if the first value to produce already does not
+meet the value constraint.
+
+Don't use this on large or infinite ranges, as it will allocate a large array
+in memory.
+
+<a name="reduce" href="#reduce">#</a> <b>reduce</b>(iterable: <i>Iterable&lt;T&gt;</i>, reducer: <i>(O, T, number) =&gt; O</i>, start: <i>O</i>): <i>O</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")<br />
+<a name="reduce" href="#reduce">#</a> <b>reduce</b>(iterable: <i>Iterable&lt;T&gt;</i>, reducer: <i>(T, T, number) =&gt; T</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Apply function of two arguments cumulatively to the items of sequence, from
 left to right, so as to reduce the sequence to a single value. For example:
@@ -249,114 +280,161 @@ it calculates
 
     ((((1+2)+3)+4)+5)
 
-<a name="sorted" href="#sorted">#</a> <b>sorted</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>, reverse?: <i>boolean</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="sorted" href="#sorted">#</a> <b>sorted</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>, reverse?: <i>boolean</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Return a new sorted list from the items in iterable.
 
 Has two optional arguments:
 
--   `keyFn` specifies a function of one argument providing a primitive identity
-    for each element in the iterable. that will be used to compare. The default
-    value is to use a default identity function that is only defined for
-    primitive types.
+- `keyFn` specifies a function of one argument providing a primitive identity
+  for each element in the iterable. that will be used to compare. The default
+  value is to use a default identity function that is only defined for
+  primitive types.
 
--   `reverse` is a boolean value. If `true`, then the list elements are sorted
-    as if each comparison were reversed.
+- `reverse` is a boolean value. If `true`, then the list elements are sorted
+  as if each comparison were reversed.
 
-<a name="sum" href="#sum">#</a> <b>sum</b>(iterable: <i>Iterable&lt;number&gt;</i>): <i>number</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="sum" href="#sum">#</a> <b>sum</b>(iterable: <i>Iterable&lt;number&gt;</i>): <i>number</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Sums the items of an iterable from left to right and returns the total. The
 sum will defaults to 0 if the iterable is empty.
 
-<a name="zip" href="#zip">#</a> <b>zip</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>): <i>[T1, T2][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')<br />
-<a name="zip3" href="#zip3">#</a> <b>zip3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>): <i>[T1, T2, T3][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js 'Source')
+<a name="zip" href="#zip">#</a> <b>zip</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>): <i>[T1, T2][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")<br />
+<a name="zip3" href="#zip3">#</a> <b>zip3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>): <i>[T1, T2, T3][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/builtins.js "Source")
 
 Eager version of [izip](#izip) / [izip3](#izip3).
 
 ### Ports of itertools
 
--   [chain](#chain)
--   [compress](#compress)
--   [count](#count)
--   [cycle](#cycle)
--   [dropwhile](#dropwhile)
--   [groupby](#groupby)
--   [icompress](#icompress)
--   [ifilter](#ifilter)
--   [imap](#imap)
--   [islice](#islice)
--   [izip](#izip)
--   [izip3](#izip3)
--   [izipLongest](#izipLongest)
--   [izipMany](#izipMany)
--   [permutations](#permutations)
--   [repeat](#repeat)
--   [takewhile](#takewhile)
--   [zipLongest](#zipLongest)
--   [zipMany](#zipMany)
-
-<a name="chain" href="#chain">#</a> <b>chain</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+- [chain](#chain)
+- [compress](#compress)
+- [count](#count)
+- [cycle](#cycle)
+- [dropwhile](#dropwhile)
+- [groupBy](#groupBy)
+- [icompress](#icompress)
+- [ifilter](#ifilter)
+- [igroupby](#igroupby)
+- [imap](#imap)
+- [indexBy](#indexBy)
+- [islice](#islice)
+- [izip](#izip)
+- [izip3](#izip3)
+- [izipLongest](#izipLongest)
+- [izipMany](#izipMany)
+- [permutations](#permutations)
+- [repeat](#repeat)
+- [takewhile](#takewhile)
+- [zipLongest](#zipLongest)
+- [zipMany](#zipMany)
+
+<a name="chain" href="#chain">#</a> <b>chain</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that returns elements from the first iterable until it is
 exhausted, then proceeds to the next iterable, until all of the iterables are
 exhausted. Used for treating consecutive sequences as a single sequence.
 
-<a name="compress" href="#compress">#</a> <b>compress</b>(iterable: <i>Iterable&lt;T&gt;</i>, selectors: <i>Iterable&lt;boolean&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="compress" href="#compress">#</a> <b>compress</b>(iterable: <i>Iterable&lt;T&gt;</i>, selectors: <i>Iterable&lt;boolean&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Eager version of [icompress](#icompress).
 
-<a name="count" href="#count">#</a> <b>count</b>(start: <i>number</i>, step: <i>number</i>): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="count" href="#count">#</a> <b>count</b>(start: <i>number</i>, step: <i>number</i>): <i>Iterable&lt;number&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that counts up values starting with number `start` (default
 0), incrementing by `step`. To decrement, use a negative step number.
 
-<a name="cycle" href="#cycle">#</a> <b>cycle</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="cycle" href="#cycle">#</a> <b>cycle</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator producing elements from the iterable and saving a copy of
 each. When the iterable is exhausted, return elements from the saved copy.
 Repeats indefinitely.
 
-<a name="dropwhile" href="#dropwhile">#</a> <b>dropwhile</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>(item: T) =&gt; boolean</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="dropwhile" href="#dropwhile">#</a> <b>dropwhile</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>(item: T) =&gt; boolean</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that drops elements from the iterable as long as the
 predicate is true; afterwards, returns every remaining element. **Note:** the
 iterator does not produce any output until the predicate first becomes false.
 
-<a name="groupby" href="#groupby">#</a> <b>groupby</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFcn: <i>(item: T) =&gt; Primitive</i>): <i>Iterable&lt;[Primitive, Iterable&lt;T&gt;]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="groupBy" href="#groupBy">#</a> <b>groupBy</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn: <i>(item: T) =&gt; K</i>): <i>Record&lt;K, T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
+
+Groups elements of the iterable into a record based on the key function. Each
+key maps to an array of all elements that share the same key.
+
+```ts
+const users = [
+  { name: "Alice", department: "Engineering" },
+  { name: "Bob", department: "Sales" },
+  { name: "Charlie", department: "Engineering" },
+];
+
+groupBy(users, (user) => user.department);
+// {
+//   'Engineering': [
+//     { name: 'Alice', department: 'Engineering' },
+//     { name: 'Charlie', department: 'Engineering' }
+//   ],
+//   'Sales': [
+//     { name: 'Bob', department: 'Sales' }
+//   ]
+// }
+```
+
+<a name="icompress" href="#icompress">#</a> <b>icompress</b>(iterable: <i>Iterable&lt;T&gt;</i>, selectors: <i>Iterable&lt;boolean&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
+
+Returns an iterator that filters elements from data returning only those that
+have a corresponding element in selectors that evaluates to `true`. Stops when
+either the data or selectors iterables has been exhausted.
+
+<a name="ifilter" href="#ifilter">#</a> <b>ifilter</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
+
+Returns an iterator that filters elements from iterable returning only those
+for which the predicate is true.
+
+<a name="igroupby" href="#igroupby">#</a> <b>igroupby</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn: <i>(item: T) =&gt; Primitive</i>): <i>Iterable&lt;[Primitive, Iterable&lt;T&gt;]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Make an Iterable that returns consecutive keys and groups from the iterable.
 The key is a function computing a key value for each element. If not specified,
 key defaults to an identity function and returns the element unchanged.
 Generally, the iterable needs to already be sorted on the same key function.
 
-The operation of `groupby()` is similar to the `uniq` filter in Unix. It
+The operation of `igroupby()` is similar to the `uniq` filter in Unix. It
 generates a break or new group every time the value of the key function changes
 (which is why it is usually necessary to have sorted the data using the same
 key function). That behavior differs from `SQL`’s `GROUP BY` which aggregates
 common elements regardless of their input order.
 
 The returned group is itself an iterator that shares the underlying iterable
-with `groupby()`. Because the source is shared, when the `groupby()` object is
+with `igroupby()`. Because the source is shared, when the `igroupby()` object is
 advanced, the previous group is no longer visible. So, if that data is needed
 later, it should be stored as an array.
 
-<a name="icompress" href="#icompress">#</a> <b>icompress</b>(iterable: <i>Iterable&lt;T&gt;</i>, selectors: <i>Iterable&lt;boolean&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="imap" href="#imap">#</a> <b>imap</b>(iterable: <i>Iterable&lt;T&gt;</i>, mapper: <i>(item: T) =&gt; V</i>): <i>Iterable&lt;V&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
-Returns an iterator that filters elements from data returning only those that
-have a corresponding element in selectors that evaluates to `true`. Stops when
-either the data or selectors iterables has been exhausted.
-
-<a name="ifilter" href="#ifilter">#</a> <b>ifilter</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+Returns an iterator that computes the given mapper function using arguments
+from each of the iterables.
 
-Returns an iterator that filters elements from iterable returning only those
-for which the predicate is true.
+<a name="indexBy" href="#indexBy">#</a> <b>indexBy</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn: <i>(item: T) =&gt; K</i>): <i>Record&lt;K, T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
-<a name="imap" href="#imap">#</a> <b>imap</b>(iterable: <i>Iterable&lt;T&gt;</i>, mapper: <i>(item: T) =&gt; V</i>): <i>Iterable&lt;V&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+Creates an index (record) from the iterable where each key maps to the last
+element that produced that key. If multiple elements produce the same key, only
+the last one is kept.
 
-Returns an iterator that computes the given mapper function using arguments
-from each of the iterables.
+```ts
+const users = [
+  { id: 1, name: "Alice" },
+  { id: 2, name: "Bob" },
+  { id: 3, name: "Charlie" },
+];
+
+indexBy(users, (user) => user.id);
+// {
+//   1: { id: 1, name: 'Alice' },
+//   2: { id: 2, name: 'Bob' },
+//   3: { id: 3, name: 'Charlie' }
+// }
+```
 
-<a name="islice" href="#islice">#</a> <b>islice</b>(iterable: <i>Iterable&lt;T&gt;</i>[start: <i>number</i>], stop: <i>number</i>[, step: <i>number</i>]): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="islice" href="#islice">#</a> <b>islice</b>(iterable: <i>Iterable&lt;T&gt;</i>[start: <i>number</i>], stop: <i>number</i>[, step: <i>number</i>]): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that returns selected elements from the iterable. If
 `start` is non-zero, then elements from the iterable are skipped until start is
@@ -366,27 +444,27 @@ then iteration continues until the iterator reached that index, otherwise, the
 iterable will be fully exhausted. `islice()` does not support negative values
 for `start`, `stop`, or `step`.
 
-<a name="izip" href="#izip">#</a> <b>izip</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>): <i>Iterable&lt;[T1, T2]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')<br />
-<a name="izip3" href="#izip3">#</a> <b>izip3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>): <i>Iterable&lt;[T1, T2, T3]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="izip" href="#izip">#</a> <b>izip</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>): <i>Iterable&lt;[T1, T2]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")<br />
+<a name="izip3" href="#izip3">#</a> <b>izip3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>): <i>Iterable&lt;[T1, T2, T3]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that aggregates elements from each of the iterables. Used
 for lock-step iteration over several iterables at a time. When iterating over
 two iterables, use `izip2`. When iterating over three iterables, use `izip3`,
 etc. `izip` is an alias for `izip2`.
 
-<a name="izipLongest" href="izipLongest">#</a> <b>izipLongest</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, filler?: <i>D</i>): <i>Iterable&lt;[T1 | D, T2 | D]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')<br />
-<a name="izipLongest3" href="izipLongest3">#</a> <b>izipLongest3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>, filler?: <i>D</i>): <i>Iterable&lt;[T1 | D, T2 | D, T3 | D]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="izipLongest" href="izipLongest">#</a> <b>izipLongest</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, filler?: <i>D</i>): <i>Iterable&lt;[T1 | D, T2 | D]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")<br />
+<a name="izipLongest3" href="izipLongest3">#</a> <b>izipLongest3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>, filler?: <i>D</i>): <i>Iterable&lt;[T1 | D, T2 | D, T3 | D]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that aggregates elements from each of the iterables. If the
 iterables are of uneven length, missing values are filled-in with fillvalue.
 Iteration continues until the longest iterable is exhausted.
 
-<a name="izipMany" href="#izipMany">#</a> <b>izipMany</b>(...iters: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="izipMany" href="#izipMany">#</a> <b>izipMany</b>(...iters: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Like the other izips (`izip`, `izip3`, etc), but generalized to take an
 unlimited amount of input iterables. Think `izip(*iterables)` in Python.
 
-<a name="permutations" href="#permutations">#</a> <b>permutations</b>(iterable: <i>Iterable&lt;T&gt;</i>, r: number = undefined): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="permutations" href="#permutations">#</a> <b>permutations</b>(iterable: <i>Iterable&lt;T&gt;</i>, r: number = undefined): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Return successive `r`-length permutations of elements in the iterable.
 
@@ -400,41 +478,41 @@ Elements are treated as unique based on their position, not on their value. So
 if the input elements are unique, there will be no repeat values in each
 permutation.
 
-<a name="repeat" href="#repeat">#</a> <b>repeat</b>(thing: <i>T</i>, times: number = undefined): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="repeat" href="#repeat">#</a> <b>repeat</b>(thing: <i>T</i>, times: number = undefined): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that produces values over and over again. Runs
 indefinitely unless the times argument is specified.
 
-<a name="takewhile" href="#takewhile">#</a> <b>takewhile</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>(item: T) =&gt; boolean</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="takewhile" href="#takewhile">#</a> <b>takewhile</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>(item: T) =&gt; boolean</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Returns an iterator that produces elements from the iterable as long as the
 predicate is true.
 
-<a name="zipLongest" href="zipLongest">#</a> <b>zipLongest</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, filler?: <i>D</i>): <i>[T1 | D, T2 | D][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')<br />
-<a name="zipLongest3" href="zipLongest3">#</a> <b>zipLongest3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>, filler?: <i>D</i>): <i>[T1 | D, T2 | D, T3 | D][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="zipLongest" href="zipLongest">#</a> <b>zipLongest</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, filler?: <i>D</i>): <i>[T1 | D, T2 | D][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")<br />
+<a name="zipLongest3" href="zipLongest3">#</a> <b>zipLongest3</b>(xs: <i>Iterable&lt;T1&gt;</i>, ys: <i>Iterable&lt;T2&gt;</i>, zs: <i>Iterable&lt;T3&gt;</i>, filler?: <i>D</i>): <i>[T1 | D, T2 | D, T3 | D][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Eager version of [izipLongest](#izipLongest) and friends.
 
-<a name="zipMany" href="#zipMany">#</a> <b>zipMany</b>(...iters: <i>Iterable&lt;T&gt;[]</i>): <i>T[][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js 'Source')
+<a name="zipMany" href="#zipMany">#</a> <b>zipMany</b>(...iters: <i>Iterable&lt;T&gt;[]</i>): <i>T[][]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/itertools.js "Source")
 
 Eager version of [izipMany](#izipMany).
 
 ### Ports of more-itertools
 
--   [chunked](#chunked)
--   [flatten](#flatten)
--   [intersperse](#intersperse)
--   [itake](#itake)
--   [pairwise](#pairwise)
--   [partition](#partition)
--   [roundrobin](#roundrobin)
--   [heads](#heads)
--   [take](#take)
--   [uniqueEverseen](#uniqueEverseen)
--   [uniqueJustseen](#uniqueJustseen)
--   [dupes](#dupes)
-
-<a name="chunked" href="#chunked">#</a> <b>chunked</b>(iterable: <i>Iterable&lt;T&gt;</i>, size: <i>number</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+- [chunked](#chunked)
+- [flatten](#flatten)
+- [intersperse](#intersperse)
+- [itake](#itake)
+- [pairwise](#pairwise)
+- [partition](#partition)
+- [roundrobin](#roundrobin)
+- [heads](#heads)
+- [take](#take)
+- [uniqueEverseen](#uniqueEverseen)
+- [uniqueJustseen](#uniqueJustseen)
+- [dupes](#dupes)
+
+<a name="chunked" href="#chunked">#</a> <b>chunked</b>(iterable: <i>Iterable&lt;T&gt;</i>, size: <i>number</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Break iterable into lists of length `size`:
 
@@ -447,26 +525,26 @@ list will be shorter:
     >>> [...chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)]
     [[1, 2, 3], [4, 5, 6], [7, 8]]
 
-<a name="flatten" href="#flatten">#</a> <b>flatten</b>(iterableOfIterables: <i>Iterable&lt;Iterable&lt;T&gt;&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="flatten" href="#flatten">#</a> <b>flatten</b>(iterableOfIterables: <i>Iterable&lt;Iterable&lt;T&gt;&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Return an iterator flattening one level of nesting in a list of lists:
 
     >>> [...flatten([[0, 1], [2, 3]])]
     [0, 1, 2, 3]
 
-<a name="intersperse" href="#intersperse">#</a> <b>intersperse</b>(value: T, iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="intersperse" href="#intersperse">#</a> <b>intersperse</b>(value: T, iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Intersperse filler element `value` among the items in `iterable`.
 
     >>> [...intersperse(-1, range(1, 5))]
     [1, -1, 2, -1, 3, -1, 4]
 
-<a name="itake" href="#itake">#</a> <b>itake</b>(n: <i>number</i>, iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="itake" href="#itake">#</a> <b>itake</b>(n: <i>number</i>, iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Returns an iterable containing only the first `n` elements of the given
 iterable.
 
-<a name="pairwise" href="#pairwise">#</a> <b>pairwise</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;[T, T]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="pairwise" href="#pairwise">#</a> <b>pairwise</b>(iterable: <i>Iterable&lt;T&gt;</i>): <i>Iterable&lt;[T, T]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Returns an iterator of paired items, overlapping, from the original. When the
 input iterable has a finite number of items `n`, the outputted iterable will
@@ -475,7 +553,7 @@ have `n - 1` items.
     >>> pairwise([8, 2, 0, 7])
     [(8, 2), (2, 0), (0, 7)]
 
-<a name="partition" href="#partition">#</a> <b>partition</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>[T[], T[]]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="partition" href="#partition">#</a> <b>partition</b>(iterable: <i>Iterable&lt;T&gt;</i>, predicate: <i>Predicate&lt;T&gt;</i>): <i>[T[], T[]]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Returns a 2-tuple of arrays. Splits the elements in the input iterable into
 either of the two arrays. Will fully exhaust the input iterable. The first
@@ -489,7 +567,7 @@ array contains all items that match the predicate, the second the rest:
     >>> evens
     [0, 2, 4, 6, 8]
 
-<a name="roundrobin" href="#roundrobin">#</a> <b>roundrobin</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="roundrobin" href="#roundrobin">#</a> <b>roundrobin</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Yields the next item from each iterable in turn, alternating between them.
 Continues until all items are exhausted.
@@ -497,18 +575,18 @@ Continues until all items are exhausted.
     >>> [...roundrobin([1, 2, 3], [4], [5, 6, 7, 8])]
     [1, 4, 5, 2, 6, 3, 7, 8]
 
-<a name="heads" href="#heads">#</a> <b>heads</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="heads" href="#heads">#</a> <b>heads</b>(...iterables: <i>Iterable&lt;T&gt;[]</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Like `roundrobin()`, but will group the output per "round".
 
     >>> [...heads([1, 2, 3], [4], [5, 6, 7, 8])]
     [[1, 4, 5], [2, 6], [3, 7], [8]]
 
-<a name="take" href="#take">#</a> <b>take</b>(n: <i>number</i>, iterable: <i>Iterable&lt;T&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="take" href="#take">#</a> <b>take</b>(n: <i>number</i>, iterable: <i>Iterable&lt;T&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Eager version of [itake](#itake).
 
-<a name="uniqueEverseen" href="#uniqueEverseen">#</a> <b>uniqueEverseen</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="uniqueEverseen" href="#uniqueEverseen">#</a> <b>uniqueEverseen</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Yield unique elements, preserving order.
 
@@ -517,7 +595,7 @@ Yield unique elements, preserving order.
     >>> [...uniqueEverseen('AbBCcAB', s => s.toLowerCase())]
     ['A', 'b', 'C']
 
-<a name="uniqueJustseen" href="#uniqueJustseen">#</a> <b>uniqueJustseen</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="uniqueJustseen" href="#uniqueJustseen">#</a> <b>uniqueJustseen</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Yields elements in order, ignoring serial duplicates.
 
@@ -526,7 +604,7 @@ Yields elements in order, ignoring serial duplicates.
     >>> [...uniqueJustseen('AbBCcAB', s => s.toLowerCase())]
     ['A', 'b', 'C', 'A', 'B']
 
-<a name="dupes" href="#dupes">#</a> <b>dupes</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js 'Source')
+<a name="dupes" href="#dupes">#</a> <b>dupes</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>(item: T) =&gt; Primitive</i></i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/more-itertools.js "Source")
 
 Yield only elements from the input that occur more than once. Needs to consume the entire input before being able to produce the first result.
 
@@ -537,31 +615,31 @@ Yield only elements from the input that occur more than once. Needs to consume t
 
 ### Additions
 
--   [compact](#compact)
--   [compactObject](#compactObject)
--   [find](#find)
--   [first](#first)
--   [flatmap](#flatmap)
--   [icompact](#icompact)
+- [compact](#compact)
+- [compactObject](#compactObject)
+- [find](#find)
+- [first](#first)
+- [flatmap](#flatmap)
+- [icompact](#icompact)
 
-<a name="compact" href="#compact">#</a> <b>compact</b>(iterable: <i>Iterable&lt;T | null | undefined&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="compact" href="#compact">#</a> <b>compact</b>(iterable: <i>Iterable&lt;T | null | undefined&gt;</i>): <i>T[]</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Eager version of [icompact](#icompact).
 
-<a name="compactObject" href="#compactObject">#</a> <b>compactObject</b>(obj: <i>Record&lt;K, V | null | undefined&gt;</i>): <i>Record&lt;K, V&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="compactObject" href="#compactObject">#</a> <b>compactObject</b>(obj: <i>Record&lt;K, V | null | undefined&gt;</i>): <i>Record&lt;K, V&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Removes all "nullish" values from the given object. Returns a new object.
 
     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })
     { a: 1, c: 0, d: null }
 
-<a name="find" href="#find">#</a> <b>find</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="find" href="#find">#</a> <b>find</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Returns the first item in the iterable for which the predicate holds, if any.
 If no such item exists, `undefined` is returned. If no default predicate is
 given, the first value from the iterable is returned.
 
-<a name="first" href="#first">#</a> <b>first</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="first" href="#first">#</a> <b>first</b>(iterable: <i>Iterable&lt;T&gt;</i>, keyFn?: <i>Predicate&lt;T&gt;</i>): <i>T | undefined</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Almost the same as `find()`, except when no explicit predicate function is
 given. `find()` will always return the first value in the iterable, whereas
@@ -569,7 +647,7 @@ given. `find()` will always return the first value in the iterable, whereas
 
 Prefer using `find()`, as its behavior is more intuitive and predictable.
 
-<a name="flatmap" href="#flatmap">#</a> <b>flatmap</b>(iterable: <i>Iterable&lt;T&gt;</i>, mapper: <i>(item: T) =&gt; Iterable&lt;S&gt;</i>): <i>Iterable&lt;S&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="flatmap" href="#flatmap">#</a> <b>flatmap</b>(iterable: <i>Iterable&lt;T&gt;</i>, mapper: <i>(item: T) =&gt; Iterable&lt;S&gt;</i>): <i>Iterable&lt;S&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Returns 0 or more values for every value in the given iterable. Technically,
 it's just calling map(), followed by flatten(), but it's a very useful
@@ -583,7 +661,7 @@ For example, to return all numbers `n` in the input iterable `n` times:
     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]
     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0
 
-<a name="icompact" href="#icompact">#</a> <b>icompact</b>(iterable: <i>Iterable&lt;T | null | undefined&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js 'Source')
+<a name="icompact" href="#icompact">#</a> <b>icompact</b>(iterable: <i>Iterable&lt;T | null | undefined&gt;</i>): <i>Iterable&lt;T&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Returns an iterable, filtering out any "nullish" values from the input
 iterable.