atomic-fns 0.4.2 → 0.4.3

package/dist/globals/index.js

@@ -3,6 +3,7 @@
  *
  * @module Globals
  */
+export * from './decimal.js';
 /** This is just a noop function. */
 export const noop = () => { };
 /** A function that always returns `true`. */
@@ -69,8 +70,8 @@ export class ValueError extends CustomError {
 export class ZeroDivisionError extends CustomError {
 }
 /**
- * Returns the true type of any value with correct detection for null, Array,
- * Object, Promise, Symbol, and NaN. The correct values are inferred from {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag | Symbol.toStringTag} and the value's prototype.
+ * Returns the true type of any value with correct detection for `null`, `Array`,
+ * `Object`, `Promise`, `Symbol`, and `NaN`. The correct values are inferred from {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag | Symbol.toStringTag} and the value's prototype.
  * @param value
  * @returns The value type.
  */
@@ -198,12 +199,12 @@ export function len(value) {
     if (isNumber(value.length)) {
         return value.length;
     }
-    if (isFunction(value.size)) {
-        return value.size();
-    }
     if (isNumber(value.size)) {
         return value.size;
     }
+    if (isFunction(value.size)) {
+        return value.size();
+    }
     if (isObject(value)) {
         return Object.keys(value).length;
     }
@@ -274,14 +275,7 @@ export const values = (object) => Object.values(object);
  * @returns `true` if the object has the property name.
  */
 export const has = (obj, attr) => obj && attr in obj;
-/**
- * Check if the attribute is present in the object or return a default value instead.
- * @param {PropertyKey} key
- * @param {*} obj
- * @param {*} [value=undefined]
- * @return The property value or default value.
- */
-export function get(key, obj, value = undefined) {
+export function get(key, obj, value) {
     if (obj == null)
         return value;
     let paths = Array.isArray(key) ? key : [key];
@@ -327,11 +321,6 @@ export function set(attr, obj, value, writable = false, enumerable = false) {
     });
 }
 export const HASH_KEY = Symbol.for('HASH_KEY');
-/**
- * Return a hash value for a given object. The hash will be the same for subsequent invocations.
- * @param obj The given object.
- * @returns The hash value.
- */
 export function hash(obj) {
     if (typeof obj === 'string') {
         return hashCode(obj);
@@ -399,9 +388,6 @@ export const int = (x, base = 10) => parseInt(x, base);
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from Array.from()}
  */
 export const list = (value) => (value ? Array.from(value) : []);
-/**
- * Retrieve the next item from the iterator by calling its `next()` method.
- * @param iter The iterator.
- * @returns The next value from the iterator.
- */
-export const next = (iter) => iter.next().value;
+export function next(iter) {
+    return iter.next().value;
+}

package/dist/i18n/currency.d.ts

@@ -0,0 +1,24 @@
+import { Decimal } from '../globals/decimal.js';
+/**
+ * Currency represents a local currency amount that can be formatted using the `Intl` apis.
+ */
+export declare class Currency extends Decimal {
+    locale: string;
+    currency: string;
+    numberFormat: Intl.NumberFormat;
+    options: Intl.NumberFormatOptions;
+    constructor(amount: any, currency: string, locale?: string, opts?: Intl.NumberFormatOptions);
+    clone(n: any): Currency;
+    negated(): Currency;
+    add(x: any): Currency;
+    sub(x: any): Currency;
+    div(x: any): Currency;
+    mul(x: any): Currency;
+    toDecimal(): any;
+    toString(): string;
+    format(opts?: Intl.NumberFormatOptions, locale?: string): string;
+    displayName(): string;
+    accounting(): string;
+    precision(digits?: number): string;
+    eq(x: any): any;
+}

package/dist/i18n/currency.js

@@ -0,0 +1,85 @@
+import { defaults } from '../collections/index.js';
+import { isObject } from '../globals/index.js';
+import { Decimal } from '../globals/decimal.js';
+/**
+ * Currency represents a local currency amount that can be formatted using the `Intl` apis.
+ */
+export class Currency extends Decimal {
+    locale;
+    currency;
+    numberFormat;
+    options = {
+        style: 'currency',
+        currencyDisplay: 'symbol',
+        maximumFractionDigits: 20
+    };
+    constructor(amount, currency, locale, opts = {}) {
+        super(amount);
+        if (isObject(locale)) {
+            opts = locale;
+            locale = undefined;
+        }
+        const systemLocale = new Intl.NumberFormat(locale, defaults(opts, { currency }, this.options));
+        const resolved = systemLocale.resolvedOptions();
+        this.numberFormat = systemLocale;
+        this.options.currency = currency;
+        this.currency = resolved.currency;
+        this.locale = resolved.locale;
+    }
+    // @ts-expect-error overrides
+    clone(n) {
+        return new Currency(n, this.currency, this.locale, this.options);
+    }
+    // @ts-expect-error overrides
+    negated() {
+        const n = super.negated.call(this);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    add(x) {
+        const n = super.add.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    sub(x) {
+        const n = super.sub.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    div(x) {
+        const n = super.div.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    mul(x) {
+        const n = super.mul.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    toDecimal() {
+        return super.clone.call(this);
+    }
+    toString() {
+        const number = this.toNumber();
+        return this.numberFormat.format(number);
+    }
+    format(opts = {}, locale) {
+        const number = this.toNumber();
+        opts = defaults(opts, this.options);
+        return new Intl.NumberFormat(locale ?? this.locale, opts).format(number);
+    }
+    displayName() {
+        return this.format({ currencyDisplay: 'name' });
+    }
+    accounting() {
+        return this.format({ currencySign: 'accounting' });
+    }
+    precision(digits) {
+        return this.format({ maximumFractionDigits: digits });
+    }
+    eq(x) {
+        if (x?.currency && x.currency !== this.currency) {
+            return false;
+        }
+        return super.eq.call(this, x);
+    }
+}

package/dist/i18n/date/index.d.ts

@@ -1,10 +1,10 @@
 import { Duration, DurationUnit, TDuration } from '../duration.js';
 import { asDate, formatDate, strftime } from '../format.js';
-import { DateParts, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weeksInYear } from './utils.js';
+import { DateObject, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weeksInYear } from './utils.js';
 export { asDate, daysInMonth, daysInYear, formatDate, isLeapYear, maxDate, minDate, strftime, weeksInYear };
-declare type DateInput = number | string | Date;
-declare type DateLike = DateInput | DateParts | IntlDate;
-export { DateInput, DateParts, DateLike };
+export { DateObject };
+export declare type DateInput = number | string | Date;
+export declare type DateLike = DateInput | IntlDate | DateObject;
 /**
  * Creates a date tied to a given locale (default system locale) which can be formatted in that locale's language using the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis} directly or using a formatting string.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis}
@@ -49,7 +49,7 @@ export declare class IntlDate {
     /** Get the number of days in this date's month. */
     daysInMonth(): number;
     /** Get the number of days in this date's year. */
-    daysInYear(): 366 | 365;
+    daysInYear(): number;
     dayOfYear(): number;
     /** Returns `true` if this date's year is a leap year. */
     isLeapYear(): boolean;
@@ -137,7 +137,7 @@ export declare class IntlDate {
      * Returns an object containing year, month, day-of-month, hours, minutes, seconds, milliseconds.
      * @returns {Object} An object like `{year, month, date, hours, minutes, seconds, ms}`
      */
-    toObject(): DateParts;
+    toObject(): DateObject;
     /** Returns the number of milliseconds since the Unix Epoch (January 1, 1970 UTC)  */
     getTime(): number;
     /** Alias of {@link IntlDate.getTime}  */
@@ -176,7 +176,7 @@ export declare class IntlDate {
     lt(other: Date | IntlDate): boolean;
     eq(other: Date | IntlDate): boolean;
     compare(other: Date | IntlDate): number;
-    set(values: DateParts): IntlDate;
+    set(values: DateObject): IntlDate;
     get relativeFormat(): Intl.RelativeTimeFormat;
     relativeTime(n: number, unit?: Intl.RelativeTimeFormatUnit): string;
     fromNow(unit?: Intl.RelativeTimeFormatUnit): string;
@@ -193,7 +193,7 @@ export declare class IntlDate {
     static min(...args: any[]): any;
     inspect(): string;
 }
-export declare function addDuration(date: DateInput, duration: number | TDuration | Duration, exact?: boolean): Date;
+export declare function addDuration(date: DateInput, duration: number | Duration | TDuration, exact?: boolean): Date;
 /**
  * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
  * @param date
@@ -201,4 +201,4 @@ export declare function addDuration(date: DateInput, duration: number | TDuratio
  * @param exact
  * @returns
  */
-export declare function subDuration(date: DateInput, duration: TDuration, exact?: boolean): Date;
+export declare function subDuration(date: DateInput, duration: number | Duration | TDuration, exact?: boolean): Date;

package/dist/i18n/date/utils.d.ts

@@ -1,4 +1,4 @@
-export declare type DateParts = {
+export declare type DateObject = {
     year?: number;
     month?: number;
     day?: number;
@@ -33,7 +33,7 @@ export declare function isLeapYear(year: number): boolean;
  * @param year The date year
  * @returns {number} Number of days in year
  */
-export declare function daysInYear(year: number): 366 | 365;
+export declare function daysInYear(year: number): number;
 /**
  * Get the number of days in the given date's month and year.
  * @param date The specified date
@@ -61,5 +61,5 @@ export declare function weekOfYear(date: string | number | Date, firstDayOfWeek?
     week: any;
     year: any;
 };
-export declare function isoWeeksInYear(year: any): number;
+export declare function isoWeeksInYear(year: number): number;
 export declare function dayOfYear(input: string | number | Date): number;

package/dist/i18n/date/utils.js

@@ -1,25 +1,3 @@
-import { isInteger, ValueError } from '../../globals/index.js';
-function bestBy(arr, by, compare) {
-    if (arr.length === 0) {
-        return undefined;
-    }
-    return arr.reduce((best, next) => {
-        const pair = [by(next), next];
-        if (!best) {
-            return pair;
-        }
-        else if (compare(best[0], pair[0]) === best[0]) {
-            return best;
-        }
-        else {
-            return pair;
-        }
-    }, null)[1];
-}
-// NUMBERS AND STRINGS
-function integerBetween(thing, bottom, top) {
-    return isInteger(thing) && thing >= bottom && thing <= top;
-}
 /**
  * Returns x % n but takes the sign of n instead of x
  * @param x
@@ -138,13 +116,13 @@ function parseZoneInfo(ts, offsetFormat, locale, timeZone) {
         day: '2-digit',
         hour: '2-digit',
         minute: '2-digit',
-        timeZone
+        timeZone,
+        timeZoneName: offsetFormat
     };
-    const modified = { timeZoneName: offsetFormat, ...intlOpts };
-    const parsed = new Intl.DateTimeFormat(locale, modified)
+    const parsed = new Intl.DateTimeFormat(locale, intlOpts)
         .formatToParts(date)
-        .find((m) => m.type.toLowerCase() === 'timezonename');
-    return parsed ? parsed.value : null;
+        .find((m) => m.type === 'timeZoneName');
+    return parsed?.value;
 }
 // signedOffset('-5', '30') -> -330
 function signedOffset(offHourStr, offMinuteStr) {
@@ -160,7 +138,7 @@ function signedOffset(offHourStr, offMinuteStr) {
 export function asNumber(value) {
     const numericValue = Number(value);
     if (typeof value === 'boolean' || value === '' || Number.isNaN(numericValue))
-        throw new ValueError(`Invalid unit value ${value}`);
+        throw new Error(`Invalid unit value ${value}`);
     return numericValue;
 }
 function formatOffset(offset, format) {

package/dist/i18n/format.d.ts

@@ -18,9 +18,9 @@ export declare function formatDate(formatStr: string, date: Date, locale?: strin
 /**
  * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
  * @param {string} fmt The format string to apply
- * @param {number | Date} date The date value
+ * @param {Date} date The date value
  * @param {?string} locale The locale to use when formatting (default is system locale).
  * @returns {string} The string representation of date
  * @see {@link https://strftime.org/ strftime format}
  */
-export declare function strftime(fmt: string, date: number | Date, locale?: any): string;
+export declare function strftime(fmt: string, date: Date, locale?: string): string;

package/dist/i18n/format.js

@@ -217,7 +217,7 @@ export function formatDate(formatStr, date, locale) {
 /**
  * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
  * @param {string} fmt The format string to apply
- * @param {number | Date} date The date value
+ * @param {Date} date The date value
  * @param {?string} locale The locale to use when formatting (default is system locale).
  * @returns {string} The string representation of date
  * @see {@link https://strftime.org/ strftime format}

package/dist/i18n/index.d.ts

@@ -3,5 +3,6 @@
  *
  * @module i18n
  */
+export * from './currency.js';
 export * from './date/index.js';
 export { Duration, TDuration, DurationUnit } from './duration.js';

package/dist/i18n/index.js

@@ -3,5 +3,6 @@
  *
  * @module i18n
  */
+export * from './currency.js';
 export * from './date/index.js';
 export { Duration } from './duration.js';

package/dist/itertools/index.d.ts

@@ -31,7 +31,7 @@ all([2, 4, 6] => (n) => n > 1)
 ```
 @see {@link any}
  */
-export declare const all: <T>(iterable: Iterable<T>, fn?: Predicate<T>) => boolean;
+export declare const all: <T>(iterable: Iterable<T>, fn?: Predicate<T, any>) => boolean;
 /**
  * Returns true when any of the items in iterable are truthy. An optional predicate function can be used to define what truthiness means for this specific collection.
  * @param iterable
@@ -50,7 +50,7 @@ any([1, 4, 5] => (n) => n % 2 === 0)
 ```
 @see {@link all}
  */
-export declare const any: <T>(iterable: Iterable<T>, fn?: Predicate<T>) => boolean;
+export declare const any: <T>(iterable: Iterable<T>, fn?: Predicate<T, any>) => boolean;
 export declare function chain<T>(...iterables: Array<Iterable<T>>): Generator<T, void, unknown>;
 /**
  * Checks if the `value` is in `collection`.
@@ -81,9 +81,9 @@ export declare function contains(collection: Iterable<any>, value: any): any;
  * @param predicate A function invoked per element to check if it should be dropped.
  * @returns Elements
  */
-export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<any, any, unknown>;
+export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): Generator<T, T, unknown>;
 export declare function iforEach<T>(iterable: Iterable<T>, fun: Iteratee<T>): void;
-export declare function IterableIterator<T = any>(next: any): Iterator<T, any, undefined> & Iterable<T>;
+export declare function IterableIterator<T = any>(next: Iterator<T>['next']): Iterable<T> & Iterator<T>;
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -100,13 +100,13 @@ console.log([...enumerate(['hello', 'world'], 1)])
 // [[1, 'hello'], [2, 'world']]
 ```
  */
-export declare function enumerate<T = any>(iterable: Iterable<T>, start?: number): Generator<(number | T)[], void, unknown>;
+export declare function enumerate<T>(iterable: Iterable<T>, start?: number): Generator<[number, T], void, unknown>;
 /**
  * Returns the first element in an iterable.
  * @param iterable The iterable to inspect.
  * @returns The first element found or undefined if iterable is empty.
  */
-export declare function first<T>(iterable: Iterable<T>): any;
+export declare function first<T>(iterable: Iterable<T>): T;
 /**
  * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
@@ -121,8 +121,8 @@ export declare function icompact<T>(iterable: Iterable<T>): Generator<T, void, u
 /**
  * Iterates over elements of collection, producing only those elements where predicate returns a `truthy` value.
  */
-export declare function ifilter<T>(iterable: Iterable<T>, predicate: Predicate): Generator<T, void, unknown>;
-export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x: T) => TReturn): Generator<TReturn, void, unknown>;
+export declare function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T, boolean>): Generator<T, void, unknown>;
+export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: Predicate<T, TReturn>): Generator<TReturn, void, unknown>;
 /**
  * Returns a generator flattening one level of nesting in a list of lists.
  * @param iterables The iterable to flatten
@@ -134,15 +134,15 @@ export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x:
  */
 export declare function iflatten<T = any>(iterables: Iterable<Iterable<T>>): Generator<T, void, unknown>;
 export declare function flatMap<T>(iterable: Iterable<T>, mapFn?: (x: T) => any): Generator<T, void, unknown>;
-export declare function islice<T>(iterable: Iterable<T>, start: number, stop?: number, step?: number): Generator<number | T, number | T, unknown>;
-export declare function itake<T>(n: number, iterable: Iterable<T>): Generator<any, void, unknown>;
+export declare function islice<T>(iterable: Iterable<T>, start: number, stop?: number, step?: number): Generator<T, T, unknown>;
+export declare function itake<T>(n: number, iterable: Iterable<T>): Generator<T, void, unknown>;
 /**
  * Returns an Iterator from the elements of a collection or the object keys.
  * @param obj The given collection to iterate over.
  * @returns An Iterator type.
  */
-export declare function iter<T>(obj: any): Iterator<T>;
-export declare function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[][];
+export declare function iter<T>(obj: any): Iterator<T, T>;
+export declare function partition<T>(iterable: Iterable<T>, predicate: Predicate<T, boolean>): [T[], T[]];
 /**
  * Returns a generator for a sequence of numbers in the given range, starting from `start` (default 0) to `stop` (not-inclusive) in increments of `step` (default 1).
  *
@@ -187,23 +187,51 @@ export declare function reduce<T>(iterable: Iterable<T>, reducer: (prev: T, valu
  * @returns A new array with the elements reversed.
  */
 export declare function reversed<T>(iterable: Iterable<T>): T[];
-export declare function sorted(args: any[]): any[];
-export declare function sorted(args: any[], reverse: boolean): any[];
-export declare function sorted(args: any[], reverse: boolean, comp: Comparer): any[];
-export declare function sorted(args: any[], key: Function): any[];
-export declare function sorted(args: any[], key: Function, reverse: boolean): any[];
-export declare function sort(args: any[]): any[];
-export declare function sort(args: any[], reverse: boolean): any[];
-export declare function sort(args: any[], compareFn: Comparer): any[];
-export declare function sort(args: any[], reverse: boolean, compareFn: Comparer): any[];
-export declare function take<T>(n: number, iterable: Iterable<T>): any[];
+/**
+ * Creates a new sorted list from the elements in the array. This can be called many ways:
+ *   - sorted([...], true) => reverse order
+ *   - sorted([...], fn = (x) => any) => using a key fn
+ *   - sorted([...], fn = (x) => any, true) => reverse order using key
+ *   - sorted([...], false, (x, y) => number) => using custom compare
+ *   - sorted([...], fn = (x) => any, true, (x, y) => number) => custom key, reverse and compare
+ *
+ * If `args` is an Object, returns the sorted keys.
+ *
+ *
+ * @param {(Array | Object)} args
+ * @param {(boolean | Function)} [key]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
+ * @return
+ */
+export declare function sorted<T>(args: T[]): T[];
+export declare function sorted<T>(args: T[], reverse: boolean): T[];
+export declare function sorted<T>(args: T[], reverse: boolean, comp: Comparer): T[];
+export declare function sorted<T>(args: T[], key: Function): T[];
+export declare function sorted<T>(args: T[], key: Function, reverse: boolean): T[];
+/**
+ * Sort `args` in place. Can be called like this:
+ *   - sort([...], true) => reverse order
+ *   - sort([...], (x, y) => number) => using custom compare
+ *   - sort([...], true, (x, y) => number) => reverse and using custom compare
+ *
+ * @param {any[]} args
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
+ * @return
+ */
+export declare function sort<T>(args: T[]): T[];
+export declare function sort<T>(args: T[], reverse: boolean): T[];
+export declare function sort<T>(args: T[], compareFn: Comparer): T[];
+export declare function sort<T>(args: T[], reverse: boolean, compareFn: Comparer): T[];
+export declare function take<T>(n: number, iterable: Iterable<T>): T[];
 /**
  * Returns a generator that takes elements from the iterable as long as the predicate is `true`.
  * @param iterable The iterable to inspect.
  * @param predicate A function invoked per element to check if it should be taken.
  * @returns Elements
  */
-export declare function takeWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<T, void, unknown>;
+export declare function takeWhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): Generator<T, void, unknown>;
 /** Returns a generator that calls `fn(index)` for each index < n */
 /**
  * Returns a generator that produces `fn(index)` for each `index < n`.

package/dist/itertools/index.js

@@ -109,7 +109,6 @@ export function contains(collection, value) {
         return includes;
     return any(collection, (x) => eq(value, x));
 }
-const compKey = (compare, key) => (x, y) => compare(key(x), key(y));
 /**
  * Returns a generator that drops elements from the iterable as long as the predicate is `true`; afterwards, returns every remaining element. Note, the generator does not produce any output until the predicate first becomes `false`.
  * @param iterable The iterable to inspect.
@@ -142,13 +141,12 @@ export function iforEach(iterable, fun) {
     }
 }
 export function IterableIterator(next) {
-    const it = {
+    return {
         next,
         [Symbol.iterator]() {
             return this;
         }
     };
-    return it;
 }
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
@@ -353,26 +351,11 @@ export function reduce(iterable, reducer, initial) {
 export function reversed(iterable) {
     return Array.from(iterable).reverse();
 }
-/**
- * Creates a new sorted list from the elements in the array. This can be called many ways:
- *   - sorted([...], true) => reverse order
- *   - sorted([...], fn = (x) => any) => using a key fn
- *   - sorted([...], fn = (x) => any, true) => reverse order using key
- *   - sorted([...], false, (x, y) => number) => using custom compare
- *   - sorted([...], fn = (x) => any, true, (x, y) => number) => custom key, reverse and compare
- *
- * If `args` is an Object, returns the sorted keys.
- *
- *
- * @param {(Array | Object)} args
- * @param {(boolean | Function)} [key]
- * @param {(boolean | Comparer)} [reverse]
- * @param {Comparer} [compareFn]
- * @return
- */
+const compKey = (compare, key) => (x, y) => compare(key(x), key(y));
 export function sorted(args, key, reverse, compareFn) {
-    if (isObject(args))
+    if (isObject(args)) {
         args = Object.keys(args);
+    }
     if (typeof key === 'boolean') {
         if (typeof reverse === 'function') {
             compareFn = reverse;
@@ -390,17 +373,6 @@ export function sorted(args, key, reverse, compareFn) {
         copy.reverse();
     return copy;
 }
-/**
- * Sort `args` in place. Can be called like this:
- *   - sort([...], true) => reverse order
- *   - sort([...], (x, y) => number) => using custom compare
- *   - sort([...], true, (x, y) => number) => reverse and using custom compare
- *
- * @param {any[]} args
- * @param {(boolean | Comparer)} [reverse]
- * @param {Comparer} [compareFn]
- * @return
- */
 export function sort(args, reverse, compareFn) {
     if (typeof reverse === 'function') {
         compareFn = reverse;

package/dist/math/index.d.ts

@@ -43,7 +43,7 @@ export declare const ceil: (x: number) => number;
  * @param y
  * @returns
  */
-export declare function divmod(x: number, y: number): number[];
+export declare function divmod(x: number, y: number): [number, number];
 export declare function log2(x: any): number;
 export declare function logBase(x: any, y: any): number;
 /**
@@ -66,7 +66,7 @@ export declare function max<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
  * Computes the mean of the values in `iterable` and accepts an optional `key` function which is invoked for each element to generate the values to be averaged.
  * @param {Array<number>|Iterable<T>} iterable
  * @param {Function} [key] Optional iteratee invoked per element.
- * @returns Returns the mean value or `false` if no elements.
+ * @returns Returns the mean value or `NaN` if no elements.
  * @template T
  * @example
 ```js
@@ -76,8 +76,8 @@ mean(objects, (o) => o.n)
 // 5
 ```
  */
-export declare function mean(iterable: number[]): false | number;
-export declare function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): false | number;
+export declare function mean(iterable: number[]): number;
+export declare function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): number;
 /**
  * Sums `initial` and the items of an iterable and returns the total.
  * @param args The elements to add to `initial`.
@@ -92,6 +92,5 @@ sum([1, 2, 3, 4], 5)
 // 15
 ```
  */
-export declare function sum(iterable: number[]): number;
-export declare function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
-export declare function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
+export declare function sum(args: number[]): number;
+export declare function sum<T>(args: Iterable<T>, key?: Predicate<T>): number;

package/dist/math/index.js

@@ -81,7 +81,9 @@ export function mean(iterable, key = id) {
         total += key(value);
         count++;
     }
-    return count !== 0 && total / count;
+    if (count !== 0)
+        return total / count;
+    return Number.NaN;
 }
 export function sum(args, key = id) {
     let initial = 0;

package/dist/operators/index.d.ts

@@ -72,7 +72,7 @@ export declare function lte(x: any, y: any): boolean;
  * @param {*} y
  * @returns {boolean} `true` if `x` is strictly greater than `y` or `false` otherwise.
  */
-export declare function gt(x: any, y: any): any;
+export declare function gt(x: any, y: any): boolean;
 /**
  * Compares two values to check if `x >= y`. If `x` is an object with a `gte` method, it returns `x.gte(y)`, also checks `x.eq(y)` and `x.gt(y)`.
  * Otherwise it returns the result of `x >= y`.
@@ -145,4 +145,4 @@ export declare function shallowEqual(obj: any, other: any): boolean;
  * @param other
  * @returns `true` if the objects are considered equal.
  */
-export declare function deepEqual(obj: any, other: any, checker?: typeof eq, seen?: WeakSet<object>): boolean;
+export declare function deepEqual(obj: any, other: any, checker?: Function, seen?: any): boolean;

package/dist/operators/index.js

@@ -231,12 +231,6 @@ export function shallowEqual(obj, other) {
     }
     return false;
 }
-/**
- * Performs a recursive comparison of two objects or arrays to check if they have the same keys, length and values. Unlike {@link shallowEqual} this method compares nested values also.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- */
 export function deepEqual(obj, other, checker = eq, seen = new WeakSet()) {
     if (checker(obj, other))
         return true;

package/dist/random/index.d.ts

@@ -22,7 +22,7 @@ export declare const randomInt: (min?: number, max?: number) => number;
  * @returns {T}
  * @template T
  */
-export declare const choice: <T>(arr: T[]) => T;
+export declare function choice<T>(arr: T[]): T;
 /**
  * Returns a random sample of size k from a list of items.
  * @param {Array} arr