atomic-fns 1.1.1 → 1.1.3

package/README.md

@@ -1,23 +1,23 @@
 # atomic-fns
 
-[Read the Docs](https://atomic-fns.dev)
+[Read the Docs](https://atomic-stack.github.io/atomic-fns/)
 
-## Like Lodash, but in TypeScript and for ESnext.
+## Like Lodash, but in TypeScript and for ESNext.
 
-Stop shipping code built for browsers from 2015. Really though, look at all the [issues](https://github.com/lodash/lodash/issues/2930).
+Stop shipping code built for browsers from 2015.
 
 You may prefer this because it's:
 
 * **TypeScript & docs**: Includes type declaration files and js with JSDocs for best in class experience.
 * **Zero deps**: Built from scratch with no runtime dependencies or polyfills.
-* **ESnext**: Uses modern idiomatic syntax, data structures, and control flow techniques.
-* **Modular**: Pick what you need. Supports tree-shaking, no side effects and works with all bundlers.
+* **ESNext**: Uses modern idiomatic syntax, data structures, and control flow techniques.
+* **Modular**: Pick what you need. Supports tree-shaking, no side effects, and works with all bundlers.
 * **Lazy**: Leverage generators, iterators, and functional composition.
-* **Well tested**: All modules have comprehensive test suites and public apis are 100% coverage.
+* **Tests**: All modules have comprehensive test suites and public apis are 100% covered.
 
 ## Docs
 
-📖 Available at [atomic-fns.dev](https://atomic-fns.dev)
+📖 Available at [https://atomic-stack.github.io/atomic-fns/](atomic-stack.github.io/atomic-fns)
 
 ## Get Started
 
@@ -47,12 +47,12 @@ uniqueId('user_')
 ...
 ```
 
-See the full list of [modules](https://atomic-fns.dev/modules.html).
+See the full list of [modules](https://atomic-stack.github.io/atomic-fns/modules.html).
 
 ## Data model
 This library features a data model similar to [Python](https://docs.python.org/3/reference/datamodel.html#special-method-names) but not always. Only the missing parts have been implemented, while respecting the JS standards.
 
-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.
+For example, in Python collections, `size()` is a method, while in JS it's just a property. So this library uses `size` property instead of method. 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 using object methods such as:
@@ -63,21 +63,23 @@ This library adds support for operators using object methods such as:
   - `obj.gte(other)`  adds custom `obj >= other`.
   - `obj.compare(other)`  overloads sorting operations.
 
-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)`.
+When working with objects, functions in this library use these custom operators for equality and sorting. You can also apply operators to values like `eq(x, y)`, `lte(x, y)`, `compare(x, y)`, etc.
 
 ## New Types
 
-Introduces some common base interfaces and typing patterns you may have seen like `Optional`, `Result`, `Comparable`, `Iterator`, and others.
+[`Decimal`](https://atomic-stack.github.io/atomic-fns/classes/decimal.Decimal.html) provides support for correct rounded floating point arithmetic, with arbitrary precision.
+
+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)
+  - [SortedSet](https://atomic-stack.github.io/atomic-fns/classes/collections.SortedSet.html)
+  - [SortedMap](https://atomic-stack.github.io/atomic-fns/classes/collections.SortedMap.html)
+  - [SortedTree](https://atomic-stack.github.io/atomic-fns/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)
+  - [Deque](https://atomic-stack.github.io/atomic-fns/classes/collections.Deque.html)
+  - [FrozenSet](https://atomic-stack.github.io/atomic-fns/classes/collections.FrozenSet.html)
+  - [LRUCache](https://atomic-stack.github.io/atomic-fns/classes/collections.LRUCache.html)
 
 
 ## Contributing

package/dist/collections/SortedMap.d.ts

@@ -1,8 +1,8 @@
 import { Mapping } from './abc.js';
 /**
  * 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}
+ * @see {@link operators.compare}
+ * @see {@link operators.lt}
  * @template K, V
  */
 export declare class SortedMap<K, V> extends Mapping<K, V> {

package/dist/collections/SortedMap.js

@@ -2,8 +2,8 @@ import { Mapping } from './abc.js';
 import { SplayTree } from './SplayTree.js';
 /**
  * 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}
+ * @see {@link operators.compare}
+ * @see {@link operators.lt}
  * @template K, V
  */
 export class SortedMap extends Mapping {

package/dist/collections/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * This module includes classes and functions to work with Container types.
  *
- * @module Collections
+ * @module collections
  */
 import { compare } from '../operators/index.js';
 import { Iteratee } from '../types';
@@ -15,6 +15,7 @@ export * from './SortedMap.js';
 export * from './SortedSet.js';
 export * from './SortedTree.js';
 export * from './SplayTree.js';
+export * from './Trie.js';
 /**
  * Creates a new array with all falsy and empty values removed.
  * @param arr The array to compact
@@ -44,18 +45,6 @@ count(['one', 'two', 'three'], x => x.length);
  */
 export declare function count<T>(obj: T[], fn: Iteratee<T>): Record<string, number>;
 export declare function count<T>(obj: Object, fn: Iteratee<T>): Record<string, number>;
-/**
- * Creates a function that can be used to create named tuple-like objects.
- * @example
-```js
-let Point = namedtuple('x', 'y', 'z')
-let userObj = User(0, 0, 0)
-// {x: 0, y: 0, z: 0}
-```
- * @param fields - A list of field names
- * @returns A function that can be called with the field values
- */
-export declare const namedtuple: (...fields: string[]) => (...args: any[]) => any;
 /**
  * Iterates over elements of collection, returning an array of all elements where predicate returns truthy value.
  *
@@ -145,7 +134,7 @@ filter(objects, matches({ a: 4, c: 6 }))
  * @param shape
  * @returns
  */
-export declare const matches: (shape: any) => (obj: any) => boolean;
+export declare function matches(shape: any): (obj: any) => boolean;
 /**
  * Iterates over elements of collection and invokes `iteratee` for each element. The iteratee is invoked with three arguments: `(value, index|key, collection)`. Iteratee functions may exit iteration early by explicitly returning `false`.
  * @example

package/dist/collections/index.js

@@ -1,9 +1,9 @@
 /**
  * This module includes classes and functions to work with Container types.
  *
- * @module Collections
+ * @module collections
  */
-import { call, get, isArray, isArrayLike, isBool, isEmpty, isFunction, isIterable, isNull, isNumber, isObject, isString, keys, set } from '../globals/index.js';
+import { call, get, isArray, isArrayLike, isBool, isEmpty, isFunction, isIterable, isNull, isNumber, isObject, isString, keys } from '../globals/index.js';
 import { enumerate } from '../itertools/index.js';
 import { compare, eq, id } from '../operators/index.js';
 export * from './abc.js';
@@ -16,6 +16,7 @@ export * from './SortedMap.js';
 export * from './SortedSet.js';
 export * from './SortedTree.js';
 export * from './SplayTree.js';
+export * from './Trie.js';
 export function compact(arr) {
     if (!arr)
         return;
@@ -37,18 +38,6 @@ export function count(obj, func) {
     });
     return counters;
 }
-/**
- * Creates a function that can be used to create named tuple-like objects.
- * @example
-```js
-let Point = namedtuple('x', 'y', 'z')
-let userObj = User(0, 0, 0)
-// {x: 0, y: 0, z: 0}
-```
- * @param fields - A list of field names
- * @returns A function that can be called with the field values
- */
-export const namedtuple = (...fields) => (...args) => fields.reduce((prev, f, i) => set(f, prev, args[i], false, true), {});
 export function filter(arr, fn = isNull) {
     if (!arr)
         return;
@@ -104,15 +93,17 @@ filter(objects, matches({ a: 4, c: 6 }))
  * @param shape
  * @returns
  */
-export const matches = (shape) => (obj) => {
-    if (!shape || !obj)
-        return false;
-    for (const key in shape) {
-        if (obj[key] !== shape[key])
+export function matches(shape) {
+    return function (obj) {
+        if (!shape || !obj)
             return false;
-    }
-    return true;
-};
+        for (const key in shape) {
+            if (obj[key] !== shape[key])
+                return false;
+        }
+        return true;
+    };
+}
 export function forEach(collection, fn) {
     if (Array.isArray(collection)) {
         for (let i = 0; i < collection.length; i++) {

package/dist/decimal/index.d.ts

@@ -8,7 +8,9 @@
  */
 export declare function decimal(x: any): Decimal;
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard Number type. It also supports user-defined precision (default is 20 decimal places) which can be as large as needed.
+ * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
+ * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
+ * can be as large as needed.
  */
 export declare class Decimal {
     static PRECISION: number;
@@ -25,7 +27,7 @@ export declare class Decimal {
      * @example
   ```js
   let a = decimal('5')
-  a.minus()  // -5
+  a.negated()  // -5
   ```
      * @returns {Decimal}
      */

package/dist/decimal/index.js

@@ -11,7 +11,9 @@ export function decimal(x) {
     return new Decimal(x);
 }
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard Number type. It also supports user-defined precision (default is 20 decimal places) which can be as large as needed.
+ * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
+ * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
+ * can be as large as needed.
  */
 export class Decimal {
     static PRECISION = 20;
@@ -86,7 +88,7 @@ export class Decimal {
      * @example
   ```js
   let a = decimal('5')
-  a.minus()  // -5
+  a.negated()  // -5
   ```
      * @returns {Decimal}
      */

package/dist/functools/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * This module includes functions that promote a more functional programming style.
  *
- * @module Functions
+ * @module functools
  */
 import { Function } from '../globals/index.js';
 /**
@@ -12,13 +12,13 @@ import { Function } from '../globals/index.js';
  * @returns {Function} Returns the new bound function.
  * @see {@link partial}
  */
-export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => any;
+export declare function bind(fn: Function, thisArg: any, ...partials: any[]): any;
 /**
  * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
  * @param {Function} func The function to curry.
  * @returns Returns the new curried function.
  */
-export declare const curry: (func: Function) => (...args: any[]) => any;
+export declare function curry(func: Function): (...args: any[]) => any;
 /**
  * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
  * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
@@ -26,24 +26,24 @@ export declare const curry: (func: Function) => (...args: any[]) => any;
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
  */
-export declare const partial: (fn: any, ...args: any[]) => any;
+export declare function partial(fn: any, ...args: any[]): any;
 /**
  * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
  * @param {...*} [args] The set of functions to apply.
  * @returns {Function} A new function that applies each given function on the result of the previous one.
  */
-export declare const flow: (...args: any[]) => (x: any) => any;
+export declare function flow(...args: any[]): (x: any) => any;
 /**
  * This is just an alias for the {@link flow} function.
  * @see {@link flow}
  */
-export declare const pipe: (...args: any[]) => (x: any) => any;
+export declare const pipe: typeof flow;
 /**
  * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from right to left.
  * @param {...*} [args] The set of functions to apply.
  * @returns {Function} A new function that applies each given function on the result of the previous step.
  */
-export declare const compose: (...args: any[]) => (x: any) => any;
+export declare function compose(...args: any[]): (x: any) => any;
 /**
  * Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key.
  *

package/dist/functools/index.js

@@ -1,7 +1,7 @@
 /**
  * This module includes functions that promote a more functional programming style.
  *
- * @module Functions
+ * @module functools
  */
 /**
  * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
@@ -11,13 +11,15 @@
  * @returns {Function} Returns the new bound function.
  * @see {@link partial}
  */
-export const bind = (fn, thisArg, ...partials) => fn.bind(thisArg, ...partials);
+export function bind(fn, thisArg, ...partials) {
+    return fn.bind(thisArg, ...partials);
+}
 /**
  * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
  * @param {Function} func The function to curry.
  * @returns Returns the new curried function.
  */
-export const curry = (func) => {
+export function curry(func) {
     return function curried(...args) {
         if (args.length >= func.length) {
             return func.apply(this, args);
@@ -26,7 +28,7 @@ export const curry = (func) => {
             return curried.apply(this, args.concat(args2));
         };
     };
-};
+}
 /**
  * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
  * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
@@ -34,18 +36,22 @@ export const curry = (func) => {
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
  */
-export const partial = (fn, ...args) => bind(fn, undefined, ...args);
+export function partial(fn, ...args) {
+    return bind(fn, undefined, ...args);
+}
 /**
  * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
  * @param {...*} [args] The set of functions to apply.
  * @returns {Function} A new function that applies each given function on the result of the previous one.
  */
-export const flow = (...args) => (x) => {
-    for (const fn of args) {
-        x = fn(x);
-    }
-    return x;
-};
+export function flow(...args) {
+    return (x) => {
+        for (const fn of args) {
+            x = fn(x);
+        }
+        return x;
+    };
+}
 /**
  * This is just an alias for the {@link flow} function.
  * @see {@link flow}
@@ -56,7 +62,9 @@ export const pipe = flow;
  * @param {...*} [args] The set of functions to apply.
  * @returns {Function} A new function that applies each given function on the result of the previous step.
  */
-export const compose = (...args) => flow(args.reverse());
+export function compose(...args) {
+    return flow(args.reverse());
+}
 /**
  * Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key.
  *

package/dist/globals/index.d.ts

@@ -1,14 +1,14 @@
 /**
  * This module includes global functions and constants.
  *
- * @module Globals
+ * @module globals
  */
 /**
  * A generic function type with arbitrary arguments and return.
  */
 export declare type Function<TReturn = any> = (...args: any) => TReturn;
 /** This is just a noop function. */
-export declare const noop: () => void;
+export declare function noop(): void;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
 /** A function that always returns `false`. */
@@ -76,60 +76,60 @@ export declare function type(value: any): string;
  * @returns `obj.toString()` or `''` if `obj` is `null` or `undefined`.
  * @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 str(obj: any): any;
 /** Check if value is a boolean type. */
-export declare const isBool: (x: any) => x is boolean;
+export declare function isBool(x: any): x is boolean;
 /** Check if value is an `Error` type. */
-export declare const isError: (x: any) => x is Error;
+export declare function isError(x: any): x is Error;
 /** Check if value is an iterable type. */
-export declare const isIterable: (x: any) => x is IterableIterator<any>;
+export declare function isIterable(x: any): x is IterableIterator<any>;
 /** Check if value is a native `Date` type. */
-export declare const isDate: (x: any) => x is Date;
+export declare function isDate(x: any): x is Date;
 /** Check if value is an object type. */
-export declare const isObject: (x: any) => x is Object;
+export declare function isObject(x: any): x is Object;
 /** Check if value is a string type. */
-export declare const isString: (x: any) => x is string;
+export declare function isString(x: any): x is string;
 /** Check if value is an Array type. */
-export declare const isArray: (x: any) => x is any[];
+export declare function isArray(x: any): x is any[];
 /**
  * Check if value is Array-like type.
  * 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;
+export declare function isArrayLike(x: any): boolean;
 /** Check if value is a number type. */
-export declare const isNumber: (x: any) => x is number;
+export declare function isNumber(x: any): x is number;
 /** Check if value is an integer number type. */
-export declare const isInteger: (x: any) => x is number;
+export declare function isInteger(x: any): x is number;
 /** Check if value is a bigint type. */
-export declare const isBigint: (x: any) => x is BigInt;
+export declare function isBigint(x: any): x is BigInt;
 /** Check if value is a Promise type. */
-export declare const isPromise: (x: any) => x is Promise<any>;
+export declare function isPromise(x: any): x is Promise<any>;
 /** Check if value is a function type. */
-export declare const isFunction: (x: any) => x is Function<any>;
+export declare function isFunction(x: any): x is Function;
 /** Check if value is an async function type. */
-export declare const isAsyncFunction: (x: any) => boolean;
+export declare function isAsyncFunction(x: any): boolean;
 /** Check if value is a generator function type. */
-export declare const isGenerator: (x: any) => x is Generator<unknown, any, unknown>;
+export declare function isGenerator(x: any): x is Generator;
 /** Check if value is `null` or `undefined`. */
-export declare const isNull: (x: any) => x is null;
+export declare function isNull(x: any): x is null | undefined;
 /** Check if value === `undefined`. */
-export declare const isUndefined: (x: any) => x is undefined;
+export declare function isUndefined(x: any): x is undefined;
 /** Check if value is not `null` or `undefined`. */
-export declare const notNull: (x: any) => boolean;
+export declare function notNull(x: any): boolean;
 /** Returns `true` for objects without length or falsy values. */
-export declare const isEmpty: (x: any) => boolean;
+export declare function isEmpty(x: any): boolean;
 /** Check if value is a `RegExp` type */
-export declare const isRegExp: (x: any) => x is RegExp;
+export declare function isRegExp(x: any): x is RegExp;
 /** Check if value is a `Symbol` type */
-export declare const isSymbol: (x: any) => x is symbol;
+export declare function isSymbol(x: any): x is symbol;
 /** Check if value is a `Set` type. */
-export declare const isSet: <T>(x: any) => x is Set<T>;
+export declare function 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>;
+export declare function 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>;
+export declare function 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>;
+export declare function isWeakMap<K extends object, V>(x: any): x is WeakMap<K, V>;
 /**
  * Returns the number of elements in a collection type.
  *
@@ -152,7 +152,7 @@ uniqueId('user_')
 // 'user_1033763188'
 ```
  */
-export declare const uniqueId: (pre?: string) => string;
+export declare function uniqueId(pre?: string): string;
 /**
  * Generates a monotonically increasing, pseudo-random based uuid-v4 string. These are sortable, url-friendly and are 100% unique if the IDs are generated more than 1 millisecond apart. If two IDs are generated at the same millisecond, the chance of collision is still pretty low (1 in 10^15).
  * @returns Returns a GUID formatted string.
@@ -162,7 +162,7 @@ uuid()
 // '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
-export declare const uuid: () => string;
+export declare function uuid(): string;
 /**
  * Checks if `obj.key` is a function, and calls it with any given `args`.
  * @param {*} obj
@@ -172,30 +172,30 @@ export declare const uuid: () => string;
  */
 export declare function call(obj: any, key: PropertyKey, ...args: any[]): any;
 /** Convert number to unicode character */
-export declare const chr: (x: number) => string;
+export declare function chr(x: number): string;
 /** Convert character to Unicode code point */
-export declare const ord: (x: string) => number;
+export declare function ord(x: string): number;
 /**
  * Returns an array of the own enumerable property names of `object`.
  * @param object The given object.
  * @returns The array of object keys.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
  */
-export declare const keys: <T>(object: T) => (keyof T)[];
+export declare function keys<T>(object: T): (keyof T)[];
 /**
  * Returns an array of the own enumerable property values of `object`.
  * @param object The given object.
  * @returns The array of object keys.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
  */
-export declare const values: (object: any) => unknown[];
+export declare function values(object: any): unknown[];
 /**
  * Check if a given property is present in a given object.
  * @param obj The object to check.
  * @param attr A property key name.
  * @returns `true` if the object has the property name.
  */
-export declare const has: (obj: any, attr: PropertyKey) => boolean;
+export declare function has(obj: any, attr: PropertyKey): boolean;
 /**
  * Check if the attribute is present in the object or return a default value instead.
  * @param {PropertyKey} key
@@ -242,40 +242,40 @@ export declare function hashCode(str: string): number;
  * @param n The given number.
  * @returns The binary string representation of `n`.
  */
-export declare const bin: (n: number) => string;
+export declare function bin(n: number): string;
 /**
  * Converts a number to a hexadecimal string.
  * @param n The given number.
  * @returns The hexadecimal string representation of `n`.
  */
-export declare const hex: (n: number) => string;
+export declare function hex(n: number): string;
 /**
  * Converts a number to an octal string.
  * @param n The given number.
  * @returns The octal string representation of `n`.
  */
-export declare const oct: (n: number) => string;
+export declare function oct(n: number): string;
 /**
  * Returns a floating point number constructed from a number or string `x`.
  * @param x The number or string.
  * @returns A floating point number parsed from the given value or `NaN`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat parseFloat}
  */
-export declare const float: (x: string) => number;
+export declare function float(x: string): number;
 /**
  * Returns an integer number constructed from a number or string `x`.
  * @param x The number or string.
  * @returns An integer number parsed from the given value or `NaN`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt parseInt}
  */
-export declare const int: (x: string, base?: number) => number;
+export declare function int(x: string, base?: number): number;
 /**
  * Converts the value to an array using `Array.from()`.
  * @param value
  * @returns A new array value.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from Array.from()}
  */
-export declare const list: <T>(value?: any) => T[];
+export declare function list<T>(value?: any): T[];
 /**
  * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.