@naturalcycles/js-lib 14.224.0 → 14.226.0

package/dist/array/array.util.d.ts

@@ -103,26 +103,30 @@ export declare function _sortBy<T>(items: T[], mapper: Mapper<T, any>, mutate?:
  */
 export declare function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutate?: boolean): T[];
 /**
- * Like items.find(), but it tries to find from the END of the array.
+ * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Node 18+ supports native array.findLast() - use that.
- * iOS Safari only has it since 15.4
+ * Use `Array.find` if you don't need to stop the iteration early.
  */
-export declare function _findLast<T>(items: T[], predicate: Predicate<T>): T | undefined;
-export declare function _takeWhile<T>(items: T[], predicate: Predicate<T>): T[];
-export declare function _takeRightWhile<T>(items: T[], predicate: Predicate<T>): T[];
-export declare function _dropWhile<T>(items: T[], predicate: Predicate<T>): T[];
-export declare function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[];
+export declare function _find<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined;
 /**
- * Counts how many items match the predicate.
+ * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
  *
- * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
+ * - in Node since 18+
+ * - in iOS Safari since 15.4
  */
-export declare function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number;
+export declare function _findLast<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined;
+export declare function _takeWhile<T>(items: readonly T[], predicate: Predicate<T>): T[];
+export declare function _takeRightWhile<T>(items: readonly T[], predicate: Predicate<T>): T[];
+export declare function _dropWhile<T>(items: readonly T[], predicate: Predicate<T>): T[];
+export declare function _dropRightWhile<T>(items: readonly T[], predicate: Predicate<T>): T[];
 /**
+ * Counts how many items match the predicate.
+ *
  * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export declare function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number>;
+export declare function _count<T>(items: Iterable<T>, predicate: AbortablePredicate<T>, limit?: number): number;
+export declare function _countBy<T>(items: Iterable<T>, mapper: Mapper<T, any>): StringMap<number>;
 /**
  * Returns an intersection between 2 arrays.
  *
@@ -153,8 +157,8 @@ export declare function _difference<T>(source: T[], ...diffs: T[][]): T[];
 /**
  * Returns the sum of items, or 0 for empty array.
  */
-export declare function _sum(items: number[]): number;
-export declare function _sumBy<T>(items: T[], mapper: Mapper<T, number | undefined>): number;
+export declare function _sum(items: Iterable<number>): number;
+export declare function _sumBy<T>(items: Iterable<T>, mapper: Mapper<T, number | undefined>): number;
 /**
  * Map an array of T to a StringMap<V>,
  * by returning a tuple of [key, value] from a mapper function.
@@ -168,7 +172,7 @@ export declare function _sumBy<T>(items: T[], mapper: Mapper<T, number | undefin
  * _mapToObject([1, 2, 3], n => [n, `id${n}`])
  * // { '1': 'id1, '2': 'id2', '3': 'id3' }
  */
-export declare function _mapToObject<T, V>(array: T[], mapper: (item: T) => [key: any, value: V] | FalsyValue): StringMap<V>;
+export declare function _mapToObject<T, V>(array: Iterable<T>, mapper: (item: T) => [key: any, value: V] | FalsyValue): StringMap<V>;
 /**
  * Randomly shuffle an array values.
  * Fisher–Yates algorithm.
@@ -179,28 +183,28 @@ export declare function _shuffle<T>(array: T[], mutate?: boolean): T[];
  * Returns last item of non-empty array.
  * Throws if array is empty.
  */
-export declare function _last<T>(array: T[]): T;
+export declare function _last<T>(array: readonly T[]): T;
 /**
  * Returns last item of the array (or undefined if array is empty).
  */
-export declare function _lastOrUndefined<T>(array: T[]): T | undefined;
+export declare function _lastOrUndefined<T>(array: readonly T[]): T | undefined;
 /**
  * Returns the first item of non-empty array.
  * Throws if array is empty.
  */
-export declare function _first<T>(array: T[]): T;
-export declare function _minOrUndefined<T>(array: T[]): NonNullable<T> | undefined;
+export declare function _first<T>(array: readonly T[]): T;
+export declare function _minOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined;
 /**
  * Filters out nullish values (undefined and null).
  */
-export declare function _min<T>(array: T[]): NonNullable<T>;
-export declare function _maxOrUndefined<T>(array: T[]): NonNullable<T> | undefined;
+export declare function _min<T>(array: readonly T[]): NonNullable<T>;
+export declare function _maxOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined;
 /**
  * Filters out nullish values (undefined and null).
  */
-export declare function _max<T>(array: T[]): NonNullable<T>;
-export declare function _maxBy<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T;
-export declare function _minBy<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T;
-export declare function _maxByOrUndefined<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
-export declare function _minByOrUndefined<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
-export declare function _zip<T1, T2>(array1: T1[], array2: T2[]): [T1, T2][];
+export declare function _max<T>(array: readonly T[]): NonNullable<T>;
+export declare function _maxBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T;
+export declare function _minBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T;
+export declare function _maxByOrUndefined<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
+export declare function _minByOrUndefined<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
+export declare function _zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][];

package/dist/array/array.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._zip = exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._first = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersectsWith = exports._intersection = exports._countBy = exports._count = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._sortDescBy = exports._sortBy = exports._groupBy = exports._mapBy = exports._by = exports._uniqBy = exports._pushUniqBy = exports._pushUniq = exports._uniq = exports._chunk = void 0;
+exports._zip = exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._first = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersectsWith = exports._intersection = exports._countBy = exports._count = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._find = exports._sortDescBy = exports._sortBy = exports._groupBy = exports._mapBy = exports._by = exports._uniqBy = exports._pushUniqBy = exports._pushUniq = exports._uniq = exports._chunk = void 0;
 const is_util_1 = require("../is.util");
 const types_1 = require("../types");
 /**
@@ -172,13 +172,29 @@ function _sortDescBy(items, mapper, mutate = false) {
 }
 exports._sortDescBy = _sortDescBy;
 /**
- * Like items.find(), but it tries to find from the END of the array.
+ * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Node 18+ supports native array.findLast() - use that.
- * iOS Safari only has it since 15.4
+ * Use `Array.find` if you don't need to stop the iteration early.
+ */
+function _find(items, predicate) {
+    for (const [i, item] of items.entries()) {
+        const result = predicate(item, i);
+        if (result === types_1.END)
+            return;
+        if (result)
+            return item;
+    }
+}
+exports._find = _find;
+/**
+ * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
+ *
+ * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
+ * - in Node since 18+
+ * - in iOS Safari since 15.4
  */
 function _findLast(items, predicate) {
-    return [...items].reverse().find(predicate);
+    return _find(items.slice().reverse(), predicate);
 }
 exports._findLast = _findLast;
 function _takeWhile(items, predicate) {
@@ -213,8 +229,9 @@ function _count(items, predicate, limit) {
     if (limit === 0)
         return 0;
     let count = 0;
-    for (const [i, item] of items.entries()) {
-        const r = predicate(item, i);
+    let i = 0;
+    for (const item of items) {
+        const r = predicate(item, i++);
         if (r === types_1.END)
             break;
         if (r) {
@@ -226,15 +243,13 @@ function _count(items, predicate, limit) {
     return count;
 }
 exports._count = _count;
-/**
- * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
- */
 function _countBy(items, mapper) {
     const map = {};
-    items.forEach((item, i) => {
-        const key = mapper(item, i);
+    let i = 0;
+    for (const item of items) {
+        const key = mapper(item, i++);
         map[key] = (map[key] || 0) + 1;
-    });
+    }
     return map;
 }
 exports._countBy = _countBy;
@@ -281,14 +296,24 @@ exports._difference = _difference;
  * Returns the sum of items, or 0 for empty array.
  */
 function _sum(items) {
-    return items.reduce((sum, n) => sum + n, 0);
+    let sum = 0;
+    for (const n of items) {
+        sum += n;
+    }
+    return sum;
 }
 exports._sum = _sum;
 function _sumBy(items, mapper) {
-    return items
-        .map((v, i) => mapper(v, i))
-        .filter(i => typeof i === 'number') // count only numbers, nothing else
-        .reduce((sum, n) => sum + n, 0);
+    let sum = 0;
+    let i = 0;
+    for (const n of items) {
+        const v = mapper(n, i++);
+        if (typeof v === 'number') {
+            // count only numbers, nothing else
+            sum += v;
+        }
+    }
+    return sum;
 }
 exports._sumBy = _sumBy;
 /**
@@ -360,7 +385,7 @@ function _minOrUndefined(array) {
     const a = array.filter(is_util_1._isNotNullish);
     if (!a.length)
         return;
-    return _min(a);
+    return a.reduce((min, item) => (min <= item ? min : item));
 }
 exports._minOrUndefined = _minOrUndefined;
 /**
@@ -377,7 +402,7 @@ function _maxOrUndefined(array) {
     const a = array.filter(is_util_1._isNotNullish);
     if (!a.length)
         return;
-    return _max(a);
+    return a.reduce((max, item) => (max >= item ? max : item));
 }
 exports._maxOrUndefined = _maxOrUndefined;
 /**

package/dist-esm/array/array.util.js

@@ -159,13 +159,28 @@ export function _sortDescBy(items, mapper, mutate = false) {
     return _sortBy(items, mapper, mutate, 'desc');
 }
 /**
- * Like items.find(), but it tries to find from the END of the array.
+ * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Node 18+ supports native array.findLast() - use that.
- * iOS Safari only has it since 15.4
+ * Use `Array.find` if you don't need to stop the iteration early.
+ */
+export function _find(items, predicate) {
+    for (const [i, item] of items.entries()) {
+        const result = predicate(item, i);
+        if (result === END)
+            return;
+        if (result)
+            return item;
+    }
+}
+/**
+ * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
+ *
+ * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
+ * - in Node since 18+
+ * - in iOS Safari since 15.4
  */
 export function _findLast(items, predicate) {
-    return [...items].reverse().find(predicate);
+    return _find(items.slice().reverse(), predicate);
 }
 export function _takeWhile(items, predicate) {
     let proceed = true;
@@ -195,8 +210,9 @@ export function _count(items, predicate, limit) {
     if (limit === 0)
         return 0;
     let count = 0;
-    for (const [i, item] of items.entries()) {
-        const r = predicate(item, i);
+    let i = 0;
+    for (const item of items) {
+        const r = predicate(item, i++);
         if (r === END)
             break;
         if (r) {
@@ -207,15 +223,13 @@ export function _count(items, predicate, limit) {
     }
     return count;
 }
-/**
- * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
- */
 export function _countBy(items, mapper) {
     const map = {};
-    items.forEach((item, i) => {
-        const key = mapper(item, i);
+    let i = 0;
+    for (const item of items) {
+        const key = mapper(item, i++);
         map[key] = (map[key] || 0) + 1;
-    });
+    }
     return map;
 }
 // investigate: _groupBy
@@ -258,13 +272,23 @@ export function _difference(source, ...diffs) {
  * Returns the sum of items, or 0 for empty array.
  */
 export function _sum(items) {
-    return items.reduce((sum, n) => sum + n, 0);
+    let sum = 0;
+    for (const n of items) {
+        sum += n;
+    }
+    return sum;
 }
 export function _sumBy(items, mapper) {
-    return items
-        .map((v, i) => mapper(v, i))
-        .filter(i => typeof i === 'number') // count only numbers, nothing else
-        .reduce((sum, n) => sum + n, 0);
+    let sum = 0;
+    let i = 0;
+    for (const n of items) {
+        const v = mapper(n, i++);
+        if (typeof v === 'number') {
+            // count only numbers, nothing else
+            sum += v;
+        }
+    }
+    return sum;
 }
 /**
  * Map an array of T to a StringMap<V>,
@@ -330,7 +354,7 @@ export function _minOrUndefined(array) {
     const a = array.filter(_isNotNullish);
     if (!a.length)
         return;
-    return _min(a);
+    return a.reduce((min, item) => (min <= item ? min : item));
 }
 /**
  * Filters out nullish values (undefined and null).
@@ -345,7 +369,7 @@ export function _maxOrUndefined(array) {
     const a = array.filter(_isNotNullish);
     if (!a.length)
         return;
-    return _max(a);
+    return a.reduce((max, item) => (max >= item ? max : item));
 }
 /**
  * Filters out nullish values (undefined and null).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.224.0",
+  "version": "14.226.0",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",

package/src/array/array.util.ts

@@ -195,31 +195,45 @@ export function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutate = fals
 }
 
 /**
- * Like items.find(), but it tries to find from the END of the array.
+ * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
- * Node 18+ supports native array.findLast() - use that.
- * iOS Safari only has it since 15.4
+ * Use `Array.find` if you don't need to stop the iteration early.
  */
-export function _findLast<T>(items: T[], predicate: Predicate<T>): T | undefined {
-  return [...items].reverse().find(predicate)
+export function _find<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined {
+  for (const [i, item] of items.entries()) {
+    const result = predicate(item, i)
+    if (result === END) return
+    if (result) return item
+  }
+}
+
+/**
+ * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
+ *
+ * Use `Array.findLast` if you don't need to stop the iteration early, which is supported:
+ * - in Node since 18+
+ * - in iOS Safari since 15.4
+ */
+export function _findLast<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined {
+  return _find(items.slice().reverse(), predicate)
 }
 
-export function _takeWhile<T>(items: T[], predicate: Predicate<T>): T[] {
+export function _takeWhile<T>(items: readonly T[], predicate: Predicate<T>): T[] {
   let proceed = true
   return items.filter((v, index) => (proceed &&= predicate(v, index)))
 }
 
-export function _takeRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
+export function _takeRightWhile<T>(items: readonly T[], predicate: Predicate<T>): T[] {
   let proceed = true
   return [...items].reverse().filter((v, index) => (proceed &&= predicate(v, index)))
 }
 
-export function _dropWhile<T>(items: T[], predicate: Predicate<T>): T[] {
+export function _dropWhile<T>(items: readonly T[], predicate: Predicate<T>): T[] {
   let proceed = false
   return items.filter((v, index) => (proceed ||= !predicate(v, index)))
 }
 
-export function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
+export function _dropRightWhile<T>(items: readonly T[], predicate: Predicate<T>): T[] {
   let proceed = false
   return [...items]
     .reverse()
@@ -232,12 +246,17 @@ export function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
  *
  * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number {
+export function _count<T>(
+  items: Iterable<T>,
+  predicate: AbortablePredicate<T>,
+  limit?: number,
+): number {
   if (limit === 0) return 0
   let count = 0
+  let i = 0
 
-  for (const [i, item] of items.entries()) {
-    const r = predicate(item, i)
+  for (const item of items) {
+    const r = predicate(item, i++)
     if (r === END) break
     if (r) {
       count++
@@ -248,16 +267,14 @@ export function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?:
   return count
 }
 
-/**
- * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
- */
-export function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number> {
+export function _countBy<T>(items: Iterable<T>, mapper: Mapper<T, any>): StringMap<number> {
   const map: StringMap<number> = {}
 
-  items.forEach((item, i) => {
-    const key = mapper(item, i)
+  let i = 0
+  for (const item of items) {
+    const key = mapper(item, i++)
     map[key] = (map[key] || 0) + 1
-  })
+  }
 
   return map
 }
@@ -305,15 +322,27 @@ export function _difference<T>(source: T[], ...diffs: T[][]): T[] {
 /**
  * Returns the sum of items, or 0 for empty array.
  */
-export function _sum(items: number[]): number {
-  return items.reduce((sum, n) => sum + n, 0)
+export function _sum(items: Iterable<number>): number {
+  let sum = 0
+  for (const n of items) {
+    sum += n
+  }
+  return sum
 }
 
-export function _sumBy<T>(items: T[], mapper: Mapper<T, number | undefined>): number {
-  return items
-    .map((v, i) => mapper(v, i)!)
-    .filter(i => typeof i === 'number') // count only numbers, nothing else
-    .reduce((sum, n) => sum + n, 0)
+export function _sumBy<T>(items: Iterable<T>, mapper: Mapper<T, number | undefined>): number {
+  let sum = 0
+  let i = 0
+
+  for (const n of items) {
+    const v = mapper(n, i++)
+    if (typeof v === 'number') {
+      // count only numbers, nothing else
+      sum += v
+    }
+  }
+
+  return sum
 }
 
 /**
@@ -330,7 +359,7 @@ export function _sumBy<T>(items: T[], mapper: Mapper<T, number | undefined>): nu
  * // { '1': 'id1, '2': 'id2', '3': 'id3' }
  */
 export function _mapToObject<T, V>(
-  array: T[],
+  array: Iterable<T>,
   mapper: (item: T) => [key: any, value: V] | FalsyValue,
 ): StringMap<V> {
   const m: StringMap<V> = {}
@@ -365,7 +394,7 @@ export function _shuffle<T>(array: T[], mutate = false): T[] {
  * Returns last item of non-empty array.
  * Throws if array is empty.
  */
-export function _last<T>(array: T[]): T {
+export function _last<T>(array: readonly T[]): T {
   if (!array.length) throw new Error('_last called on empty array')
   return array[array.length - 1]!
 }
@@ -373,7 +402,7 @@ export function _last<T>(array: T[]): T {
 /**
  * Returns last item of the array (or undefined if array is empty).
  */
-export function _lastOrUndefined<T>(array: T[]): T | undefined {
+export function _lastOrUndefined<T>(array: readonly T[]): T | undefined {
   return array[array.length - 1]
 }
 
@@ -381,48 +410,48 @@ export function _lastOrUndefined<T>(array: T[]): T | undefined {
  * Returns the first item of non-empty array.
  * Throws if array is empty.
  */
-export function _first<T>(array: T[]): T {
+export function _first<T>(array: readonly T[]): T {
   if (!array.length) throw new Error('_first called on empty array')
   return array[0]!
 }
 
-export function _minOrUndefined<T>(array: T[]): NonNullable<T> | undefined {
+export function _minOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined {
   const a = array.filter(_isNotNullish)
   if (!a.length) return
-  return _min(a)
+  return a.reduce((min, item) => (min <= item ? min : item))
 }
 
 /**
  * Filters out nullish values (undefined and null).
  */
-export function _min<T>(array: T[]): NonNullable<T> {
+export function _min<T>(array: readonly T[]): NonNullable<T> {
   const a = array.filter(_isNotNullish)
   if (!a.length) throw new Error('_min called on empty array')
   return a.reduce((min, item) => (min <= item ? min : item))
 }
 
-export function _maxOrUndefined<T>(array: T[]): NonNullable<T> | undefined {
+export function _maxOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined {
   const a = array.filter(_isNotNullish)
   if (!a.length) return
-  return _max(a)
+  return a.reduce((max, item) => (max >= item ? max : item))
 }
 
 /**
  * Filters out nullish values (undefined and null).
  */
-export function _max<T>(array: T[]): NonNullable<T> {
+export function _max<T>(array: readonly T[]): NonNullable<T> {
   const a = array.filter(_isNotNullish)
   if (!a.length) throw new Error('_max called on empty array')
   return a.reduce((max, item) => (max >= item ? max : item))
 }
 
-export function _maxBy<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T {
+export function _maxBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T {
   const max = _maxByOrUndefined(array, mapper)
   if (max === undefined) throw new Error(`_maxBy returned undefined`)
   return max
 }
 
-export function _minBy<T>(array: T[], mapper: Mapper<T, number | string | undefined>): T {
+export function _minBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T {
   const min = _minByOrUndefined(array, mapper)
   if (min === undefined) throw new Error(`_minBy returned undefined`)
   return min
@@ -431,7 +460,7 @@ export function _minBy<T>(array: T[], mapper: Mapper<T, number | string | undefi
 // todo: looks like it _maxByOrUndefined/_minByOrUndefined can be DRYer
 
 export function _maxByOrUndefined<T>(
-  array: T[],
+  array: readonly T[],
   mapper: Mapper<T, number | string | undefined>,
 ): T | undefined {
   if (!array.length) return
@@ -450,7 +479,7 @@ export function _maxByOrUndefined<T>(
 }
 
 export function _minByOrUndefined<T>(
-  array: T[],
+  array: readonly T[],
   mapper: Mapper<T, number | string | undefined>,
 ): T | undefined {
   if (!array.length) return
@@ -468,7 +497,7 @@ export function _minByOrUndefined<T>(
   return minItem
 }
 
-export function _zip<T1, T2>(array1: T1[], array2: T2[]): [T1, T2][] {
+export function _zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][] {
   const len = Math.min(array1.length, array2.length)
   const res: [T1, T2][] = []