itertools 2.6.0-0 → 2.6.0

package/README.md

@@ -85,6 +85,8 @@ The `itertools` package consists of a few building blocks:
 - [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
@@ -107,6 +109,8 @@ 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")
 
 Returns true when some of the items in iterable are truthy. An optional key
@@ -128,6 +132,8 @@ some([1, 4, 5], (n) => n % 2 === 0); // => true
 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")
 
 Returns true when some of the items in the iterable are equal to the target
@@ -142,6 +148,8 @@ 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")
 
 Returns an iterable of enumeration pairs. Iterable must be a sequence, an
@@ -158,10 +166,14 @@ 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")
 
 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")
 
 Returns an iterator object for the given iterable. This can be used to
@@ -169,10 +181,14 @@ 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")
 
 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")
 
 Return the largest item in an iterable. Only works for numbers, as ordering is
@@ -185,6 +201,8 @@ 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")
 
 Return the smallest item in an iterable. Only works for numbers, as ordering
@@ -197,6 +215,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")
 
@@ -224,6 +244,8 @@ 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="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")
 
@@ -253,6 +275,8 @@ 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")
 
@@ -280,6 +304,8 @@ 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")
 
 Return a new sorted list from the items in iterable.
@@ -294,11 +320,15 @@ Has two optional arguments:
 - `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")
 
 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")
 
@@ -328,33 +358,45 @@ Eager version of [izip](#izip) / [izip3](#izip3).
 - [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")
 
 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")
 
 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")
 
 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")
 
 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>, 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
@@ -379,17 +421,23 @@ groupBy(users, (user) => user.department);
 // }
 ```
 
+---
+
 <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.
@@ -408,11 +456,15 @@ 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="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 computes the given mapper function using arguments
 from each of the iterables.
 
+---
+
 <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")
 
 Creates an index (record) from the iterable where each key maps to the last
@@ -434,6 +486,8 @@ indexBy(users, (user) => user.id);
 // }
 ```
 
+---
+
 <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
@@ -444,6 +498,8 @@ 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")
 
@@ -452,6 +508,8 @@ 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")
 
@@ -459,11 +517,15 @@ 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")
 
 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")
 
 Return successive `r`-length permutations of elements in the iterable.
@@ -478,25 +540,35 @@ 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")
 
 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")
 
 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")
 
 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")
 
 Eager version of [izipMany](#izipMany).
 
+---
+
 ### Ports of more-itertools
 
 - [chunked](#chunked)
@@ -512,6 +584,8 @@ Eager version of [izipMany](#izipMany).
 - [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`:
@@ -525,6 +599,8 @@ 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")
 
 Return an iterator flattening one level of nesting in a list of lists:
@@ -532,6 +608,8 @@ 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")
 
 Intersperse filler element `value` among the items in `iterable`.
@@ -539,11 +617,15 @@ 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")
 
 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")
 
 Returns an iterator of paired items, overlapping, from the original. When the
@@ -553,6 +635,8 @@ 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")
 
 Returns a 2-tuple of arrays. Splits the elements in the input iterable into
@@ -567,6 +651,8 @@ 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")
 
 Yields the next item from each iterable in turn, alternating between them.
@@ -575,6 +661,8 @@ 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")
 
 Like `roundrobin()`, but will group the output per "round".
@@ -582,10 +670,14 @@ 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")
 
 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")
 
 Yield unique elements, preserving order.
@@ -595,6 +687,8 @@ 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")
 
 Yields elements in order, ignoring serial duplicates.
@@ -604,6 +698,8 @@ 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")
 
 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.
@@ -613,6 +709,8 @@ Yield only elements from the input that occur more than once. Needs to consume t
     >>> [...dupes('AbBCcAB', s => s.toLowerCase())]
     [['b', 'B', 'B'], ['C', 'c'], ['A', 'A']]
 
+---
+
 ### Additions
 
 - [compact](#compact)
@@ -622,10 +720,14 @@ Yield only elements from the input that occur more than once. Needs to consume t
 - [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")
 
 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")
 
 Removes all "nullish" values from the given object. Returns a new object.
@@ -633,12 +735,16 @@ 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")
 
 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")
 
 Almost the same as `find()`, except when no explicit predicate function is
@@ -647,6 +753,8 @@ 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")
 
 Returns 0 or more values for every value in the given iterable. Technically,
@@ -661,6 +769,8 @@ 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")
 
 Returns an iterable, filtering out any "nullish" values from the input

package/dist/index.cjs

@@ -174,7 +174,7 @@ function* uniqueJustseen(iterable, keyFn = primitiveIdentity) {
 }
 
 // src/itertools.ts
-var SENTINEL = Symbol();
+var SENTINEL = /* @__PURE__ */ Symbol();
 function chain(...iterables) {
   return flatten(iterables);
 }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/nvie/Projects/itertools/dist/index.cjs","../src/utils.ts","../src/more-itertools.ts","../src/itertools.ts","../src/builtins.ts","../src/custom.ts"],"names":[],"mappings":"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,EAAA;AACW,IAAA;AACxC,EAAA;AACO,EAAA;AACT;AAE0G;AAChF,EAAA;AACH,EAAA;AACI,EAAA;AAChB,IAAA;AACF,EAAA;AAC4B,IAAA;AACnC,EAAA;AACF;AAiBkC;AAGE,EAAA;AACP,EAAA;AAEd,EAAA;AACI,IAAA;AACjB,EAAA;AAEO,EAAA;AACT;AAMwD;AACZ,EAAA;AAC5C;AAK4E;AAC5C,EAAA;AAChC;AAKuG;AAClE,EAAA;AACrC;AJsOgD;AACA;AKrjBC;AACnC,EAAA;AACd;AAEwC;AACzB,EAAA;AACf;AAU2F;AACvD,EAAA;AACpC;AAU0E;AACpC,EAAA;AACtC;AASuG;AACrF,EAAA;AAC8B,EAAA;AAC9B,IAAA;AACK,IAAA;AACE,MAAA;AACrB,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAQqF;AAC3C,EAAA;AAC1C;AAgB4G;AACrE,EAAA;AACvC;ALsgBgD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/Users/nvie/Projects/itertools/dist/index.cjs","sourcesContent":[null,"import type { Primitive } from \"./types\";\n\ntype CmpFn<T> = (a: T, b: T) => number;\n\nexport function keyToCmp<T>(keyFn: (item: T) => Primitive): CmpFn<T> {\n  return (a: T, b: T) => {\n    const ka = keyFn(a);\n    const kb = keyFn(b);\n    // istanbul ignore else -- @preserve\n    if (typeof ka === \"boolean\" && typeof kb === \"boolean\") {\n      return ka === kb ? 0 : !ka && kb ? -1 : 1;\n    } else if (typeof ka === \"number\" && typeof kb === \"number\") {\n      return ka - kb;\n    } else if (typeof ka === \"string\" && typeof kb === \"string\") {\n      return ka === kb ? 0 : ka < kb ? -1 : 1;\n    } else {\n      return -1;\n    }\n  };\n}\n\nexport function identityPredicate(x: unknown): boolean {\n  return !!x;\n}\n\nexport function numberIdentity(x: unknown): number {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"number\") {\n    throw new Error(\"Inputs must be numbers\");\n  }\n  return x;\n}\n\nexport function primitiveIdentity<P extends Primitive>(x: P): P;\nexport function primitiveIdentity(x: unknown): Primitive;\nexport function primitiveIdentity(x: unknown): Primitive {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"string\" && typeof x !== \"number\" && typeof x !== \"boolean\") {\n    throw new Error(\"Please provide a key function that can establish object identity\");\n  }\n  return x;\n}\n","import { iter, map } from \"./builtins\";\nimport { izip, repeat } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\n/**\n * Break iterable into lists of length `size`:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6], 3)]\n *     // [[1, 2, 3], [4, 5, 6]]\n *\n * If the length of iterable is not evenly divisible by `size`, the last returned\n * list will be shorter:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)]\n *     // [[1, 2, 3], [4, 5, 6], [7, 8]]\n */\nexport function* chunked<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]> {\n  if (size < 1) {\n    throw new Error(`Invalid chunk size: ${size}`);\n  }\n\n  const it = iter(iterable);\n  for (;;) {\n    const chunk = take(size, it);\n    if (chunk.length > 0) {\n      yield chunk;\n    }\n    if (chunk.length < size) {\n      return;\n    }\n  }\n}\n\n/**\n * Return an iterator flattening one level of nesting in a list of lists:\n *\n *     [...flatten([[0, 1], [2, 3]])]\n *     // [0, 1, 2, 3]\n *\n */\nexport function* flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T> {\n  for (const iterable of iterableOfIterables) {\n    for (const item of iterable) {\n      yield item;\n    }\n  }\n}\n\n/**\n * Intersperse filler element `value` among the items in `iterable`.\n *\n *     >>> [...intersperse(-1, range(1, 5))]\n *     [1, -1, 2, -1, 3, -1, 4]\n *\n */\nexport function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V> {\n  const stream = flatten<T | V>(izip(repeat(value), iterable));\n  stream.next(); // eat away and discard the first value from the output\n  return stream;\n}\n\n/**\n * Returns an iterable containing only the first `n` elements of the given\n * iterable.\n */\nexport function* itake<T>(n: number, iterable: Iterable<T>): IterableIterator<T> {\n  const it = iter(iterable);\n  let count = n;\n  while (count-- > 0) {\n    const s = it.next();\n    if (!s.done) {\n      yield s.value;\n    } else {\n      // Iterable exhausted, quit early\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator of paired items, overlapping, from the original.  When\n * the input iterable has a finite number of items `n`, the outputted iterable\n * will have `n - 1` items.\n *\n *     >>> pairwise([8, 2, 0, 7])\n *     [(8, 2), (2, 0), (0, 7)]\n *\n */\nexport function* pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]> {\n  const it = iter(iterable);\n  const first = it.next();\n  if (first.done) {\n    return;\n  }\n\n  let r1: T = first.value;\n  for (const r2 of it) {\n    yield [r1, r2];\n    r1 = r2;\n  }\n}\n\n/**\n * Returns a 2-tuple of arrays.  Splits the elements in the input iterable into\n * either of the two arrays.  Will fully exhaust the input iterable.  The first\n * array contains all items that match the predicate, the second the rest:\n *\n *     >>> const isOdd = x => x % 2 !== 0;\n *     >>> const iterable = range(10);\n *     >>> const [odds, evens] = partition(iterable, isOdd);\n *     >>> odds\n *     [1, 3, 5, 7, 9]\n *     >>> evens\n *     [0, 2, 4, 6, 8]\n *\n */\nexport function partition<T, N extends T>(\n  iterable: Iterable<T>,\n  predicate: (item: T, index: number) => item is N,\n): [N[], Exclude<T, N>[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]] {\n  const good = [];\n  const bad = [];\n\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      good.push(item);\n    } else {\n      bad.push(item);\n    }\n  }\n\n  return [good, bad];\n}\n\n/**\n * Yields the next item from each iterable in turn, alternating between them.\n * Continues until all items are exhausted.\n *\n *     >>> [...roundrobin([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [1, 4, 5, 2, 6, 3, 7, 8]\n */\nexport function* roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        yield result.value;\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n  }\n}\n\n/**\n * Yields the heads of all of the given iterables.  This is almost like\n * `roundrobin()`, except that the yielded outputs are grouped in to the\n * \"rounds\":\n *\n *     >>> [...heads([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [[1, 4, 5], [2, 6], [3, 7], [8]]\n *\n * This is also different from `zipLongest()`, since the number of items in\n * each round can decrease over time, rather than being filled with a filler.\n */\nexport function* heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    const round = [];\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        round.push(result.value);\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n    if (round.length > 0) {\n      yield round;\n    }\n  }\n}\n\n/**\n * Non-lazy version of itake().\n */\nexport function take<T>(n: number, iterable: Iterable<T>): T[] {\n  return Array.from(itake(n, iterable));\n}\n\n/**\n * Yield unique elements, preserving order.\n *\n *     >>> [...uniqueEverseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D']\n *     >>> [...uniqueEverseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C']\n *\n */\nexport function* uniqueEverseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  const seen = new Set();\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      yield item;\n    }\n  }\n}\n\n/**\n * Yield only elements from the input that occur more than once. Needs to\n * consume the entire input before being able to produce the first result.\n *\n *     >>> [...dupes('AAAABCDEEEFABG')]\n *     [['A', 'A', 'A', 'A', 'A'], ['E', 'E', 'E'], ['B', 'B']]\n *     >>> [...dupes('AbBCcAB', s => s.toLowerCase())]\n *     [['b', 'B', 'B'], ['C', 'c'], ['A', 'A']]\n *\n */\nexport function dupes<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T[]> {\n  const multiples = new Map<Primitive, T[]>();\n\n  {\n    const singles = new Map<Primitive, T>();\n    for (const item of iterable) {\n      const key = keyFn(item);\n      if (multiples.has(key)) {\n        multiples.get(key)!.push(item);\n      } else if (singles.has(key)) {\n        multiples.set(key, [singles.get(key)!, item]);\n        singles.delete(key);\n      } else {\n        singles.set(key, item);\n      }\n    }\n  }\n\n  return multiples.values();\n}\n\n/**\n * Yields elements in order, ignoring serial duplicates.\n *\n *     >>> [...uniqueJustseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D', 'A', 'B']\n *     >>> [...uniqueJustseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C', 'A', 'B']\n *\n */\nexport function* uniqueJustseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  let last = undefined;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (key !== last) {\n      yield item;\n      last = key;\n    }\n  }\n}\n","import { every, iter, range } from \"./builtins\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\nconst SENTINEL = Symbol();\n\n/**\n * Returns an iterator that returns elements from the first iterable until it\n * is exhausted, then proceeds to the next iterable, until all of the iterables\n * are exhausted.  Used for treating consecutive sequences as a single\n * sequence.\n */\nexport function chain<T>(...iterables: Iterable<T>[]): IterableIterator<T> {\n  return flatten(iterables);\n}\n\n/**\n * Returns an iterator that counts up values starting with number `start`\n * (default 0), incrementing by `step`.  To decrement, use a negative step\n * number.\n */\nexport function* count(start = 0, step = 1): IterableIterator<number> {\n  let n = start;\n  for (;;) {\n    yield n;\n    n += step;\n  }\n}\n\n/**\n * Non-lazy version of icompress().\n */\nexport function compress<T>(data: Iterable<T>, selectors: Iterable<boolean>): T[] {\n  return Array.from(icompress(data, selectors));\n}\n\n/**\n * Returns an iterator producing elements from the iterable and saving a copy\n * of each.  When the iterable is exhausted, return elements from the saved\n * copy.  Repeats indefinitely.\n */\nexport function* cycle<T>(iterable: Iterable<T>): IterableIterator<T> {\n  const saved = [];\n  for (const element of iterable) {\n    yield element;\n    saved.push(element);\n  }\n\n  while (saved.length > 0) {\n    for (const element of saved) {\n      yield element;\n    }\n  }\n}\n\n/**\n * Returns an iterator that drops elements from the iterable as long as the\n * predicate is true; afterwards, returns every remaining element.  Note, the\n * iterator does not produce any output until the predicate first becomes\n * false.\n */\nexport function* dropwhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) {\n      yield value;\n      break; // we break, so we cannot use a for..of loop!\n    }\n  }\n\n  for (const value of it) {\n    yield value;\n  }\n}\n\n/** @deprecated Please rename to `igroupby`, or use the new eager version `groupBy`. */\nexport const groupby = igroupby;\n\nexport function* igroupby<T, K extends Primitive>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => K = primitiveIdentity,\n): Generator<[K, Generator<T, undefined>], undefined> {\n  const it = iter(iterable);\n\n  let currentValue: T;\n  let currentKey: K = SENTINEL as unknown as K;\n  //                           ^^^^^^^^^^^^^^^ Hack!\n  let targetKey: K = currentKey;\n\n  const grouper = function* grouper(tgtKey: K): Generator<T, undefined> {\n    while (currentKey === tgtKey) {\n      yield currentValue;\n\n      const nextVal = it.next();\n      if (nextVal.done) return;\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n  };\n\n  for (;;) {\n    while (currentKey === targetKey) {\n      const nextVal = it.next();\n      if (nextVal.done) {\n        currentKey = SENTINEL as unknown as K;\n        //                    ^^^^^^^^^^^^^^^ Hack!\n        return;\n      }\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n\n    targetKey = currentKey;\n    yield [currentKey, grouper(targetKey)];\n  }\n}\n\nexport function groupBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!Object.hasOwn(result, key)) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n  return result;\n}\n\nexport function indexBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    result[key] = item;\n  }\n  return result;\n}\n\n/**\n * Returns an iterator that filters elements from data returning only those\n * that have a corresponding element in selectors that evaluates to `true`.\n * Stops when either the data or selectors iterables has been exhausted.\n */\nexport function* icompress<T>(data: Iterable<T>, selectors: Iterable<boolean>): IterableIterator<T> {\n  for (const [d, s] of izip(data, selectors)) {\n    if (s) {\n      yield d;\n    }\n  }\n}\n\n/**\n * Returns an iterator that filters elements from iterable returning only those\n * for which the predicate is true.\n */\nexport function ifilter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): IterableIterator<N>;\nexport function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;\nexport function* ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  for (const value of iterable) {\n    if (predicate(value, index++)) {\n      yield value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that computes the given mapper function using arguments\n * from each of the iterables.\n */\nexport function* imap<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): IterableIterator<V> {\n  for (const value of iterable) {\n    yield mapper(value);\n  }\n}\n\n/**\n * Returns an iterator that returns selected elements from the iterable.  If\n * `start` is non-zero, then elements from the iterable are skipped until start\n * is reached.  Then, elements are returned by making steps of `step` (defaults\n * to 1).  If set to higher than 1, items will be skipped.  If `stop` is\n * provided, then iteration continues until the iterator reached that index,\n * otherwise, the iterable will be fully exhausted.  `islice()` does not\n * support negative values for `start`, `stop`, or `step`.\n */\nexport function islice<T>(iterable: Iterable<T>, stop: number): IterableIterator<T>;\nexport function islice<T>(\n  iterable: Iterable<T>,\n  start: number,\n  stop?: number | null,\n  step?: number,\n): IterableIterator<T>;\nexport function* islice<T>(\n  iterable: Iterable<T>,\n  stopOrStart: number,\n  possiblyStop?: number | null,\n  step = 1,\n): IterableIterator<T> {\n  let start, stop;\n  if (possiblyStop !== undefined) {\n    // islice(iterable, start, stop[, step])\n    start = stopOrStart;\n    stop = possiblyStop;\n  } else {\n    // islice(iterable, stop)\n    start = 0;\n    stop = stopOrStart;\n  }\n\n  if (start < 0) throw new Error(\"start cannot be negative\");\n  if (stop !== null && stop < 0) throw new Error(\"stop cannot be negative\");\n  if (step <= 0) throw new Error(\"step cannot be negative\");\n\n  let i = -1;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (true) {\n    i++;\n    if (stop !== null && i >= stop) return; // early returns, so we cannot use a for..of loop!\n\n    res = it.next();\n    if (res.done) return;\n\n    if (i < start) continue;\n    if ((i - start) % step === 0) {\n      yield res.value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.\n * Used for lock-step iteration over several iterables at a time.  When\n * iterating over two iterables, use `izip2`.  When iterating over three\n * iterables, use `izip3`, etc.  `izip` is an alias for `izip2`.\n */\nexport function* izip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): IterableIterator<[T1, T2]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (!x.done && !y.done) {\n      yield [x.value, y.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Like izip2, but for three input iterables.\n */\nexport function* izip3<T1, T2, T3>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n): IterableIterator<[T1, T2, T3]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (!x.done && !y.done && !z.done) {\n      yield [x.value, y.value, z.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\nexport const izip2 = izip;\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.  If\n * the iterables are of uneven length, missing values are filled-in with\n * fillvalue.  Iteration continues until the longest iterable is exhausted.\n */\nexport function* izipLongest2<T1, T2, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (x.done && y.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_];\n    }\n  }\n}\n\n/**\n * See izipLongest2, but for three.\n */\nexport function* izipLongest3<T1, T2, T3, D = undefined>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D, T3 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (x.done && y.done && z.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_, !z.done ? z.value : filler_];\n    }\n  }\n}\n\n/**\n * Like the other izips (`izip`, `izip3`, etc), but generalized to take an\n * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.\n *\n * **Note:** Due to Flow type system limitations, you can only \"generially\" zip\n * iterables with homogeneous types, so you cannot mix types like <A, B> like\n * you can with izip2().\n */\nexport function* izipMany<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // Make them all iterables\n  const iterables = iters.map(iter);\n\n  for (;;) {\n    const heads: IteratorResult<T, undefined>[] = iterables.map((xs) => xs.next());\n    if (every(heads, (h) => !h.done)) {\n      yield heads.map((h) => h.value as T);\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Return successive `r`-length permutations of elements in the iterable.\n *\n * If `r` is not specified, then `r` defaults to the length of the iterable and\n * all possible full-length permutations are generated.\n *\n * Permutations are emitted in lexicographic sort order.  So, if the input\n * iterable is sorted, the permutation tuples will be produced in sorted order.\n *\n * Elements are treated as unique based on their position, not on their value.\n * So if the input elements are unique, there will be no repeat values in each\n * permutation.\n */\nexport function* permutations<T>(iterable: Iterable<T>, r?: number): IterableIterator<T[]> {\n  const pool = Array.from(iterable);\n  const n = pool.length;\n  const x = r ?? n;\n\n  if (x > n) {\n    return;\n  }\n\n  let indices: number[] = Array.from(range(n));\n  const cycles: number[] = Array.from(range(n, n - x, -1));\n  const poolgetter = (i: number) => pool[i];\n\n  yield indices.slice(0, x).map(poolgetter);\n\n  while (n > 0) {\n    let cleanExit = true;\n    for (const i of range(x - 1, -1, -1)) {\n      cycles[i] -= 1;\n      if (cycles[i] === 0) {\n        indices = indices\n          .slice(0, i)\n          .concat(indices.slice(i + 1))\n          .concat(indices.slice(i, i + 1));\n        cycles[i] = n - i;\n      } else {\n        const j: number = cycles[i];\n\n        const [p, q] = [indices[indices.length - j], indices[i]];\n        indices[i] = p;\n        indices[indices.length - j] = q;\n        yield indices.slice(0, x).map(poolgetter);\n        cleanExit = false;\n        break;\n      }\n    }\n\n    if (cleanExit) {\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces values over and over again.  Runs\n * indefinitely unless the times argument is specified.\n */\nexport function* repeat<T>(thing: T, times?: number): IterableIterator<T> {\n  if (times === undefined) {\n    for (;;) {\n      yield thing;\n    }\n  } else {\n    for (const _ of range(times)) {\n      yield thing;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces elements from the iterable as long as the\n * predicate is true.\n */\nexport function* takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) return; // early return, so we cannot use for..of loop!\n    yield value;\n  }\n}\n\nexport function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][] {\n  return Array.from(izipLongest2(xs, ys, filler));\n}\n\nexport function zipLongest3<T1, T2, T3, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): [T1 | D, T2 | D, T3 | D][] {\n  return Array.from(izipLongest3(xs, ys, zs, filler));\n}\n\nexport const izipLongest = izipLongest2;\nexport const zipLongest = zipLongest2;\n\nexport function zipMany<T>(...iters: Iterable<T>[]): T[][] {\n  return Array.from(izipMany(...iters));\n}\n","import { count, ifilter, imap, izip, izip3, takewhile } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { identityPredicate, keyToCmp, numberIdentity, primitiveIdentity } from \"./utils\";\n\n/**\n * Returns the first item in the iterable for which the predicate holds, if\n * any. If no predicate is given, it will return the first value returned by\n * the iterable.\n */\nexport function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined {\n  const it = iter(iterable);\n  if (predicate === undefined) {\n    const value = it.next();\n    return value.done ? undefined : value.value;\n  } else {\n    let res: IteratorResult<T>;\n    let i = 0;\n    while (!(res = it.next()).done) {\n      const value = res.value;\n      if (predicate(value, i++)) {\n        return value;\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Returns true when all of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     all([])                           // => true\n *     all([0])                          // => false\n *     all([0, 1, 2])                    // => false\n *     all([1, 2, 3])                    // => true\n *\n * Examples with using a key function:\n *\n *     all([2, 4, 6], n => n % 2 === 0)  // => true\n *     all([2, 4, 5], n => n % 2 === 0)  // => false\n *\n */\nexport function every<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (!predicate(item, index++)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true when some of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     some([])                           // => false\n *     some([0])                          // => false\n *     some([0, 1, null, undefined])      // => true\n *\n * Examples with using a key function:\n *\n *     some([1, 4, 5], n => n % 2 === 0)  // => true\n *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false\n *\n */\nexport function some<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Alias of `every()`.\n */\nexport const all = every;\n\n/**\n * Alias of `some()`.\n */\nexport const any = some;\n\n/**\n * Returns true when any of the items in the iterable are equal to the target object.\n *\n * Examples:\n *\n *     contains([], 'whatever')         // => false\n *     contains([3], 42)                // => false\n *     contains([3], 3)                 // => true\n *     contains([0, 1, 2], 2)           // => true\n *\n */\nexport function contains<T>(haystack: Iterable<T>, needle: T): boolean {\n  return some(haystack, (x) => x === needle);\n}\n\n/**\n * Returns an iterable of enumeration pairs.  Iterable must be a sequence, an\n * iterator, or some other object which supports iteration.  The elements\n * produced by returns a tuple containing a counter value (starting from 0 by\n * default) and the values obtained from iterating over given iterable.\n *\n * Example:\n *\n *     import { enumerate } from 'itertools';\n *\n *     console.log([...enumerate(['hello', 'world'])]);\n *     // [0, 'hello'], [1, 'world']]\n */\nexport function* enumerate<T>(iterable: Iterable<T>, start = 0): IterableIterator<[number, T]> {\n  let index: number = start;\n  for (const value of iterable) {\n    yield [index++, value];\n  }\n}\n\n/**\n * Non-lazy version of ifilter().\n */\nexport function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[] {\n  return Array.from(ifilter(iterable, predicate));\n}\n\n/**\n * Returns an iterator object for the given iterable.  This can be used to\n * manually get an iterator for any iterable datastructure.  The purpose and\n * main use case of this function is to get a single iterator (a thing with\n * state, think of it as a \"cursor\") which can only be consumed once.\n */\nexport function iter<T>(iterable: Iterable<T>): IterableIterator<T> {\n  return iterable[Symbol.iterator]() as IterableIterator<T>;\n  //                                 ^^^^^^^^^^^^^^^^^^^^^^ Not safe!\n}\n\n/**\n * Non-lazy version of imap().\n */\nexport function map<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): V[] {\n  return Array.from(imap(iterable, mapper));\n}\n\n/**\n * Return the largest item in an iterable.  Only works for numbers, as ordering\n * is pretty poorly defined on any other data type in JS.  The optional `keyFn`\n * argument specifies a one-argument ordering function like that used for\n * sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are maximal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function max<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) > keyFn(y) ? x : y));\n}\n\n/**\n * Return the smallest item in an iterable.  Only works for numbers, as\n * ordering is pretty poorly defined on any other data type in JS.  The\n * optional `keyFn` argument specifies a one-argument ordering function like\n * that used for sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are minimal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function min<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) < keyFn(y) ? x : y));\n}\n\n/**\n * Internal helper for the range function\n */\nfunction range_(start: number, stop: number, step: number): IterableIterator<number> {\n  const counter = count(start, step);\n  const pred = step >= 0 ? (n: number) => n < stop : (n: number) => n > stop;\n  return takewhile(counter, pred);\n}\n\n/**\n * Returns an iterator producing all the numbers in the given range one by one,\n * starting from `start` (default 0), as long as `i < stop`, in increments of\n * `step` (default 1).\n *\n * `range(a)` is a convenient shorthand for `range(0, a)`.\n *\n * Various valid invocations:\n *\n *     range(5)           // [0, 1, 2, 3, 4]\n *     range(2, 5)        // [2, 3, 4]\n *     range(0, 5, 2)     // [0, 2, 4]\n *     range(5, 0, -1)    // [5, 4, 3, 2, 1]\n *     range(-3)          // []\n *\n * For a positive `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n < stop` is satisfied.\n *\n * For a negative `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n > stop` is satisfied.\n *\n * The produced range will be empty if the first value to produce already does\n * not meet the value constraint.\n */\nexport function range(stop: number): IterableIterator<number>;\nexport function range(start: number, stop: number, step?: number): IterableIterator<number>;\nexport function range(startOrStop: number, definitelyStop?: number, step = 1): IterableIterator<number> {\n  if (definitelyStop !== undefined) {\n    return range_(startOrStop /* as start */, definitelyStop, step);\n  } else {\n    return range_(0, startOrStop /* as stop */, step);\n  }\n}\n\nexport function xrange(stop: number): number[];\nexport function xrange(start: number, stop: number, step?: number): number[];\nexport function xrange(startOrStop: number, definitelyStop?: number, step = 1): number[] {\n  if (definitelyStop !== undefined) {\n    return Array.from(range_(startOrStop /* as start */, definitelyStop, step));\n  } else {\n    return Array.from(range_(0, startOrStop /* as stop */, step));\n  }\n}\n\n/**\n * Apply function of two arguments cumulatively to the items of sequence, from\n * left to right, so as to reduce the sequence to a single value.  For example:\n *\n *     reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)\n *\n * calculates\n *\n *     (((((0+1)+2)+3)+4)+5)\n *\n * The left argument, `x`, is the accumulated value and the right argument,\n * `y`, is the update value from the sequence.\n *\n * **Difference between `reduce()` and `reduce\\_()`**:  `reduce()` requires an\n * explicit initializer, whereas `reduce_()` will automatically use the first\n * item in the given iterable as the initializer.  When using `reduce()`, the\n * initializer value is placed before the items of the sequence in the\n * calculation, and serves as a default when the sequence is empty.  When using\n * `reduce_()`, and the given iterable is empty, then no default value can be\n * derived and `undefined` will be returned.\n */\nexport function reduce<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined;\nexport function reduce<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O;\nexport function reduce<T, O>(\n  iterable: Iterable<T>,\n  reducer: ((agg: T, item: T, index: number) => T) | ((agg: O, item: T, index: number) => O),\n  start?: O,\n): O | (T | undefined) {\n  if (start === undefined) {\n    return reduce2(iterable, reducer as (agg: T, item: T, index: number) => T);\n  } else {\n    return reduce3(iterable, reducer as (agg: O, item: T, index: number) => O, start);\n  }\n}\n\nfunction reduce3<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O {\n  let output = start;\n  let index = 0;\n  for (const item of iterable) {\n    output = reducer(output, item, index++);\n  }\n  return output;\n}\n\nfunction reduce2<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined {\n  const it = iter(iterable);\n  const start = find(it);\n  if (start === undefined) {\n    return undefined;\n  } else {\n    return reduce3(it, reducer, start);\n  }\n}\n\n/**\n * Return a new sorted list from the items in iterable.\n *\n * Has two optional arguments:\n *\n * * `keyFn` specifies a function of one argument providing a primitive\n *   identity for each element in the iterable.  that will be used to compare.\n *   The default value is to use a default identity function that is only\n *   defined for primitive types.\n *\n * * `reverse` is a boolean value.  If `true`, then the list elements are\n *   sorted as if each comparison were reversed.\n */\nexport function sorted<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n  reverse = false,\n): T[] {\n  const result = Array.from(iterable);\n  result.sort(keyToCmp(keyFn)); // sort in-place\n\n  if (reverse) {\n    result.reverse(); // reverse in-place\n  }\n\n  return result;\n}\n\n/**\n * Sums the items of an iterable from left to right and returns the total.  The\n * sum will defaults to 0 if the iterable is empty.\n */\nexport function sum(iterable: Iterable<number>): number {\n  return reduce(iterable, (x, y) => x + y, 0);\n}\n\n/**\n * See izip.\n */\nexport function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][] {\n  return Array.from(izip(xs, ys));\n}\n\n/**\n * See izip3.\n */\nexport function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][] {\n  return Array.from(izip3(xs, ys, zs));\n}\n","import { find } from \"./builtins\";\nimport { ifilter, imap } from \"./itertools\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate } from \"./types\";\n\nfunction isNullish<T>(x: T): x is NonNullable<T> {\n  return x != null;\n}\n\nfunction isDefined(x: unknown): boolean {\n  return x !== undefined;\n}\n\n/**\n * Returns an iterable, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For an eager version, @see compact().\n */\nexport function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T> {\n  return ifilter(iterable, isNullish);\n}\n\n/**\n * Returns an array, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For a lazy version, @see icompact().\n */\nexport function compact<T>(iterable: Iterable<T | null | undefined>): T[] {\n  return Array.from(icompact(iterable));\n}\n\n/**\n * Removes all \"nullish\" values from the given object. Returns a new object.\n *\n *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })\n *     { a: 1, c: 0 }\n *\n */\nexport function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V> {\n  const result = {} as Record<K, V>;\n  for (const [key, value_] of Object.entries(obj)) {\n    const value = value_ as V | null | undefined;\n    if (value != null) {\n      result[key as K] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Almost an alias of find(). There only is a difference if no key fn is\n * provided. In that case, `find()` will return the first item in the iterable,\n * whereas `first()` will return the first non-`undefined` value in the\n * iterable.\n */\nexport function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined {\n  return find(iterable, keyFn ?? isDefined);\n}\n\n/**\n * Returns 0 or more values for every value in the given iterable.\n * Technically, it's just calling map(), followed by flatten(), but it's a very\n * useful operation if you want to map over a structure, but not have a 1:1\n * input-output mapping.  Instead, if you want to potentially return 0 or more\n * values per input element, use flatmap():\n *\n * For example, to return all numbers `n` in the input iterable `n` times:\n *\n *     >>> const repeatN = n => repeat(n, n);\n *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]\n *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0\n *\n */\nexport function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S> {\n  return flatten(imap(iterable, mapper));\n}\n"]}
+{"version":3,"sources":["/home/runner/work/itertools/itertools/dist/index.cjs","../src/utils.ts","../src/more-itertools.ts","../src/itertools.ts","../src/builtins.ts","../src/custom.ts"],"names":[],"mappings":"AAAA;ACIO,SAAS,QAAA,CAAY,KAAA,EAAyC;AACnE,EAAA,OAAO,CAAC,CAAA,EAAM,CAAA,EAAA,GAAS;AACrB,IAAA,MAAM,GAAA,EAAK,KAAA,CAAM,CAAC,CAAA;AAClB,IAAA,MAAM,GAAA,EAAK,KAAA,CAAM,CAAC,CAAA;AAElB,IAAA,GAAA,CAAI,OAAO,GAAA,IAAO,UAAA,GAAa,OAAO,GAAA,IAAO,SAAA,EAAW;AACtD,MAAA,OAAO,GAAA,IAAO,GAAA,EAAK,EAAA,EAAI,CAAC,GAAA,GAAM,GAAA,EAAK,CAAA,EAAA,EAAK,CAAA;AAAA,IAC1C,EAAA,KAAA,GAAA,CAAW,OAAO,GAAA,IAAO,SAAA,GAAY,OAAO,GAAA,IAAO,QAAA,EAAU;AAC3D,MAAA,OAAO,GAAA,EAAK,EAAA;AAAA,IACd,EAAA,KAAA,GAAA,CAAW,OAAO,GAAA,IAAO,SAAA,GAAY,OAAO,GAAA,IAAO,QAAA,EAAU;AAC3D,MAAA,OAAO,GAAA,IAAO,GAAA,EAAK,EAAA,EAAI,GAAA,EAAK,GAAA,EAAK,CAAA,EAAA,EAAK,CAAA;AAAA,IACxC,EAAA,KAAO;AACL,MAAA,OAAO,CAAA,CAAA;AAAA,IACT;AAAA,EACF,CAAA;AACF;AAEO,SAAS,iBAAA,CAAkB,CAAA,EAAqB;AACrD,EAAA,OAAO,CAAC,CAAC,CAAA;AACX;AAEO,SAAS,cAAA,CAAe,CAAA,EAAoB;AAEjD,EAAA,GAAA,CAAI,OAAO,EAAA,IAAM,QAAA,EAAU;AACzB,IAAA,MAAM,IAAI,KAAA,CAAM,wBAAwB,CAAA;AAAA,EAC1C;AACA,EAAA,OAAO,CAAA;AACT;AAIO,SAAS,iBAAA,CAAkB,CAAA,EAAuB;AAEvD,EAAA,GAAA,CAAI,OAAO,EAAA,IAAM,SAAA,GAAY,OAAO,EAAA,IAAM,SAAA,GAAY,OAAO,EAAA,IAAM,SAAA,EAAW;AAC5E,IAAA,MAAM,IAAI,KAAA,CAAM,kEAAkE,CAAA;AAAA,EACpF;AACA,EAAA,OAAO,CAAA;AACT;ADVA;AACA;AEfO,QAAA,EAAU,OAAA,CAAW,QAAA,EAAuB,IAAA,EAAqC;AACtF,EAAA,GAAA,CAAI,KAAA,EAAO,CAAA,EAAG;AACZ,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,oBAAA,EAAuB,IAAI,CAAA,CAAA;AAC7C,EAAA;AAEwB,EAAA;AACf,EAAA;AACoB,IAAA;AACL,IAAA;AACd,MAAA;AACR,IAAA;AACyB,IAAA;AACvB,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAS6F;AAC/C,EAAA;AACb,IAAA;AACrB,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAS4F;AACxC,EAAA;AACtC,EAAA;AACL,EAAA;AACT;AAMiF;AACvD,EAAA;AACZ,EAAA;AACQ,EAAA;AACA,IAAA;AACL,IAAA;AACH,MAAA;AACH,IAAA;AAEL,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAW8E;AACpD,EAAA;AACF,EAAA;AACN,EAAA;AACd,IAAA;AACF,EAAA;AAEkB,EAAA;AACG,EAAA;AACN,IAAA;AACR,IAAA;AACP,EAAA;AACF;AAqByF;AACzE,EAAA;AACD,EAAA;AAED,EAAA;AACiB,EAAA;AACG,IAAA;AACd,MAAA;AACT,IAAA;AACQ,MAAA;AACf,IAAA;AACF,EAAA;AAEiB,EAAA;AACnB;AAS6E;AAK3B,EAAA;AAEnB,EAAA;AACf,IAAA;AACqB,IAAA;AACL,MAAA;AACH,MAAA;AAEL,MAAA;AACH,QAAA;AACb,QAAA;AACK,MAAA;AAIoB,QAAA;AAC3B,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAa0E;AAKxB,EAAA;AAEnB,EAAA;AACf,IAAA;AACG,IAAA;AACkB,IAAA;AACL,MAAA;AACH,MAAA;AAEL,MAAA;AACO,QAAA;AACvB,QAAA;AACK,MAAA;AAIoB,QAAA;AAC3B,MAAA;AACF,IAAA;AACsB,IAAA;AACd,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAK+D;AACzB,EAAA;AACtC;AAakC;AAEX,EAAA;AACQ,EAAA;AACL,IAAA;AACF,IAAA;AACN,MAAA;AACN,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAckC;AAEU,EAAA;AAE1C,EAAA;AACwC,IAAA;AACT,IAAA;AACL,MAAA;AACE,MAAA;AACO,QAAA;AACF,MAAA;AACY,QAAA;AACrB,QAAA;AACb,MAAA;AACgB,QAAA;AACvB,MAAA;AACF,IAAA;AACF,EAAA;AAEwB,EAAA;AAC1B;AAakC;AAErB,EAAA;AACkB,EAAA;AACL,IAAA;AACJ,IAAA;AACV,MAAA;AACC,MAAA;AACT,IAAA;AACF,EAAA;AACF;AF3HgD;AACA;AG1KxB;AAQmD;AACjD,EAAA;AAC1B;AAOsE;AAC5D,EAAA;AACC,EAAA;AACD,IAAA;AACD,IAAA;AACP,EAAA;AACF;AAKkF;AACpC,EAAA;AAC9C;AAOsE;AACrD,EAAA;AACiB,EAAA;AACxB,IAAA;AACY,IAAA;AACpB,EAAA;AAEyB,EAAA;AACM,IAAA;AACrB,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAQmG;AACrF,EAAA;AACY,EAAA;AACpB,EAAA;AAC4B,EAAA;AACZ,IAAA;AACc,IAAA;AACxB,MAAA;AACN,MAAA;AACF,IAAA;AACF,EAAA;AAEwB,EAAA;AAChB,IAAA;AACR,EAAA;AACF;AAGuB;AAIG;AAEA,EAAA;AAEpB,EAAA;AACgB,EAAA;AAED,EAAA;AAEmD,EAAA;AACtC,IAAA;AACtB,MAAA;AAEkB,MAAA;AACN,MAAA;AACK,MAAA;AACQ,MAAA;AACjC,IAAA;AACF,EAAA;AAES,EAAA;AAC0B,IAAA;AACP,MAAA;AACN,MAAA;AACH,QAAA;AAEb,QAAA;AACF,MAAA;AACuB,MAAA;AACQ,MAAA;AACjC,IAAA;AAEY,IAAA;AACyB,IAAA;AACvC,EAAA;AACF;AAEoH;AAClG,EAAA;AACa,EAAA;AACL,IAAA;AACW,IAAA;AAChB,MAAA;AACjB,IAAA;AACqB,IAAA;AACvB,EAAA;AACO,EAAA;AACT;AAEkH;AAChG,EAAA;AACa,EAAA;AACL,IAAA;AACR,IAAA;AAChB,EAAA;AACO,EAAA;AACT;AAOoG;AACtD,EAAA;AACnC,IAAA;AACC,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAQiG;AACnF,EAAA;AACkB,EAAA;AACG,IAAA;AACvB,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAMgG;AAChE,EAAA;AACV,IAAA;AACpB,EAAA;AACF;AAqBE;AAGW,EAAA;AACqB,EAAA;AAEtB,IAAA;AACD,IAAA;AACF,EAAA;AAEG,IAAA;AACD,IAAA;AACT,EAAA;AAE+B,EAAA;AACU,EAAA;AACV,EAAA;AAEvB,EAAA;AACgB,EAAA;AACpB,EAAA;AACS,EAAA;AACX,IAAA;AACgC,IAAA;AAElB,IAAA;AACA,IAAA;AAEC,IAAA;AACe,IAAA;AAClB,MAAA;AACZ,IAAA;AACF,EAAA;AACF;AAQ8F;AACzE,EAAA;AACA,EAAA;AACV,EAAA;AACY,IAAA;AACA,IAAA;AACK,IAAA;AACC,MAAA;AAClB,IAAA;AAEL,MAAA;AACF,IAAA;AACF,EAAA;AACF;AASkC;AACb,EAAA;AACA,EAAA;AACA,EAAA;AACV,EAAA;AACY,IAAA;AACA,IAAA;AACA,IAAA;AACgB,IAAA;AACD,MAAA;AAC3B,IAAA;AAEL,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAEqB;AAWiB;AACpB,EAAA;AACG,EAAA;AACA,EAAA;AACV,EAAA;AACY,IAAA;AACA,IAAA;AACG,IAAA;AAEpB,MAAA;AACK,IAAA;AACkC,MAAA;AACzC,IAAA;AACF,EAAA;AACF;AAU8C;AAC5B,EAAA;AACG,EAAA;AACA,EAAA;AACA,EAAA;AACV,EAAA;AACY,IAAA;AACA,IAAA;AACA,IAAA;AACa,IAAA;AAE9B,MAAA;AACK,IAAA;AACkC,MAAA;AACzC,IAAA;AACF,EAAA;AACF;AAU6E;AAE3C,EAAA;AAEvB,EAAA;AACgE,IAAA;AACrC,IAAA;AACG,MAAA;AAC9B,IAAA;AAEL,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAe2F;AACzD,EAAA;AACjB,EAAA;AACA,EAAA;AAEJ,EAAA;AACT,IAAA;AACF,EAAA;AAE2C,EAAA;AACY,EAAA;AACf,EAAA;AAEA,EAAA;AAE1B,EAAA;AACI,IAAA;AACsB,IAAA;AACvB,MAAA;AACQ,MAAA;AAGT,QAAA;AAEM,QAAA;AACX,MAAA;AACqB,QAAA;AAEM,QAAA;AACnB,QAAA;AACiB,QAAA;AACU,QAAA;AAC5B,QAAA;AACZ,QAAA;AACF,MAAA;AACF,IAAA;AAEe,IAAA;AACb,MAAA;AACF,IAAA;AACF,EAAA;AACF;AAM0E;AAC/C,EAAA;AACd,IAAA;AACD,MAAA;AACR,IAAA;AACK,EAAA;AACyB,IAAA;AACtB,MAAA;AACR,IAAA;AACF,EAAA;AACF;AAMmG;AACrF,EAAA;AACY,EAAA;AACpB,EAAA;AAC4B,EAAA;AACZ,IAAA;AACc,IAAA;AAC1B,IAAA;AACR,EAAA;AACF;AAE2G;AAC3D,EAAA;AAChD;AAO8B;AACe,EAAA;AAC7C;AAE2B;AACD;AAEiC;AACrB,EAAA;AACtC;AHdgD;AACA;AItbwC;AAC9D,EAAA;AACK,EAAA;AACL,IAAA;AACgB,IAAA;AACjC,EAAA;AACD,IAAA;AACI,IAAA;AACwB,IAAA;AACZ,MAAA;AACS,MAAA;AAClB,QAAA;AACT,MAAA;AACF,IAAA;AACO,IAAA;AACT,EAAA;AACF;AAoB0E;AAC5D,EAAA;AACiB,EAAA;AACI,IAAA;AACtB,MAAA;AACT,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAmByE;AAC3D,EAAA;AACiB,EAAA;AACG,IAAA;AACrB,MAAA;AACT,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAKmB;AAKA;AAaoD;AAC5B,EAAA;AAC3C;AAe+F;AACzE,EAAA;AACU,EAAA;AACP,IAAA;AACvB,EAAA;AACF;AAO+E;AAC/B,EAAA;AAChD;AAQoE;AACjC,EAAA;AAEnC;AAK8E;AACpC,EAAA;AAC1C;AAa0G;AACzD,EAAA;AACjD;AAa0G;AACzD,EAAA;AACjD;AAKqF;AAClD,EAAA;AACmB,EAAA;AACtB,EAAA;AAChC;AA4BoE;AAChC,EAAA;AAC0B,IAAA;AACrD,EAAA;AAC2C,IAAA;AAClD,EAAA;AACF;AAIqE;AACjC,EAAA;AACqB,IAAA;AAChD,EAAA;AACkD,IAAA;AACzD,EAAA;AACF;AA6BuB;AACI,EAAA;AACkD,IAAA;AACpE,EAAA;AAC2E,IAAA;AAClF,EAAA;AACF;AAE2G;AAC5F,EAAA;AACD,EAAA;AACiB,EAAA;AACW,IAAA;AACxC,EAAA;AACO,EAAA;AACT;AAE0G;AAChF,EAAA;AACH,EAAA;AACI,EAAA;AAChB,IAAA;AACF,EAAA;AAC4B,IAAA;AACnC,EAAA;AACF;AAiBkC;AAGE,EAAA;AACP,EAAA;AAEd,EAAA;AACI,IAAA;AACjB,EAAA;AAEO,EAAA;AACT;AAMwD;AACZ,EAAA;AAC5C;AAK4E;AAC5C,EAAA;AAChC;AAKuG;AAClE,EAAA;AACrC;AJsOgD;AACA;AKrjBC;AACnC,EAAA;AACd;AAEwC;AACzB,EAAA;AACf;AAU2F;AACvD,EAAA;AACpC;AAU0E;AACpC,EAAA;AACtC;AASuG;AACrF,EAAA;AAC8B,EAAA;AAC9B,IAAA;AACK,IAAA;AACE,MAAA;AACrB,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAQqF;AAC3C,EAAA;AAC1C;AAgB4G;AACrE,EAAA;AACvC;ALsgBgD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/itertools/itertools/dist/index.cjs","sourcesContent":[null,"import type { Primitive } from \"./types\";\n\ntype CmpFn<T> = (a: T, b: T) => number;\n\nexport function keyToCmp<T>(keyFn: (item: T) => Primitive): CmpFn<T> {\n  return (a: T, b: T) => {\n    const ka = keyFn(a);\n    const kb = keyFn(b);\n    // istanbul ignore else -- @preserve\n    if (typeof ka === \"boolean\" && typeof kb === \"boolean\") {\n      return ka === kb ? 0 : !ka && kb ? -1 : 1;\n    } else if (typeof ka === \"number\" && typeof kb === \"number\") {\n      return ka - kb;\n    } else if (typeof ka === \"string\" && typeof kb === \"string\") {\n      return ka === kb ? 0 : ka < kb ? -1 : 1;\n    } else {\n      return -1;\n    }\n  };\n}\n\nexport function identityPredicate(x: unknown): boolean {\n  return !!x;\n}\n\nexport function numberIdentity(x: unknown): number {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"number\") {\n    throw new Error(\"Inputs must be numbers\");\n  }\n  return x;\n}\n\nexport function primitiveIdentity<P extends Primitive>(x: P): P;\nexport function primitiveIdentity(x: unknown): Primitive;\nexport function primitiveIdentity(x: unknown): Primitive {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"string\" && typeof x !== \"number\" && typeof x !== \"boolean\") {\n    throw new Error(\"Please provide a key function that can establish object identity\");\n  }\n  return x;\n}\n","import { iter, map } from \"./builtins\";\nimport { izip, repeat } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\n/**\n * Break iterable into lists of length `size`:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6], 3)]\n *     // [[1, 2, 3], [4, 5, 6]]\n *\n * If the length of iterable is not evenly divisible by `size`, the last returned\n * list will be shorter:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)]\n *     // [[1, 2, 3], [4, 5, 6], [7, 8]]\n */\nexport function* chunked<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]> {\n  if (size < 1) {\n    throw new Error(`Invalid chunk size: ${size}`);\n  }\n\n  const it = iter(iterable);\n  for (;;) {\n    const chunk = take(size, it);\n    if (chunk.length > 0) {\n      yield chunk;\n    }\n    if (chunk.length < size) {\n      return;\n    }\n  }\n}\n\n/**\n * Return an iterator flattening one level of nesting in a list of lists:\n *\n *     [...flatten([[0, 1], [2, 3]])]\n *     // [0, 1, 2, 3]\n *\n */\nexport function* flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T> {\n  for (const iterable of iterableOfIterables) {\n    for (const item of iterable) {\n      yield item;\n    }\n  }\n}\n\n/**\n * Intersperse filler element `value` among the items in `iterable`.\n *\n *     >>> [...intersperse(-1, range(1, 5))]\n *     [1, -1, 2, -1, 3, -1, 4]\n *\n */\nexport function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V> {\n  const stream = flatten<T | V>(izip(repeat(value), iterable));\n  stream.next(); // eat away and discard the first value from the output\n  return stream;\n}\n\n/**\n * Returns an iterable containing only the first `n` elements of the given\n * iterable.\n */\nexport function* itake<T>(n: number, iterable: Iterable<T>): IterableIterator<T> {\n  const it = iter(iterable);\n  let count = n;\n  while (count-- > 0) {\n    const s = it.next();\n    if (!s.done) {\n      yield s.value;\n    } else {\n      // Iterable exhausted, quit early\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator of paired items, overlapping, from the original.  When\n * the input iterable has a finite number of items `n`, the outputted iterable\n * will have `n - 1` items.\n *\n *     >>> pairwise([8, 2, 0, 7])\n *     [(8, 2), (2, 0), (0, 7)]\n *\n */\nexport function* pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]> {\n  const it = iter(iterable);\n  const first = it.next();\n  if (first.done) {\n    return;\n  }\n\n  let r1: T = first.value;\n  for (const r2 of it) {\n    yield [r1, r2];\n    r1 = r2;\n  }\n}\n\n/**\n * Returns a 2-tuple of arrays.  Splits the elements in the input iterable into\n * either of the two arrays.  Will fully exhaust the input iterable.  The first\n * array contains all items that match the predicate, the second the rest:\n *\n *     >>> const isOdd = x => x % 2 !== 0;\n *     >>> const iterable = range(10);\n *     >>> const [odds, evens] = partition(iterable, isOdd);\n *     >>> odds\n *     [1, 3, 5, 7, 9]\n *     >>> evens\n *     [0, 2, 4, 6, 8]\n *\n */\nexport function partition<T, N extends T>(\n  iterable: Iterable<T>,\n  predicate: (item: T, index: number) => item is N,\n): [N[], Exclude<T, N>[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]] {\n  const good = [];\n  const bad = [];\n\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      good.push(item);\n    } else {\n      bad.push(item);\n    }\n  }\n\n  return [good, bad];\n}\n\n/**\n * Yields the next item from each iterable in turn, alternating between them.\n * Continues until all items are exhausted.\n *\n *     >>> [...roundrobin([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [1, 4, 5, 2, 6, 3, 7, 8]\n */\nexport function* roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        yield result.value;\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n  }\n}\n\n/**\n * Yields the heads of all of the given iterables.  This is almost like\n * `roundrobin()`, except that the yielded outputs are grouped in to the\n * \"rounds\":\n *\n *     >>> [...heads([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [[1, 4, 5], [2, 6], [3, 7], [8]]\n *\n * This is also different from `zipLongest()`, since the number of items in\n * each round can decrease over time, rather than being filled with a filler.\n */\nexport function* heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    const round = [];\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        round.push(result.value);\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n    if (round.length > 0) {\n      yield round;\n    }\n  }\n}\n\n/**\n * Non-lazy version of itake().\n */\nexport function take<T>(n: number, iterable: Iterable<T>): T[] {\n  return Array.from(itake(n, iterable));\n}\n\n/**\n * Yield unique elements, preserving order.\n *\n *     >>> [...uniqueEverseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D']\n *     >>> [...uniqueEverseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C']\n *\n */\nexport function* uniqueEverseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  const seen = new Set();\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      yield item;\n    }\n  }\n}\n\n/**\n * Yield only elements from the input that occur more than once. Needs to\n * consume the entire input before being able to produce the first result.\n *\n *     >>> [...dupes('AAAABCDEEEFABG')]\n *     [['A', 'A', 'A', 'A', 'A'], ['E', 'E', 'E'], ['B', 'B']]\n *     >>> [...dupes('AbBCcAB', s => s.toLowerCase())]\n *     [['b', 'B', 'B'], ['C', 'c'], ['A', 'A']]\n *\n */\nexport function dupes<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T[]> {\n  const multiples = new Map<Primitive, T[]>();\n\n  {\n    const singles = new Map<Primitive, T>();\n    for (const item of iterable) {\n      const key = keyFn(item);\n      if (multiples.has(key)) {\n        multiples.get(key)!.push(item);\n      } else if (singles.has(key)) {\n        multiples.set(key, [singles.get(key)!, item]);\n        singles.delete(key);\n      } else {\n        singles.set(key, item);\n      }\n    }\n  }\n\n  return multiples.values();\n}\n\n/**\n * Yields elements in order, ignoring serial duplicates.\n *\n *     >>> [...uniqueJustseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D', 'A', 'B']\n *     >>> [...uniqueJustseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C', 'A', 'B']\n *\n */\nexport function* uniqueJustseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  let last = undefined;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (key !== last) {\n      yield item;\n      last = key;\n    }\n  }\n}\n","import { every, iter, range } from \"./builtins\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\nconst SENTINEL = Symbol();\n\n/**\n * Returns an iterator that returns elements from the first iterable until it\n * is exhausted, then proceeds to the next iterable, until all of the iterables\n * are exhausted.  Used for treating consecutive sequences as a single\n * sequence.\n */\nexport function chain<T>(...iterables: Iterable<T>[]): IterableIterator<T> {\n  return flatten(iterables);\n}\n\n/**\n * Returns an iterator that counts up values starting with number `start`\n * (default 0), incrementing by `step`.  To decrement, use a negative step\n * number.\n */\nexport function* count(start = 0, step = 1): IterableIterator<number> {\n  let n = start;\n  for (;;) {\n    yield n;\n    n += step;\n  }\n}\n\n/**\n * Non-lazy version of icompress().\n */\nexport function compress<T>(data: Iterable<T>, selectors: Iterable<boolean>): T[] {\n  return Array.from(icompress(data, selectors));\n}\n\n/**\n * Returns an iterator producing elements from the iterable and saving a copy\n * of each.  When the iterable is exhausted, return elements from the saved\n * copy.  Repeats indefinitely.\n */\nexport function* cycle<T>(iterable: Iterable<T>): IterableIterator<T> {\n  const saved = [];\n  for (const element of iterable) {\n    yield element;\n    saved.push(element);\n  }\n\n  while (saved.length > 0) {\n    for (const element of saved) {\n      yield element;\n    }\n  }\n}\n\n/**\n * Returns an iterator that drops elements from the iterable as long as the\n * predicate is true; afterwards, returns every remaining element.  Note, the\n * iterator does not produce any output until the predicate first becomes\n * false.\n */\nexport function* dropwhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) {\n      yield value;\n      break; // we break, so we cannot use a for..of loop!\n    }\n  }\n\n  for (const value of it) {\n    yield value;\n  }\n}\n\n/** @deprecated Please rename to `igroupby`, or use the new eager version `groupBy`. */\nexport const groupby = igroupby;\n\nexport function* igroupby<T, K extends Primitive>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => K = primitiveIdentity,\n): Generator<[K, Generator<T, undefined>], undefined> {\n  const it = iter(iterable);\n\n  let currentValue: T;\n  let currentKey: K = SENTINEL as unknown as K;\n  //                           ^^^^^^^^^^^^^^^ Hack!\n  let targetKey: K = currentKey;\n\n  const grouper = function* grouper(tgtKey: K): Generator<T, undefined> {\n    while (currentKey === tgtKey) {\n      yield currentValue;\n\n      const nextVal = it.next();\n      if (nextVal.done) return;\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n  };\n\n  for (;;) {\n    while (currentKey === targetKey) {\n      const nextVal = it.next();\n      if (nextVal.done) {\n        currentKey = SENTINEL as unknown as K;\n        //                    ^^^^^^^^^^^^^^^ Hack!\n        return;\n      }\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n\n    targetKey = currentKey;\n    yield [currentKey, grouper(targetKey)];\n  }\n}\n\nexport function groupBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!Object.hasOwn(result, key)) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n  return result;\n}\n\nexport function indexBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    result[key] = item;\n  }\n  return result;\n}\n\n/**\n * Returns an iterator that filters elements from data returning only those\n * that have a corresponding element in selectors that evaluates to `true`.\n * Stops when either the data or selectors iterables has been exhausted.\n */\nexport function* icompress<T>(data: Iterable<T>, selectors: Iterable<boolean>): IterableIterator<T> {\n  for (const [d, s] of izip(data, selectors)) {\n    if (s) {\n      yield d;\n    }\n  }\n}\n\n/**\n * Returns an iterator that filters elements from iterable returning only those\n * for which the predicate is true.\n */\nexport function ifilter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): IterableIterator<N>;\nexport function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;\nexport function* ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  for (const value of iterable) {\n    if (predicate(value, index++)) {\n      yield value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that computes the given mapper function using arguments\n * from each of the iterables.\n */\nexport function* imap<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): IterableIterator<V> {\n  for (const value of iterable) {\n    yield mapper(value);\n  }\n}\n\n/**\n * Returns an iterator that returns selected elements from the iterable.  If\n * `start` is non-zero, then elements from the iterable are skipped until start\n * is reached.  Then, elements are returned by making steps of `step` (defaults\n * to 1).  If set to higher than 1, items will be skipped.  If `stop` is\n * provided, then iteration continues until the iterator reached that index,\n * otherwise, the iterable will be fully exhausted.  `islice()` does not\n * support negative values for `start`, `stop`, or `step`.\n */\nexport function islice<T>(iterable: Iterable<T>, stop: number): IterableIterator<T>;\nexport function islice<T>(\n  iterable: Iterable<T>,\n  start: number,\n  stop?: number | null,\n  step?: number,\n): IterableIterator<T>;\nexport function* islice<T>(\n  iterable: Iterable<T>,\n  stopOrStart: number,\n  possiblyStop?: number | null,\n  step = 1,\n): IterableIterator<T> {\n  let start, stop;\n  if (possiblyStop !== undefined) {\n    // islice(iterable, start, stop[, step])\n    start = stopOrStart;\n    stop = possiblyStop;\n  } else {\n    // islice(iterable, stop)\n    start = 0;\n    stop = stopOrStart;\n  }\n\n  if (start < 0) throw new Error(\"start cannot be negative\");\n  if (stop !== null && stop < 0) throw new Error(\"stop cannot be negative\");\n  if (step <= 0) throw new Error(\"step cannot be negative\");\n\n  let i = -1;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (true) {\n    i++;\n    if (stop !== null && i >= stop) return; // early returns, so we cannot use a for..of loop!\n\n    res = it.next();\n    if (res.done) return;\n\n    if (i < start) continue;\n    if ((i - start) % step === 0) {\n      yield res.value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.\n * Used for lock-step iteration over several iterables at a time.  When\n * iterating over two iterables, use `izip2`.  When iterating over three\n * iterables, use `izip3`, etc.  `izip` is an alias for `izip2`.\n */\nexport function* izip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): IterableIterator<[T1, T2]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (!x.done && !y.done) {\n      yield [x.value, y.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Like izip2, but for three input iterables.\n */\nexport function* izip3<T1, T2, T3>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n): IterableIterator<[T1, T2, T3]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (!x.done && !y.done && !z.done) {\n      yield [x.value, y.value, z.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\nexport const izip2 = izip;\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.  If\n * the iterables are of uneven length, missing values are filled-in with\n * fillvalue.  Iteration continues until the longest iterable is exhausted.\n */\nexport function* izipLongest2<T1, T2, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (x.done && y.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_];\n    }\n  }\n}\n\n/**\n * See izipLongest2, but for three.\n */\nexport function* izipLongest3<T1, T2, T3, D = undefined>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D, T3 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (x.done && y.done && z.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_, !z.done ? z.value : filler_];\n    }\n  }\n}\n\n/**\n * Like the other izips (`izip`, `izip3`, etc), but generalized to take an\n * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.\n *\n * **Note:** Due to Flow type system limitations, you can only \"generially\" zip\n * iterables with homogeneous types, so you cannot mix types like <A, B> like\n * you can with izip2().\n */\nexport function* izipMany<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // Make them all iterables\n  const iterables = iters.map(iter);\n\n  for (;;) {\n    const heads: IteratorResult<T, undefined>[] = iterables.map((xs) => xs.next());\n    if (every(heads, (h) => !h.done)) {\n      yield heads.map((h) => h.value as T);\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Return successive `r`-length permutations of elements in the iterable.\n *\n * If `r` is not specified, then `r` defaults to the length of the iterable and\n * all possible full-length permutations are generated.\n *\n * Permutations are emitted in lexicographic sort order.  So, if the input\n * iterable is sorted, the permutation tuples will be produced in sorted order.\n *\n * Elements are treated as unique based on their position, not on their value.\n * So if the input elements are unique, there will be no repeat values in each\n * permutation.\n */\nexport function* permutations<T>(iterable: Iterable<T>, r?: number): IterableIterator<T[]> {\n  const pool = Array.from(iterable);\n  const n = pool.length;\n  const x = r ?? n;\n\n  if (x > n) {\n    return;\n  }\n\n  let indices: number[] = Array.from(range(n));\n  const cycles: number[] = Array.from(range(n, n - x, -1));\n  const poolgetter = (i: number) => pool[i];\n\n  yield indices.slice(0, x).map(poolgetter);\n\n  while (n > 0) {\n    let cleanExit = true;\n    for (const i of range(x - 1, -1, -1)) {\n      cycles[i] -= 1;\n      if (cycles[i] === 0) {\n        indices = indices\n          .slice(0, i)\n          .concat(indices.slice(i + 1))\n          .concat(indices.slice(i, i + 1));\n        cycles[i] = n - i;\n      } else {\n        const j: number = cycles[i];\n\n        const [p, q] = [indices[indices.length - j], indices[i]];\n        indices[i] = p;\n        indices[indices.length - j] = q;\n        yield indices.slice(0, x).map(poolgetter);\n        cleanExit = false;\n        break;\n      }\n    }\n\n    if (cleanExit) {\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces values over and over again.  Runs\n * indefinitely unless the times argument is specified.\n */\nexport function* repeat<T>(thing: T, times?: number): IterableIterator<T> {\n  if (times === undefined) {\n    for (;;) {\n      yield thing;\n    }\n  } else {\n    for (const _ of range(times)) {\n      yield thing;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces elements from the iterable as long as the\n * predicate is true.\n */\nexport function* takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) return; // early return, so we cannot use for..of loop!\n    yield value;\n  }\n}\n\nexport function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][] {\n  return Array.from(izipLongest2(xs, ys, filler));\n}\n\nexport function zipLongest3<T1, T2, T3, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): [T1 | D, T2 | D, T3 | D][] {\n  return Array.from(izipLongest3(xs, ys, zs, filler));\n}\n\nexport const izipLongest = izipLongest2;\nexport const zipLongest = zipLongest2;\n\nexport function zipMany<T>(...iters: Iterable<T>[]): T[][] {\n  return Array.from(izipMany(...iters));\n}\n","import { count, ifilter, imap, izip, izip3, takewhile } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { identityPredicate, keyToCmp, numberIdentity, primitiveIdentity } from \"./utils\";\n\n/**\n * Returns the first item in the iterable for which the predicate holds, if\n * any. If no predicate is given, it will return the first value returned by\n * the iterable.\n */\nexport function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined {\n  const it = iter(iterable);\n  if (predicate === undefined) {\n    const value = it.next();\n    return value.done ? undefined : value.value;\n  } else {\n    let res: IteratorResult<T>;\n    let i = 0;\n    while (!(res = it.next()).done) {\n      const value = res.value;\n      if (predicate(value, i++)) {\n        return value;\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Returns true when all of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     all([])                           // => true\n *     all([0])                          // => false\n *     all([0, 1, 2])                    // => false\n *     all([1, 2, 3])                    // => true\n *\n * Examples with using a key function:\n *\n *     all([2, 4, 6], n => n % 2 === 0)  // => true\n *     all([2, 4, 5], n => n % 2 === 0)  // => false\n *\n */\nexport function every<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (!predicate(item, index++)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true when some of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     some([])                           // => false\n *     some([0])                          // => false\n *     some([0, 1, null, undefined])      // => true\n *\n * Examples with using a key function:\n *\n *     some([1, 4, 5], n => n % 2 === 0)  // => true\n *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false\n *\n */\nexport function some<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Alias of `every()`.\n */\nexport const all = every;\n\n/**\n * Alias of `some()`.\n */\nexport const any = some;\n\n/**\n * Returns true when any of the items in the iterable are equal to the target object.\n *\n * Examples:\n *\n *     contains([], 'whatever')         // => false\n *     contains([3], 42)                // => false\n *     contains([3], 3)                 // => true\n *     contains([0, 1, 2], 2)           // => true\n *\n */\nexport function contains<T>(haystack: Iterable<T>, needle: T): boolean {\n  return some(haystack, (x) => x === needle);\n}\n\n/**\n * Returns an iterable of enumeration pairs.  Iterable must be a sequence, an\n * iterator, or some other object which supports iteration.  The elements\n * produced by returns a tuple containing a counter value (starting from 0 by\n * default) and the values obtained from iterating over given iterable.\n *\n * Example:\n *\n *     import { enumerate } from 'itertools';\n *\n *     console.log([...enumerate(['hello', 'world'])]);\n *     // [0, 'hello'], [1, 'world']]\n */\nexport function* enumerate<T>(iterable: Iterable<T>, start = 0): IterableIterator<[number, T]> {\n  let index: number = start;\n  for (const value of iterable) {\n    yield [index++, value];\n  }\n}\n\n/**\n * Non-lazy version of ifilter().\n */\nexport function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[] {\n  return Array.from(ifilter(iterable, predicate));\n}\n\n/**\n * Returns an iterator object for the given iterable.  This can be used to\n * manually get an iterator for any iterable datastructure.  The purpose and\n * main use case of this function is to get a single iterator (a thing with\n * state, think of it as a \"cursor\") which can only be consumed once.\n */\nexport function iter<T>(iterable: Iterable<T>): IterableIterator<T> {\n  return iterable[Symbol.iterator]() as IterableIterator<T>;\n  //                                 ^^^^^^^^^^^^^^^^^^^^^^ Not safe!\n}\n\n/**\n * Non-lazy version of imap().\n */\nexport function map<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): V[] {\n  return Array.from(imap(iterable, mapper));\n}\n\n/**\n * Return the largest item in an iterable.  Only works for numbers, as ordering\n * is pretty poorly defined on any other data type in JS.  The optional `keyFn`\n * argument specifies a one-argument ordering function like that used for\n * sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are maximal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function max<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) > keyFn(y) ? x : y));\n}\n\n/**\n * Return the smallest item in an iterable.  Only works for numbers, as\n * ordering is pretty poorly defined on any other data type in JS.  The\n * optional `keyFn` argument specifies a one-argument ordering function like\n * that used for sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are minimal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function min<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) < keyFn(y) ? x : y));\n}\n\n/**\n * Internal helper for the range function\n */\nfunction range_(start: number, stop: number, step: number): IterableIterator<number> {\n  const counter = count(start, step);\n  const pred = step >= 0 ? (n: number) => n < stop : (n: number) => n > stop;\n  return takewhile(counter, pred);\n}\n\n/**\n * Returns an iterator producing all the numbers in the given range one by one,\n * starting from `start` (default 0), as long as `i < stop`, in increments of\n * `step` (default 1).\n *\n * `range(a)` is a convenient shorthand for `range(0, a)`.\n *\n * Various valid invocations:\n *\n *     range(5)           // [0, 1, 2, 3, 4]\n *     range(2, 5)        // [2, 3, 4]\n *     range(0, 5, 2)     // [0, 2, 4]\n *     range(5, 0, -1)    // [5, 4, 3, 2, 1]\n *     range(-3)          // []\n *\n * For a positive `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n < stop` is satisfied.\n *\n * For a negative `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n > stop` is satisfied.\n *\n * The produced range will be empty if the first value to produce already does\n * not meet the value constraint.\n */\nexport function range(stop: number): IterableIterator<number>;\nexport function range(start: number, stop: number, step?: number): IterableIterator<number>;\nexport function range(startOrStop: number, definitelyStop?: number, step = 1): IterableIterator<number> {\n  if (definitelyStop !== undefined) {\n    return range_(startOrStop /* as start */, definitelyStop, step);\n  } else {\n    return range_(0, startOrStop /* as stop */, step);\n  }\n}\n\nexport function xrange(stop: number): number[];\nexport function xrange(start: number, stop: number, step?: number): number[];\nexport function xrange(startOrStop: number, definitelyStop?: number, step = 1): number[] {\n  if (definitelyStop !== undefined) {\n    return Array.from(range_(startOrStop /* as start */, definitelyStop, step));\n  } else {\n    return Array.from(range_(0, startOrStop /* as stop */, step));\n  }\n}\n\n/**\n * Apply function of two arguments cumulatively to the items of sequence, from\n * left to right, so as to reduce the sequence to a single value.  For example:\n *\n *     reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)\n *\n * calculates\n *\n *     (((((0+1)+2)+3)+4)+5)\n *\n * The left argument, `x`, is the accumulated value and the right argument,\n * `y`, is the update value from the sequence.\n *\n * **Difference between `reduce()` and `reduce\\_()`**:  `reduce()` requires an\n * explicit initializer, whereas `reduce_()` will automatically use the first\n * item in the given iterable as the initializer.  When using `reduce()`, the\n * initializer value is placed before the items of the sequence in the\n * calculation, and serves as a default when the sequence is empty.  When using\n * `reduce_()`, and the given iterable is empty, then no default value can be\n * derived and `undefined` will be returned.\n */\nexport function reduce<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined;\nexport function reduce<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O;\nexport function reduce<T, O>(\n  iterable: Iterable<T>,\n  reducer: ((agg: T, item: T, index: number) => T) | ((agg: O, item: T, index: number) => O),\n  start?: O,\n): O | (T | undefined) {\n  if (start === undefined) {\n    return reduce2(iterable, reducer as (agg: T, item: T, index: number) => T);\n  } else {\n    return reduce3(iterable, reducer as (agg: O, item: T, index: number) => O, start);\n  }\n}\n\nfunction reduce3<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O {\n  let output = start;\n  let index = 0;\n  for (const item of iterable) {\n    output = reducer(output, item, index++);\n  }\n  return output;\n}\n\nfunction reduce2<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined {\n  const it = iter(iterable);\n  const start = find(it);\n  if (start === undefined) {\n    return undefined;\n  } else {\n    return reduce3(it, reducer, start);\n  }\n}\n\n/**\n * Return a new sorted list from the items in iterable.\n *\n * Has two optional arguments:\n *\n * * `keyFn` specifies a function of one argument providing a primitive\n *   identity for each element in the iterable.  that will be used to compare.\n *   The default value is to use a default identity function that is only\n *   defined for primitive types.\n *\n * * `reverse` is a boolean value.  If `true`, then the list elements are\n *   sorted as if each comparison were reversed.\n */\nexport function sorted<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n  reverse = false,\n): T[] {\n  const result = Array.from(iterable);\n  result.sort(keyToCmp(keyFn)); // sort in-place\n\n  if (reverse) {\n    result.reverse(); // reverse in-place\n  }\n\n  return result;\n}\n\n/**\n * Sums the items of an iterable from left to right and returns the total.  The\n * sum will defaults to 0 if the iterable is empty.\n */\nexport function sum(iterable: Iterable<number>): number {\n  return reduce(iterable, (x, y) => x + y, 0);\n}\n\n/**\n * See izip.\n */\nexport function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][] {\n  return Array.from(izip(xs, ys));\n}\n\n/**\n * See izip3.\n */\nexport function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][] {\n  return Array.from(izip3(xs, ys, zs));\n}\n","import { find } from \"./builtins\";\nimport { ifilter, imap } from \"./itertools\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate } from \"./types\";\n\nfunction isNullish<T>(x: T): x is NonNullable<T> {\n  return x != null;\n}\n\nfunction isDefined(x: unknown): boolean {\n  return x !== undefined;\n}\n\n/**\n * Returns an iterable, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For an eager version, @see compact().\n */\nexport function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T> {\n  return ifilter(iterable, isNullish);\n}\n\n/**\n * Returns an array, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For a lazy version, @see icompact().\n */\nexport function compact<T>(iterable: Iterable<T | null | undefined>): T[] {\n  return Array.from(icompact(iterable));\n}\n\n/**\n * Removes all \"nullish\" values from the given object. Returns a new object.\n *\n *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })\n *     { a: 1, c: 0 }\n *\n */\nexport function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V> {\n  const result = {} as Record<K, V>;\n  for (const [key, value_] of Object.entries(obj)) {\n    const value = value_ as V | null | undefined;\n    if (value != null) {\n      result[key as K] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Almost an alias of find(). There only is a difference if no key fn is\n * provided. In that case, `find()` will return the first item in the iterable,\n * whereas `first()` will return the first non-`undefined` value in the\n * iterable.\n */\nexport function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined {\n  return find(iterable, keyFn ?? isDefined);\n}\n\n/**\n * Returns 0 or more values for every value in the given iterable.\n * Technically, it's just calling map(), followed by flatten(), but it's a very\n * useful operation if you want to map over a structure, but not have a 1:1\n * input-output mapping.  Instead, if you want to potentially return 0 or more\n * values per input element, use flatmap():\n *\n * For example, to return all numbers `n` in the input iterable `n` times:\n *\n *     >>> const repeatN = n => repeat(n, n);\n *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]\n *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0\n *\n */\nexport function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S> {\n  return flatten(imap(iterable, mapper));\n}\n"]}

package/dist/index.js

@@ -174,7 +174,7 @@ function* uniqueJustseen(iterable, keyFn = primitiveIdentity) {
 }
 
 // src/itertools.ts
-var SENTINEL = Symbol();
+var SENTINEL = /* @__PURE__ */ Symbol();
 function chain(...iterables) {
   return flatten(iterables);
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts","../src/more-itertools.ts","../src/itertools.ts","../src/builtins.ts","../src/custom.ts"],"sourcesContent":["import type { Primitive } from \"./types\";\n\ntype CmpFn<T> = (a: T, b: T) => number;\n\nexport function keyToCmp<T>(keyFn: (item: T) => Primitive): CmpFn<T> {\n  return (a: T, b: T) => {\n    const ka = keyFn(a);\n    const kb = keyFn(b);\n    // istanbul ignore else -- @preserve\n    if (typeof ka === \"boolean\" && typeof kb === \"boolean\") {\n      return ka === kb ? 0 : !ka && kb ? -1 : 1;\n    } else if (typeof ka === \"number\" && typeof kb === \"number\") {\n      return ka - kb;\n    } else if (typeof ka === \"string\" && typeof kb === \"string\") {\n      return ka === kb ? 0 : ka < kb ? -1 : 1;\n    } else {\n      return -1;\n    }\n  };\n}\n\nexport function identityPredicate(x: unknown): boolean {\n  return !!x;\n}\n\nexport function numberIdentity(x: unknown): number {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"number\") {\n    throw new Error(\"Inputs must be numbers\");\n  }\n  return x;\n}\n\nexport function primitiveIdentity<P extends Primitive>(x: P): P;\nexport function primitiveIdentity(x: unknown): Primitive;\nexport function primitiveIdentity(x: unknown): Primitive {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"string\" && typeof x !== \"number\" && typeof x !== \"boolean\") {\n    throw new Error(\"Please provide a key function that can establish object identity\");\n  }\n  return x;\n}\n","import { iter, map } from \"./builtins\";\nimport { izip, repeat } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\n/**\n * Break iterable into lists of length `size`:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6], 3)]\n *     // [[1, 2, 3], [4, 5, 6]]\n *\n * If the length of iterable is not evenly divisible by `size`, the last returned\n * list will be shorter:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)]\n *     // [[1, 2, 3], [4, 5, 6], [7, 8]]\n */\nexport function* chunked<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]> {\n  if (size < 1) {\n    throw new Error(`Invalid chunk size: ${size}`);\n  }\n\n  const it = iter(iterable);\n  for (;;) {\n    const chunk = take(size, it);\n    if (chunk.length > 0) {\n      yield chunk;\n    }\n    if (chunk.length < size) {\n      return;\n    }\n  }\n}\n\n/**\n * Return an iterator flattening one level of nesting in a list of lists:\n *\n *     [...flatten([[0, 1], [2, 3]])]\n *     // [0, 1, 2, 3]\n *\n */\nexport function* flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T> {\n  for (const iterable of iterableOfIterables) {\n    for (const item of iterable) {\n      yield item;\n    }\n  }\n}\n\n/**\n * Intersperse filler element `value` among the items in `iterable`.\n *\n *     >>> [...intersperse(-1, range(1, 5))]\n *     [1, -1, 2, -1, 3, -1, 4]\n *\n */\nexport function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V> {\n  const stream = flatten<T | V>(izip(repeat(value), iterable));\n  stream.next(); // eat away and discard the first value from the output\n  return stream;\n}\n\n/**\n * Returns an iterable containing only the first `n` elements of the given\n * iterable.\n */\nexport function* itake<T>(n: number, iterable: Iterable<T>): IterableIterator<T> {\n  const it = iter(iterable);\n  let count = n;\n  while (count-- > 0) {\n    const s = it.next();\n    if (!s.done) {\n      yield s.value;\n    } else {\n      // Iterable exhausted, quit early\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator of paired items, overlapping, from the original.  When\n * the input iterable has a finite number of items `n`, the outputted iterable\n * will have `n - 1` items.\n *\n *     >>> pairwise([8, 2, 0, 7])\n *     [(8, 2), (2, 0), (0, 7)]\n *\n */\nexport function* pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]> {\n  const it = iter(iterable);\n  const first = it.next();\n  if (first.done) {\n    return;\n  }\n\n  let r1: T = first.value;\n  for (const r2 of it) {\n    yield [r1, r2];\n    r1 = r2;\n  }\n}\n\n/**\n * Returns a 2-tuple of arrays.  Splits the elements in the input iterable into\n * either of the two arrays.  Will fully exhaust the input iterable.  The first\n * array contains all items that match the predicate, the second the rest:\n *\n *     >>> const isOdd = x => x % 2 !== 0;\n *     >>> const iterable = range(10);\n *     >>> const [odds, evens] = partition(iterable, isOdd);\n *     >>> odds\n *     [1, 3, 5, 7, 9]\n *     >>> evens\n *     [0, 2, 4, 6, 8]\n *\n */\nexport function partition<T, N extends T>(\n  iterable: Iterable<T>,\n  predicate: (item: T, index: number) => item is N,\n): [N[], Exclude<T, N>[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]] {\n  const good = [];\n  const bad = [];\n\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      good.push(item);\n    } else {\n      bad.push(item);\n    }\n  }\n\n  return [good, bad];\n}\n\n/**\n * Yields the next item from each iterable in turn, alternating between them.\n * Continues until all items are exhausted.\n *\n *     >>> [...roundrobin([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [1, 4, 5, 2, 6, 3, 7, 8]\n */\nexport function* roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        yield result.value;\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n  }\n}\n\n/**\n * Yields the heads of all of the given iterables.  This is almost like\n * `roundrobin()`, except that the yielded outputs are grouped in to the\n * \"rounds\":\n *\n *     >>> [...heads([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [[1, 4, 5], [2, 6], [3, 7], [8]]\n *\n * This is also different from `zipLongest()`, since the number of items in\n * each round can decrease over time, rather than being filled with a filler.\n */\nexport function* heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    const round = [];\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        round.push(result.value);\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n    if (round.length > 0) {\n      yield round;\n    }\n  }\n}\n\n/**\n * Non-lazy version of itake().\n */\nexport function take<T>(n: number, iterable: Iterable<T>): T[] {\n  return Array.from(itake(n, iterable));\n}\n\n/**\n * Yield unique elements, preserving order.\n *\n *     >>> [...uniqueEverseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D']\n *     >>> [...uniqueEverseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C']\n *\n */\nexport function* uniqueEverseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  const seen = new Set();\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      yield item;\n    }\n  }\n}\n\n/**\n * Yield only elements from the input that occur more than once. Needs to\n * consume the entire input before being able to produce the first result.\n *\n *     >>> [...dupes('AAAABCDEEEFABG')]\n *     [['A', 'A', 'A', 'A', 'A'], ['E', 'E', 'E'], ['B', 'B']]\n *     >>> [...dupes('AbBCcAB', s => s.toLowerCase())]\n *     [['b', 'B', 'B'], ['C', 'c'], ['A', 'A']]\n *\n */\nexport function dupes<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T[]> {\n  const multiples = new Map<Primitive, T[]>();\n\n  {\n    const singles = new Map<Primitive, T>();\n    for (const item of iterable) {\n      const key = keyFn(item);\n      if (multiples.has(key)) {\n        multiples.get(key)!.push(item);\n      } else if (singles.has(key)) {\n        multiples.set(key, [singles.get(key)!, item]);\n        singles.delete(key);\n      } else {\n        singles.set(key, item);\n      }\n    }\n  }\n\n  return multiples.values();\n}\n\n/**\n * Yields elements in order, ignoring serial duplicates.\n *\n *     >>> [...uniqueJustseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D', 'A', 'B']\n *     >>> [...uniqueJustseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C', 'A', 'B']\n *\n */\nexport function* uniqueJustseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  let last = undefined;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (key !== last) {\n      yield item;\n      last = key;\n    }\n  }\n}\n","import { every, iter, range } from \"./builtins\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\nconst SENTINEL = Symbol();\n\n/**\n * Returns an iterator that returns elements from the first iterable until it\n * is exhausted, then proceeds to the next iterable, until all of the iterables\n * are exhausted.  Used for treating consecutive sequences as a single\n * sequence.\n */\nexport function chain<T>(...iterables: Iterable<T>[]): IterableIterator<T> {\n  return flatten(iterables);\n}\n\n/**\n * Returns an iterator that counts up values starting with number `start`\n * (default 0), incrementing by `step`.  To decrement, use a negative step\n * number.\n */\nexport function* count(start = 0, step = 1): IterableIterator<number> {\n  let n = start;\n  for (;;) {\n    yield n;\n    n += step;\n  }\n}\n\n/**\n * Non-lazy version of icompress().\n */\nexport function compress<T>(data: Iterable<T>, selectors: Iterable<boolean>): T[] {\n  return Array.from(icompress(data, selectors));\n}\n\n/**\n * Returns an iterator producing elements from the iterable and saving a copy\n * of each.  When the iterable is exhausted, return elements from the saved\n * copy.  Repeats indefinitely.\n */\nexport function* cycle<T>(iterable: Iterable<T>): IterableIterator<T> {\n  const saved = [];\n  for (const element of iterable) {\n    yield element;\n    saved.push(element);\n  }\n\n  while (saved.length > 0) {\n    for (const element of saved) {\n      yield element;\n    }\n  }\n}\n\n/**\n * Returns an iterator that drops elements from the iterable as long as the\n * predicate is true; afterwards, returns every remaining element.  Note, the\n * iterator does not produce any output until the predicate first becomes\n * false.\n */\nexport function* dropwhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) {\n      yield value;\n      break; // we break, so we cannot use a for..of loop!\n    }\n  }\n\n  for (const value of it) {\n    yield value;\n  }\n}\n\n/** @deprecated Please rename to `igroupby`, or use the new eager version `groupBy`. */\nexport const groupby = igroupby;\n\nexport function* igroupby<T, K extends Primitive>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => K = primitiveIdentity,\n): Generator<[K, Generator<T, undefined>], undefined> {\n  const it = iter(iterable);\n\n  let currentValue: T;\n  let currentKey: K = SENTINEL as unknown as K;\n  //                           ^^^^^^^^^^^^^^^ Hack!\n  let targetKey: K = currentKey;\n\n  const grouper = function* grouper(tgtKey: K): Generator<T, undefined> {\n    while (currentKey === tgtKey) {\n      yield currentValue;\n\n      const nextVal = it.next();\n      if (nextVal.done) return;\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n  };\n\n  for (;;) {\n    while (currentKey === targetKey) {\n      const nextVal = it.next();\n      if (nextVal.done) {\n        currentKey = SENTINEL as unknown as K;\n        //                    ^^^^^^^^^^^^^^^ Hack!\n        return;\n      }\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n\n    targetKey = currentKey;\n    yield [currentKey, grouper(targetKey)];\n  }\n}\n\nexport function groupBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!Object.hasOwn(result, key)) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n  return result;\n}\n\nexport function indexBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    result[key] = item;\n  }\n  return result;\n}\n\n/**\n * Returns an iterator that filters elements from data returning only those\n * that have a corresponding element in selectors that evaluates to `true`.\n * Stops when either the data or selectors iterables has been exhausted.\n */\nexport function* icompress<T>(data: Iterable<T>, selectors: Iterable<boolean>): IterableIterator<T> {\n  for (const [d, s] of izip(data, selectors)) {\n    if (s) {\n      yield d;\n    }\n  }\n}\n\n/**\n * Returns an iterator that filters elements from iterable returning only those\n * for which the predicate is true.\n */\nexport function ifilter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): IterableIterator<N>;\nexport function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;\nexport function* ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  for (const value of iterable) {\n    if (predicate(value, index++)) {\n      yield value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that computes the given mapper function using arguments\n * from each of the iterables.\n */\nexport function* imap<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): IterableIterator<V> {\n  for (const value of iterable) {\n    yield mapper(value);\n  }\n}\n\n/**\n * Returns an iterator that returns selected elements from the iterable.  If\n * `start` is non-zero, then elements from the iterable are skipped until start\n * is reached.  Then, elements are returned by making steps of `step` (defaults\n * to 1).  If set to higher than 1, items will be skipped.  If `stop` is\n * provided, then iteration continues until the iterator reached that index,\n * otherwise, the iterable will be fully exhausted.  `islice()` does not\n * support negative values for `start`, `stop`, or `step`.\n */\nexport function islice<T>(iterable: Iterable<T>, stop: number): IterableIterator<T>;\nexport function islice<T>(\n  iterable: Iterable<T>,\n  start: number,\n  stop?: number | null,\n  step?: number,\n): IterableIterator<T>;\nexport function* islice<T>(\n  iterable: Iterable<T>,\n  stopOrStart: number,\n  possiblyStop?: number | null,\n  step = 1,\n): IterableIterator<T> {\n  let start, stop;\n  if (possiblyStop !== undefined) {\n    // islice(iterable, start, stop[, step])\n    start = stopOrStart;\n    stop = possiblyStop;\n  } else {\n    // islice(iterable, stop)\n    start = 0;\n    stop = stopOrStart;\n  }\n\n  if (start < 0) throw new Error(\"start cannot be negative\");\n  if (stop !== null && stop < 0) throw new Error(\"stop cannot be negative\");\n  if (step <= 0) throw new Error(\"step cannot be negative\");\n\n  let i = -1;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (true) {\n    i++;\n    if (stop !== null && i >= stop) return; // early returns, so we cannot use a for..of loop!\n\n    res = it.next();\n    if (res.done) return;\n\n    if (i < start) continue;\n    if ((i - start) % step === 0) {\n      yield res.value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.\n * Used for lock-step iteration over several iterables at a time.  When\n * iterating over two iterables, use `izip2`.  When iterating over three\n * iterables, use `izip3`, etc.  `izip` is an alias for `izip2`.\n */\nexport function* izip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): IterableIterator<[T1, T2]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (!x.done && !y.done) {\n      yield [x.value, y.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Like izip2, but for three input iterables.\n */\nexport function* izip3<T1, T2, T3>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n): IterableIterator<[T1, T2, T3]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (!x.done && !y.done && !z.done) {\n      yield [x.value, y.value, z.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\nexport const izip2 = izip;\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.  If\n * the iterables are of uneven length, missing values are filled-in with\n * fillvalue.  Iteration continues until the longest iterable is exhausted.\n */\nexport function* izipLongest2<T1, T2, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (x.done && y.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_];\n    }\n  }\n}\n\n/**\n * See izipLongest2, but for three.\n */\nexport function* izipLongest3<T1, T2, T3, D = undefined>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D, T3 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (x.done && y.done && z.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_, !z.done ? z.value : filler_];\n    }\n  }\n}\n\n/**\n * Like the other izips (`izip`, `izip3`, etc), but generalized to take an\n * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.\n *\n * **Note:** Due to Flow type system limitations, you can only \"generially\" zip\n * iterables with homogeneous types, so you cannot mix types like <A, B> like\n * you can with izip2().\n */\nexport function* izipMany<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // Make them all iterables\n  const iterables = iters.map(iter);\n\n  for (;;) {\n    const heads: IteratorResult<T, undefined>[] = iterables.map((xs) => xs.next());\n    if (every(heads, (h) => !h.done)) {\n      yield heads.map((h) => h.value as T);\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Return successive `r`-length permutations of elements in the iterable.\n *\n * If `r` is not specified, then `r` defaults to the length of the iterable and\n * all possible full-length permutations are generated.\n *\n * Permutations are emitted in lexicographic sort order.  So, if the input\n * iterable is sorted, the permutation tuples will be produced in sorted order.\n *\n * Elements are treated as unique based on their position, not on their value.\n * So if the input elements are unique, there will be no repeat values in each\n * permutation.\n */\nexport function* permutations<T>(iterable: Iterable<T>, r?: number): IterableIterator<T[]> {\n  const pool = Array.from(iterable);\n  const n = pool.length;\n  const x = r ?? n;\n\n  if (x > n) {\n    return;\n  }\n\n  let indices: number[] = Array.from(range(n));\n  const cycles: number[] = Array.from(range(n, n - x, -1));\n  const poolgetter = (i: number) => pool[i];\n\n  yield indices.slice(0, x).map(poolgetter);\n\n  while (n > 0) {\n    let cleanExit = true;\n    for (const i of range(x - 1, -1, -1)) {\n      cycles[i] -= 1;\n      if (cycles[i] === 0) {\n        indices = indices\n          .slice(0, i)\n          .concat(indices.slice(i + 1))\n          .concat(indices.slice(i, i + 1));\n        cycles[i] = n - i;\n      } else {\n        const j: number = cycles[i];\n\n        const [p, q] = [indices[indices.length - j], indices[i]];\n        indices[i] = p;\n        indices[indices.length - j] = q;\n        yield indices.slice(0, x).map(poolgetter);\n        cleanExit = false;\n        break;\n      }\n    }\n\n    if (cleanExit) {\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces values over and over again.  Runs\n * indefinitely unless the times argument is specified.\n */\nexport function* repeat<T>(thing: T, times?: number): IterableIterator<T> {\n  if (times === undefined) {\n    for (;;) {\n      yield thing;\n    }\n  } else {\n    for (const _ of range(times)) {\n      yield thing;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces elements from the iterable as long as the\n * predicate is true.\n */\nexport function* takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) return; // early return, so we cannot use for..of loop!\n    yield value;\n  }\n}\n\nexport function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][] {\n  return Array.from(izipLongest2(xs, ys, filler));\n}\n\nexport function zipLongest3<T1, T2, T3, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): [T1 | D, T2 | D, T3 | D][] {\n  return Array.from(izipLongest3(xs, ys, zs, filler));\n}\n\nexport const izipLongest = izipLongest2;\nexport const zipLongest = zipLongest2;\n\nexport function zipMany<T>(...iters: Iterable<T>[]): T[][] {\n  return Array.from(izipMany(...iters));\n}\n","import { count, ifilter, imap, izip, izip3, takewhile } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { identityPredicate, keyToCmp, numberIdentity, primitiveIdentity } from \"./utils\";\n\n/**\n * Returns the first item in the iterable for which the predicate holds, if\n * any. If no predicate is given, it will return the first value returned by\n * the iterable.\n */\nexport function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined {\n  const it = iter(iterable);\n  if (predicate === undefined) {\n    const value = it.next();\n    return value.done ? undefined : value.value;\n  } else {\n    let res: IteratorResult<T>;\n    let i = 0;\n    while (!(res = it.next()).done) {\n      const value = res.value;\n      if (predicate(value, i++)) {\n        return value;\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Returns true when all of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     all([])                           // => true\n *     all([0])                          // => false\n *     all([0, 1, 2])                    // => false\n *     all([1, 2, 3])                    // => true\n *\n * Examples with using a key function:\n *\n *     all([2, 4, 6], n => n % 2 === 0)  // => true\n *     all([2, 4, 5], n => n % 2 === 0)  // => false\n *\n */\nexport function every<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (!predicate(item, index++)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true when some of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     some([])                           // => false\n *     some([0])                          // => false\n *     some([0, 1, null, undefined])      // => true\n *\n * Examples with using a key function:\n *\n *     some([1, 4, 5], n => n % 2 === 0)  // => true\n *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false\n *\n */\nexport function some<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Alias of `every()`.\n */\nexport const all = every;\n\n/**\n * Alias of `some()`.\n */\nexport const any = some;\n\n/**\n * Returns true when any of the items in the iterable are equal to the target object.\n *\n * Examples:\n *\n *     contains([], 'whatever')         // => false\n *     contains([3], 42)                // => false\n *     contains([3], 3)                 // => true\n *     contains([0, 1, 2], 2)           // => true\n *\n */\nexport function contains<T>(haystack: Iterable<T>, needle: T): boolean {\n  return some(haystack, (x) => x === needle);\n}\n\n/**\n * Returns an iterable of enumeration pairs.  Iterable must be a sequence, an\n * iterator, or some other object which supports iteration.  The elements\n * produced by returns a tuple containing a counter value (starting from 0 by\n * default) and the values obtained from iterating over given iterable.\n *\n * Example:\n *\n *     import { enumerate } from 'itertools';\n *\n *     console.log([...enumerate(['hello', 'world'])]);\n *     // [0, 'hello'], [1, 'world']]\n */\nexport function* enumerate<T>(iterable: Iterable<T>, start = 0): IterableIterator<[number, T]> {\n  let index: number = start;\n  for (const value of iterable) {\n    yield [index++, value];\n  }\n}\n\n/**\n * Non-lazy version of ifilter().\n */\nexport function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[] {\n  return Array.from(ifilter(iterable, predicate));\n}\n\n/**\n * Returns an iterator object for the given iterable.  This can be used to\n * manually get an iterator for any iterable datastructure.  The purpose and\n * main use case of this function is to get a single iterator (a thing with\n * state, think of it as a \"cursor\") which can only be consumed once.\n */\nexport function iter<T>(iterable: Iterable<T>): IterableIterator<T> {\n  return iterable[Symbol.iterator]() as IterableIterator<T>;\n  //                                 ^^^^^^^^^^^^^^^^^^^^^^ Not safe!\n}\n\n/**\n * Non-lazy version of imap().\n */\nexport function map<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): V[] {\n  return Array.from(imap(iterable, mapper));\n}\n\n/**\n * Return the largest item in an iterable.  Only works for numbers, as ordering\n * is pretty poorly defined on any other data type in JS.  The optional `keyFn`\n * argument specifies a one-argument ordering function like that used for\n * sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are maximal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function max<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) > keyFn(y) ? x : y));\n}\n\n/**\n * Return the smallest item in an iterable.  Only works for numbers, as\n * ordering is pretty poorly defined on any other data type in JS.  The\n * optional `keyFn` argument specifies a one-argument ordering function like\n * that used for sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are minimal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function min<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) < keyFn(y) ? x : y));\n}\n\n/**\n * Internal helper for the range function\n */\nfunction range_(start: number, stop: number, step: number): IterableIterator<number> {\n  const counter = count(start, step);\n  const pred = step >= 0 ? (n: number) => n < stop : (n: number) => n > stop;\n  return takewhile(counter, pred);\n}\n\n/**\n * Returns an iterator producing all the numbers in the given range one by one,\n * starting from `start` (default 0), as long as `i < stop`, in increments of\n * `step` (default 1).\n *\n * `range(a)` is a convenient shorthand for `range(0, a)`.\n *\n * Various valid invocations:\n *\n *     range(5)           // [0, 1, 2, 3, 4]\n *     range(2, 5)        // [2, 3, 4]\n *     range(0, 5, 2)     // [0, 2, 4]\n *     range(5, 0, -1)    // [5, 4, 3, 2, 1]\n *     range(-3)          // []\n *\n * For a positive `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n < stop` is satisfied.\n *\n * For a negative `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n > stop` is satisfied.\n *\n * The produced range will be empty if the first value to produce already does\n * not meet the value constraint.\n */\nexport function range(stop: number): IterableIterator<number>;\nexport function range(start: number, stop: number, step?: number): IterableIterator<number>;\nexport function range(startOrStop: number, definitelyStop?: number, step = 1): IterableIterator<number> {\n  if (definitelyStop !== undefined) {\n    return range_(startOrStop /* as start */, definitelyStop, step);\n  } else {\n    return range_(0, startOrStop /* as stop */, step);\n  }\n}\n\nexport function xrange(stop: number): number[];\nexport function xrange(start: number, stop: number, step?: number): number[];\nexport function xrange(startOrStop: number, definitelyStop?: number, step = 1): number[] {\n  if (definitelyStop !== undefined) {\n    return Array.from(range_(startOrStop /* as start */, definitelyStop, step));\n  } else {\n    return Array.from(range_(0, startOrStop /* as stop */, step));\n  }\n}\n\n/**\n * Apply function of two arguments cumulatively to the items of sequence, from\n * left to right, so as to reduce the sequence to a single value.  For example:\n *\n *     reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)\n *\n * calculates\n *\n *     (((((0+1)+2)+3)+4)+5)\n *\n * The left argument, `x`, is the accumulated value and the right argument,\n * `y`, is the update value from the sequence.\n *\n * **Difference between `reduce()` and `reduce\\_()`**:  `reduce()` requires an\n * explicit initializer, whereas `reduce_()` will automatically use the first\n * item in the given iterable as the initializer.  When using `reduce()`, the\n * initializer value is placed before the items of the sequence in the\n * calculation, and serves as a default when the sequence is empty.  When using\n * `reduce_()`, and the given iterable is empty, then no default value can be\n * derived and `undefined` will be returned.\n */\nexport function reduce<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined;\nexport function reduce<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O;\nexport function reduce<T, O>(\n  iterable: Iterable<T>,\n  reducer: ((agg: T, item: T, index: number) => T) | ((agg: O, item: T, index: number) => O),\n  start?: O,\n): O | (T | undefined) {\n  if (start === undefined) {\n    return reduce2(iterable, reducer as (agg: T, item: T, index: number) => T);\n  } else {\n    return reduce3(iterable, reducer as (agg: O, item: T, index: number) => O, start);\n  }\n}\n\nfunction reduce3<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O {\n  let output = start;\n  let index = 0;\n  for (const item of iterable) {\n    output = reducer(output, item, index++);\n  }\n  return output;\n}\n\nfunction reduce2<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined {\n  const it = iter(iterable);\n  const start = find(it);\n  if (start === undefined) {\n    return undefined;\n  } else {\n    return reduce3(it, reducer, start);\n  }\n}\n\n/**\n * Return a new sorted list from the items in iterable.\n *\n * Has two optional arguments:\n *\n * * `keyFn` specifies a function of one argument providing a primitive\n *   identity for each element in the iterable.  that will be used to compare.\n *   The default value is to use a default identity function that is only\n *   defined for primitive types.\n *\n * * `reverse` is a boolean value.  If `true`, then the list elements are\n *   sorted as if each comparison were reversed.\n */\nexport function sorted<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n  reverse = false,\n): T[] {\n  const result = Array.from(iterable);\n  result.sort(keyToCmp(keyFn)); // sort in-place\n\n  if (reverse) {\n    result.reverse(); // reverse in-place\n  }\n\n  return result;\n}\n\n/**\n * Sums the items of an iterable from left to right and returns the total.  The\n * sum will defaults to 0 if the iterable is empty.\n */\nexport function sum(iterable: Iterable<number>): number {\n  return reduce(iterable, (x, y) => x + y, 0);\n}\n\n/**\n * See izip.\n */\nexport function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][] {\n  return Array.from(izip(xs, ys));\n}\n\n/**\n * See izip3.\n */\nexport function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][] {\n  return Array.from(izip3(xs, ys, zs));\n}\n","import { find } from \"./builtins\";\nimport { ifilter, imap } from \"./itertools\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate } from \"./types\";\n\nfunction isNullish<T>(x: T): x is NonNullable<T> {\n  return x != null;\n}\n\nfunction isDefined(x: unknown): boolean {\n  return x !== undefined;\n}\n\n/**\n * Returns an iterable, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For an eager version, @see compact().\n */\nexport function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T> {\n  return ifilter(iterable, isNullish);\n}\n\n/**\n * Returns an array, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For a lazy version, @see icompact().\n */\nexport function compact<T>(iterable: Iterable<T | null | undefined>): T[] {\n  return Array.from(icompact(iterable));\n}\n\n/**\n * Removes all \"nullish\" values from the given object. Returns a new object.\n *\n *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })\n *     { a: 1, c: 0 }\n *\n */\nexport function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V> {\n  const result = {} as Record<K, V>;\n  for (const [key, value_] of Object.entries(obj)) {\n    const value = value_ as V | null | undefined;\n    if (value != null) {\n      result[key as K] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Almost an alias of find(). There only is a difference if no key fn is\n * provided. In that case, `find()` will return the first item in the iterable,\n * whereas `first()` will return the first non-`undefined` value in the\n * iterable.\n */\nexport function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined {\n  return find(iterable, keyFn ?? isDefined);\n}\n\n/**\n * Returns 0 or more values for every value in the given iterable.\n * Technically, it's just calling map(), followed by flatten(), but it's a very\n * useful operation if you want to map over a structure, but not have a 1:1\n * input-output mapping.  Instead, if you want to potentially return 0 or more\n * values per input element, use flatmap():\n *\n * For example, to return all numbers `n` in the input iterable `n` times:\n *\n *     >>> const repeatN = n => repeat(n, n);\n *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]\n *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0\n *\n */\nexport function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S> {\n  return flatten(imap(iterable, mapper));\n}\n"],"mappings":"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","names":["count","first","grouper","heads"]}
+{"version":3,"sources":["../src/utils.ts","../src/more-itertools.ts","../src/itertools.ts","../src/builtins.ts","../src/custom.ts"],"sourcesContent":["import type { Primitive } from \"./types\";\n\ntype CmpFn<T> = (a: T, b: T) => number;\n\nexport function keyToCmp<T>(keyFn: (item: T) => Primitive): CmpFn<T> {\n  return (a: T, b: T) => {\n    const ka = keyFn(a);\n    const kb = keyFn(b);\n    // istanbul ignore else -- @preserve\n    if (typeof ka === \"boolean\" && typeof kb === \"boolean\") {\n      return ka === kb ? 0 : !ka && kb ? -1 : 1;\n    } else if (typeof ka === \"number\" && typeof kb === \"number\") {\n      return ka - kb;\n    } else if (typeof ka === \"string\" && typeof kb === \"string\") {\n      return ka === kb ? 0 : ka < kb ? -1 : 1;\n    } else {\n      return -1;\n    }\n  };\n}\n\nexport function identityPredicate(x: unknown): boolean {\n  return !!x;\n}\n\nexport function numberIdentity(x: unknown): number {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"number\") {\n    throw new Error(\"Inputs must be numbers\");\n  }\n  return x;\n}\n\nexport function primitiveIdentity<P extends Primitive>(x: P): P;\nexport function primitiveIdentity(x: unknown): Primitive;\nexport function primitiveIdentity(x: unknown): Primitive {\n  // istanbul ignore if -- @preserve\n  if (typeof x !== \"string\" && typeof x !== \"number\" && typeof x !== \"boolean\") {\n    throw new Error(\"Please provide a key function that can establish object identity\");\n  }\n  return x;\n}\n","import { iter, map } from \"./builtins\";\nimport { izip, repeat } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\n/**\n * Break iterable into lists of length `size`:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6], 3)]\n *     // [[1, 2, 3], [4, 5, 6]]\n *\n * If the length of iterable is not evenly divisible by `size`, the last returned\n * list will be shorter:\n *\n *     [...chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)]\n *     // [[1, 2, 3], [4, 5, 6], [7, 8]]\n */\nexport function* chunked<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]> {\n  if (size < 1) {\n    throw new Error(`Invalid chunk size: ${size}`);\n  }\n\n  const it = iter(iterable);\n  for (;;) {\n    const chunk = take(size, it);\n    if (chunk.length > 0) {\n      yield chunk;\n    }\n    if (chunk.length < size) {\n      return;\n    }\n  }\n}\n\n/**\n * Return an iterator flattening one level of nesting in a list of lists:\n *\n *     [...flatten([[0, 1], [2, 3]])]\n *     // [0, 1, 2, 3]\n *\n */\nexport function* flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T> {\n  for (const iterable of iterableOfIterables) {\n    for (const item of iterable) {\n      yield item;\n    }\n  }\n}\n\n/**\n * Intersperse filler element `value` among the items in `iterable`.\n *\n *     >>> [...intersperse(-1, range(1, 5))]\n *     [1, -1, 2, -1, 3, -1, 4]\n *\n */\nexport function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V> {\n  const stream = flatten<T | V>(izip(repeat(value), iterable));\n  stream.next(); // eat away and discard the first value from the output\n  return stream;\n}\n\n/**\n * Returns an iterable containing only the first `n` elements of the given\n * iterable.\n */\nexport function* itake<T>(n: number, iterable: Iterable<T>): IterableIterator<T> {\n  const it = iter(iterable);\n  let count = n;\n  while (count-- > 0) {\n    const s = it.next();\n    if (!s.done) {\n      yield s.value;\n    } else {\n      // Iterable exhausted, quit early\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator of paired items, overlapping, from the original.  When\n * the input iterable has a finite number of items `n`, the outputted iterable\n * will have `n - 1` items.\n *\n *     >>> pairwise([8, 2, 0, 7])\n *     [(8, 2), (2, 0), (0, 7)]\n *\n */\nexport function* pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]> {\n  const it = iter(iterable);\n  const first = it.next();\n  if (first.done) {\n    return;\n  }\n\n  let r1: T = first.value;\n  for (const r2 of it) {\n    yield [r1, r2];\n    r1 = r2;\n  }\n}\n\n/**\n * Returns a 2-tuple of arrays.  Splits the elements in the input iterable into\n * either of the two arrays.  Will fully exhaust the input iterable.  The first\n * array contains all items that match the predicate, the second the rest:\n *\n *     >>> const isOdd = x => x % 2 !== 0;\n *     >>> const iterable = range(10);\n *     >>> const [odds, evens] = partition(iterable, isOdd);\n *     >>> odds\n *     [1, 3, 5, 7, 9]\n *     >>> evens\n *     [0, 2, 4, 6, 8]\n *\n */\nexport function partition<T, N extends T>(\n  iterable: Iterable<T>,\n  predicate: (item: T, index: number) => item is N,\n): [N[], Exclude<T, N>[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];\nexport function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]] {\n  const good = [];\n  const bad = [];\n\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      good.push(item);\n    } else {\n      bad.push(item);\n    }\n  }\n\n  return [good, bad];\n}\n\n/**\n * Yields the next item from each iterable in turn, alternating between them.\n * Continues until all items are exhausted.\n *\n *     >>> [...roundrobin([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [1, 4, 5, 2, 6, 3, 7, 8]\n */\nexport function* roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        yield result.value;\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n  }\n}\n\n/**\n * Yields the heads of all of the given iterables.  This is almost like\n * `roundrobin()`, except that the yielded outputs are grouped in to the\n * \"rounds\":\n *\n *     >>> [...heads([1, 2, 3], [4], [5, 6, 7, 8])]\n *     [[1, 4, 5], [2, 6], [3, 7], [8]]\n *\n * This is also different from `zipLongest()`, since the number of items in\n * each round can decrease over time, rather than being filled with a filler.\n */\nexport function* heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // We'll only keep lazy versions of the input iterables in here that we'll\n  // slowly going to exhaust.  Once an iterable is exhausted, it will be\n  // removed from this list.  Once the entire list is empty, this algorithm\n  // ends.\n  const iterables: Iterator<T>[] = map(iters, iter);\n\n  while (iterables.length > 0) {\n    let index = 0;\n    const round = [];\n    while (index < iterables.length) {\n      const it = iterables[index];\n      const result = it.next();\n\n      if (!result.done) {\n        round.push(result.value);\n        index++;\n      } else {\n        // This iterable is exhausted, make sure to remove it from the\n        // list of iterables.  We'll splice the array from under our\n        // feet, and NOT advancing the index counter.\n        iterables.splice(index, 1); // intentional side-effect!\n      }\n    }\n    if (round.length > 0) {\n      yield round;\n    }\n  }\n}\n\n/**\n * Non-lazy version of itake().\n */\nexport function take<T>(n: number, iterable: Iterable<T>): T[] {\n  return Array.from(itake(n, iterable));\n}\n\n/**\n * Yield unique elements, preserving order.\n *\n *     >>> [...uniqueEverseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D']\n *     >>> [...uniqueEverseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C']\n *\n */\nexport function* uniqueEverseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  const seen = new Set();\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      yield item;\n    }\n  }\n}\n\n/**\n * Yield only elements from the input that occur more than once. Needs to\n * consume the entire input before being able to produce the first result.\n *\n *     >>> [...dupes('AAAABCDEEEFABG')]\n *     [['A', 'A', 'A', 'A', 'A'], ['E', 'E', 'E'], ['B', 'B']]\n *     >>> [...dupes('AbBCcAB', s => s.toLowerCase())]\n *     [['b', 'B', 'B'], ['C', 'c'], ['A', 'A']]\n *\n */\nexport function dupes<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T[]> {\n  const multiples = new Map<Primitive, T[]>();\n\n  {\n    const singles = new Map<Primitive, T>();\n    for (const item of iterable) {\n      const key = keyFn(item);\n      if (multiples.has(key)) {\n        multiples.get(key)!.push(item);\n      } else if (singles.has(key)) {\n        multiples.set(key, [singles.get(key)!, item]);\n        singles.delete(key);\n      } else {\n        singles.set(key, item);\n      }\n    }\n  }\n\n  return multiples.values();\n}\n\n/**\n * Yields elements in order, ignoring serial duplicates.\n *\n *     >>> [...uniqueJustseen('AAAABBBCCDAABBB')]\n *     ['A', 'B', 'C', 'D', 'A', 'B']\n *     >>> [...uniqueJustseen('AbBCcAB', s => s.toLowerCase())]\n *     ['A', 'b', 'C', 'A', 'B']\n *\n */\nexport function* uniqueJustseen<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n): IterableIterator<T> {\n  let last = undefined;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (key !== last) {\n      yield item;\n      last = key;\n    }\n  }\n}\n","import { every, iter, range } from \"./builtins\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { primitiveIdentity } from \"./utils\";\n\nconst SENTINEL = Symbol();\n\n/**\n * Returns an iterator that returns elements from the first iterable until it\n * is exhausted, then proceeds to the next iterable, until all of the iterables\n * are exhausted.  Used for treating consecutive sequences as a single\n * sequence.\n */\nexport function chain<T>(...iterables: Iterable<T>[]): IterableIterator<T> {\n  return flatten(iterables);\n}\n\n/**\n * Returns an iterator that counts up values starting with number `start`\n * (default 0), incrementing by `step`.  To decrement, use a negative step\n * number.\n */\nexport function* count(start = 0, step = 1): IterableIterator<number> {\n  let n = start;\n  for (;;) {\n    yield n;\n    n += step;\n  }\n}\n\n/**\n * Non-lazy version of icompress().\n */\nexport function compress<T>(data: Iterable<T>, selectors: Iterable<boolean>): T[] {\n  return Array.from(icompress(data, selectors));\n}\n\n/**\n * Returns an iterator producing elements from the iterable and saving a copy\n * of each.  When the iterable is exhausted, return elements from the saved\n * copy.  Repeats indefinitely.\n */\nexport function* cycle<T>(iterable: Iterable<T>): IterableIterator<T> {\n  const saved = [];\n  for (const element of iterable) {\n    yield element;\n    saved.push(element);\n  }\n\n  while (saved.length > 0) {\n    for (const element of saved) {\n      yield element;\n    }\n  }\n}\n\n/**\n * Returns an iterator that drops elements from the iterable as long as the\n * predicate is true; afterwards, returns every remaining element.  Note, the\n * iterator does not produce any output until the predicate first becomes\n * false.\n */\nexport function* dropwhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) {\n      yield value;\n      break; // we break, so we cannot use a for..of loop!\n    }\n  }\n\n  for (const value of it) {\n    yield value;\n  }\n}\n\n/** @deprecated Please rename to `igroupby`, or use the new eager version `groupBy`. */\nexport const groupby = igroupby;\n\nexport function* igroupby<T, K extends Primitive>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => K = primitiveIdentity,\n): Generator<[K, Generator<T, undefined>], undefined> {\n  const it = iter(iterable);\n\n  let currentValue: T;\n  let currentKey: K = SENTINEL as unknown as K;\n  //                           ^^^^^^^^^^^^^^^ Hack!\n  let targetKey: K = currentKey;\n\n  const grouper = function* grouper(tgtKey: K): Generator<T, undefined> {\n    while (currentKey === tgtKey) {\n      yield currentValue;\n\n      const nextVal = it.next();\n      if (nextVal.done) return;\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n  };\n\n  for (;;) {\n    while (currentKey === targetKey) {\n      const nextVal = it.next();\n      if (nextVal.done) {\n        currentKey = SENTINEL as unknown as K;\n        //                    ^^^^^^^^^^^^^^^ Hack!\n        return;\n      }\n      currentValue = nextVal.value;\n      currentKey = keyFn(currentValue);\n    }\n\n    targetKey = currentKey;\n    yield [currentKey, grouper(targetKey)];\n  }\n}\n\nexport function groupBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    if (!Object.hasOwn(result, key)) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n  return result;\n}\n\nexport function indexBy<T, K extends string | number>(iterable: Iterable<T>, keyFn: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n  for (const item of iterable) {\n    const key = keyFn(item);\n    result[key] = item;\n  }\n  return result;\n}\n\n/**\n * Returns an iterator that filters elements from data returning only those\n * that have a corresponding element in selectors that evaluates to `true`.\n * Stops when either the data or selectors iterables has been exhausted.\n */\nexport function* icompress<T>(data: Iterable<T>, selectors: Iterable<boolean>): IterableIterator<T> {\n  for (const [d, s] of izip(data, selectors)) {\n    if (s) {\n      yield d;\n    }\n  }\n}\n\n/**\n * Returns an iterator that filters elements from iterable returning only those\n * for which the predicate is true.\n */\nexport function ifilter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): IterableIterator<N>;\nexport function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;\nexport function* ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  for (const value of iterable) {\n    if (predicate(value, index++)) {\n      yield value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that computes the given mapper function using arguments\n * from each of the iterables.\n */\nexport function* imap<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): IterableIterator<V> {\n  for (const value of iterable) {\n    yield mapper(value);\n  }\n}\n\n/**\n * Returns an iterator that returns selected elements from the iterable.  If\n * `start` is non-zero, then elements from the iterable are skipped until start\n * is reached.  Then, elements are returned by making steps of `step` (defaults\n * to 1).  If set to higher than 1, items will be skipped.  If `stop` is\n * provided, then iteration continues until the iterator reached that index,\n * otherwise, the iterable will be fully exhausted.  `islice()` does not\n * support negative values for `start`, `stop`, or `step`.\n */\nexport function islice<T>(iterable: Iterable<T>, stop: number): IterableIterator<T>;\nexport function islice<T>(\n  iterable: Iterable<T>,\n  start: number,\n  stop?: number | null,\n  step?: number,\n): IterableIterator<T>;\nexport function* islice<T>(\n  iterable: Iterable<T>,\n  stopOrStart: number,\n  possiblyStop?: number | null,\n  step = 1,\n): IterableIterator<T> {\n  let start, stop;\n  if (possiblyStop !== undefined) {\n    // islice(iterable, start, stop[, step])\n    start = stopOrStart;\n    stop = possiblyStop;\n  } else {\n    // islice(iterable, stop)\n    start = 0;\n    stop = stopOrStart;\n  }\n\n  if (start < 0) throw new Error(\"start cannot be negative\");\n  if (stop !== null && stop < 0) throw new Error(\"stop cannot be negative\");\n  if (step <= 0) throw new Error(\"step cannot be negative\");\n\n  let i = -1;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (true) {\n    i++;\n    if (stop !== null && i >= stop) return; // early returns, so we cannot use a for..of loop!\n\n    res = it.next();\n    if (res.done) return;\n\n    if (i < start) continue;\n    if ((i - start) % step === 0) {\n      yield res.value;\n    }\n  }\n}\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.\n * Used for lock-step iteration over several iterables at a time.  When\n * iterating over two iterables, use `izip2`.  When iterating over three\n * iterables, use `izip3`, etc.  `izip` is an alias for `izip2`.\n */\nexport function* izip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): IterableIterator<[T1, T2]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (!x.done && !y.done) {\n      yield [x.value, y.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Like izip2, but for three input iterables.\n */\nexport function* izip3<T1, T2, T3>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n): IterableIterator<[T1, T2, T3]> {\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (!x.done && !y.done && !z.done) {\n      yield [x.value, y.value, z.value];\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\nexport const izip2 = izip;\n\n/**\n * Returns an iterator that aggregates elements from each of the iterables.  If\n * the iterables are of uneven length, missing values are filled-in with\n * fillvalue.  Iteration continues until the longest iterable is exhausted.\n */\nexport function* izipLongest2<T1, T2, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    if (x.done && y.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_];\n    }\n  }\n}\n\n/**\n * See izipLongest2, but for three.\n */\nexport function* izipLongest3<T1, T2, T3, D = undefined>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): IterableIterator<[T1 | D, T2 | D, T3 | D]> {\n  const filler_ = filler as D;\n  const ixs = iter(xs);\n  const iys = iter(ys);\n  const izs = iter(zs);\n  for (;;) {\n    const x = ixs.next();\n    const y = iys.next();\n    const z = izs.next();\n    if (x.done && y.done && z.done) {\n      // All iterables exhausted\n      return;\n    } else {\n      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_, !z.done ? z.value : filler_];\n    }\n  }\n}\n\n/**\n * Like the other izips (`izip`, `izip3`, etc), but generalized to take an\n * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.\n *\n * **Note:** Due to Flow type system limitations, you can only \"generially\" zip\n * iterables with homogeneous types, so you cannot mix types like <A, B> like\n * you can with izip2().\n */\nexport function* izipMany<T>(...iters: Iterable<T>[]): IterableIterator<T[]> {\n  // Make them all iterables\n  const iterables = iters.map(iter);\n\n  for (;;) {\n    const heads: IteratorResult<T, undefined>[] = iterables.map((xs) => xs.next());\n    if (every(heads, (h) => !h.done)) {\n      yield heads.map((h) => h.value as T);\n    } else {\n      // One of the iterables exhausted\n      return;\n    }\n  }\n}\n\n/**\n * Return successive `r`-length permutations of elements in the iterable.\n *\n * If `r` is not specified, then `r` defaults to the length of the iterable and\n * all possible full-length permutations are generated.\n *\n * Permutations are emitted in lexicographic sort order.  So, if the input\n * iterable is sorted, the permutation tuples will be produced in sorted order.\n *\n * Elements are treated as unique based on their position, not on their value.\n * So if the input elements are unique, there will be no repeat values in each\n * permutation.\n */\nexport function* permutations<T>(iterable: Iterable<T>, r?: number): IterableIterator<T[]> {\n  const pool = Array.from(iterable);\n  const n = pool.length;\n  const x = r ?? n;\n\n  if (x > n) {\n    return;\n  }\n\n  let indices: number[] = Array.from(range(n));\n  const cycles: number[] = Array.from(range(n, n - x, -1));\n  const poolgetter = (i: number) => pool[i];\n\n  yield indices.slice(0, x).map(poolgetter);\n\n  while (n > 0) {\n    let cleanExit = true;\n    for (const i of range(x - 1, -1, -1)) {\n      cycles[i] -= 1;\n      if (cycles[i] === 0) {\n        indices = indices\n          .slice(0, i)\n          .concat(indices.slice(i + 1))\n          .concat(indices.slice(i, i + 1));\n        cycles[i] = n - i;\n      } else {\n        const j: number = cycles[i];\n\n        const [p, q] = [indices[indices.length - j], indices[i]];\n        indices[i] = p;\n        indices[indices.length - j] = q;\n        yield indices.slice(0, x).map(poolgetter);\n        cleanExit = false;\n        break;\n      }\n    }\n\n    if (cleanExit) {\n      return;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces values over and over again.  Runs\n * indefinitely unless the times argument is specified.\n */\nexport function* repeat<T>(thing: T, times?: number): IterableIterator<T> {\n  if (times === undefined) {\n    for (;;) {\n      yield thing;\n    }\n  } else {\n    for (const _ of range(times)) {\n      yield thing;\n    }\n  }\n}\n\n/**\n * Returns an iterator that produces elements from the iterable as long as the\n * predicate is true.\n */\nexport function* takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {\n  let index = 0;\n  const it = iter(iterable);\n  let res: IteratorResult<T>;\n  while (!(res = it.next()).done) {\n    const value = res.value;\n    if (!predicate(value, index++)) return; // early return, so we cannot use for..of loop!\n    yield value;\n  }\n}\n\nexport function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][] {\n  return Array.from(izipLongest2(xs, ys, filler));\n}\n\nexport function zipLongest3<T1, T2, T3, D>(\n  xs: Iterable<T1>,\n  ys: Iterable<T2>,\n  zs: Iterable<T3>,\n  filler?: D,\n): [T1 | D, T2 | D, T3 | D][] {\n  return Array.from(izipLongest3(xs, ys, zs, filler));\n}\n\nexport const izipLongest = izipLongest2;\nexport const zipLongest = zipLongest2;\n\nexport function zipMany<T>(...iters: Iterable<T>[]): T[][] {\n  return Array.from(izipMany(...iters));\n}\n","import { count, ifilter, imap, izip, izip3, takewhile } from \"./itertools\";\nimport type { Predicate, Primitive } from \"./types\";\nimport { identityPredicate, keyToCmp, numberIdentity, primitiveIdentity } from \"./utils\";\n\n/**\n * Returns the first item in the iterable for which the predicate holds, if\n * any. If no predicate is given, it will return the first value returned by\n * the iterable.\n */\nexport function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined {\n  const it = iter(iterable);\n  if (predicate === undefined) {\n    const value = it.next();\n    return value.done ? undefined : value.value;\n  } else {\n    let res: IteratorResult<T>;\n    let i = 0;\n    while (!(res = it.next()).done) {\n      const value = res.value;\n      if (predicate(value, i++)) {\n        return value;\n      }\n    }\n    return undefined;\n  }\n}\n\n/**\n * Returns true when all of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     all([])                           // => true\n *     all([0])                          // => false\n *     all([0, 1, 2])                    // => false\n *     all([1, 2, 3])                    // => true\n *\n * Examples with using a key function:\n *\n *     all([2, 4, 6], n => n % 2 === 0)  // => true\n *     all([2, 4, 5], n => n % 2 === 0)  // => false\n *\n */\nexport function every<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (!predicate(item, index++)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true when some of the items in iterable are truthy.  An optional key\n * function can be used to define what truthiness means for this specific\n * collection.\n *\n * Examples:\n *\n *     some([])                           // => false\n *     some([0])                          // => false\n *     some([0, 1, null, undefined])      // => true\n *\n * Examples with using a key function:\n *\n *     some([1, 4, 5], n => n % 2 === 0)  // => true\n *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false\n *\n */\nexport function some<T>(iterable: Iterable<T>, predicate: Predicate<T> = identityPredicate): boolean {\n  let index = 0;\n  for (const item of iterable) {\n    if (predicate(item, index++)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Alias of `every()`.\n */\nexport const all = every;\n\n/**\n * Alias of `some()`.\n */\nexport const any = some;\n\n/**\n * Returns true when any of the items in the iterable are equal to the target object.\n *\n * Examples:\n *\n *     contains([], 'whatever')         // => false\n *     contains([3], 42)                // => false\n *     contains([3], 3)                 // => true\n *     contains([0, 1, 2], 2)           // => true\n *\n */\nexport function contains<T>(haystack: Iterable<T>, needle: T): boolean {\n  return some(haystack, (x) => x === needle);\n}\n\n/**\n * Returns an iterable of enumeration pairs.  Iterable must be a sequence, an\n * iterator, or some other object which supports iteration.  The elements\n * produced by returns a tuple containing a counter value (starting from 0 by\n * default) and the values obtained from iterating over given iterable.\n *\n * Example:\n *\n *     import { enumerate } from 'itertools';\n *\n *     console.log([...enumerate(['hello', 'world'])]);\n *     // [0, 'hello'], [1, 'world']]\n */\nexport function* enumerate<T>(iterable: Iterable<T>, start = 0): IterableIterator<[number, T]> {\n  let index: number = start;\n  for (const value of iterable) {\n    yield [index++, value];\n  }\n}\n\n/**\n * Non-lazy version of ifilter().\n */\nexport function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];\nexport function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[] {\n  return Array.from(ifilter(iterable, predicate));\n}\n\n/**\n * Returns an iterator object for the given iterable.  This can be used to\n * manually get an iterator for any iterable datastructure.  The purpose and\n * main use case of this function is to get a single iterator (a thing with\n * state, think of it as a \"cursor\") which can only be consumed once.\n */\nexport function iter<T>(iterable: Iterable<T>): IterableIterator<T> {\n  return iterable[Symbol.iterator]() as IterableIterator<T>;\n  //                                 ^^^^^^^^^^^^^^^^^^^^^^ Not safe!\n}\n\n/**\n * Non-lazy version of imap().\n */\nexport function map<T, V>(iterable: Iterable<T>, mapper: (item: T) => V): V[] {\n  return Array.from(imap(iterable, mapper));\n}\n\n/**\n * Return the largest item in an iterable.  Only works for numbers, as ordering\n * is pretty poorly defined on any other data type in JS.  The optional `keyFn`\n * argument specifies a one-argument ordering function like that used for\n * sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are maximal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function max<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) > keyFn(y) ? x : y));\n}\n\n/**\n * Return the smallest item in an iterable.  Only works for numbers, as\n * ordering is pretty poorly defined on any other data type in JS.  The\n * optional `keyFn` argument specifies a one-argument ordering function like\n * that used for sorted().\n *\n * If the iterable is empty, `undefined` is returned.\n *\n * If multiple items are minimal, the function returns either one of them, but\n * which one is not defined.\n */\nexport function min<T>(iterable: Iterable<T>, keyFn: (item: T) => number = numberIdentity): T | undefined {\n  return reduce2(iterable, (x, y) => (keyFn(x) < keyFn(y) ? x : y));\n}\n\n/**\n * Internal helper for the range function\n */\nfunction range_(start: number, stop: number, step: number): IterableIterator<number> {\n  const counter = count(start, step);\n  const pred = step >= 0 ? (n: number) => n < stop : (n: number) => n > stop;\n  return takewhile(counter, pred);\n}\n\n/**\n * Returns an iterator producing all the numbers in the given range one by one,\n * starting from `start` (default 0), as long as `i < stop`, in increments of\n * `step` (default 1).\n *\n * `range(a)` is a convenient shorthand for `range(0, a)`.\n *\n * Various valid invocations:\n *\n *     range(5)           // [0, 1, 2, 3, 4]\n *     range(2, 5)        // [2, 3, 4]\n *     range(0, 5, 2)     // [0, 2, 4]\n *     range(5, 0, -1)    // [5, 4, 3, 2, 1]\n *     range(-3)          // []\n *\n * For a positive `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n < stop` is satisfied.\n *\n * For a negative `step`, the iterator will keep producing values `n` as long\n * as the stop condition `n > stop` is satisfied.\n *\n * The produced range will be empty if the first value to produce already does\n * not meet the value constraint.\n */\nexport function range(stop: number): IterableIterator<number>;\nexport function range(start: number, stop: number, step?: number): IterableIterator<number>;\nexport function range(startOrStop: number, definitelyStop?: number, step = 1): IterableIterator<number> {\n  if (definitelyStop !== undefined) {\n    return range_(startOrStop /* as start */, definitelyStop, step);\n  } else {\n    return range_(0, startOrStop /* as stop */, step);\n  }\n}\n\nexport function xrange(stop: number): number[];\nexport function xrange(start: number, stop: number, step?: number): number[];\nexport function xrange(startOrStop: number, definitelyStop?: number, step = 1): number[] {\n  if (definitelyStop !== undefined) {\n    return Array.from(range_(startOrStop /* as start */, definitelyStop, step));\n  } else {\n    return Array.from(range_(0, startOrStop /* as stop */, step));\n  }\n}\n\n/**\n * Apply function of two arguments cumulatively to the items of sequence, from\n * left to right, so as to reduce the sequence to a single value.  For example:\n *\n *     reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)\n *\n * calculates\n *\n *     (((((0+1)+2)+3)+4)+5)\n *\n * The left argument, `x`, is the accumulated value and the right argument,\n * `y`, is the update value from the sequence.\n *\n * **Difference between `reduce()` and `reduce\\_()`**:  `reduce()` requires an\n * explicit initializer, whereas `reduce_()` will automatically use the first\n * item in the given iterable as the initializer.  When using `reduce()`, the\n * initializer value is placed before the items of the sequence in the\n * calculation, and serves as a default when the sequence is empty.  When using\n * `reduce_()`, and the given iterable is empty, then no default value can be\n * derived and `undefined` will be returned.\n */\nexport function reduce<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined;\nexport function reduce<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O;\nexport function reduce<T, O>(\n  iterable: Iterable<T>,\n  reducer: ((agg: T, item: T, index: number) => T) | ((agg: O, item: T, index: number) => O),\n  start?: O,\n): O | (T | undefined) {\n  if (start === undefined) {\n    return reduce2(iterable, reducer as (agg: T, item: T, index: number) => T);\n  } else {\n    return reduce3(iterable, reducer as (agg: O, item: T, index: number) => O, start);\n  }\n}\n\nfunction reduce3<T, O>(iterable: Iterable<T>, reducer: (agg: O, item: T, index: number) => O, start: O): O {\n  let output = start;\n  let index = 0;\n  for (const item of iterable) {\n    output = reducer(output, item, index++);\n  }\n  return output;\n}\n\nfunction reduce2<T>(iterable: Iterable<T>, reducer: (agg: T, item: T, index: number) => T): T | undefined {\n  const it = iter(iterable);\n  const start = find(it);\n  if (start === undefined) {\n    return undefined;\n  } else {\n    return reduce3(it, reducer, start);\n  }\n}\n\n/**\n * Return a new sorted list from the items in iterable.\n *\n * Has two optional arguments:\n *\n * * `keyFn` specifies a function of one argument providing a primitive\n *   identity for each element in the iterable.  that will be used to compare.\n *   The default value is to use a default identity function that is only\n *   defined for primitive types.\n *\n * * `reverse` is a boolean value.  If `true`, then the list elements are\n *   sorted as if each comparison were reversed.\n */\nexport function sorted<T>(\n  iterable: Iterable<T>,\n  keyFn: (item: T) => Primitive = primitiveIdentity,\n  reverse = false,\n): T[] {\n  const result = Array.from(iterable);\n  result.sort(keyToCmp(keyFn)); // sort in-place\n\n  if (reverse) {\n    result.reverse(); // reverse in-place\n  }\n\n  return result;\n}\n\n/**\n * Sums the items of an iterable from left to right and returns the total.  The\n * sum will defaults to 0 if the iterable is empty.\n */\nexport function sum(iterable: Iterable<number>): number {\n  return reduce(iterable, (x, y) => x + y, 0);\n}\n\n/**\n * See izip.\n */\nexport function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][] {\n  return Array.from(izip(xs, ys));\n}\n\n/**\n * See izip3.\n */\nexport function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][] {\n  return Array.from(izip3(xs, ys, zs));\n}\n","import { find } from \"./builtins\";\nimport { ifilter, imap } from \"./itertools\";\nimport { flatten } from \"./more-itertools\";\nimport type { Predicate } from \"./types\";\n\nfunction isNullish<T>(x: T): x is NonNullable<T> {\n  return x != null;\n}\n\nfunction isDefined(x: unknown): boolean {\n  return x !== undefined;\n}\n\n/**\n * Returns an iterable, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For an eager version, @see compact().\n */\nexport function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T> {\n  return ifilter(iterable, isNullish);\n}\n\n/**\n * Returns an array, filtering out any \"nullish\" values from the iterable.\n *\n *     >>> compact([1, 2, undefined, 3, null])\n *     [1, 2, 3]\n *\n * For a lazy version, @see icompact().\n */\nexport function compact<T>(iterable: Iterable<T | null | undefined>): T[] {\n  return Array.from(icompact(iterable));\n}\n\n/**\n * Removes all \"nullish\" values from the given object. Returns a new object.\n *\n *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })\n *     { a: 1, c: 0 }\n *\n */\nexport function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V> {\n  const result = {} as Record<K, V>;\n  for (const [key, value_] of Object.entries(obj)) {\n    const value = value_ as V | null | undefined;\n    if (value != null) {\n      result[key as K] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Almost an alias of find(). There only is a difference if no key fn is\n * provided. In that case, `find()` will return the first item in the iterable,\n * whereas `first()` will return the first non-`undefined` value in the\n * iterable.\n */\nexport function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined {\n  return find(iterable, keyFn ?? isDefined);\n}\n\n/**\n * Returns 0 or more values for every value in the given iterable.\n * Technically, it's just calling map(), followed by flatten(), but it's a very\n * useful operation if you want to map over a structure, but not have a 1:1\n * input-output mapping.  Instead, if you want to potentially return 0 or more\n * values per input element, use flatmap():\n *\n * For example, to return all numbers `n` in the input iterable `n` times:\n *\n *     >>> const repeatN = n => repeat(n, n);\n *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]\n *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0\n *\n */\nexport function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S> {\n  return flatten(imap(iterable, mapper));\n}\n"],"mappings":"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","names":["count","first","grouper","heads"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itertools",
-  "version": "2.6.0-0",
+  "version": "2.6.0",
   "description": "A JavaScript port of Python's awesome itertools standard library",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "lint:package": "publint --strict && attw --pack",
     "test": "vitest run --coverage",
     "test:types": "npm run build && tsd --typings ./dist/index.d.ts",
-    "release": "npm run test && npm run lint && npm run build && npm run lint:package && release-it"
+    "release": "release-it"
   },
   "files": [
     "dist/",
@@ -38,21 +38,21 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
     "@eslint/js": "^9.35.0",
-    "@release-it/keep-a-changelog": "^7.0.0",
-    "@vitest/coverage-istanbul": "^3.2.4",
+    "@release-it/keep-a-changelog": "^7.0.1",
+    "@vitest/coverage-istanbul": "^4.0.18",
     "eslint": "^9.35.0",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "fast-check": "^4.3.0",
-    "prettier": "^3.6.2",
-    "publint": "^0.3.12",
-    "release-it": "^19.0.4",
+    "fast-check": "^4.5.3",
+    "prettier": "^3.8.1",
+    "publint": "^0.3.17",
+    "release-it": "^19.2.4",
     "tsd": "^0.33.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.43.0",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.2.4"
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
   },
   "author": "Vincent Driessen",
   "repository": {