@naturalcycles/js-lib 15.8.0 → 15.9.0

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

@@ -90,6 +90,18 @@ export declare function _mapBy<ITEM, KEY>(items: readonly ITEM[], mapper: Mapper
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 export declare function _groupBy<T>(items: readonly T[], mapper: Mapper<T, any>): StringMap<T[]>;
+export interface MutateOptions {
+    /**
+     * Defaults to false.
+     */
+    mutate?: boolean;
+}
+export interface SortByOptions extends MutateOptions {
+    /**
+     * Defaults to 'asc'.
+     */
+    dir?: SortDirection;
+}
 /**
  * _sortBy([{age: 20}, {age: 10}], 'age')
  * // => [{age: 10}, {age: 20}]
@@ -97,11 +109,7 @@ export declare function _groupBy<T>(items: readonly T[], mapper: Mapper<T, any>)
  * Same:
  * _sortBy([{age: 20}, {age: 10}], o => o.age)
  */
-export declare function _sortBy<T>(items: T[], mapper: Mapper<T, any>, mutate?: boolean, dir?: SortDirection): T[];
-/**
- * Alias for _sortBy with descending order.
- */
-export declare function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutate?: boolean): T[];
+export declare function _sortBy<T, COMPARE_TYPE extends string | number>(items: T[], mapper: Mapper<T, COMPARE_TYPE>, opt?: SortByOptions): T[];
 /**
  * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
@@ -194,7 +202,7 @@ export declare function _mapToObject<T, V>(array: Iterable<T>, mapper: (item: T)
  * Fisher–Yates algorithm.
  * Based on: https://stackoverflow.com/a/12646864/4919972
  */
-export declare function _shuffle<T>(array: T[], mutate?: boolean): T[];
+export declare function _shuffle<T>(array: T[], opt?: MutateOptions): T[];
 /**
  * Returns last item of non-empty array.
  * Throws if array is empty.

package/dist/array/array.util.js

@@ -50,9 +50,9 @@ export function _pushUniq(a, ...items) {
  * Mutates the array (same as normal `push`).
  */
 export function _pushUniqBy(a, mapper, ...items) {
-    const mappedSet = new Set(a.map((item, i) => mapper(item, i)));
-    items.forEach((item, i) => {
-        const mapped = mapper(item, i);
+    const mappedSet = new Set(a.map(mapper));
+    items.forEach(item => {
+        const mapped = mapper(item);
         if (!mappedSet.has(mapped)) {
             a.push(item);
             mappedSet.add(mapped);
@@ -79,8 +79,9 @@ export function _pushUniqBy(a, mapper, ...items) {
  */
 export function _uniqBy(arr, mapper) {
     const map = new Map();
-    for (const [i, item] of arr.entries()) {
-        const key = item === undefined || item === null ? item : mapper(item, i);
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        const key = item === undefined || item === null ? item : mapper(item);
         if (!map.has(key))
             map.set(key, item);
     }
@@ -107,13 +108,29 @@ export function _uniqBy(arr, mapper) {
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 export function _by(items, mapper) {
-    return Object.fromEntries(items.map((item, i) => [mapper(item, i), item]).filter(([k]) => k !== undefined));
+    const map = {};
+    for (let i = 0; i < items.length; i++) {
+        const v = items[i];
+        const k = mapper(v);
+        if (k !== undefined) {
+            map[k] = v;
+        }
+    }
+    return map;
 }
 /**
  * Map an array of items by a key, that is calculated by a Mapper.
  */
 export function _mapBy(items, mapper) {
-    return new Map(items.map((item, i) => [mapper(item, i), item]).filter(([k]) => k !== undefined));
+    const map = new Map();
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const key = mapper(item);
+        if (key !== undefined) {
+            map.set(key, item);
+        }
+    }
+    return map;
 }
 /**
  * const a = [1, 2, 3, 4, 5]
@@ -128,11 +145,13 @@ export function _mapBy(items, mapper) {
  */
 export function _groupBy(items, mapper) {
     const map = {};
-    for (const [i, item] of items.entries()) {
-        const key = mapper(item, i);
-        if (key === undefined)
-            continue;
-        (map[key] ||= []).push(item);
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const key = mapper(item);
+        if (key !== undefined) {
+            ;
+            (map[key] ||= []).push(item);
+        }
     }
     return map;
 }
@@ -143,28 +162,30 @@ export function _groupBy(items, mapper) {
  * Same:
  * _sortBy([{age: 20}, {age: 10}], o => o.age)
  */
-export function _sortBy(items, mapper, mutate = false, dir = 'asc') {
-    const mod = dir === 'desc' ? -1 : 1;
-    return (mutate ? items : [...items]).sort((_a, _b) => {
-        const [a, b] = [_a, _b].map(mapper);
-        if (typeof a === 'number' && typeof b === 'number')
-            return (a - b) * mod;
-        return String(a).localeCompare(String(b)) * mod;
+export function _sortBy(items, mapper, opt = {}) {
+    const mod = opt.dir === 'desc' ? -1 : 1;
+    return (opt.mutate ? items : [...items]).sort((_a, _b) => {
+        // This implementation may call mapper more than once per item,
+        // but the benchmarks show no significant difference in performance.
+        const a = mapper(_a);
+        const b = mapper(_b);
+        // if (typeof a === 'number' && typeof b === 'number') return (a - b) * mod
+        // return String(a).localeCompare(String(b)) * mod
+        if (a > b)
+            return mod;
+        if (a < b)
+            return -mod;
+        return 0;
     });
 }
-/**
- * Alias for _sortBy with descending order.
- */
-export function _sortDescBy(items, mapper, mutate = false) {
-    return _sortBy(items, mapper, mutate, 'desc');
-}
 /**
  * Similar to `Array.find`, but the `predicate` may return `END` to stop the iteration early.
  *
  * 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()) {
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
         const result = predicate(item, i);
         if (result === END)
             return;
@@ -241,9 +262,8 @@ export function _count(items, predicate, limit) {
 }
 export function _countBy(items, mapper) {
     const map = {};
-    let i = 0;
     for (const item of items) {
-        const key = mapper(item, i++);
+        const key = mapper(item);
         map[key] = (map[key] || 0) + 1;
     }
     return map;
@@ -301,9 +321,8 @@ export function _sum(items) {
 }
 export function _sumBy(items, mapper) {
     let sum = 0;
-    let i = 0;
     for (const n of items) {
-        const v = mapper(n, i++);
+        const v = mapper(n);
         if (typeof v === 'number') {
             // count only numbers, nothing else
             sum = (sum + v);
@@ -339,8 +358,8 @@ export function _mapToObject(array, mapper) {
  * Fisher–Yates algorithm.
  * Based on: https://stackoverflow.com/a/12646864/4919972
  */
-export function _shuffle(array, mutate = false) {
-    const a = mutate ? array : [...array];
+export function _shuffle(array, opt = {}) {
+    const a = opt.mutate ? array : [...array];
     for (let i = a.length - 1; i > 0; i--) {
         const j = Math.floor(Math.random() * (i + 1));
         [a[i], a[j]] = [a[j], a[i]];
@@ -425,8 +444,9 @@ export function _maxByOrUndefined(array, mapper) {
         return;
     let maxItem;
     let max;
-    for (const [i, item] of array.entries()) {
-        const v = mapper(item, i);
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        const v = mapper(item);
         if (v !== undefined && (max === undefined || v > max)) {
             maxItem = item;
             max = v;
@@ -439,8 +459,9 @@ export function _minByOrUndefined(array, mapper) {
         return;
     let minItem;
     let min;
-    for (const [i, item] of array.entries()) {
-        const v = mapper(item, i);
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        const v = mapper(item);
         if (v !== undefined && (min === undefined || v < min)) {
             minItem = item;
             min = v;

package/dist/array/range.d.ts

@@ -22,7 +22,7 @@ export declare function _range(fromIncl: Integer, toExcl: Integer, step?: number
  * Fill is Primitive, because it's safe to shallow-copy.
  * If it was an object - it'll paste the same object reference, which can create bugs.
  */
-export declare function _rangeFilled<T extends Primitive>(length: Integer, fill: T): T[];
+export declare function _arrayFilled<T extends Primitive>(length: Integer, fill: T): T[];
 /**
  * Like _range, but returns an Iterable2.
  */

package/dist/array/range.js

@@ -19,7 +19,7 @@ export function _range(fromIncl, toExcl, step = 1) {
  * Fill is Primitive, because it's safe to shallow-copy.
  * If it was an object - it'll paste the same object reference, which can create bugs.
  */
-export function _rangeFilled(length, fill) {
+export function _arrayFilled(length, fill) {
     // biome-ignore lint/style/useConsistentBuiltinInstantiation: ok
     return Array(length).fill(fill);
 }

package/dist/datetime/dateInterval.d.ts

@@ -1,4 +1,3 @@
-import type { Inclusiveness } from '../types.js';
 import type { LocalDate, LocalDateInput, LocalDateUnit } from './localDate.js';
 export type DateIntervalConfig = DateInterval | DateIntervalString;
 export type DateIntervalString = string;
@@ -24,18 +23,18 @@ export declare class DateInterval {
     /**
      * Ranges of DateInterval (start, end) are INCLUSIVE.
      */
-    includes(d: LocalDateInput, incl?: Inclusiveness): boolean;
-    intersects(int: DateIntervalConfig, inclusive?: boolean): boolean;
+    includes(d: LocalDateInput): boolean;
+    intersects(int: DateIntervalConfig): boolean;
     /**
      * DateIntervals compare by start date.
      * If it's the same - then by end date.
      */
     cmp(d: DateIntervalConfig): -1 | 0 | 1;
-    getDays(incl?: Inclusiveness): LocalDate[];
+    getDays(): LocalDate[];
     /**
      * Returns an array of LocalDates that are included in the interval.
      */
-    range(incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
+    range(step?: number, stepUnit?: LocalDateUnit): LocalDate[];
     toString(): DateIntervalString;
     toJSON(): DateIntervalString;
 }

package/dist/datetime/dateInterval.js

@@ -46,15 +46,12 @@ export class DateInterval {
     /**
      * Ranges of DateInterval (start, end) are INCLUSIVE.
      */
-    includes(d, incl = '[]') {
-        d = localDate(d);
-        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-        return d.isAfter(this.start, incl[0] === '[') && d.isBefore(this.end, incl[1] === ']');
+    includes(d) {
+        return localDate(d).isBetween(this.start, this.end, '[]');
     }
-    intersects(int, inclusive = true) {
+    intersects(int) {
         const $int = DateInterval.parse(int);
-        const incl = inclusive ? '[]' : '()';
-        return this.includes($int.start, incl) || this.includes($int.end, incl);
+        return this.includes($int.start) || this.includes($int.end);
     }
     /**
      * DateIntervals compare by start date.
@@ -64,14 +61,14 @@ export class DateInterval {
         d = DateInterval.parse(d);
         return this.start.compare(d.start) || this.end.compare(d.end);
     }
-    getDays(incl = '[]') {
-        return localDate.range(this.start, this.end, incl, 1, 'day');
+    getDays() {
+        return localDate.range(this.start, this.end, '[]', 1, 'day');
     }
     /**
      * Returns an array of LocalDates that are included in the interval.
      */
-    range(incl = '[]', step = 1, stepUnit = 'day') {
-        return localDate.range(this.start, this.end, incl, step, stepUnit);
+    range(step = 1, stepUnit = 'day') {
+        return localDate.range(this.start, this.end, '[]', step, stepUnit);
     }
     toString() {
         return [this.start, this.end].join('/');

package/dist/datetime/localDate.d.ts

@@ -38,7 +38,7 @@ export declare class LocalDate {
     isSameOrBefore(d: LocalDateInput): boolean;
     isAfter(d: LocalDateInput, inclusive?: boolean): boolean;
     isSameOrAfter(d: LocalDateInput): boolean;
-    isBetween(min: LocalDateInput, max: LocalDateInput, incl?: Inclusiveness): boolean;
+    isBetween(min: LocalDateInput, max: LocalDateInput, incl: Inclusiveness): boolean;
     /**
      * Checks if this localDate is older (<) than "today" by X units.
      *
@@ -269,12 +269,12 @@ declare class LocalDateFactory {
      * Returns the range (array) of LocalDates between min and max.
      * By default, min is included, max is excluded.
      */
-    range(min: LocalDateInput, max: LocalDateInput, incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
+    range(min: LocalDateInput, max: LocalDateInput, incl: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
     /**
      * Returns the Iterable2 of LocalDates between min and max.
      * By default, min is included, max is excluded.
      */
-    rangeIterable(min: LocalDateInput, max: LocalDateInput, incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): Iterable2<LocalDate>;
+    rangeIterable(min: LocalDateInput, max: LocalDateInput, incl: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): Iterable2<LocalDate>;
     getYearLength(year: number): number;
     getMonthLength(year: number, month: number): number;
     isLeapYear(year: number): boolean;

package/dist/datetime/localDate.js

@@ -88,10 +88,9 @@ export class LocalDate {
     isSameOrAfter(d) {
         return this.compare(d) >= 0;
     }
-    isBetween(min, max, incl = '[)') {
+    isBetween(min, max, incl) {
         let r = this.compare(min);
-        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-        if (r < 0 || (r === 0 && incl[0] === '('))
+        if (r < 0)
             return false;
         r = this.compare(max);
         if (r > 0 || (r === 0 && incl[1] === ')'))
@@ -669,14 +668,14 @@ class LocalDateFactory {
      * Returns the range (array) of LocalDates between min and max.
      * By default, min is included, max is excluded.
      */
-    range(min, max, incl = '[)', step = 1, stepUnit = 'day') {
+    range(min, max, incl, step = 1, stepUnit = 'day') {
         return this.rangeIterable(min, max, incl, step, stepUnit).toArray();
     }
     /**
      * Returns the Iterable2 of LocalDates between min and max.
      * By default, min is included, max is excluded.
      */
-    rangeIterable(min, max, incl = '[)', step = 1, stepUnit = 'day') {
+    rangeIterable(min, max, incl, step = 1, stepUnit = 'day') {
         if (stepUnit === 'week') {
             step *= 7;
             stepUnit = 'day';
@@ -684,8 +683,7 @@ class LocalDateFactory {
         const $min = this.fromInput(min).startOf(stepUnit);
         const $max = this.fromInput(max).startOf(stepUnit);
         let value = $min;
-        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-        if (value.isAfter($min, incl[0] === '[')) {
+        if (value.isSameOrAfter($min)) {
             // ok
         }
         else {

package/dist/datetime/localTime.d.ts

@@ -148,7 +148,7 @@ export declare class LocalTime {
     isSameOrBefore(d: LocalTimeInput): boolean;
     isAfter(d: LocalTimeInput, inclusive?: boolean): boolean;
     isSameOrAfter(d: LocalTimeInput): boolean;
-    isBetween(min: LocalTimeInput, max: LocalTimeInput, incl?: Inclusiveness): boolean;
+    isBetween(min: LocalTimeInput, max: LocalTimeInput, incl: Inclusiveness): boolean;
     /**
      * Checks if this localTime is older (<) than "now" by X units.
      *

package/dist/datetime/localTime.js

@@ -426,10 +426,9 @@ export class LocalTime {
     isSameOrAfter(d) {
         return this.compare(d) >= 0;
     }
-    isBetween(min, max, incl = '[)') {
+    isBetween(min, max, incl) {
         let r = this.compare(min);
-        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-        if (r < 0 || (r === 0 && incl[0] === '('))
+        if (r < 0)
             return false;
         r = this.compare(max);
         if (r > 0 || (r === 0 && incl[1] === ')'))

package/dist/datetime/timeInterval.d.ts

@@ -1,4 +1,4 @@
-import type { Inclusiveness, UnixTimestamp } from '../types.js';
+import type { UnixTimestamp } from '../types.js';
 import type { LocalTime, LocalTimeInput } from './localTime.js';
 export type TimeIntervalConfig = TimeInterval | TimeIntervalString;
 export type TimeIntervalString = string;
@@ -26,7 +26,7 @@ export declare class TimeInterval {
     isSameOrBefore(d: TimeIntervalConfig): boolean;
     isAfter(d: TimeIntervalConfig, inclusive?: boolean): boolean;
     isSameOrAfter(d: TimeIntervalConfig): boolean;
-    includes(d: LocalTimeInput, incl?: Inclusiveness): boolean;
+    includes(d: LocalTimeInput): boolean;
     /**
      * TimeIntervals compare by start date.
      * If it's the same - then by end date.

package/dist/datetime/timeInterval.js

@@ -56,12 +56,11 @@ export class TimeInterval {
     isSameOrAfter(d) {
         return this.cmp(d) >= 0;
     }
-    includes(d, incl = '[)') {
+    includes(d) {
         d = localTime.fromInput(d).unix;
-        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-        if (d < this.$start || (d === this.$start && incl[0] === '('))
+        if (d < this.$start)
             return false;
-        if (d > this.$end || (d === this.$end && incl[1] === ')'))
+        if (d > this.$end)
             return false;
         return true;
     }

package/dist/http/fetcher.js

@@ -668,7 +668,7 @@ export class Fetcher {
             }),
         };
         // Because all header values are stringified, so `a: undefined` becomes `undefined` as a string
-        _filterNullishValues(req.init.headers, true);
+        _filterNullishValues(req.init.headers, { mutate: true });
         // setup url
         const baseUrl = opt.baseUrl || this.cfg.baseUrl;
         if (baseUrl) {

package/dist/json-schema/jsonSchema.util.js

@@ -23,5 +23,5 @@ export function mergeJsonSchemaObjects(s1, s2) {
     s1.required.push(...s2.required);
     s1.required = _uniq(s1.required).sort();
     // `additionalProperties` remains the same
-    return _filterNullishValues(s1, true);
+    return _filterNullishValues(s1, { mutate: true });
 }

package/dist/math/math.util.js

@@ -27,7 +27,6 @@ export function _averageOrNull(values) {
 export function _averageWeighted(values, weights) {
     let numerator = 0;
     let denominator = 0;
-    // eslint-disable-next-line unicorn/no-for-loop
     for (let i = 0; i < values.length; i++) {
         numerator += values[i] * weights[i];
         denominator += weights[i];

package/dist/number/number.util.d.ts

@@ -26,7 +26,7 @@ export declare function _runLessOften(percent: number): boolean;
  * Also works with strings:
  * _isBetween('2020-01-03', '2020-01-01', '2020-01-05') // true
  */
-export declare function _isBetween<T extends number | string>(x: T, min: T, max: T, incl?: Inclusiveness): boolean;
+export declare function _isBetween<T extends number | string>(x: T, min: T, max: T, incl: Inclusiveness): boolean;
 export declare function _clamp(x: number, minIncl: number, maxIncl: number): number;
 /**
  * This function exists, because in JS you cannot just .sort() numbers,

package/dist/number/number.util.js

@@ -32,17 +32,12 @@ export function _runLessOften(percent) {
  * Also works with strings:
  * _isBetween('2020-01-03', '2020-01-01', '2020-01-05') // true
  */
-export function _isBetween(x, min, max, incl = '[)') {
-    if (incl === '[)') {
-        return x >= min && x < max;
-    }
-    if (incl === '[]') {
-        return x >= min && x <= max;
-    }
-    if (incl === '(]') {
-        return x > min && x <= max;
-    }
-    return x > min && x < max;
+export function _isBetween(x, min, max, incl) {
+    if (x < min || x > max)
+        return false;
+    if (x === max && incl === '[)')
+        return false;
+    return true;
 }
 export function _clamp(x, minIncl, maxIncl) {
     // eslint-disable-next-line unicorn/prefer-math-min-max

package/dist/object/object.util.d.ts

@@ -1,25 +1,26 @@
+import type { MutateOptions } from '../array/array.util.js';
 import type { AnyObject, KeyValueTuple, ObjectMapper, ObjectPredicate, Reviver, ValueOf } from '../types.js';
 import { SKIP } from '../types.js';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
  */
-export declare function _pick<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], mutate?: boolean): T;
+export declare function _pick<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], opt?: MutateOptions): T;
 /**
  * Sets all properties of an object except passed ones to `undefined`.
  * This is a more performant alternative to `_pick` that does picking/deleting.
  */
-export declare function _pickWithUndefined<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], mutate?: boolean): T;
+export declare function _pickWithUndefined<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], opt?: MutateOptions): T;
 /**
  * Returns clone of `obj` with `props` omitted.
  * Opposite of Pick.
  */
-export declare function _omit<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], mutate?: boolean): T;
+export declare function _omit<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], opt?: MutateOptions): T;
 /**
  * Sets all passed properties of an object to `undefined`.
  * This is a more performant alternative to `_omit` that does picking/deleting.
  */
-export declare function _omitWithUndefined<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], mutate?: boolean): T;
+export declare function _omitWithUndefined<T extends AnyObject, K extends keyof T>(obj: T, props: readonly K[], opt?: MutateOptions): T;
 /**
  * Returns object with filtered keys from `props` array.
  * E.g:
@@ -28,26 +29,26 @@ export declare function _omitWithUndefined<T extends AnyObject, K extends keyof
  *  'account.updated',
  * ])
  */
-export declare function _mask<T extends AnyObject>(obj: T, props: string[], mutate?: boolean): T;
+export declare function _mask<T extends AnyObject>(obj: T, props: string[], opt?: MutateOptions): T;
 /**
  * Removes "falsy" values from the object.
  */
-export declare function _filterFalsyValues<T extends AnyObject>(obj: T, mutate?: boolean): T;
+export declare function _filterFalsyValues<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
 /**
  * Removes values from the object that are `null` or `undefined`.
  */
-export declare function _filterNullishValues<T extends AnyObject>(obj: T, mutate?: boolean): T;
+export declare function _filterNullishValues<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
 /**
  * Removes values from the object that are `undefined`.
  * Only `undefined` values are removed. `null` values are kept!
  */
-export declare function _filterUndefinedValues<T extends AnyObject>(obj: T, mutate?: boolean): T;
-export declare function _filterEmptyArrays<T extends AnyObject>(obj: T, mutate?: boolean): T;
+export declare function _filterUndefinedValues<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
+export declare function _filterEmptyArrays<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
 /**
  * Returns clone of `obj` without properties that does not pass `predicate`.
  * Allows filtering by both key and value.
  */
-export declare function _filterObject<T extends AnyObject>(obj: T, predicate: ObjectPredicate<T>, mutate?: boolean): T;
+export declare function _filterObject<T extends AnyObject>(obj: T, predicate: ObjectPredicate<T>, opt?: MutateOptions): T;
 /**
  * var users = {
  *  'fred':    { 'user': 'fred',    'age': 40 },
@@ -59,7 +60,7 @@ export declare function _filterObject<T extends AnyObject>(obj: T, predicate: Ob
  *
  * To skip some key-value pairs - use _mapObject instead.
  */
-export declare function _mapValues<OUT = unknown, IN extends AnyObject = AnyObject>(obj: IN, mapper: ObjectMapper<IN, any>, mutate?: boolean): OUT;
+export declare function _mapValues<OUT = unknown, IN extends AnyObject = AnyObject>(obj: IN, mapper: ObjectMapper<IN, any>, opt?: MutateOptions): OUT;
 /**
  * _.mapKeys({ 'a': 1, 'b': 2 }, (key, value) => key + value)
  * // => { 'a1': 1, 'b2': 2 }
@@ -87,7 +88,7 @@ export declare function _mapKeys<T extends AnyObject>(obj: T, mapper: ObjectMapp
  */
 export declare function _mapObject<OUT = unknown, IN extends AnyObject = AnyObject>(obj: IN, mapper: ObjectMapper<IN, KeyValueTuple<string, any> | typeof SKIP>): OUT;
 export declare function _findKeyByValue<T extends AnyObject>(obj: T, v: ValueOf<T>): keyof T | undefined;
-export declare function _objectNullValuesToUndefined<T extends AnyObject>(obj: T, mutate?: boolean): T;
+export declare function _objectNullValuesToUndefined<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
 /**
  * Deep copy object (by json parse/stringify, since it has unbeatable performance+simplicity combo).
  */
@@ -100,7 +101,7 @@ export declare function _undefinedIfEmpty<T>(obj: T | undefined): T | undefined;
 /**
  * Filters the object by removing all key-value pairs where Value is Empty (according to _isEmpty() specification).
  */
-export declare function _filterEmptyValues<T extends AnyObject>(obj: T, mutate?: boolean): T;
+export declare function _filterEmptyValues<T extends AnyObject>(obj: T, opt?: MutateOptions): T;
 /**
  * Recursively merges own and inherited enumerable properties of source
  * objects into the destination object, skipping source properties that resolve