itertools 2.7.0 → 2.7.1

package/README.md

@@ -723,31 +723,42 @@ Yield only elements from the input that occur more than once. Needs to consume t
 
 ---
 
-<a name="chunkedByCost" href="#chunkedByCost">#</a> <b>chunkedByCost</b>(items: <i>Iterable&lt;T&gt;</i>, costOf: <i>(item: T, index: number) =&gt; number</i>, maxCost: <i>number</i>, minCost?: <i>number</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
+<a name="chunkedByCost" href="#chunkedByCost">#</a> <b>chunkedByCost</b>(items: <i>Iterable&lt;T&gt;</i>, costOf: <i>(item: T) =&gt; number</i>, maxCost: <i>number</i>, minCost?: <i>number | ((chunkIndex: number) =&gt; number)</i>): <i>Iterable&lt;T[]&gt;</i> [&lt;&gt;](https://github.com/nvie/itertools.js/blob/master/src/custom.js "Source")
 
 Group items from a stream into chunks, where each chunk's total cost stays
 under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).
 
 `maxCost` is a hard cap: a chunk is flushed before adding an item that would
-push the running cost to or past `maxCost`. `minCost` is an optional soft
-target: when provided, a chunk is flushed as soon as the running cost exceeds
-it (overshooting by at most one item's cost). When omitted, chunks grow as
-large as `maxCost` allows.
+push the running cost past `maxCost`.
 
-    >>> // Pack rows into batches of <= 100 KB
+`minCost` is an optional soft target. When provided, a chunk is flushed as
+soon as the running cost reaches it. It may be:
+
+- a `number`: same target for every chunk
+- a function `(chunkIndex: number) => number`: per-chunk target, indexed by the
+  0-based output chunk number. Useful for ramp-up schedules.
+
+When `minCost` is omitted, chunks grow as large as `maxCost` allows.
+
+    >>> // Pack rows into batches of <= 10 bytes
     >>> const rows = ["aaaa", "bbbb", "cc", "dddddd", "ee"];
     >>> [...chunkedByCost(rows, (s) => s.length, 10)]
     [["aaaa", "bbbb", "cc"], ["dddddd", "ee"]]
 
-With a `minCost` soft target, the chunker flushes early to keep chunks
-roughly that size — useful when you want predictable chunk sizes without
-locking them to a fixed item count:
+With a constant `minCost` soft target, the chunker flushes early to keep
+chunks roughly that size — useful when you want predictable chunk sizes
+without locking them to a fixed item count:
 
     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]
     [["aaaa", "bbbb"], ["cc", "dddddd"], ["ee"]]
 
-`costOf` receives the item and its 0-based index in the input stream, so
-position-dependent costs are possible.
+With a scheduled `minCost`, early chunks can target smaller sizes than later
+ones — useful for fast-start patterns (e.g. emit a few small chunks first to
+clear a slow outgoing queue, then settle into larger ones):
+
+    >>> const items = Array.from({ length: 30 }, () => 1);
+    >>> [...chunkedByCost(items, () => 1, 100, (i) => Math.min(8, 1 << i))]
+    [[1], [1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], ...]
 
 If a single item's cost alone is >= `maxCost`, it is still emitted as its own
 chunk. Only in this edge case can an output chunk exceed the hard cap.

package/dist/index.cjs

@@ -597,22 +597,31 @@ function first(iterable, keyFn) {
 function flatmap(iterable, mapper) {
   return flatten(imap(iterable, mapper));
 }
-function* chunkedByCost(items, costOf, maxCost, minCost) {
+function* chunkedByCost(items, costFn, maxCost, minCost) {
+  const getIdealCost = typeof minCost === "function" ? minCost : minCost !== void 0 ? () => minCost : () => Number.POSITIVE_INFINITY;
   let buf = [];
   let bufcost = 0;
-  let i = 0;
+  let chunkIndex = 0;
+  let idealCost;
   for (const item of items) {
-    const c = costOf(item, i++);
+    const c = costFn(item);
     if (bufcost + c <= maxCost) {
       buf.push(item);
       bufcost += c;
     } else {
-      if (buf.length > 0) yield buf;
+      if (buf.length > 0) {
+        yield buf;
+        chunkIndex++;
+        idealCost = void 0;
+      }
       buf = [item];
       bufcost = c;
     }
-    if (minCost !== void 0 && bufcost >= minCost) {
+    idealCost ??= getIdealCost(chunkIndex);
+    if (bufcost >= idealCost) {
       yield buf;
+      chunkIndex++;
+      idealCost = void 0;
       buf = [];
       bufcost = 0;
     }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"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":"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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;AAkCE;AAEgB,EAAA;AACF,EAAA;AACN,EAAA;AAEkB,EAAA;AACE,IAAA;AACE,IAAA;AACb,MAAA;AACF,MAAA;AACN,IAAA;AACqB,MAAA;AACf,MAAA;AACD,MAAA;AACZ,IAAA;AAEwC,IAAA;AAChC,MAAA;AACC,MAAA;AACG,MAAA;AACZ,IAAA;AACF,EAAA;AAE0B,EAAA;AAC5B;ALiegD;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;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\n/**\n * Group items from a stream into chunks, where each chunk's total cost stays\n * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).\n *\n * `maxCost` is a hard cap: a chunk is flushed before adding an item that would\n * push the running cost to or past `maxCost`. `minCost` is an optional soft\n * target: when provided, a chunk is flushed as soon as the running cost\n * exceeds it (overshooting by at most one item's cost). When omitted, chunks\n * grow as large as `maxCost` allows.\n *\n *     >>> // Pack rows into batches of <= 100 KB\n *     >>> const rows = [\"aaaa\", \"bbbb\", \"cc\", \"dddddd\", \"ee\"];\n *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]\n *     [[\"aaaa\", \"bbbb\", \"cc\"], [\"dddddd\", \"ee\"]]\n *\n * With a `minCost` soft target, the chunker flushes early to keep chunks\n * roughly that size — useful when you want predictable chunk sizes without\n * locking them to a fixed item count:\n *\n *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]\n *     [[\"aaaa\", \"bbbb\"], [\"cc\", \"dddddd\"], [\"ee\"]]\n *\n * `costOf` receives the item and its 0-based index in the input stream, so\n * position-dependent costs are possible.\n *\n * If a single item's cost alone is >= `maxCost`, it is still emitted as its\n * own chunk. Only in this edge case can an output chunk exceed the hard cap.\n */\nexport function* chunkedByCost<T>(\n  items: Iterable<T>,\n  costOf: (item: T, index: number) => number,\n  maxCost: number,\n  minCost?: number,\n): Iterable<T[]> {\n  let buf: T[] = [];\n  let bufcost = 0;\n  let i = 0;\n\n  for (const item of items) {\n    const c = costOf(item, i++);\n    if (bufcost + c <= maxCost) {\n      buf.push(item);\n      bufcost += c;\n    } else {\n      if (buf.length > 0) yield buf;\n      buf = [item];\n      bufcost = c;\n    }\n\n    if (minCost !== undefined && bufcost >= minCost) {\n      yield buf;\n      buf = [];\n      bufcost = 0;\n    }\n  }\n\n  if (buf.length > 0) yield buf;\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":"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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;AA4CE;AAGqB,EAAA;AAEL,EAAA;AACF,EAAA;AACG,EAAA;AACb,EAAA;AAEsB,EAAA;AACH,IAAA;AACO,IAAA;AACb,MAAA;AACF,MAAA;AACN,IAAA;AACe,MAAA;AACZ,QAAA;AACN,QAAA;AACY,QAAA;AACd,MAAA;AACW,MAAA;AACD,MAAA;AACZ,IAAA;AAEqC,IAAA;AACX,IAAA;AAClB,MAAA;AACN,MAAA;AACY,MAAA;AACL,MAAA;AACG,MAAA;AACZ,IAAA;AACF,EAAA;AAE0B,EAAA;AAC5B;ALqdgD;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;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\n/**\n * Group items from a stream into chunks, where each chunk's total cost stays\n * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).\n *\n * `maxCost` is a hard cap: a chunk is flushed before adding an item that would\n * push the running cost past `maxCost`. `minCost` is an optional soft target:\n * when provided, a chunk is flushed as soon as the running cost reaches it.\n * `minCost` may be:\n *\n *   - a `number`: same target for every chunk\n *   - a function `(chunkIndex: number) => number`: per-chunk target, indexed\n *     by the 0-based output chunk number. Useful for ramp-up schedules.\n *\n * When `minCost` is omitted, chunks grow as large as `maxCost` allows.\n *\n *     >>> // Pack rows into batches of <= 10 bytes\n *     >>> const rows = [\"aaaa\", \"bbbb\", \"cc\", \"dddddd\", \"ee\"];\n *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]\n *     [[\"aaaa\", \"bbbb\", \"cc\"], [\"dddddd\", \"ee\"]]\n *\n * With a constant `minCost` soft target, the chunker flushes early to keep\n * chunks roughly that size — useful when you want predictable chunk sizes\n * without locking them to a fixed item count:\n *\n *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]\n *     [[\"aaaa\", \"bbbb\"], [\"cc\", \"dddddd\"], [\"ee\"]]\n *\n * With a scheduled `minCost`, early chunks can be smaller than later ones —\n * useful for fast-start patterns (e.g. clearing a slow outgoing queue with a\n * few small chunks before settling into larger ones):\n *\n *     >>> const items = Array.from({ length: 30 }, () => 1);\n *     >>> [...chunkedByCost(items, () => 1, 100, (i) => Math.min(8, 1 << i))]\n *     [[1], [1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], ...]\n *\n * If a single item's cost alone is >= `maxCost`, it is still emitted as its\n * own chunk. Only in this edge case can an output chunk exceed the hard cap.\n */\nexport function* chunkedByCost<T>(\n  items: Iterable<T>,\n  costFn: (item: T) => number,\n  maxCost: number,\n  minCost?: number | ((chunkIndex: number) => number),\n): Iterable<T[]> {\n  const getIdealCost =\n    typeof minCost === \"function\" ? minCost : minCost !== undefined ? () => minCost : () => Number.POSITIVE_INFINITY;\n\n  let buf: T[] = [];\n  let bufcost = 0;\n  let chunkIndex = 0;\n  let idealCost: number | undefined;\n\n  for (const item of items) {\n    const c = costFn(item);\n    if (bufcost + c <= maxCost) {\n      buf.push(item);\n      bufcost += c;\n    } else {\n      if (buf.length > 0) {\n        yield buf;\n        chunkIndex++;\n        idealCost = undefined;\n      }\n      buf = [item];\n      bufcost = c;\n    }\n\n    idealCost ??= getIdealCost(chunkIndex);\n    if (bufcost >= idealCost) {\n      yield buf;\n      chunkIndex++;\n      idealCost = undefined;\n      buf = [];\n      bufcost = 0;\n    }\n  }\n\n  if (buf.length > 0) yield buf;\n}\n"]}

package/dist/index.d.cts

@@ -250,30 +250,40 @@ declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Itera
  * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).
  *
  * `maxCost` is a hard cap: a chunk is flushed before adding an item that would
- * push the running cost to or past `maxCost`. `minCost` is an optional soft
- * target: when provided, a chunk is flushed as soon as the running cost
- * exceeds it (overshooting by at most one item's cost). When omitted, chunks
- * grow as large as `maxCost` allows.
+ * push the running cost past `maxCost`. `minCost` is an optional soft target:
+ * when provided, a chunk is flushed as soon as the running cost reaches it.
+ * `minCost` may be:
  *
- *     >>> // Pack rows into batches of <= 100 KB
+ *   - a `number`: same target for every chunk
+ *   - a function `(chunkIndex: number) => number`: per-chunk target, indexed
+ *     by the 0-based output chunk number. Useful for ramp-up schedules.
+ *
+ * When `minCost` is omitted, chunks grow as large as `maxCost` allows.
+ *
+ *     >>> // Pack rows into batches of <= 10 bytes
  *     >>> const rows = ["aaaa", "bbbb", "cc", "dddddd", "ee"];
  *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]
  *     [["aaaa", "bbbb", "cc"], ["dddddd", "ee"]]
  *
- * With a `minCost` soft target, the chunker flushes early to keep chunks
- * roughly that size — useful when you want predictable chunk sizes without
- * locking them to a fixed item count:
+ * With a constant `minCost` soft target, the chunker flushes early to keep
+ * chunks roughly that size — useful when you want predictable chunk sizes
+ * without locking them to a fixed item count:
  *
  *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]
  *     [["aaaa", "bbbb"], ["cc", "dddddd"], ["ee"]]
  *
- * `costOf` receives the item and its 0-based index in the input stream, so
- * position-dependent costs are possible.
+ * With a scheduled `minCost`, early chunks can be smaller than later ones —
+ * useful for fast-start patterns (e.g. clearing a slow outgoing queue with a
+ * few small chunks before settling into larger ones):
+ *
+ *     >>> const items = Array.from({ length: 30 }, () => 1);
+ *     >>> [...chunkedByCost(items, () => 1, 100, (i) => Math.min(8, 1 << i))]
+ *     [[1], [1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], ...]
  *
  * If a single item's cost alone is >= `maxCost`, it is still emitted as its
  * own chunk. Only in this edge case can an output chunk exceed the hard cap.
  */
-declare function chunkedByCost<T>(items: Iterable<T>, costOf: (item: T, index: number) => number, maxCost: number, minCost?: number): Iterable<T[]>;
+declare function chunkedByCost<T>(items: Iterable<T>, costFn: (item: T) => number, maxCost: number, minCost?: number | ((chunkIndex: number) => number)): Iterable<T[]>;
 
 /**
  * Returns an iterator that returns elements from the first iterable until it

package/dist/index.d.ts

@@ -250,30 +250,40 @@ declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Itera
  * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).
  *
  * `maxCost` is a hard cap: a chunk is flushed before adding an item that would
- * push the running cost to or past `maxCost`. `minCost` is an optional soft
- * target: when provided, a chunk is flushed as soon as the running cost
- * exceeds it (overshooting by at most one item's cost). When omitted, chunks
- * grow as large as `maxCost` allows.
+ * push the running cost past `maxCost`. `minCost` is an optional soft target:
+ * when provided, a chunk is flushed as soon as the running cost reaches it.
+ * `minCost` may be:
  *
- *     >>> // Pack rows into batches of <= 100 KB
+ *   - a `number`: same target for every chunk
+ *   - a function `(chunkIndex: number) => number`: per-chunk target, indexed
+ *     by the 0-based output chunk number. Useful for ramp-up schedules.
+ *
+ * When `minCost` is omitted, chunks grow as large as `maxCost` allows.
+ *
+ *     >>> // Pack rows into batches of <= 10 bytes
  *     >>> const rows = ["aaaa", "bbbb", "cc", "dddddd", "ee"];
  *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]
  *     [["aaaa", "bbbb", "cc"], ["dddddd", "ee"]]
  *
- * With a `minCost` soft target, the chunker flushes early to keep chunks
- * roughly that size — useful when you want predictable chunk sizes without
- * locking them to a fixed item count:
+ * With a constant `minCost` soft target, the chunker flushes early to keep
+ * chunks roughly that size — useful when you want predictable chunk sizes
+ * without locking them to a fixed item count:
  *
  *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]
  *     [["aaaa", "bbbb"], ["cc", "dddddd"], ["ee"]]
  *
- * `costOf` receives the item and its 0-based index in the input stream, so
- * position-dependent costs are possible.
+ * With a scheduled `minCost`, early chunks can be smaller than later ones —
+ * useful for fast-start patterns (e.g. clearing a slow outgoing queue with a
+ * few small chunks before settling into larger ones):
+ *
+ *     >>> const items = Array.from({ length: 30 }, () => 1);
+ *     >>> [...chunkedByCost(items, () => 1, 100, (i) => Math.min(8, 1 << i))]
+ *     [[1], [1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], ...]
  *
  * If a single item's cost alone is >= `maxCost`, it is still emitted as its
  * own chunk. Only in this edge case can an output chunk exceed the hard cap.
  */
-declare function chunkedByCost<T>(items: Iterable<T>, costOf: (item: T, index: number) => number, maxCost: number, minCost?: number): Iterable<T[]>;
+declare function chunkedByCost<T>(items: Iterable<T>, costFn: (item: T) => number, maxCost: number, minCost?: number | ((chunkIndex: number) => number)): Iterable<T[]>;
 
 /**
  * Returns an iterator that returns elements from the first iterable until it

package/dist/index.js

@@ -597,22 +597,31 @@ function first(iterable, keyFn) {
 function flatmap(iterable, mapper) {
   return flatten(imap(iterable, mapper));
 }
-function* chunkedByCost(items, costOf, maxCost, minCost) {
+function* chunkedByCost(items, costFn, maxCost, minCost) {
+  const getIdealCost = typeof minCost === "function" ? minCost : minCost !== void 0 ? () => minCost : () => Number.POSITIVE_INFINITY;
   let buf = [];
   let bufcost = 0;
-  let i = 0;
+  let chunkIndex = 0;
+  let idealCost;
   for (const item of items) {
-    const c = costOf(item, i++);
+    const c = costFn(item);
     if (bufcost + c <= maxCost) {
       buf.push(item);
       bufcost += c;
     } else {
-      if (buf.length > 0) yield buf;
+      if (buf.length > 0) {
+        yield buf;
+        chunkIndex++;
+        idealCost = void 0;
+      }
       buf = [item];
       bufcost = c;
     }
-    if (minCost !== void 0 && bufcost >= minCost) {
+    idealCost ??= getIdealCost(chunkIndex);
+    if (bufcost >= idealCost) {
       yield buf;
+      chunkIndex++;
+      idealCost = void 0;
       buf = [];
       bufcost = 0;
     }

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\n/**\n * Group items from a stream into chunks, where each chunk's total cost stays\n * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).\n *\n * `maxCost` is a hard cap: a chunk is flushed before adding an item that would\n * push the running cost to or past `maxCost`. `minCost` is an optional soft\n * target: when provided, a chunk is flushed as soon as the running cost\n * exceeds it (overshooting by at most one item's cost). When omitted, chunks\n * grow as large as `maxCost` allows.\n *\n *     >>> // Pack rows into batches of <= 100 KB\n *     >>> const rows = [\"aaaa\", \"bbbb\", \"cc\", \"dddddd\", \"ee\"];\n *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]\n *     [[\"aaaa\", \"bbbb\", \"cc\"], [\"dddddd\", \"ee\"]]\n *\n * With a `minCost` soft target, the chunker flushes early to keep chunks\n * roughly that size — useful when you want predictable chunk sizes without\n * locking them to a fixed item count:\n *\n *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]\n *     [[\"aaaa\", \"bbbb\"], [\"cc\", \"dddddd\"], [\"ee\"]]\n *\n * `costOf` receives the item and its 0-based index in the input stream, so\n * position-dependent costs are possible.\n *\n * If a single item's cost alone is >= `maxCost`, it is still emitted as its\n * own chunk. Only in this edge case can an output chunk exceed the hard cap.\n */\nexport function* chunkedByCost<T>(\n  items: Iterable<T>,\n  costOf: (item: T, index: number) => number,\n  maxCost: number,\n  minCost?: number,\n): Iterable<T[]> {\n  let buf: T[] = [];\n  let bufcost = 0;\n  let i = 0;\n\n  for (const item of items) {\n    const c = costOf(item, i++);\n    if (bufcost + c <= maxCost) {\n      buf.push(item);\n      bufcost += c;\n    } else {\n      if (buf.length > 0) yield buf;\n      buf = [item];\n      bufcost = c;\n    }\n\n    if (minCost !== undefined && bufcost >= minCost) {\n      yield buf;\n      buf = [];\n      bufcost = 0;\n    }\n  }\n\n  if (buf.length > 0) yield buf;\n}\n"],"mappings":";AAIO,SAAS,SAAY,OAAyC;AACnE,SAAO,CAAC,GAAM,MAAS;AACrB,UAAM,KAAK,MAAM,CAAC;AAClB,UAAM,KAAK,MAAM,CAAC;AAElB,QAAI,OAAO,OAAO,aAAa,OAAO,OAAO,WAAW;AACtD,aAAO,OAAO,KAAK,IAAI,CAAC,MAAM,KAAK,KAAK;AAAA,IAC1C,WAAW,OAAO,OAAO,YAAY,OAAO,OAAO,UAAU;AAC3D,aAAO,KAAK;AAAA,IACd,WAAW,OAAO,OAAO,YAAY,OAAO,OAAO,UAAU;AAC3D,aAAO,OAAO,KAAK,IAAI,KAAK,KAAK,KAAK;AAAA,IACxC,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEO,SAAS,kBAAkB,GAAqB;AACrD,SAAO,CAAC,CAAC;AACX;AAEO,SAAS,eAAe,GAAoB;AAEjD,MAAI,OAAO,MAAM,UAAU;AACzB,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AACA,SAAO;AACT;AAIO,SAAS,kBAAkB,GAAuB;AAEvD,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,YAAY,OAAO,MAAM,WAAW;AAC5E,UAAM,IAAI,MAAM,kEAAkE;AAAA,EACpF;AACA,SAAO;AACT;;;ACxBO,UAAU,QAAW,UAAuB,MAAqC;AACtF,MAAI,OAAO,GAAG;AACZ,UAAM,IAAI,MAAM,uBAAuB,IAAI,EAAE;AAAA,EAC/C;AAEA,QAAM,KAAK,KAAK,QAAQ;AACxB,aAAS;AACP,UAAM,QAAQ,KAAK,MAAM,EAAE;AAC3B,QAAI,MAAM,SAAS,GAAG;AACpB,YAAM;AAAA,IACR;AACA,QAAI,MAAM,SAAS,MAAM;AACvB;AAAA,IACF;AAAA,EACF;AACF;AASO,UAAU,QAAW,qBAAiE;AAC3F,aAAW,YAAY,qBAAqB;AAC1C,eAAW,QAAQ,UAAU;AAC3B,YAAM;AAAA,IACR;AAAA,EACF;AACF;AASO,SAAS,YAAkB,OAAU,UAAgD;AAC1F,QAAM,SAAS,QAAe,KAAK,OAAO,KAAK,GAAG,QAAQ,CAAC;AAC3D,SAAO,KAAK;AACZ,SAAO;AACT;AAMO,UAAU,MAAS,GAAW,UAA4C;AAC/E,QAAM,KAAK,KAAK,QAAQ;AACxB,MAAIA,SAAQ;AACZ,SAAOA,WAAU,GAAG;AAClB,UAAM,IAAI,GAAG,KAAK;AAClB,QAAI,CAAC,EAAE,MAAM;AACX,YAAM,EAAE;AAAA,IACV,OAAO;AAEL;AAAA,IACF;AAAA,EACF;AACF;AAWO,UAAU,SAAY,UAAiD;AAC5E,QAAM,KAAK,KAAK,QAAQ;AACxB,QAAMC,SAAQ,GAAG,KAAK;AACtB,MAAIA,OAAM,MAAM;AACd;AAAA,EACF;AAEA,MAAI,KAAQA,OAAM;AAClB,aAAW,MAAM,IAAI;AACnB,UAAM,CAAC,IAAI,EAAE;AACb,SAAK;AAAA,EACP;AACF;AAqBO,SAAS,UAAa,UAAuB,WAAqC;AACvF,QAAM,OAAO,CAAC;AACd,QAAM,MAAM,CAAC;AAEb,MAAI,QAAQ;AACZ,aAAW,QAAQ,UAAU;AAC3B,QAAI,UAAU,MAAM,OAAO,GAAG;AAC5B,WAAK,KAAK,IAAI;AAAA,IAChB,OAAO;AACL,UAAI,KAAK,IAAI;AAAA,IACf;AAAA,EACF;AAEA,SAAO,CAAC,MAAM,GAAG;AACnB;AASO,UAAU,cAAiB,OAA2C;AAK3E,QAAM,YAA2B,IAAI,OAAO,IAAI;AAEhD,SAAO,UAAU,SAAS,GAAG;AAC3B,QAAI,QAAQ;AACZ,WAAO,QAAQ,UAAU,QAAQ;AAC/B,YAAM,KAAK,UAAU,KAAK;AAC1B,YAAM,SAAS,GAAG,KAAK;AAEvB,UAAI,CAAC,OAAO,MAAM;AAChB,cAAM,OAAO;AACb;AAAA,MACF,OAAO;AAIL,kBAAU,OAAO,OAAO,CAAC;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AACF;AAaO,UAAU,SAAY,OAA6C;AAKxE,QAAM,YAA2B,IAAI,OAAO,IAAI;AAEhD,SAAO,UAAU,SAAS,GAAG;AAC3B,QAAI,QAAQ;AACZ,UAAM,QAAQ,CAAC;AACf,WAAO,QAAQ,UAAU,QAAQ;AAC/B,YAAM,KAAK,UAAU,KAAK;AAC1B,YAAM,SAAS,GAAG,KAAK;AAEvB,UAAI,CAAC,OAAO,MAAM;AAChB,cAAM,KAAK,OAAO,KAAK;AACvB;AAAA,MACF,OAAO;AAIL,kBAAU,OAAO,OAAO,CAAC;AAAA,MAC3B;AAAA,IACF;AACA,QAAI,MAAM,SAAS,GAAG;AACpB,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAKO,SAAS,KAAQ,GAAW,UAA4B;AAC7D,SAAO,MAAM,KAAK,MAAM,GAAG,QAAQ,CAAC;AACtC;AAWO,UAAU,eACf,UACA,QAAgC,mBACX;AACrB,QAAM,OAAO,oBAAI,IAAI;AACrB,aAAW,QAAQ,UAAU;AAC3B,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,CAAC,KAAK,IAAI,GAAG,GAAG;AAClB,WAAK,IAAI,GAAG;AACZ,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAYO,SAAS,MACd,UACA,QAAgC,mBACT;AACvB,QAAM,YAAY,oBAAI,IAAoB;AAE1C;AACE,UAAM,UAAU,oBAAI,IAAkB;AACtC,eAAW,QAAQ,UAAU;AAC3B,YAAM,MAAM,MAAM,IAAI;AACtB,UAAI,UAAU,IAAI,GAAG,GAAG;AACtB,kBAAU,IAAI,GAAG,EAAG,KAAK,IAAI;AAAA,MAC/B,WAAW,QAAQ,IAAI,GAAG,GAAG;AAC3B,kBAAU,IAAI,KAAK,CAAC,QAAQ,IAAI,GAAG,GAAI,IAAI,CAAC;AAC5C,gBAAQ,OAAO,GAAG;AAAA,MACpB,OAAO;AACL,gBAAQ,IAAI,KAAK,IAAI;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,UAAU,OAAO;AAC1B;AAWO,UAAU,eACf,UACA,QAAgC,mBACX;AACrB,MAAI,OAAO;AACX,aAAW,QAAQ,UAAU;AAC3B,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,QAAQ,MAAM;AAChB,YAAM;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACF;;;ACpSA,IAAM,WAAW,uBAAO;AAQjB,SAAS,SAAY,WAA+C;AACzE,SAAO,QAAQ,SAAS;AAC1B;AAOO,UAAU,MAAM,QAAQ,GAAG,OAAO,GAA6B;AACpE,MAAI,IAAI;AACR,aAAS;AACP,UAAM;AACN,SAAK;AAAA,EACP;AACF;AAKO,SAAS,SAAY,MAAmB,WAAmC;AAChF,SAAO,MAAM,KAAK,UAAU,MAAM,SAAS,CAAC;AAC9C;AAOO,UAAU,MAAS,UAA4C;AACpE,QAAM,QAAQ,CAAC;AACf,aAAW,WAAW,UAAU;AAC9B,UAAM;AACN,UAAM,KAAK,OAAO;AAAA,EACpB;AAEA,SAAO,MAAM,SAAS,GAAG;AACvB,eAAW,WAAW,OAAO;AAC3B,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAQO,UAAU,UAAa,UAAuB,WAA8C;AACjG,MAAI,QAAQ;AACZ,QAAM,KAAK,KAAK,QAAQ;AACxB,MAAI;AACJ,SAAO,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM;AAC9B,UAAM,QAAQ,IAAI;AAClB,QAAI,CAAC,UAAU,OAAO,OAAO,GAAG;AAC9B,YAAM;AACN;AAAA,IACF;AAAA,EACF;AAEA,aAAW,SAAS,IAAI;AACtB,UAAM;AAAA,EACR;AACF;AAGO,IAAM,UAAU;AAEhB,UAAU,SACf,UACA,QAAwB,mBAC4B;AACpD,QAAM,KAAK,KAAK,QAAQ;AAExB,MAAI;AACJ,MAAI,aAAgB;AAEpB,MAAI,YAAe;AAEnB,QAAM,UAAU,UAAUC,SAAQ,QAAoC;AACpE,WAAO,eAAe,QAAQ;AAC5B,YAAM;AAEN,YAAM,UAAU,GAAG,KAAK;AACxB,UAAI,QAAQ,KAAM;AAClB,qBAAe,QAAQ;AACvB,mBAAa,MAAM,YAAY;AAAA,IACjC;AAAA,EACF;AAEA,aAAS;AACP,WAAO,eAAe,WAAW;AAC/B,YAAM,UAAU,GAAG,KAAK;AACxB,UAAI,QAAQ,MAAM;AAChB,qBAAa;AAEb;AAAA,MACF;AACA,qBAAe,QAAQ;AACvB,mBAAa,MAAM,YAAY;AAAA,IACjC;AAEA,gBAAY;AACZ,UAAM,CAAC,YAAY,QAAQ,SAAS,CAAC;AAAA,EACvC;AACF;AAEO,SAAS,QAAsC,UAAuB,OAAuC;AAClH,QAAM,SAAS,CAAC;AAChB,aAAW,QAAQ,UAAU;AAC3B,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,CAAC,OAAO,OAAO,QAAQ,GAAG,GAAG;AAC/B,aAAO,GAAG,IAAI,CAAC;AAAA,IACjB;AACA,WAAO,GAAG,EAAE,KAAK,IAAI;AAAA,EACvB;AACA,SAAO;AACT;AAEO,SAAS,QAAsC,UAAuB,OAAqC;AAChH,QAAM,SAAS,CAAC;AAChB,aAAW,QAAQ,UAAU;AAC3B,UAAM,MAAM,MAAM,IAAI;AACtB,WAAO,GAAG,IAAI;AAAA,EAChB;AACA,SAAO;AACT;AAOO,UAAU,UAAa,MAAmB,WAAmD;AAClG,aAAW,CAAC,GAAG,CAAC,KAAK,KAAK,MAAM,SAAS,GAAG;AAC1C,QAAI,GAAG;AACL,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAQO,UAAU,QAAW,UAAuB,WAA8C;AAC/F,MAAI,QAAQ;AACZ,aAAW,SAAS,UAAU;AAC5B,QAAI,UAAU,OAAO,OAAO,GAAG;AAC7B,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAMO,UAAU,KAAW,UAAuB,QAA6C;AAC9F,aAAW,SAAS,UAAU;AAC5B,UAAM,OAAO,KAAK;AAAA,EACpB;AACF;AAkBO,UAAU,OACf,UACA,aACA,cACA,OAAO,GACc;AACrB,MAAI,OAAO;AACX,MAAI,iBAAiB,QAAW;AAE9B,YAAQ;AACR,WAAO;AAAA,EACT,OAAO;AAEL,YAAQ;AACR,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,EAAG,OAAM,IAAI,MAAM,0BAA0B;AACzD,MAAI,SAAS,QAAQ,OAAO,EAAG,OAAM,IAAI,MAAM,yBAAyB;AACxE,MAAI,QAAQ,EAAG,OAAM,IAAI,MAAM,yBAAyB;AAExD,MAAI,IAAI;AACR,QAAM,KAAK,KAAK,QAAQ;AACxB,MAAI;AACJ,SAAO,MAAM;AACX;AACA,QAAI,SAAS,QAAQ,KAAK,KAAM;AAEhC,UAAM,GAAG,KAAK;AACd,QAAI,IAAI,KAAM;AAEd,QAAI,IAAI,MAAO;AACf,SAAK,IAAI,SAAS,SAAS,GAAG;AAC5B,YAAM,IAAI;AAAA,IACZ;AAAA,EACF;AACF;AAQO,UAAU,KAAa,IAAkB,IAA8C;AAC5F,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,aAAS;AACP,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,QAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM;AACtB,YAAM,CAAC,EAAE,OAAO,EAAE,KAAK;AAAA,IACzB,OAAO;AAEL;AAAA,IACF;AAAA,EACF;AACF;AAKO,UAAU,MACf,IACA,IACA,IACgC;AAChC,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,aAAS;AACP,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,QAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM;AACjC,YAAM,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK;AAAA,IAClC,OAAO;AAEL;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,QAAQ;AAOd,UAAU,aACf,IACA,IACA,QACoC;AACpC,QAAM,UAAU;AAChB,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,aAAS;AACP,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,QAAI,EAAE,QAAQ,EAAE,MAAM;AAEpB;AAAA,IACF,OAAO;AACL,YAAM,CAAC,CAAC,EAAE,OAAO,EAAE,QAAQ,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,OAAO;AAAA,IACjE;AAAA,EACF;AACF;AAKO,UAAU,aACf,IACA,IACA,IACA,QAC4C;AAC5C,QAAM,UAAU;AAChB,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,QAAM,MAAM,KAAK,EAAE;AACnB,aAAS;AACP,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,UAAM,IAAI,IAAI,KAAK;AACnB,QAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM;AAE9B;AAAA,IACF,OAAO;AACL,YAAM,CAAC,CAAC,EAAE,OAAO,EAAE,QAAQ,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,OAAO;AAAA,IAC9F;AAAA,EACF;AACF;AAUO,UAAU,YAAe,OAA6C;AAE3E,QAAM,YAAY,MAAM,IAAI,IAAI;AAEhC,aAAS;AACP,UAAMC,SAAwC,UAAU,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;AAC7E,QAAI,MAAMA,QAAO,CAAC,MAAM,CAAC,EAAE,IAAI,GAAG;AAChC,YAAMA,OAAM,IAAI,CAAC,MAAM,EAAE,KAAU;AAAA,IACrC,OAAO;AAEL;AAAA,IACF;AAAA,EACF;AACF;AAeO,UAAU,aAAgB,UAAuB,GAAmC;AACzF,QAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,QAAM,IAAI,KAAK;AACf,QAAM,IAAI,KAAK;AAEf,MAAI,IAAI,GAAG;AACT;AAAA,EACF;AAEA,MAAI,UAAoB,MAAM,KAAK,MAAM,CAAC,CAAC;AAC3C,QAAM,SAAmB,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;AACvD,QAAM,aAAa,CAAC,MAAc,KAAK,CAAC;AAExC,QAAM,QAAQ,MAAM,GAAG,CAAC,EAAE,IAAI,UAAU;AAExC,SAAO,IAAI,GAAG;AACZ,QAAI,YAAY;AAChB,eAAW,KAAK,MAAM,IAAI,GAAG,IAAI,EAAE,GAAG;AACpC,aAAO,CAAC,KAAK;AACb,UAAI,OAAO,CAAC,MAAM,GAAG;AACnB,kBAAU,QACP,MAAM,GAAG,CAAC,EACV,OAAO,QAAQ,MAAM,IAAI,CAAC,CAAC,EAC3B,OAAO,QAAQ,MAAM,GAAG,IAAI,CAAC,CAAC;AACjC,eAAO,CAAC,IAAI,IAAI;AAAA,MAClB,OAAO;AACL,cAAM,IAAY,OAAO,CAAC;AAE1B,cAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,QAAQ,SAAS,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvD,gBAAQ,CAAC,IAAI;AACb,gBAAQ,QAAQ,SAAS,CAAC,IAAI;AAC9B,cAAM,QAAQ,MAAM,GAAG,CAAC,EAAE,IAAI,UAAU;AACxC,oBAAY;AACZ;AAAA,MACF;AAAA,IACF;AAEA,QAAI,WAAW;AACb;AAAA,IACF;AAAA,EACF;AACF;AAMO,UAAU,OAAU,OAAU,OAAqC;AACxE,MAAI,UAAU,QAAW;AACvB,eAAS;AACP,YAAM;AAAA,IACR;AAAA,EACF,OAAO;AACL,eAAW,KAAK,MAAM,KAAK,GAAG;AAC5B,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAMO,UAAU,UAAa,UAAuB,WAA8C;AACjG,MAAI,QAAQ;AACZ,QAAM,KAAK,KAAK,QAAQ;AACxB,MAAI;AACJ,SAAO,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM;AAC9B,UAAM,QAAQ,IAAI;AAClB,QAAI,CAAC,UAAU,OAAO,OAAO,EAAG;AAChC,UAAM;AAAA,EACR;AACF;AAEO,SAAS,YAAuB,IAAkB,IAAkB,QAAgC;AACzG,SAAO,MAAM,KAAK,aAAa,IAAI,IAAI,MAAM,CAAC;AAChD;AAEO,SAAS,YACd,IACA,IACA,IACA,QAC4B;AAC5B,SAAO,MAAM,KAAK,aAAa,IAAI,IAAI,IAAI,MAAM,CAAC;AACpD;AAEO,IAAM,cAAc;AACpB,IAAM,aAAa;AAEnB,SAAS,WAAc,OAA6B;AACzD,SAAO,MAAM,KAAK,SAAS,GAAG,KAAK,CAAC;AACtC;;;ACncO,SAAS,KAAQ,UAAuB,WAAyC;AACtF,QAAM,KAAK,KAAK,QAAQ;AACxB,MAAI,cAAc,QAAW;AAC3B,UAAM,QAAQ,GAAG,KAAK;AACtB,WAAO,MAAM,OAAO,SAAY,MAAM;AAAA,EACxC,OAAO;AACL,QAAI;AACJ,QAAI,IAAI;AACR,WAAO,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM;AAC9B,YAAM,QAAQ,IAAI;AAClB,UAAI,UAAU,OAAO,GAAG,GAAG;AACzB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAoBO,SAAS,MAAS,UAAuB,YAA0B,mBAA4B;AACpG,MAAI,QAAQ;AACZ,aAAW,QAAQ,UAAU;AAC3B,QAAI,CAAC,UAAU,MAAM,OAAO,GAAG;AAC7B,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAmBO,SAAS,KAAQ,UAAuB,YAA0B,mBAA4B;AACnG,MAAI,QAAQ;AACZ,aAAW,QAAQ,UAAU;AAC3B,QAAI,UAAU,MAAM,OAAO,GAAG;AAC5B,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAKO,IAAM,MAAM;AAKZ,IAAM,MAAM;AAaZ,SAAS,SAAY,UAAuB,QAAoB;AACrE,SAAO,KAAK,UAAU,CAAC,MAAM,MAAM,MAAM;AAC3C;AAeO,UAAU,UAAa,UAAuB,QAAQ,GAAkC;AAC7F,MAAI,QAAgB;AACpB,aAAW,SAAS,UAAU;AAC5B,UAAM,CAAC,SAAS,KAAK;AAAA,EACvB;AACF;AAOO,SAAS,OAAU,UAAuB,WAA8B;AAC7E,SAAO,MAAM,KAAK,QAAQ,UAAU,SAAS,CAAC;AAChD;AAQO,SAAS,KAAQ,UAA4C;AAClE,SAAO,SAAS,OAAO,QAAQ,EAAE;AAEnC;AAKO,SAAS,IAAU,UAAuB,QAA6B;AAC5E,SAAO,MAAM,KAAK,KAAK,UAAU,MAAM,CAAC;AAC1C;AAaO,SAAS,IAAO,UAAuB,QAA6B,gBAA+B;AACxG,SAAO,QAAQ,UAAU,CAAC,GAAG,MAAO,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,CAAE;AAClE;AAaO,SAAS,IAAO,UAAuB,QAA6B,gBAA+B;AACxG,SAAO,QAAQ,UAAU,CAAC,GAAG,MAAO,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,CAAE;AAClE;AAKA,SAAS,OAAO,OAAe,MAAc,MAAwC;AACnF,QAAM,UAAU,MAAM,OAAO,IAAI;AACjC,QAAM,OAAO,QAAQ,IAAI,CAAC,MAAc,IAAI,OAAO,CAAC,MAAc,IAAI;AACtE,SAAO,UAAU,SAAS,IAAI;AAChC;AA4BO,SAAS,MAAM,aAAqB,gBAAyB,OAAO,GAA6B;AACtG,MAAI,mBAAmB,QAAW;AAChC,WAAO,OAAO,aAA4B,gBAAgB,IAAI;AAAA,EAChE,OAAO;AACL,WAAO,OAAO,GAAG,aAA2B,IAAI;AAAA,EAClD;AACF;AAIO,SAAS,OAAO,aAAqB,gBAAyB,OAAO,GAAa;AACvF,MAAI,mBAAmB,QAAW;AAChC,WAAO,MAAM,KAAK,OAAO,aAA4B,gBAAgB,IAAI,CAAC;AAAA,EAC5E,OAAO;AACL,WAAO,MAAM,KAAK,OAAO,GAAG,aAA2B,IAAI,CAAC;AAAA,EAC9D;AACF;AAyBO,SAAS,OACd,UACA,SACA,OACqB;AACrB,MAAI,UAAU,QAAW;AACvB,WAAO,QAAQ,UAAU,OAAgD;AAAA,EAC3E,OAAO;AACL,WAAO,QAAQ,UAAU,SAAkD,KAAK;AAAA,EAClF;AACF;AAEA,SAAS,QAAc,UAAuB,SAAgD,OAAa;AACzG,MAAI,SAAS;AACb,MAAI,QAAQ;AACZ,aAAW,QAAQ,UAAU;AAC3B,aAAS,QAAQ,QAAQ,MAAM,OAAO;AAAA,EACxC;AACA,SAAO;AACT;AAEA,SAAS,QAAW,UAAuB,SAA+D;AACxG,QAAM,KAAK,KAAK,QAAQ;AACxB,QAAM,QAAQ,KAAK,EAAE;AACrB,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT,OAAO;AACL,WAAO,QAAQ,IAAI,SAAS,KAAK;AAAA,EACnC;AACF;AAeO,SAAS,OACd,UACA,QAAgC,mBAChC,UAAU,OACL;AACL,QAAM,SAAS,MAAM,KAAK,QAAQ;AAClC,SAAO,KAAK,SAAS,KAAK,CAAC;AAE3B,MAAI,SAAS;AACX,WAAO,QAAQ;AAAA,EACjB;AAEA,SAAO;AACT;AAMO,SAAS,IAAI,UAAoC;AACtD,SAAO,OAAO,UAAU,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC;AAC5C;AAKO,SAAS,IAAY,IAAkB,IAA8B;AAC1E,SAAO,MAAM,KAAK,KAAK,IAAI,EAAE,CAAC;AAChC;AAKO,SAAS,KAAiB,IAAkB,IAAkB,IAAkC;AACrG,SAAO,MAAM,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC;AACrC;;;AC9UA,SAAS,UAAa,GAA2B;AAC/C,SAAO,KAAK;AACd;AAEA,SAAS,UAAU,GAAqB;AACtC,SAAO,MAAM;AACf;AAUO,SAAS,SAAY,UAA+D;AACzF,SAAO,QAAQ,UAAU,SAAS;AACpC;AAUO,SAAS,QAAW,UAA+C;AACxE,SAAO,MAAM,KAAK,SAAS,QAAQ,CAAC;AACtC;AASO,SAAS,cAAmC,KAAoD;AACrG,QAAM,SAAS,CAAC;AAChB,aAAW,CAAC,KAAK,MAAM,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC/C,UAAM,QAAQ;AACd,QAAI,SAAS,MAAM;AACjB,aAAO,GAAQ,IAAI;AAAA,IACrB;AAAA,EACF;AACA,SAAO;AACT;AAQO,SAAS,MAAS,UAAuB,OAAqC;AACnF,SAAO,KAAK,UAAU,SAAS,SAAS;AAC1C;AAgBO,SAAS,QAAc,UAAuB,QAAuD;AAC1G,SAAO,QAAQ,KAAK,UAAU,MAAM,CAAC;AACvC;AA8BO,UAAU,cACf,OACA,QACA,SACA,SACe;AACf,MAAI,MAAW,CAAC;AAChB,MAAI,UAAU;AACd,MAAI,IAAI;AAER,aAAW,QAAQ,OAAO;AACxB,UAAM,IAAI,OAAO,MAAM,GAAG;AAC1B,QAAI,UAAU,KAAK,SAAS;AAC1B,UAAI,KAAK,IAAI;AACb,iBAAW;AAAA,IACb,OAAO;AACL,UAAI,IAAI,SAAS,EAAG,OAAM;AAC1B,YAAM,CAAC,IAAI;AACX,gBAAU;AAAA,IACZ;AAEA,QAAI,YAAY,UAAa,WAAW,SAAS;AAC/C,YAAM;AACN,YAAM,CAAC;AACP,gBAAU;AAAA,IACZ;AAAA,EACF;AAEA,MAAI,IAAI,SAAS,EAAG,OAAM;AAC5B;","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\n/**\n * Group items from a stream into chunks, where each chunk's total cost stays\n * under `maxCost` (hard cap) and optionally reaches `minCost` (soft target).\n *\n * `maxCost` is a hard cap: a chunk is flushed before adding an item that would\n * push the running cost past `maxCost`. `minCost` is an optional soft target:\n * when provided, a chunk is flushed as soon as the running cost reaches it.\n * `minCost` may be:\n *\n *   - a `number`: same target for every chunk\n *   - a function `(chunkIndex: number) => number`: per-chunk target, indexed\n *     by the 0-based output chunk number. Useful for ramp-up schedules.\n *\n * When `minCost` is omitted, chunks grow as large as `maxCost` allows.\n *\n *     >>> // Pack rows into batches of <= 10 bytes\n *     >>> const rows = [\"aaaa\", \"bbbb\", \"cc\", \"dddddd\", \"ee\"];\n *     >>> [...chunkedByCost(rows, (s) => s.length, 10)]\n *     [[\"aaaa\", \"bbbb\", \"cc\"], [\"dddddd\", \"ee\"]]\n *\n * With a constant `minCost` soft target, the chunker flushes early to keep\n * chunks roughly that size — useful when you want predictable chunk sizes\n * without locking them to a fixed item count:\n *\n *     >>> [...chunkedByCost(rows, (s) => s.length, 100, 6)]\n *     [[\"aaaa\", \"bbbb\"], [\"cc\", \"dddddd\"], [\"ee\"]]\n *\n * With a scheduled `minCost`, early chunks can be smaller than later ones —\n * useful for fast-start patterns (e.g. clearing a slow outgoing queue with a\n * few small chunks before settling into larger ones):\n *\n *     >>> const items = Array.from({ length: 30 }, () => 1);\n *     >>> [...chunkedByCost(items, () => 1, 100, (i) => Math.min(8, 1 << i))]\n *     [[1], [1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], ...]\n *\n * If a single item's cost alone is >= `maxCost`, it is still emitted as its\n * own chunk. Only in this edge case can an output chunk exceed the hard cap.\n */\nexport function* chunkedByCost<T>(\n  items: Iterable<T>,\n  costFn: (item: T) => number,\n  maxCost: number,\n  minCost?: number | ((chunkIndex: number) => number),\n): Iterable<T[]> {\n  const getIdealCost =\n    typeof minCost === \"function\" ? minCost : minCost !== undefined ? () => minCost : () => Number.POSITIVE_INFINITY;\n\n  let buf: T[] = [];\n  let bufcost = 0;\n  let chunkIndex = 0;\n  let idealCost: number | undefined;\n\n  for (const item of items) {\n    const c = costFn(item);\n    if (bufcost + c <= maxCost) {\n      buf.push(item);\n      bufcost += c;\n    } else {\n      if (buf.length > 0) {\n        yield buf;\n        chunkIndex++;\n        idealCost = undefined;\n      }\n      buf = [item];\n      bufcost = c;\n    }\n\n    idealCost ??= getIdealCost(chunkIndex);\n    if (bufcost >= idealCost) {\n      yield buf;\n      chunkIndex++;\n      idealCost = undefined;\n      buf = [];\n      bufcost = 0;\n    }\n  }\n\n  if (buf.length > 0) yield buf;\n}\n"],"mappings":"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","names":["count","first","grouper","heads"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itertools",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "A JavaScript port of Python's awesome itertools standard library",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
     "test": "vitest run --coverage",
     "test:types": "pnpm run build && tsd --typings ./dist/index.d.ts",
     "release": "release-it",
-    "postinstall": "syncpack lint"
+    "prepare": "syncpack lint"
   },
   "files": [
     "dist/",