atomic-fns 0.4.2 → 1.1.1

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/test.html

@@ -0,0 +1,72 @@
+<script type="module">
+  import { IntlDate } from './index.js'
+  window.IntlDate = IntlDate
+
+  let d = IntlDate.now()
+  console.log('toString', d.toString())
+
+  console.log('%A', d.format('%A'))
+  console.log('%a', d.format('%a'))
+
+  console.log('%%d', d.format('%d'))
+  console.log('%-d', d.format('%-d'))
+
+  console.log('%m', d.format('%m'))
+  console.log('%-m', d.format('%-m'))
+  console.log('%B', d.format('%B'))
+  console.log('%b', d.format('%b'))
+  console.log('%bb', d.format('%bb'))
+
+  console.log('%Y', d.format('%Y'))
+  console.log('%y', d.format('%y'))
+
+  console.log('%N', d.format('%N'))
+  console.log('%n', d.format('%n'))
+
+  console.log('%I', d.format('%I'))
+  console.log('%-I', d.format('%-I'))
+  console.log('%H', d.format('%H'))
+  console.log('%-H', d.format('%-H'))
+  console.log('%K', d.format('%K'))
+  console.log('%k', d.format('%k'))
+
+  console.log('%M', d.format('%M'))
+  console.log('%-M', d.format('%-M'))
+
+  console.log('%S', d.format('%S'))
+  console.log('%-S', d.format('%-S'))
+
+  console.log('%P', d.format('%P'))
+  console.log('%p', d.format('%p'))
+  console.log('%pp', d.format('%pp'))
+
+  console.log('%Z', d.format('%Z'))
+  console.log('%-Z', d.format('%-Z'))
+  console.log('%z', d.format('%z'))
+  console.log('%-z', d.format('%-z'))
+  console.log('%ZZ', d.format('%ZZ'))
+  console.log('%-ZZ', d.format('%-ZZ'))
+
+  console.log('Z', d.format('Z'))
+  console.log('ZZ', d.format('ZZ'))
+  console.log('z', d.format('z'))
+  console.log('zzz', d.format('zzz'))
+
+  console.log(d.toObject())
+  console.log(d.zoneName())
+  console.log(d.offset())
+  console.log(d.offsetInMinutes())
+
+  console.log('month starts', d.startOf('month').toDate())
+  console.log('month ends', d.endOf('month').toDate())
+  console.log('1 day', d.add({ days: 1 }).toDate())
+  console.log('60 days', d.add({ days: 60 }).toDate())
+  console.log('2 months', d.add({ months: 2 }).toDate())
+  console.log('4 months', d.add({ months: 4, weeks: 2 }).toDate())
+  console.log('14 days', d.add({ days: 14 }).toDate())
+  console.log('2 week', d.add({ weeks: 2 }).toDate())
+  console.log('1 month', d.add({ months: 1 }).toDate())
+  console.log('1 year', d.add({ years: 1 }).toDate())
+
+  console.log('-30 years', d.subtract({ years: 30 }, true).toDate())
+</script>

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

@@ -3,8 +3,8 @@
  *
  * @module Iterators
  */
-import { Function, Iteratee, Predicate } from '../globals/index.js';
 import { add, Comparer } from '../operators/index.js';
+import { Function, Iteratee, Predicate } from '../types';
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
  * @param iterable The iterable to accumulate
@@ -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

@@ -3,7 +3,7 @@
  *
  * @module Math
  */
-import { Predicate } from '../globals/index.js';
+import { Predicate } from '../types.js';
 /**
  * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
  * @param x The value.
@@ -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

package/dist/random/index.js

@@ -23,11 +23,11 @@ export const randomInt = (min = 0, max = 1) => Math.round(random(min, max));
  * @returns {T}
  * @template T
  */
-export const choice = (arr) => {
+export function choice(arr) {
     if (!arr?.length)
         return;
     return arr[randomInt(0, arr.length - 1)];
-};
+}
 /**
  * Returns a random sample of size k from a list of items.
  * @param {Array} arr

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A generic function type with arbitrary arguments and return.
+ */
+export declare type Function<TReturn = any> = (...args: any) => TReturn;
+/**
+ * An iteratee function used for collection methods.
+ * @see {@link Collections.filter}
+ * @see {@link Collections.find}
+ * @see {@link Collections.forEach}
+ * @see {@link Collections.index}
+ * @see {@link Collections.map}
+ * @see {@link Collections.pick}
+ * @see {@link Collections.omit}
+ * @see {@link Collections.uniq}
+ * @see {@link Collections.sortedUniq}
+ * @see {@link Collections.groupBy}
+ */
+export declare type Iteratee<T = any, K = any, TResult = any> = (value: T, key?: K, arr?: any) => TResult;
+export declare type Predicate<T = any, TReturn = any> = (value: T) => TReturn;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atomic-fns",
   "description": "Like Lodash, but for ESNext and with types. Stop shipping code built for browsers from 2015.",
-  "version": "0.4.2",
+  "version": "1.1.1",
   "files": [
     "dist/*"
   ],