atomic-fns 0.3.3 → 0.3.4

package/README.md

@@ -52,7 +52,7 @@ You could also import any individual module directly from an html page like this
 ```html
 <script type="module">
   import {
-    namedtuple, Deque, Heap, SortedSet, SortedMap
+    namedtuple, FrozenSet, SortedSet, SortedMap
   } from 'https://unpkg.com/atomic-fns/core/collections';
   // your code goes here...
 </script>
@@ -66,7 +66,7 @@ This library features a data model similar to [Python](https://docs.python.org/3
 For example in Python collections `size()` is a method while in JS its just a property. So this library uses `size` property instead of methods. Similarly, the `len` function implementation checks for both `length` and `size` since many JS objects have a `length` property.
 
 ## Special method names
-This library adds support for operators via object methods like:
+This library adds support for operators using object methods such as:
   - `obj.eq(other)`  adds custom `obj == other`.
   - `obj.lt(other)`  adds custom `obj < other`.
   - `obj.lte(other)`  adds custom `obj <= other`.
@@ -76,11 +76,25 @@ This library adds support for operators via object methods like:
 
 When you implement those, you can also apply operators to values like `eq(x, y), lte(x, y), compare(x, y)`, etc. to get the result of `x.<operator>(y)`.
 
-Some new base types introduced: `Collection, Sequence, Mapping, FrozenSet, IterableIterator`.
+## New Types
+
+Introduces some common base interfaces and typing patterns you may have seen like `Optional`, `Result`, `Comparable`, `Iterator`, and others.
+
+### Sorted Containers
+  - [SortedSet](https://atomic-fns.dev/classes/Collections.SortedSet.html)
+  - [SortedMap](https://atomic-fns.dev/classes/Collections.SortedMap.html)
+  - [SortedTree](https://atomic-fns.dev/classes/Collections.SortedTree.html)
+
+### Other Containers
+  - [Deque](https://atomic-fns.dev/classes/Collections.Deque.html)
+  - [FrozenSet](https://atomic-fns.dev/classes/Collections.FrozenSet.html)
+  - [LRUCache](https://atomic-fns.dev/classes/Collections.LRUCache.html)
+
 
 ## Contributing
 If you want to contribute to the project and make it better, your help is very welcome. Contributing is also a great way to learn more about social coding on Github, new technologies and and their ecosystems and how to make constructive, helpful bug reports, feature requests and the noblest of all contributions: a good, clean pull request. You will be listed as a **Champion** on the official site as well.
 
+
 ## License
 
 [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0)

package/core/collections/LRUCache.d.ts

@@ -1,7 +1,9 @@
 import { Iteratee } from '../globals/index.js';
 import { Mapping } from './abc.js';
 /**
- * Base append-only Cache collection.
+ * Base append-only Cache collection that supports adding and accessing keys in O(1).
+ * The collection has a fixed given size (default 1024) and when full, it evicts keys using LRU approach. This operation is also O(1).
+ * @template K, V
  */
 export declare class Cache<K, V = any> extends Mapping<K, V> {
     capacity: number;
@@ -13,6 +15,12 @@ export declare class Cache<K, V = any> extends Mapping<K, V> {
     protected backward: Uint8Array | Uint16Array | Uint32Array;
     protected K: K[];
     protected V: V[];
+    /**
+     * Create a new cache object of fixed size.
+     * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+     * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+     * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+     */
     constructor(capacity?: number, Keys?: ArrayConstructor, Values?: ArrayConstructor);
     /**
      * This is just an alias of {@link Cache.set}.
@@ -30,6 +38,9 @@ export declare class Cache<K, V = any> extends Mapping<K, V> {
      * Method used to clear the structure.
      */
     clear(): void;
+    /**
+     * Returns the number of keys in the cache.
+     */
     get size(): number;
     /**
      * Method used to splay a value on top.
@@ -101,10 +112,20 @@ export declare class Cache<K, V = any> extends Mapping<K, V> {
      */
     inspect(): Map<any, any>;
 }
+/**
+ * Implements a Least Recently Used fixed-capacity cache which supports updating, removing, and accessing keys in O(1).
+ */
 export declare class LRUCache<K, V> extends Cache<K, V> {
     deletedSize: number;
     deleted: Uint8Array | Uint16Array | Uint32Array;
+    /**
+     * Create a new LRU cache object of fixed size.
+     * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+     * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+     * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+     */
     constructor(capacity?: number, Keys?: ArrayConstructor, Values?: ArrayConstructor);
+    /** Remove all elements in the cache. */
     clear(): void;
     /**
      * Method used to set the value for the given key in the cache.

package/core/collections/LRUCache.js

@@ -3,7 +3,9 @@ import { IterableIterator } from '../itertools/index.js';
 import { Mapping } from './abc.js';
 import { getPointerArray } from './typedArrays.js';
 /**
- * Base append-only Cache collection.
+ * Base append-only Cache collection that supports adding and accessing keys in O(1).
+ * The collection has a fixed given size (default 1024) and when full, it evicts keys using LRU approach. This operation is also O(1).
+ * @template K, V
  */
 export class Cache extends Mapping {
     capacity;
@@ -15,6 +17,12 @@ export class Cache extends Mapping {
     backward;
     K;
     V;
+    /**
+     * Create a new cache object of fixed size.
+     * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+     * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+     * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+     */
     constructor(capacity = 1024, Keys = Array, Values = Array) {
         super();
         this.capacity = capacity;
@@ -53,6 +61,9 @@ export class Cache extends Mapping {
         this.tail = 0;
         this.items = new Map();
     }
+    /**
+     * Returns the number of keys in the cache.
+     */
     get size() {
         return this.count;
     }
@@ -264,14 +275,24 @@ export class Cache extends Mapping {
         return this.inspect();
     }
 }
+/**
+ * Implements a Least Recently Used fixed-capacity cache which supports updating, removing, and accessing keys in O(1).
+ */
 export class LRUCache extends Cache {
     deletedSize = 0;
     deleted;
+    /**
+     * Create a new LRU cache object of fixed size.
+     * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+     * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+     * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+     */
     constructor(capacity = 1024, Keys = Array, Values = Array) {
         super(capacity, Keys, Values);
         const PointerArray = getPointerArray(capacity);
         this.deleted = new PointerArray(capacity);
     }
+    /** Remove all elements in the cache. */
     clear() {
         super.clear();
         this.deletedSize = 0;

package/core/collections/LRUCache.ts

@@ -4,7 +4,9 @@ import { Mapping } from './abc.js'
 import { getPointerArray } from './typedArrays.js'
 
 /**
- * Base append-only Cache collection.
+ * Base append-only Cache collection that supports adding and accessing keys in O(1).
+ * The collection has a fixed given size (default 1024) and when full, it evicts keys using LRU approach. This operation is also O(1).
+ * @template K, V
  */
 export class Cache<K, V = any> extends Mapping<K, V> {
   capacity: number
@@ -17,6 +19,12 @@ export class Cache<K, V = any> extends Mapping<K, V> {
   protected K: K[]
   protected V: V[]
 
+  /**
+   * Create a new cache object of fixed size.
+   * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+   * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+   * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+   */
   constructor(capacity = 1024, Keys = Array, Values = Array) {
     super()
     this.capacity = capacity
@@ -61,6 +69,9 @@ export class Cache<K, V = any> extends Mapping<K, V> {
     this.items = new Map()
   }
 
+  /**
+   * Returns the number of keys in the cache.
+   */
   get size() {
     return this.count
   }
@@ -315,16 +326,26 @@ export class Cache<K, V = any> extends Mapping<K, V> {
   }
 }
 
+/**
+ * Implements a Least Recently Used fixed-capacity cache which supports updating, removing, and accessing keys in O(1).
+ */
 export class LRUCache<K, V> extends Cache<K, V> {
   deletedSize = 0
   deleted: Uint8Array | Uint16Array | Uint32Array
 
+  /**
+   * Create a new LRU cache object of fixed size.
+   * @param {number} [capacity=1024] The maximum number of keys to keep in cache.
+   * @param {Function} [Keys=Array] The constructor to use for the Keys array. When using numeric values, a TypedArray constructor can be used.
+   * @param {Function} [Values=Array] The constructor to use for the Values array. When using numeric values, a TypedArray constructor can be used.
+   */
   constructor(capacity = 1024, Keys = Array, Values = Array) {
     super(capacity, Keys, Values)
     const PointerArray = getPointerArray(capacity)
     this.deleted = new PointerArray(capacity)
   }
 
+  /** Remove all elements in the cache. */
   clear() {
     super.clear()
     this.deletedSize = 0

package/core/collections/SortedMap.d.ts

@@ -1,6 +1,6 @@
 import { Mapping } from './abc.js';
 /**
- * A `SortedMap` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
+ * A `SortedMap` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
  * @see {@link Operators.compare}
  * @see {@link Operators.lt}
  * @template K, V

package/core/collections/SortedMap.js

@@ -1,7 +1,7 @@
 import { Mapping } from './abc.js';
 import { SplayTree } from './SplayTree.js';
 /**
- * A `SortedMap` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
+ * A `SortedMap` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
  * @see {@link Operators.compare}
  * @see {@link Operators.lt}
  * @template K, V

package/core/collections/SortedMap.ts

@@ -2,7 +2,7 @@ import { Mapping } from './abc.js'
 import { SplayTree } from './SplayTree.js'
 
 /**
- * A `SortedMap` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
+ * A `SortedMap` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
  * @see {@link Operators.compare}
  * @see {@link Operators.lt}
  * @template K, V

package/core/collections/SortedSet.d.ts

@@ -1,4 +1,10 @@
 import { Collection } from './abc.js';
+/**
+ * A `SortedSet` is a set that holds values in order. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
+ * @template K, V
+ */
 export declare class SortedSet<T> extends Collection {
     private readonly store;
     /**

package/core/collections/SortedSet.js

@@ -1,5 +1,11 @@
 import { Collection } from './abc.js';
 import { SplayTree } from './SplayTree.js';
+/**
+ * A `SortedSet` is a set that holds values in order. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
+ * @template K, V
+ */
 export class SortedSet extends Collection {
     store;
     /**

package/core/collections/SortedSet.ts

@@ -1,6 +1,12 @@
 import { Collection } from './abc.js'
 import { SplayTree } from './SplayTree.js'
 
+/**
+ * A `SortedSet` is a set that holds values in order. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
+ * @template K, V
+ */
 export class SortedSet<T> extends Collection {
   private readonly store: SplayTree<T>
   /**

package/core/collections/SortedTree.d.ts

@@ -1,9 +1,9 @@
 import { Comparer } from '../operators/index.js';
 import { Mapping } from './abc.js';
 /**
- * A `SortedTree` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
- * @see {@link Operators.compare}
- * @see {@link Operators.lt}
+ * A `SortedTree` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
  * @template K, V
  */
 export declare class SortedTree<K, V> extends Mapping<K, V> {

package/core/collections/SortedTree.js

@@ -1,9 +1,9 @@
 import { Mapping } from './abc.js';
 import { BTree } from './BTree.js';
 /**
- * A `SortedTree` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
- * @see {@link Operators.compare}
- * @see {@link Operators.lt}
+ * A `SortedTree` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
  * @template K, V
  */
 export class SortedTree extends Mapping {

package/core/collections/SortedTree.ts

@@ -3,9 +3,9 @@ import { Mapping } from './abc.js'
 import { BTree } from './BTree.js'
 
 /**
- * A `SortedTree` is a map that holds key value pairs in sorted orders of keys. Any primitive value (and objects that implement a `compare` or `lt` methods) can be used as keys or values.
- * @see {@link Operators.compare}
- * @see {@link Operators.lt}
+ * A `SortedTree` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
+ * @see {@link Compare}
+ * @see {@link Ordered}
  * @template K, V
  */
 export class SortedTree<K, V> extends Mapping<K, V> {

package/core/collections/index.d.ts

@@ -110,6 +110,8 @@ export declare function findRight(arr: any, fn: Iteratee | PropertyKey | Object)
 /**
  * Performs an efficient array insert operation in the given array. If the index or the array is invalid, it just returns the given array.
  *
+ * **Note:** Uses the same behavior as `Array.splice`.
+ *
  * @param {Array<*>} arr The given array to insert into
  * @param {number} index The index of the array insert operation.
  * @param {*} value The value to insert in the array at the given `index`.

package/core/collections/index.js

@@ -4,7 +4,7 @@
  * @module Collections
  */
 import { partial } from '../functools/index.js';
-import { call, get, isArray, isArrayLike, isBool, isEmpty, isFunc, isIterable, isNull, isNumber, isObject, isString, isSymbol, keys, set } from '../globals/index.js';
+import { call, get, isArray, isArrayLike, isBool, isEmpty, isFunction, isIterable, isNull, isNumber, isObject, isString, isSymbol, keys, set } from '../globals/index.js';
 import { enumerate } from '../itertools/index.js';
 import { compare, eq, id } from '../operators/index.js';
 export * from './abc.js';
@@ -81,7 +81,7 @@ filter(users, 'active')
  */
 export function filter(arr, fn = isNull) {
     if (Array.isArray(arr)) {
-        if (isFunc(fn))
+        if (isFunction(fn))
             return arr.filter(fn);
         if (isNumber(fn) || isString(fn) || isSymbol(fn))
             return arr.filter((x) => get(fn, x));
@@ -117,7 +117,7 @@ find(users, 'active')
  */
 export function find(arr, fn) {
     if (Array.isArray(arr)) {
-        if (isFunc(fn))
+        if (isFunction(fn))
             return arr.find(fn);
         if (isNumber(fn) || isString(fn) || isSymbol(fn))
             return arr.find((x) => x?.[fn]);
@@ -159,6 +159,8 @@ export function findRight(arr, fn) {
 /**
  * Performs an efficient array insert operation in the given array. If the index or the array is invalid, it just returns the given array.
  *
+ * **Note:** Uses the same behavior as `Array.splice`.
+ *
  * @param {Array<*>} arr The given array to insert into
  * @param {number} index The index of the array insert operation.
  * @param {*} value The value to insert in the array at the given `index`.
@@ -642,7 +644,7 @@ export function clone(value, deep = false) {
         return cloneArray(value, deep);
     }
     if (isObject(value)) {
-        if (isFunc(value.clone)) {
+        if (isFunction(value.clone)) {
             return value.clone();
         }
         const copy = {};
@@ -974,7 +976,7 @@ export function remove(arr, func) {
     return arr.filter((x, i) => {
         if (isArray(func))
             return !func.includes(x);
-        else if (isFunc(func))
+        else if (isFunction(func))
             return !func(x, i, arr);
         return x !== func;
     });

package/core/collections/index.ts

@@ -12,7 +12,7 @@ import {
   isArrayLike,
   isBool,
   isEmpty,
-  isFunc,
+  isFunction,
   isIterable,
   isNull,
   isNumber,
@@ -114,7 +114,7 @@ filter(users, 'active')
  */
 export function filter(arr, fn: Iteratee | PropertyKey | Object = isNull) {
   if (Array.isArray(arr)) {
-    if (isFunc(fn)) return arr.filter(fn)
+    if (isFunction(fn)) return arr.filter(fn)
     if (isNumber(fn) || isString(fn) || isSymbol(fn)) return arr.filter((x) => get(fn, x))
     if (isObject(fn)) return arr.filter(matches(fn))
   }
@@ -148,7 +148,7 @@ find(users, 'active')
  */
 export function find(arr, fn: Iteratee | PropertyKey | Object) {
   if (Array.isArray(arr)) {
-    if (isFunc(fn)) return arr.find(fn)
+    if (isFunction(fn)) return arr.find(fn)
     if (isNumber(fn) || isString(fn) || isSymbol(fn)) return arr.find((x) => x?.[fn])
     if (isObject(fn)) return arr.find(matches(fn))
   }
@@ -183,6 +183,8 @@ export function findRight(arr, fn: Iteratee | PropertyKey | Object) {
 /**
  * Performs an efficient array insert operation in the given array. If the index or the array is invalid, it just returns the given array.
  *
+ * **Note:** Uses the same behavior as `Array.splice`.
+ *
  * @param {Array<*>} arr The given array to insert into
  * @param {number} index The index of the array insert operation.
  * @param {*} value The value to insert in the array at the given `index`.
@@ -670,7 +672,7 @@ export function clone(value, deep = false) {
     return cloneArray(value, deep)
   }
   if (isObject(value)) {
-    if (isFunc(value.clone)) {
+    if (isFunction(value.clone)) {
       return value.clone()
     }
     const copy = {}
@@ -1013,7 +1015,7 @@ export function groupByMap<K = any, V = any>(
 export function remove<T>(arr: T[], func: any) {
   return arr.filter((x, i) => {
     if (isArray(func)) return !func.includes(x)
-    else if (isFunc(func)) return !func(x, i, arr)
+    else if (isFunction(func)) return !func(x, i, arr)
     return x !== func
   })
 }

package/core/functools/index.d.ts

@@ -47,7 +47,7 @@ export declare const compose: (...args: any[]) => (x: any) => any;
  * @param {Function} [resolver] The function to resolve the cache key.
  * @return {Function} Returns the new memoized function.
  */
-export declare function memoize(func: Function, resolver?: Function): Function;
+export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<ReturnType<typeof func>>;
 export declare function cache(target: any, name: any, descriptor: any): any;
 /**
  * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
@@ -84,7 +84,7 @@ single(3) // => 1
 // => `func` is invoked only once.
 ```
  */
-export declare function once(func: Function): (...args: any[]) => any;
+export declare function once<T>(func: Function<T>): (...args: any[]) => T;
 export declare type Maybe<T> = T | undefined;
 export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
 /**

package/core/functools/index.ts

@@ -98,7 +98,10 @@ export const compose = (...args) => flow(args.reverse())
  * @param {Function} [resolver] The function to resolve the cache key.
  * @return {Function} Returns the new memoized function.
  */
-export function memoize(func: Function, resolver?: Function): Function {
+export function memoize<T>(
+  func: Function<T>,
+  resolver?: Function
+): Function<ReturnType<typeof func>> {
   const cache = new Map()
   return (...args) => {
     const key = resolver ? resolver(...args) : args[0]
@@ -188,14 +191,14 @@ single(3) // => 1
 // => `func` is invoked only once.
 ```
  */
-export function once(func: Function) {
+export function once<T>(func: Function<T>) {
   let result, isCalled
   return (...args) => {
     if (!isCalled) {
       result = func(...args)
       isCalled = true
     }
-    return result
+    return result as T
   }
 }
 

package/core/globals/index.d.ts

@@ -92,10 +92,15 @@ export declare function type(value: any): any;
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export declare const str: (obj: any) => any;
+export declare function hasOwnProperty(obj: any, prop: any): boolean;
 /** Check if value is a boolean type. */
 export declare const isBool: (x: any) => x is boolean;
+/** Check if value is an `Error` type. */
+export declare const isError: (x: any) => x is Error;
 /** Check if value is an iterable type. */
 export declare const isIterable: (x: any) => x is IterableIterator<any>;
+/** Check if value is a native `Date` type. */
+export declare const isDate: (x: any) => x is Date;
 /** Check if value is an object type. */
 export declare const isObject: (x: any) => x is Object;
 /** Check if value is a string type. */
@@ -107,28 +112,42 @@ export declare const isArray: (x: any) => x is any[];
  * A value is considered array-like if it's not a function and has a `.length` number property.
  */
 export declare const isArrayLike: (x: any) => boolean;
-/** Check if value is a function type. */
-export declare const isFunc: (x: any) => x is Function<any>;
 /** Check if value is a number type. */
 export declare const isNumber: (x: any) => x is number;
+/** Check if value is an integer number type. */
+export declare const isInteger: (x: any) => x is number;
 /** Check if value is a bigint type. */
 export declare const isBigint: (x: any) => x is BigInt;
 /** Check if value is NaN based on `Number.isNaN`. */
 export declare const isNaN: (x: any) => x is number;
 /** Check if value is a Promise type. */
 export declare const isPromise: (x: any) => x is Promise<any>;
+/** Check if value is a function type. */
+export declare const isFunction: (x: any) => x is Function<any>;
 /** Check if value is an async function type. */
-export declare const isAsync: (x: any) => boolean;
+export declare const isAsyncFunction: (x: any) => boolean;
 /** Check if value is a generator function type. */
 export declare const isGenerator: (x: any) => x is Generator<unknown, any, unknown>;
 /** Check if value is `null` or `undefined`. */
 export declare const isNull: (x: any) => x is null | undefined;
+/** Check if value === `undefined`. */
+export declare function isUndefined(o: any): boolean;
 /** Check if value is not `null` or `undefined`. */
 export declare const notNull: (x: any) => boolean;
 /** Returns `true` for objects without length or falsy values. */
 export declare const isEmpty: (x: any) => boolean;
+/** Check if value is a `RegExp` type */
+export declare const isRegExp: (x: any) => x is RegExp;
 /** Check if value is a `Symbol` type */
 export declare const isSymbol: (x: any) => x is symbol;
+/** Check if value is a `Set` type. */
+export declare const isSet: <T>(x: any) => x is Set<T>;
+/** Check if value is a `Map` type. */
+export declare const isMap: <K, V>(x: any) => x is Map<K, V>;
+/** Check if value is a `WeakSet` type. */
+export declare const isWeakSet: <T extends object>(x: any) => x is WeakSet<T>;
+/** Check if value is a `WeakMap` type. */
+export declare const isWeakMap: <K extends object, V>(x: any) => x is WeakMap<K, V>;
 /**
  * Returns the number of elements in a collection type.
  *

package/core/globals/index.js

@@ -122,14 +122,21 @@ export function type(value) {
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export const str = (obj) => (obj != null ? obj.toString() : '');
+export function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
 /** Check if value is a boolean type. */
 export const isBool = (x) => type(x) === 'boolean';
+/** Check if value is an `Error` type. */
+export const isError = (x) => x instanceof Error;
 /** Check if value is an iterable type. */
 export const isIterable = (x) => {
     if (x == null)
         return false;
     return typeof x[Symbol.iterator] === 'function';
 };
+/** Check if value is a native `Date` type. */
+export const isDate = (x) => x instanceof Date;
 /** Check if value is an object type. */
 export const isObject = (x) => typeof x === 'object' && type(x) === 'object';
 /** Check if value is a string type. */
@@ -144,30 +151,46 @@ export const isArrayLike = (x) => {
     const T = type(x);
     return T === 'array' || (T === 'object' && isNumber(x.length));
 };
-/** Check if value is a function type. */
-export const isFunc = (x) => x?.constructor === Function;
 /** Check if value is a number type. */
 export const isNumber = (x) => type(x) === 'number';
+/** Check if value is an integer number type. */
+export const isInteger = (x) => type(x) === 'number' && Math.floor(x) === x;
 /** Check if value is a bigint type. */
 export const isBigint = (x) => type(x) === 'bigint';
 /** Check if value is NaN based on `Number.isNaN`. */
 export const isNaN = (x) => Number.isNaN(x);
 /** Check if value is a Promise type. */
 export const isPromise = (x) => type(x) === 'Promise';
+/** Check if value is a function type. */
+export const isFunction = (x) => x?.constructor === Function;
 /** Check if value is an async function type. */
-export const isAsync = (x) => x?.constructor.name === 'AsyncFunction';
+export const isAsyncFunction = (x) => x?.constructor.name === 'AsyncFunction';
 /** Check if value is a generator function type. */
 export const isGenerator = (x) => {
     return x?.constructor.constructor?.name === 'GeneratorFunction';
 };
 /** Check if value is `null` or `undefined`. */
 export const isNull = (x) => x == null;
+/** Check if value === `undefined`. */
+export function isUndefined(o) {
+    return typeof o === 'undefined';
+}
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null;
 /** Returns `true` for objects without length or falsy values. */
 export const isEmpty = (x) => (len(x) === 0 ? true : !x);
+/** Check if value is a `RegExp` type */
+export const isRegExp = (x) => x instanceof RegExp;
 /** Check if value is a `Symbol` type */
 export const isSymbol = (x) => type(x) === 'symbol';
+/** Check if value is a `Set` type. */
+export const isSet = (x) => x instanceof Set;
+/** Check if value is a `Map` type. */
+export const isMap = (x) => x instanceof Map;
+/** Check if value is a `WeakSet` type. */
+export const isWeakSet = (x) => x instanceof WeakSet;
+/** Check if value is a `WeakMap` type. */
+export const isWeakMap = (x) => x instanceof WeakMap;
 /**
  * Returns the number of elements in a collection type.
  *
@@ -182,7 +205,7 @@ export function len(value) {
     if (isNumber(value.length)) {
         return value.length;
     }
-    if (isFunc(value.size)) {
+    if (isFunction(value.size)) {
         return value.size();
     }
     if (isNumber(value.size)) {
@@ -229,7 +252,7 @@ export const uuid = () => {
  * @return `obj.key(...args)` or `undefined`.
  */
 export function call(obj, key, ...args) {
-    if (isFunc(get(key, obj))) {
+    if (isFunction(get(key, obj))) {
         return obj[key](...args);
     }
 }