@naturalcycles/js-lib 14.225.0 → 14.227.0

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

@@ -107,7 +107,7 @@ export declare function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutat
  *
  * Use `Array.find` if you don't need to stop the iteration early.
  */
-export declare function _find<T>(items: T[], predicate: AbortablePredicate<T>): T | undefined;
+export declare function _find<T>(items: readonly T[], predicate: AbortablePredicate<T>): T | undefined;
 /**
  * Similar to `Array.findLast`, but the `predicate` may return `END` to stop the iteration early.
  *
@@ -115,21 +115,18 @@ export declare function _find<T>(items: T[], predicate: AbortablePredicate<T>):
  * - in Node since 18+
  * - in iOS Safari since 15.4
  */
-export declare function _findLast<T>(items: T[], predicate: AbortablePredicate<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 _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 _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number;
-/**
- * `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.
  *
@@ -160,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.
@@ -175,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.
@@ -186,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

@@ -229,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) {
@@ -242,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;
@@ -297,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;
 /**
@@ -376,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;
 /**
@@ -393,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/datetime/localDate.d.ts

@@ -94,15 +94,7 @@ export declare class LocalDate {
      */
     diff(d: LocalDateInput, unit: LocalDateUnit): number;
     plus(num: number, unit: LocalDateUnit, mutate?: boolean): LocalDate;
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num: number, unit: LocalDateUnit, mutate?: boolean): LocalDate;
     minus(num: number, unit: LocalDateUnit, mutate?: boolean): LocalDate;
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num: number, unit: LocalDateUnit, mutate?: boolean): LocalDate;
     startOf(unit: LocalDateUnitStrict): LocalDate;
     endOf(unit: LocalDateUnitStrict): LocalDate;
     static getYearLength(year: number): number;

package/dist/datetime/localDate.js

@@ -342,21 +342,9 @@ class LocalDate {
         }
         return new LocalDate($year, $month, $day);
     }
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num, unit, mutate = false) {
-        return this.plus(-num, unit, mutate);
-    }
     minus(num, unit, mutate = false) {
         return this.plus(-num, unit, mutate);
     }
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num, unit, mutate = false) {
-        return this.plus(num, unit, mutate);
-    }
     startOf(unit) {
         if (unit === 'day')
             return this;

package/dist/datetime/localTime.d.ts

@@ -70,15 +70,7 @@ export declare class LocalTime {
     second(v: number): LocalTime;
     setComponents(c: Partial<LocalTimeComponents>, mutate?: boolean): LocalTime;
     plus(num: number, unit: LocalTimeUnit, mutate?: boolean): LocalTime;
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num: number, unit: LocalTimeUnit, mutate?: boolean): LocalTime;
     minus(num: number, unit: LocalTimeUnit, mutate?: boolean): LocalTime;
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num: number, unit: LocalTimeUnit, mutate?: boolean): LocalTime;
     absDiff(other: LocalTimeInput, unit: LocalTimeUnit): number;
     diff(other: LocalTimeInput, unit: LocalTimeUnit): number;
     startOf(unit: LocalTimeUnit, mutate?: boolean): LocalTime;

package/dist/datetime/localTime.js

@@ -211,21 +211,9 @@ class LocalTime {
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num, unit, mutate = false) {
-        return this.plus(num * -1, unit, mutate);
-    }
     minus(num, unit, mutate = false) {
         return this.plus(num * -1, unit, mutate);
     }
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num, unit, mutate = false) {
-        return this.plus(num, unit, mutate);
-    }
     absDiff(other, unit) {
         return Math.abs(this.diff(other, unit));
     }

package/dist/promise/pRetry.js

@@ -25,7 +25,6 @@ async function pRetry(fn, opt = {}) {
     const fname = name || fn.name || 'pRetry function';
     let delay = initialDelay;
     let attempt = 0;
-    /* eslint-disable no-constant-condition */
     while (true) {
         const started = Date.now();
         try {

package/dist/string/stringify.d.ts

@@ -65,7 +65,3 @@ export interface StringifyOptions {
  * Returns 'undefined' if undefined is passed (default util.inspect behavior).
  */
 export declare function _stringify(obj: any, opt?: StringifyOptions): string;
-/**
- * @deprecated renamed to _stringify
- */
-export declare const _stringifyAny: typeof _stringify;

package/dist/string/stringify.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._stringifyAny = exports._stringify = exports.setGlobalStringifyFunction = void 0;
+exports._stringify = exports.setGlobalStringifyFunction = void 0;
 const error_util_1 = require("../error/error.util");
 const json_util_1 = require("./json.util");
 const safeJsonStringify_1 = require("./safeJsonStringify");
@@ -136,7 +136,3 @@ function _stringify(obj, opt = {}) {
     return s;
 }
 exports._stringify = _stringify;
-/**
- * @deprecated renamed to _stringify
- */
-exports._stringifyAny = _stringify;

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

@@ -210,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) {
@@ -222,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
@@ -273,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>,
@@ -345,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).
@@ -360,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/dist-esm/datetime/localDate.js

@@ -339,21 +339,9 @@ export class LocalDate {
         }
         return new LocalDate($year, $month, $day);
     }
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num, unit, mutate = false) {
-        return this.plus(-num, unit, mutate);
-    }
     minus(num, unit, mutate = false) {
         return this.plus(-num, unit, mutate);
     }
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num, unit, mutate = false) {
-        return this.plus(num, unit, mutate);
-    }
     startOf(unit) {
         if (unit === 'day')
             return this;

package/dist-esm/datetime/localTime.js

@@ -209,21 +209,9 @@ export class LocalTime {
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
-    /**
-     * @deprecated use `minus` instead
-     */
-    subtract(num, unit, mutate = false) {
-        return this.plus(num * -1, unit, mutate);
-    }
     minus(num, unit, mutate = false) {
         return this.plus(num * -1, unit, mutate);
     }
-    /**
-     * @deprecated use `plus` instead
-     */
-    add(num, unit, mutate = false) {
-        return this.plus(num, unit, mutate);
-    }
     absDiff(other, unit) {
         return Math.abs(this.diff(other, unit));
     }

package/dist-esm/promise/pRetry.js

@@ -21,7 +21,6 @@ export async function pRetry(fn, opt = {}) {
     const fname = name || fn.name || 'pRetry function';
     let delay = initialDelay;
     let attempt = 0;
-    /* eslint-disable no-constant-condition */
     while (true) {
         const started = Date.now();
         try {

package/dist-esm/string/stringify.js

@@ -131,7 +131,3 @@ export function _stringify(obj, opt = {}) {
     }
     return s;
 }
-/**
- * @deprecated renamed to _stringify
- */
-export const _stringifyAny = _stringify;

package/package.json

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

package/src/array/array.util.ts

@@ -199,7 +199,7 @@ export function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutate = fals
  *
  * Use `Array.find` if you don't need to stop the iteration early.
  */
-export function _find<T>(items: T[], predicate: AbortablePredicate<T>): T | undefined {
+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
@@ -214,26 +214,26 @@ export function _find<T>(items: T[], predicate: AbortablePredicate<T>): T | unde
  * - in Node since 18+
  * - in iOS Safari since 15.4
  */
-export function _findLast<T>(items: T[], predicate: AbortablePredicate<T>): T | undefined {
+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()
@@ -246,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++
@@ -262,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
 }
@@ -319,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
 }
 
 /**
@@ -344,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> = {}
@@ -379,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]!
 }
@@ -387,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]
 }
 
@@ -395,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
@@ -445,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
@@ -464,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
@@ -482,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][] = []
 

package/src/datetime/localDate.ts

@@ -415,24 +415,10 @@ export class LocalDate {
     return new LocalDate($year, $month, $day)
   }
 
-  /**
-   * @deprecated use `minus` instead
-   */
-  subtract(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
-    return this.plus(-num, unit, mutate)
-  }
-
   minus(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
     return this.plus(-num, unit, mutate)
   }
 
-  /**
-   * @deprecated use `plus` instead
-   */
-  add(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
-    return this.plus(num, unit, mutate)
-  }
-
   startOf(unit: LocalDateUnitStrict): LocalDate {
     if (unit === 'day') return this
     if (unit === 'month') return LocalDate.create(this.$year, this.$month, 1)

package/src/datetime/localTime.ts

@@ -281,24 +281,10 @@ export class LocalTime {
     return this.set(unit, this.get(unit) + num, mutate)
   }
 
-  /**
-   * @deprecated use `minus` instead
-   */
-  subtract(num: number, unit: LocalTimeUnit, mutate = false): LocalTime {
-    return this.plus(num * -1, unit, mutate)
-  }
-
   minus(num: number, unit: LocalTimeUnit, mutate = false): LocalTime {
     return this.plus(num * -1, unit, mutate)
   }
 
-  /**
-   * @deprecated use `plus` instead
-   */
-  add(num: number, unit: LocalTimeUnit, mutate = false): LocalTime {
-    return this.plus(num, unit, mutate)
-  }
-
   absDiff(other: LocalTimeInput, unit: LocalTimeUnit): number {
     return Math.abs(this.diff(other, unit))
   }

package/src/promise/pRetry.ts

@@ -128,7 +128,6 @@ export async function pRetry<T>(
   let delay = initialDelay
   let attempt = 0
 
-  /* eslint-disable no-constant-condition */
   while (true) {
     const started = Date.now()
 

package/src/string/stringify.ts

@@ -184,8 +184,3 @@ export function _stringify(obj: any, opt: StringifyOptions = {}): string {
 
   return s
 }
-
-/**
- * @deprecated renamed to _stringify
- */
-export const _stringifyAny = _stringify