atomic-fns 0.3.4 → 0.3.5

package/README.md

@@ -21,7 +21,7 @@ You may prefer this because it's:
 
 ## Get Started
 
-This library is available as an npm package.
+This library is available as an [npm package](https://www.npmjs.com/package/atomic-fns).
 
 To install the package you need to have [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) (or [yarn](https://yarnpkg.com/getting-started/install)) and then run:
 

package/core/collections/abc.d.ts

@@ -32,7 +32,7 @@ export interface Ordered<T> {
  * Implements an iterable that allows backward iteration.
  * @interface Reversible
  */
-export interface Reversible<T = unknown> {
+export interface Reversible<T = any> {
     reversed: () => Iterable<T>;
 }
 /**

package/core/collections/abc.ts

@@ -36,7 +36,7 @@ export interface Ordered<T> {
  * Implements an iterable that allows backward iteration.
  * @interface Reversible
  */
-export interface Reversible<T = unknown> {
+export interface Reversible<T = any> {
   reversed: () => Iterable<T>
 }
 

package/core/collections/deque.d.ts

@@ -2,107 +2,114 @@ import { Iteratee } from '../globals/index.js';
 import { Sequence } from './abc.js';
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
+ * @template T
  */
-export declare class Deque<T> extends Sequence<T> {
+export declare class Deque<T = any> extends Sequence<T> {
     items: T[];
     start: number;
     count: number;
     capacity: number;
-    ArrayClass: any;
-    constructor(ArrayClass?: T[], capacity?: number);
+    ArrayConstructor: any;
+    /**
+     * Creates a new `Deque` instance of a fixed size.
+     * @param {Array} [arrType = []] The initial elements or array type to use (accepts any kind of typed array).
+     * @param {number} [capacity=1024] The fixed size of the deque. Defaults to `1024`.
+     */
+    constructor(arrType?: T[], capacity?: number);
+    /** Returns the total number of elements in the deque. */
     get size(): number;
     /**
      * Method used to clear the structure.
-     *
-     * @return {undefined}
      */
     clear(): void;
     /**
      * Alias of {@link Deque.append}
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     add(item: any): number;
     /**
-     * Method used to append a value to the deque.
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the end of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     append(item: any): number;
     /**
-     * Method used to prepend a value to the deque.
-     *
-     * @param  {any}    item - Item to prepend.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the beginning of the deque.
+     * @param {T} item Item to prepend.
+     * @returns {number} Returns the new size of the deque.
      */
     appendleft(item: any): number;
     /**
-     * Method used to pop the deque.
-     *
-     * @return {any} - Returns the popped item.
+     * Removes and returns the element at the end of the deque.
+     * @returns {?T} Returns the popped item.
      */
     pop(): T | undefined;
     /**
      * Alias of {@link Deque.pop}
+     * @returns {?T} Returns the popped item.
      */
     remove(): T | undefined;
     /**
-     * Method used to shift the deque.
-     *
-     * @return {any} - Returns the shifted item.
+     * Removes and returns the element at the beginning of the deque.
+     * @returns {?T} Returns the removed deque element.
      */
     popleft(): T | undefined;
     /**
-     * Method used to peek the first value of the deque.
-     *
-     * @return {any}
+     * Returns the element at the beginning of the deque.
+     * @returns {?T} The element if exists
      */
     first(): T | undefined;
     /**
-     * Method used to get the desired value of the deque.
-     *
-     * @param  {number} index
-     * @return {any}
+     * Returns the element at a specified index position in the deque.
+     * @param {number} index The given index
+     * @returns {?T} The element if exists
      */
     get(index: any): T | undefined;
     /**
-     * Update the value at a given `index`.
-     * @param index The given index
-     * @param value The new value to set at `index`.
+     * Update the element at a given `index`.
+     * @param {number} index The given index
      */
     set(index: number, value: T): void;
+    /**
+     * Check if a given element is in the deque.
+     * @param {T} x The value to find
+     * @returns {boolean} `true` if the value is found
+     */
     contains(x: any): boolean;
+    /**
+     * Returns the first element that matches the `iteratee` function.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
+     * @returns {?T} The element if exists
+     */
     find(iteratee: Iteratee<T>): T | undefined;
     /**
-     * Method used to iterate over the deque.
-     *
-     * @param  {function}  iteratee - Function to call for each item.
-     * @param  {object}    scope    - Optional scope.
-     * @return {undefined}
+     * Calls `iteratee` function for every element in the deque.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
      */
     forEach(iteratee: any): void;
+    /**
+     * Returns a new array with all the elements in reverse order.
+     * @returns {Array<T>} The elements reversed
+     */
     reversed(): any;
     /**
-     * Method used to convert the deque to a JavaScript array.
-     *
-     * @return {array}
+     * Returns a new array with all the elements in the order they were added to the deque.
+     * @returns {Array<T>} The elements array
      */
     toArray(): any;
     /**
-     * Method used to create an iterator over the deque's values.
-     *
-     * @return {Iterator}
+     * Returns an iterator over the deque's values.
+     * @returns {Iterator}
      */
     values(): Iterable<T>;
+    /**
+     * Alias of {@link Deque.values}. Returns iterator of values.
+     */
     keys(): Iterable<T>;
     /**
-     * Method used to create an iterator over the deque's entries.
-     *
-     * @return {Iterator}
+     * Creates an iterator of `[index, value]` pairs for all elements in the deque.
+     * @returns {Iterator}
      */
     entries(): Iterator<[number, T], any, undefined> & Iterable<[number, T]>;
     [Symbol.iterator](): Iterable<T>;

package/core/collections/deque.js

@@ -4,36 +4,39 @@ import { eq } from '../operators/index.js';
 import { Sequence } from './abc.js';
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
+ * @template T
  */
 export class Deque extends Sequence {
     items;
     start = 0;
     count = 0;
     capacity;
-    ArrayClass;
-    constructor(ArrayClass = [], capacity = 1024) {
+    ArrayConstructor;
+    /**
+     * Creates a new `Deque` instance of a fixed size.
+     * @param {Array} [arrType = []] The initial elements or array type to use (accepts any kind of typed array).
+     * @param {number} [capacity=1024] The fixed size of the deque. Defaults to `1024`.
+     */
+    constructor(arrType = [], capacity = 1024) {
         super();
         if (typeof capacity !== 'number' || capacity <= 0)
             throw new ValueError(`Deque capacity should be a positive integer.`);
-        this.ArrayClass = ArrayClass.constructor;
+        this.ArrayConstructor = arrType.constructor;
         this.capacity = capacity;
-        this.items = new this.ArrayClass(ArrayClass.length || this.capacity);
+        this.items = new this.ArrayConstructor(arrType.length || this.capacity);
         this.clear();
-        if (ArrayClass.length) {
-            for (const item of ArrayClass) {
+        if (arrType.length) {
+            for (const item of arrType) {
                 this.append(item);
             }
         }
     }
+    /** Returns the total number of elements in the deque. */
     get size() {
         return this.count;
     }
     /**
      * Method used to clear the structure.
-     *
-     * @return {undefined}
      */
     clear() {
         // Properties
@@ -42,18 +45,16 @@ export class Deque extends Sequence {
     }
     /**
      * Alias of {@link Deque.append}
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     add(item) {
         return this.append(item);
     }
     /**
-     * Method used to append a value to the deque.
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the end of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     append(item) {
         if (this.count === this.capacity)
@@ -63,10 +64,9 @@ export class Deque extends Sequence {
         return ++this.count;
     }
     /**
-     * Method used to prepend a value to the deque.
-     *
-     * @param  {any}    item - Item to prepend.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the beginning of the deque.
+     * @param {T} item Item to prepend.
+     * @returns {number} Returns the new size of the deque.
      */
     appendleft(item) {
         if (this.count === this.capacity)
@@ -79,9 +79,8 @@ export class Deque extends Sequence {
         return ++this.count;
     }
     /**
-     * Method used to pop the deque.
-     *
-     * @return {any} - Returns the popped item.
+     * Removes and returns the element at the end of the deque.
+     * @returns {?T} Returns the popped item.
      */
     pop() {
         if (this.count === 0)
@@ -92,14 +91,14 @@ export class Deque extends Sequence {
     }
     /**
      * Alias of {@link Deque.pop}
+     * @returns {?T} Returns the popped item.
      */
     remove() {
         return this.pop();
     }
     /**
-     * Method used to shift the deque.
-     *
-     * @return {any} - Returns the shifted item.
+     * Removes and returns the element at the beginning of the deque.
+     * @returns {?T} Returns the removed deque element.
      */
     popleft() {
         if (this.count === 0)
@@ -112,9 +111,8 @@ export class Deque extends Sequence {
         return this.items[index];
     }
     /**
-     * Method used to peek the first value of the deque.
-     *
-     * @return {any}
+     * Returns the element at the beginning of the deque.
+     * @returns {?T} The element if exists
      */
     first() {
         if (this.count === 0)
@@ -122,10 +120,9 @@ export class Deque extends Sequence {
         return this.items[this.start];
     }
     /**
-     * Method used to get the desired value of the deque.
-     *
-     * @param  {number} index
-     * @return {any}
+     * Returns the element at a specified index position in the deque.
+     * @param {number} index The given index
+     * @returns {?T} The element if exists
      */
     get(index) {
         if (this.count === 0)
@@ -138,9 +135,8 @@ export class Deque extends Sequence {
         return this.items[index];
     }
     /**
-     * Update the value at a given `index`.
-     * @param index The given index
-     * @param value The new value to set at `index`.
+     * Update the element at a given `index`.
+     * @param {number} index The given index
      */
     set(index, value) {
         if (index < 0)
@@ -149,6 +145,11 @@ export class Deque extends Sequence {
             throw new KeyError(`Invalid index: ${index} not in Deque.`);
         this.items[index] = value;
     }
+    /**
+     * Check if a given element is in the deque.
+     * @param {T} x The value to find
+     * @returns {boolean} `true` if the value is found
+     */
     contains(x) {
         for (const value of this.values()) {
             if (eq(x, value))
@@ -156,6 +157,11 @@ export class Deque extends Sequence {
         }
         return false;
     }
+    /**
+     * Returns the first element that matches the `iteratee` function.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
+     * @returns {?T} The element if exists
+     */
     find(iteratee) {
         for (const [key, value] of this.entries()) {
             if (iteratee(value, key, this))
@@ -163,11 +169,8 @@ export class Deque extends Sequence {
         }
     }
     /**
-     * Method used to iterate over the deque.
-     *
-     * @param  {function}  iteratee - Function to call for each item.
-     * @param  {object}    scope    - Optional scope.
-     * @return {undefined}
+     * Calls `iteratee` function for every element in the deque.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
      */
     forEach(iteratee) {
         const c = this.capacity;
@@ -182,20 +185,23 @@ export class Deque extends Sequence {
                 i = 0;
         }
     }
+    /**
+     * Returns a new array with all the elements in reverse order.
+     * @returns {Array<T>} The elements reversed
+     */
     reversed() {
         return this.toArray().reverse();
     }
     /**
-     * Method used to convert the deque to a JavaScript array.
-     *
-     * @return {array}
+     * Returns a new array with all the elements in the order they were added to the deque.
+     * @returns {Array<T>} The elements array
      */
     toArray() {
         // Optimization
         const offset = this.start + this.count;
         if (offset < this.capacity)
             return this.items.slice(this.start, offset);
-        const array = new this.ArrayClass(this.count);
+        const array = new this.ArrayConstructor(this.count);
         const c = this.capacity;
         const l = this.count;
         let i = this.start;
@@ -210,9 +216,8 @@ export class Deque extends Sequence {
         return array;
     }
     /**
-     * Method used to create an iterator over the deque's values.
-     *
-     * @return {Iterator}
+     * Returns an iterator over the deque's values.
+     * @returns {Iterator}
      */
     values() {
         const items = this.items;
@@ -236,13 +241,15 @@ export class Deque extends Sequence {
             };
         });
     }
+    /**
+     * Alias of {@link Deque.values}. Returns iterator of values.
+     */
     keys() {
         return this.values();
     }
     /**
-     * Method used to create an iterator over the deque's entries.
-     *
-     * @return {Iterator}
+     * Creates an iterator of `[index, value]` pairs for all elements in the deque.
+     * @returns {Iterator}
      */
     entries() {
         const items = this.items;
@@ -271,9 +278,10 @@ export class Deque extends Sequence {
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
     }
+    // This is just for debugging in nodejs
     inspect() {
         const array = this.toArray();
-        array.type = this.ArrayClass.name;
+        array.type = this.ArrayConstructor.name;
         array.capacity = this.capacity;
         // Trick so that node displays the name of the constructor
         Object.defineProperty(array, 'constructor', {

package/core/collections/deque.ts

@@ -5,40 +5,44 @@ import { Sequence } from './abc.js'
 
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
+ * @template T
  */
-export class Deque<T> extends Sequence<T> {
+export class Deque<T = any> extends Sequence<T> {
   items: T[]
   start: number = 0
   count: number = 0
   capacity: number
-  ArrayClass: any
+  ArrayConstructor: any
 
-  constructor(ArrayClass = [] as T[], capacity = 1024) {
+  /**
+   * Creates a new `Deque` instance of a fixed size.
+   * @param {Array} [arrType = []] The initial elements or array type to use (accepts any kind of typed array).
+   * @param {number} [capacity=1024] The fixed size of the deque. Defaults to `1024`.
+   */
+  constructor(arrType = [] as T[], capacity = 1024) {
     super()
     if (typeof capacity !== 'number' || capacity <= 0)
       throw new ValueError(`Deque capacity should be a positive integer.`)
 
-    this.ArrayClass = ArrayClass.constructor
+    this.ArrayConstructor = arrType.constructor
     this.capacity = capacity
-    this.items = new this.ArrayClass(ArrayClass.length || this.capacity)
+    this.items = new this.ArrayConstructor(arrType.length || this.capacity)
     this.clear()
-    if (ArrayClass.length) {
-      for (const item of ArrayClass) {
+
+    if (arrType.length) {
+      for (const item of arrType) {
         this.append(item)
       }
     }
   }
 
+  /** Returns the total number of elements in the deque. */
   get size() {
     return this.count
   }
 
   /**
    * Method used to clear the structure.
-   *
-   * @return {undefined}
    */
   clear() {
     // Properties
@@ -48,19 +52,17 @@ export class Deque<T> extends Sequence<T> {
 
   /**
    * Alias of {@link Deque.append}
-   *
-   * @param  {any}    item - Item to append.
-   * @return {number}      - Returns the new size of the deque.
+   * @param {T} item Item to append.
+   * @returns {number} Returns the new size of the deque.
    */
   add(item) {
     return this.append(item)
   }
 
   /**
-   * Method used to append a value to the deque.
-   *
-   * @param  {any}    item - Item to append.
-   * @return {number}      - Returns the new size of the deque.
+   * Appends a new element to the end of the deque.
+   * @param {T} item Item to append.
+   * @returns {number} Returns the new size of the deque.
    */
   append(item) {
     if (this.count === this.capacity) this.popleft()
@@ -73,10 +75,9 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to prepend a value to the deque.
-   *
-   * @param  {any}    item - Item to prepend.
-   * @return {number}      - Returns the new size of the deque.
+   * Appends a new element to the beginning of the deque.
+   * @param {T} item Item to prepend.
+   * @returns {number} Returns the new size of the deque.
    */
   appendleft(item) {
     if (this.count === this.capacity) this.pop()
@@ -92,9 +93,8 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to pop the deque.
-   *
-   * @return {any} - Returns the popped item.
+   * Removes and returns the element at the end of the deque.
+   * @returns {?T} Returns the popped item.
    */
   pop() {
     if (this.count === 0) return
@@ -108,15 +108,15 @@ export class Deque<T> extends Sequence<T> {
 
   /**
    * Alias of {@link Deque.pop}
+   * @returns {?T} Returns the popped item.
    */
   remove() {
     return this.pop()
   }
 
   /**
-   * Method used to shift the deque.
-   *
-   * @return {any} - Returns the shifted item.
+   * Removes and returns the element at the beginning of the deque.
+   * @returns {?T} Returns the removed deque element.
    */
   popleft() {
     if (this.count === 0) return
@@ -132,9 +132,8 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to peek the first value of the deque.
-   *
-   * @return {any}
+   * Returns the element at the beginning of the deque.
+   * @returns {?T} The element if exists
    */
   first() {
     if (this.count === 0) return
@@ -143,10 +142,9 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to get the desired value of the deque.
-   *
-   * @param  {number} index
-   * @return {any}
+   * Returns the element at a specified index position in the deque.
+   * @param {number} index The given index
+   * @returns {?T} The element if exists
    */
   get(index) {
     if (this.count === 0) return
@@ -160,9 +158,8 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Update the value at a given `index`.
-   * @param index The given index
-   * @param value The new value to set at `index`.
+   * Update the element at a given `index`.
+   * @param {number} index The given index
    */
   set(index: number, value: T) {
     if (index < 0) index += this.count
@@ -170,6 +167,11 @@ export class Deque<T> extends Sequence<T> {
     this.items[index] = value
   }
 
+  /**
+   * Check if a given element is in the deque.
+   * @param {T} x The value to find
+   * @returns {boolean} `true` if the value is found
+   */
   contains(x) {
     for (const value of this.values()) {
       if (eq(x, value)) return true
@@ -177,6 +179,11 @@ export class Deque<T> extends Sequence<T> {
     return false
   }
 
+  /**
+   * Returns the first element that matches the `iteratee` function.
+   * @param {Iteratee<T>} iteratee A function that will be invoked per element
+   * @returns {?T} The element if exists
+   */
   find(iteratee: Iteratee<T>) {
     for (const [key, value] of this.entries()) {
       if (iteratee(value, key, this)) return value
@@ -184,11 +191,8 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to iterate over the deque.
-   *
-   * @param  {function}  iteratee - Function to call for each item.
-   * @param  {object}    scope    - Optional scope.
-   * @return {undefined}
+   * Calls `iteratee` function for every element in the deque.
+   * @param {Iteratee<T>} iteratee A function that will be invoked per element
    */
   forEach(iteratee) {
     const c = this.capacity
@@ -205,14 +209,17 @@ export class Deque<T> extends Sequence<T> {
     }
   }
 
+  /**
+   * Returns a new array with all the elements in reverse order.
+   * @returns {Array<T>} The elements reversed
+   */
   reversed() {
     return this.toArray().reverse()
   }
 
   /**
-   * Method used to convert the deque to a JavaScript array.
-   *
-   * @return {array}
+   * Returns a new array with all the elements in the order they were added to the deque.
+   * @returns {Array<T>} The elements array
    */
   toArray() {
     // Optimization
@@ -220,7 +227,7 @@ export class Deque<T> extends Sequence<T> {
 
     if (offset < this.capacity) return this.items.slice(this.start, offset)
 
-    const array = new this.ArrayClass(this.count)
+    const array = new this.ArrayConstructor(this.count)
     const c = this.capacity
     const l = this.count
     let i = this.start
@@ -238,9 +245,8 @@ export class Deque<T> extends Sequence<T> {
   }
 
   /**
-   * Method used to create an iterator over the deque's values.
-   *
-   * @return {Iterator}
+   * Returns an iterator over the deque's values.
+   * @returns {Iterator}
    */
   values(): Iterable<T> {
     const items = this.items
@@ -269,14 +275,16 @@ export class Deque<T> extends Sequence<T> {
     })
   }
 
+  /**
+   * Alias of {@link Deque.values}. Returns iterator of values.
+   */
   keys() {
     return this.values()
   }
 
   /**
-   * Method used to create an iterator over the deque's entries.
-   *
-   * @return {Iterator}
+   * Creates an iterator of `[index, value]` pairs for all elements in the deque.
+   * @returns {Iterator}
    */
   entries() {
     const items = this.items
@@ -312,10 +320,11 @@ export class Deque<T> extends Sequence<T> {
     return this.inspect()
   }
 
+  // This is just for debugging in nodejs
   inspect() {
     const array = this.toArray()
 
-    array.type = this.ArrayClass.name
+    array.type = this.ArrayConstructor.name
     array.capacity = this.capacity
 
     // Trick so that node displays the name of the constructor

package/core/functools/index.d.ts

@@ -87,6 +87,7 @@ single(3) // => 1
 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>];
+export declare type Optional<T> = Maybe<T>;
 /**
  * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *

package/core/functools/index.ts

@@ -206,6 +206,8 @@ export type Maybe<T> = T | undefined
 
 export type Result<T, E = any> = [Maybe<T>, Maybe<E>]
 
+export type Optional<T> = Maybe<T>
+
 /**
  * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *

package/core/globals/index.d.ts

@@ -4,7 +4,7 @@
  * @module Globals
  */
 /** This is just a noop function. */
-export declare const _: () => void;
+export declare const noop: () => void;
 /**
  * A generic function type with arbitrary arguments and return.
  */

package/core/globals/index.js

@@ -4,7 +4,7 @@
  * @module Globals
  */
 /** This is just a noop function. */
-export const _ = () => { };
+export const noop = () => { };
 /** A function that always returns `true`. */
 export const True = () => true;
 /** A function that always returns `false`. */

package/core/globals/index.ts

@@ -5,7 +5,7 @@
  */
 
 /** This is just a noop function. */
-export const _ = () => {}
+export const noop = () => {}
 
 /**
  * A generic function type with arbitrary arguments and return.

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

@@ -7,7 +7,7 @@ export declare type DateParts = {
     second?: number;
     millisecond?: number;
 };
-export declare type DateLike = number | string | Date | DateParts;
+declare type DateLike = number | string | Date | DateParts;
 /**
  * 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 compatible with `strftime`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis}
@@ -221,3 +221,4 @@ export declare function daysInMonth(year: number, month: number): number | null;
  * @returns {number}
  */
 export declare function weeksInYear(weekYear: number): 53 | 52;
+export {};

package/core/i18n/date/index.ts

@@ -22,7 +22,7 @@ export type DateParts = {
   millisecond?: number
 }
 
-export type DateLike = number | string | Date | DateParts
+type DateLike = number | string | Date | DateParts
 
 /**
  * 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 compatible with `strftime`.

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.3.4",
+  "version": "0.3.5",
   "main": "core/index.js",
   "type": "module",
   "types": "core/index.d.ts",

package/tests/globals.spec.ts

@@ -34,7 +34,7 @@ import {
   type,
   uniqueId,
   values,
-  _
+  noop
 } from '../core/globals/index.js'
 import { enumerate } from '../core/itertools/index.js'
 
@@ -74,7 +74,7 @@ describe('globals', () => {
     assert(type(new WeakMap()) === 'WeakMap')
     assert(type(new Set()) === 'Set')
     assert(type(new WeakSet()) === 'WeakSet')
-    assert(type(new Promise(_)) === 'Promise')
+    assert(type(new Promise(noop)) === 'Promise')
     assert(type(new Int8Array()) === 'Int8Array')
     assert(type(new Uint8Array()) === 'Uint8Array')
     assert(type(new Uint8ClampedArray()) === 'Uint8ClampedArray')
@@ -115,14 +115,14 @@ describe('globals', () => {
   })
 
   it('isFunction', () => {
-    assert(isFunction(_))
+    assert(isFunction(noop))
     assert(!isFunction([]))
   })
 
   it('isAsyncFunction', () => {
     assert(isAsyncFunction(async function () {}))
     assert(isAsyncFunction(async () => {}))
-    assert(!isAsyncFunction(_))
+    assert(!isAsyncFunction(noop))
   })
 
   it('isNaN', () => {
@@ -143,7 +143,7 @@ describe('globals', () => {
   })
 
   it('isPromise', () => {
-    assert(isPromise(new Promise(_)))
+    assert(isPromise(new Promise(noop)))
   })
 
   it('isSymbol', () => {