atomic-fns 0.3.1 → 0.3.3-beta

package/{src → core}/functools/index.js

@@ -171,7 +171,7 @@ export function once(func) {
     };
 }
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type.
+ * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *
  * @param {Function} fun The function to wrap and catch if it throws.
  * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
@@ -198,7 +198,7 @@ export function result(fun, onFinally) {
  *
  * @param {Function|Promise} awaitable The function or promise to await.
  * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a return type.
+ * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
  */
 export function resultAsync(awaitable, onFinally) {

package/{src → core}/functools/index.ts

@@ -204,7 +204,7 @@ export type Maybe<T> = T | undefined
 export type Result<T, E = any> = [Maybe<T>, Maybe<E>]
 
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type.
+ * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *
  * @param {Function} fun The function to wrap and catch if it throws.
  * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
@@ -233,7 +233,7 @@ export function result<T = any, E = unknown>(
  *
  * @param {Function|Promise} awaitable The function or promise to await.
  * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a return type.
+ * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
  */
 export function resultAsync<T = any, E = unknown>(

package/{src → core}/globals/index.d.ts

@@ -3,11 +3,6 @@
  *
  * @module Globals
  */
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description Array.sort()}
- */
-export declare type Comp = (x: any, y: any) => -1 | 0 | 1;
 /** This is just a noop function. */
 export declare const _: () => void;
 /**
@@ -27,7 +22,7 @@ export declare type Function<T = any> = (...args: any) => T;
  * @see {@link Collections.sortedUniq}
  * @see {@link Collections.groupBy}
  */
-export declare type Iteratee<T = any> = (value: T, key?: any, arr?: any) => any;
+export declare type Iteratee<T = any, K = any> = (value: T, key?: K, arr?: any) => any;
 export declare type Predicate<T = any> = (value: T) => any;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
@@ -130,7 +125,7 @@ export declare const isGenerator: (x: any) => x is Generator<unknown, any, unkno
 export declare const isNull: (x: any) => x is null | undefined;
 /** Check if value is not `null` or `undefined`. */
 export declare const notNull: (x: any) => boolean;
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export declare const isEmpty: (x: any) => boolean;
 /** Check if value is a `Symbol` type */
 export declare const isSymbol: (x: any) => x is symbol;

package/{src → core}/globals/index.js

@@ -164,7 +164,7 @@ export const isGenerator = (x) => {
 export const isNull = (x) => x == null;
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null;
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export const isEmpty = (x) => (len(x) === 0 ? true : !x);
 /** Check if value is a `Symbol` type */
 export const isSymbol = (x) => type(x) === 'symbol';
@@ -179,12 +179,15 @@ export const isSymbol = (x) => type(x) === 'symbol';
 export function len(value) {
     if (value == null)
         return;
-    if (value.length !== undefined) {
+    if (isNumber(value.length)) {
         return value.length;
     }
     if (isFunc(value.size)) {
         return value.size();
     }
+    if (isNumber(value.size)) {
+        return value.size;
+    }
     if (isObject(value)) {
         return Object.keys(value).length;
     }

package/{src → core}/globals/index.ts

@@ -4,12 +4,6 @@
  * @module Globals
  */
 
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description Array.sort()}
- */
-export type Comp = (x, y) => -1 | 0 | 1
-
 /** This is just a noop function. */
 export const _ = () => {}
 
@@ -31,7 +25,7 @@ export type Function<T = any> = (...args: any) => T
  * @see {@link Collections.sortedUniq}
  * @see {@link Collections.groupBy}
  */
-export type Iteratee<T = any> = (value: T, key?, arr?) => any
+export type Iteratee<T = any, K = any> = (value: T, key?: K, arr?) => any
 
 export type Predicate<T = any> = (value: T) => any
 
@@ -204,7 +198,7 @@ export const isNull = (x): x is null | undefined => x == null
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null
 
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export const isEmpty = (x) => (len(x) === 0 ? true : !x)
 
 /** Check if value is a `Symbol` type */
@@ -220,12 +214,15 @@ export const isSymbol = (x): x is symbol => type(x) === 'symbol'
  */
 export function len(value) {
   if (value == null) return
-  if (value.length !== undefined) {
+  if (isNumber(value.length)) {
     return value.length
   }
   if (isFunc(value.size)) {
     return value.size()
   }
+  if (isNumber(value.size)) {
+    return value.size
+  }
   if (isObject(value)) {
     return Object.keys(value).length
   }

package/{src → core}/index.d.ts

@@ -1,5 +1,4 @@
 export * from './collections/index.js';
-export * from './datetime/index.js';
 export * from './functools/index.js';
 export * from './globals/index.js';
 export * from './itertools/index.js';

package/{src → core}/index.js

@@ -1,5 +1,4 @@
 export * from './collections/index.js';
-export * from './datetime/index.js';
 export * from './functools/index.js';
 export * from './globals/index.js';
 export * from './itertools/index.js';

package/{src → core}/index.ts

@@ -1,5 +1,4 @@
 export * from './collections/index.js'
-export * from './datetime/index.js'
 export * from './functools/index.js'
 export * from './globals/index.js'
 export * from './itertools/index.js'

package/{src → core}/itertools/index.d.ts

@@ -3,8 +3,8 @@
  *
  * @module Iterators
  */
-import { Comp, Function, Predicate } from '../globals/index.js';
-import { add } from '../operators/index.js';
+import { Function, Iteratee, Predicate } from '../globals/index.js';
+import { add, Comparer } from '../operators/index.js';
 /**
  * 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
@@ -82,6 +82,8 @@ export declare function contains(collection: Iterable<any>, value: any): any;
  * @returns Elements
  */
 export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<unknown, any, 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>;
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -106,7 +108,7 @@ export declare function enumerate<T = any>(iterable: Iterable<T>, start?: number
  */
 export declare function first<T>(iterable: Iterable<T>): any;
 /**
- * Creates a new generator that filters all `falsey` and empty values from iterable.
+ * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
  * @returns A new array with the filtered values.
  * @example
@@ -120,7 +122,7 @@ 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>(iterable: Iterable<T>, mapFn: (x: T) => any): Generator<any, void, unknown>;
+export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x: 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
@@ -187,13 +189,13 @@ export declare function reduce<T>(iterable: Iterable<T>, reducer: (prev: T, valu
 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: Comp): 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: Comp): any[];
-export declare function sort(args: any[], reverse: boolean, compareFn: Comp): 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>): unknown[];
 /**
  * Returns a generator that takes elements from the iterable as long as the predicate is `true`.

package/{src → core}/itertools/index.js

@@ -4,7 +4,7 @@
  * @module Iterators
  */
 import { call, isEmpty, isObject, notNull, ValueError } from '../globals/index.js';
-import { add, bool, comp, eq, id } from '../operators/index.js';
+import { add, bool, compare, eq, id } from '../operators/index.js';
 /**
  * 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
@@ -109,7 +109,7 @@ export function contains(collection, value) {
         return includes;
     return any(collection, (x) => eq(value, x));
 }
-const compKey = (cmp, key) => (x, y) => cmp(key(x), key(y));
+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.
@@ -134,6 +134,22 @@ export function* dropWhile(iterable, predicate) {
         yield head.value;
     }
 }
+export function iforEach(iterable, fun) {
+    for (const [index, value] of enumerate(iterable)) {
+        if (fun(value, index, iterable) === false) {
+            return;
+        }
+    }
+}
+export function IterableIterator(next) {
+    const it = {
+        next,
+        [Symbol.iterator]() {
+            return this;
+        }
+    };
+    return it;
+}
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -165,7 +181,7 @@ export function first(iterable) {
     return iter(iterable).next().value;
 }
 /**
- * Creates a new generator that filters all `falsey` and empty values from iterable.
+ * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
  * @returns A new array with the filtered values.
  * @example
@@ -350,8 +366,8 @@ export function reversed(iterable) {
  *
  * @param {(Array | Object)} args
  * @param {(boolean | Function)} [key]
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
 export function sorted(args, key, reverse, compareFn) {
@@ -368,7 +384,7 @@ export function sorted(args, key, reverse, compareFn) {
         key = id;
     }
     const copy = Array.from(args);
-    const _compare = compKey(compareFn || comp, key || id);
+    const _compare = compKey(compareFn || compare, key || id);
     copy.sort(_compare);
     if (reverse)
         copy.reverse();
@@ -381,8 +397,8 @@ export function sorted(args, key, reverse, compareFn) {
  *   - sort([...], true, (x, y) => number) => reverse and using custom compare
  *
  * @param {any[]} args
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
 export function sort(args, reverse, compareFn) {
@@ -390,7 +406,7 @@ export function sort(args, reverse, compareFn) {
         compareFn = reverse;
         reverse = false;
     }
-    args.sort(compareFn || comp);
+    args.sort(compareFn || compare);
     if (reverse === true)
         args.reverse();
     return args;

package/{src → core}/itertools/index.ts

@@ -6,15 +6,15 @@
 
 import {
   call,
-  Comp,
   Function,
   isEmpty,
   isObject,
+  Iteratee,
   notNull,
   Predicate,
   ValueError
 } from '../globals/index.js'
-import { add, bool, comp, eq, id } from '../operators/index.js'
+import { add, bool, compare, Comparer, eq, id } from '../operators/index.js'
 
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
@@ -119,7 +119,7 @@ export function contains(collection: Iterable<any>, value) {
   return any(collection, (x) => eq(value, x))
 }
 
-const compKey = (cmp: Comp, key) => (x, y) => cmp(key(x), key(y))
+const compKey = (compare: Comparer, 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`.
@@ -144,6 +144,24 @@ export function* dropWhile<T>(iterable: Iterable<T>, predicate: Predicate) {
   }
 }
 
+export function iforEach<T>(iterable: Iterable<T>, fun: Iteratee<T>) {
+  for (const [index, value] of enumerate(iterable)) {
+    if (fun(value as T, index, iterable) === false) {
+      return
+    }
+  }
+}
+
+export function IterableIterator<T = any>(next) {
+  const it: Iterator<T> & Iterable<T> = {
+    next,
+    [Symbol.iterator]() {
+      return this
+    }
+  }
+  return it
+}
+
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -177,7 +195,7 @@ export function first<T>(iterable: Iterable<T>) {
 }
 
 /**
- * Creates a new generator that filters all `falsey` and empty values from iterable.
+ * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
  * @returns A new array with the filtered values.
  * @example
@@ -201,7 +219,7 @@ export function* ifilter<T>(iterable: Iterable<T>, predicate: Predicate) {
   }
 }
 
-export function* imap<T>(iterable: Iterable<T>, mapFn: (x: T) => any) {
+export function* imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x: T) => TReturn) {
   for (const item of iterable) {
     yield mapFn(item)
   }
@@ -352,7 +370,7 @@ export function reversed<T>(iterable: Iterable<T>) {
 
 export function sorted(args: any[]): any[]
 export function sorted(args: any[], reverse: boolean): any[]
-export function sorted(args: any[], reverse: boolean, comp: Comp): any[]
+export function sorted(args: any[], reverse: boolean, comp: Comparer): any[]
 export function sorted(args: any[], key: Function): any[]
 export function sorted(args: any[], key: Function, reverse: boolean): any[]
 
@@ -369,11 +387,16 @@ export function sorted(args: any[], key: Function, reverse: boolean): any[]
  *
  * @param {(Array | Object)} args
  * @param {(boolean | Function)} [key]
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
-export function sorted(args, key?: boolean | Function, reverse?: boolean | Comp, compareFn?: Comp) {
+export function sorted(
+  args,
+  key?: boolean | Function,
+  reverse?: boolean | Comparer,
+  compareFn?: Comparer
+) {
   if (isObject(args)) args = Object.keys(args)
   if (typeof key === 'boolean') {
     if (typeof reverse === 'function') {
@@ -385,7 +408,7 @@ export function sorted(args, key?: boolean | Function, reverse?: boolean | Comp,
     key = id
   }
   const copy = Array.from(args)
-  const _compare = compKey(compareFn || comp, key || id)
+  const _compare = compKey(compareFn || compare, key || id)
   copy.sort(_compare)
   if (reverse) copy.reverse()
   return copy
@@ -393,8 +416,8 @@ export function sorted(args, key?: boolean | Function, reverse?: boolean | Comp,
 
 export function sort(args: any[]): any[]
 export function sort(args: any[], reverse: boolean): any[]
-export function sort(args: any[], compareFn: Comp): any[]
-export function sort(args: any[], reverse: boolean, compareFn: Comp): any[]
+export function sort(args: any[], compareFn: Comparer): any[]
+export function sort(args: any[], reverse: boolean, compareFn: Comparer): any[]
 
 /**
  * Sort `args` in place. Can be called like this:
@@ -403,16 +426,16 @@ export function sort(args: any[], reverse: boolean, compareFn: Comp): any[]
  *   - sort([...], true, (x, y) => number) => reverse and using custom compare
  *
  * @param {any[]} args
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
-export function sort(args: any[], reverse?: boolean | Comp, compareFn?: Comp) {
+export function sort(args: any[], reverse?: boolean | Comparer, compareFn?: Comparer) {
   if (typeof reverse === 'function') {
     compareFn = reverse
     reverse = false
   }
-  args.sort(compareFn || comp)
+  args.sort(compareFn || compare)
   if (reverse === true) args.reverse()
   return args
 }

package/core/operators/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
+/** This is the identity function. It always returns the same value that was passed in */
+export declare const id: (x: any) => any;
+/**
+ * Called to implement truth value testing.
+ * @param x
+ * @returns {boolean} `x.bool()` if exists or `!!x`.
+ */
+export declare const bool: (x: any) => any;
+/**
+ * Returns `true` if `x` is a falsy value.
+ * @see {@link bool}
+ */
+export declare const not: (x: any) => boolean;
+/**
+ * Returns `true` if `x` is an instance of class `y`
+ * @param x The instance object
+ * @param y The parent class
+ * @returns {boolean}
+ */
+export declare const isinstance: (x: any, y: any) => boolean;
+/** Describes a function used to compare two values.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
+ */
+export declare type Comparer<T = any> = (x: T, y: T) => number;
+/**
+ * Checks whether `x` is a comparable type and returns the result of `x.compare(y)`.
+ * Otherwise the return value of the compare function is equivalent to `obj === other ? 0 : obj < other ? -1 : 1`
+ * @param {*} x An initial value
+ * @param {*} y Other value to compare
+ * @returns {number} The comparison result
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
+ * @see {@link eq}
+ * @see {@link lt}
+ */
+export declare function compare(x: any, y: any): number;
+/**
+ * Compares two values to check if they are the same. If `x` is an object with an `eq` method, it returns `x.eq(y)`.
+ * Otherwise it returns the result of `x === y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean} `true` if `x` and `y` are equal or `false` otherwise.
+ */
+export declare function eq(x: any, y: any): boolean;
+/**
+ * Compares two values to check if `x` is strictly less than `y`. If `x` is an object with a `lt` method, it returns `x.lt(y)`.
+ * Otherwise it returns the result of `x < y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean} `true` if `x` is strictly less than `y` or `false` otherwise.
+ */
+export declare function lt(x: any, y: any): boolean;
+/**
+ * Compares two values to check if `x <= y`. If `x` is an object with a `lte` method, it returns `x.lte(y)`, also checks `x.eq(y)` and `x.lt(y)`.
+ * Otherwise it returns the result of `x <= y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean} `true` if `x` is less than or equal to `y` or `false` otherwise.
+ * @see {@link eq}
+ * @see {@link lt}
+ */
+export declare function lte(x: any, y: any): boolean;
+/**
+ * Compares two values to check if `x` is strictly greater than `y`. If `x` is an object with a `gt` method, it returns `x.gt(y)`.
+ * Otherwise it returns the result of `x > y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean} `true` if `x` is strictly greater than `y` or `false` otherwise.
+ */
+export declare function gt(x: any, y: any): any;
+/**
+ * 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`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean} `true` if `x` is less greater than or equal to `y` or `false` otherwise.
+ * @see {@link eq}
+ * @see {@link gt}
+ */
+export declare function gte(x: any, y: any): boolean;
+/**
+ * The addition (+) operator. If `x` is an object with an `add` method, it returns `x.add(y)`.
+ * Otherwise it returns the result of `x + y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x + y
+ */
+export declare function add(x: any, y: any): any;
+/**
+ * The subtraction (-) operator. If `x` is an object with a `sub` method, it returns `x.sub(y)`.
+ * Otherwise it returns the result of `x - y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x - y
+ */
+export declare function sub(x: any, y: any): any;
+/**
+ * The multiplication (*) operator. If `x` is an object with an `mul` method, it returns `x.mul(y)`.
+ * Otherwise it returns the result of `x * y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x * y
+ */
+export declare function mul(x: any, y: any): any;
+/**
+ * The division (/) operator. If `x` is an object with a `div` method, it returns `x.div(y)`.
+ * Otherwise it returns the result of `x / y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x / y
+ */
+export declare function div(x: any, y: any): any;
+/**
+ * The modulo (%) operator. If `x` is an object with a `mod` method, it returns `x.mod(y)`.
+ * Otherwise it returns the result of `x % y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x % y
+ */
+export declare function mod(x: any, y: any): any;
+/**
+ * The power (**) operator. If `x` is an object with a `pow` method, it returns `x.pow(y)`.
+ * Otherwise it returns the result of `x ** y`.
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x ** y
+ */
+export declare function pow(x: any, y: any): any;
+/**
+ * Performs a shallow comparison of two objects or arrays to check if they have the same keys, length and values.
+ * @param obj
+ * @param other
+ * @returns `true` if the objects are considered equal.
+ * @see {@link deepEqual}
+ */
+export declare function shallowEqual(obj: any, other: any): boolean;
+/**
+ * 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 declare function deepEqual(obj: any, other: any, checker?: typeof eq): boolean;