atomic-fns 0.4.3 → 1.1.2

package/dist/decimal/index.js

@@ -0,0 +1,378 @@
+/**
+ * `Decimal` provides support for correct rounded floating point arithmetic.
+ *
+ * @module decimal
+ */
+const NUMBER_REGEX = /^(-?)([0-9]+)(\.([0-9]+))?$/;
+/**
+ * Casts the given value as a {@link Decimal}.
+ */
+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.
+ */
+export class Decimal {
+    static PRECISION = 20;
+    i = 0n;
+    e = 0;
+    /**
+     * Returns a new `Decimal` instance from the value or `0`.
+     * @param {*} value
+     * @returns {Decimal}
+     */
+    constructor(value) {
+        if (value == null) {
+            return this;
+        }
+        // Check if value is a Decimal like
+        if (typeof value?.i === 'bigint' && typeof value.e === 'number') {
+            this.i = value.i;
+            this.e = value.e;
+            this._normalize();
+            return this;
+        }
+        const result = NUMBER_REGEX.exec(value.toString());
+        if (result) {
+            // console.log(result);
+            // Construct from string if possible
+            // this.i = parseInt(result[1] + result[2] + result[4]);
+            if (typeof result[2] === 'undefined')
+                result[2] = '';
+            if (typeof result[4] === 'undefined')
+                result[4] = '';
+            this.i = BigInt(result[1] + result[2] + result[4]);
+            this.e = result[4] ? -result[4].length : 0;
+            this._normalize();
+        }
+        else {
+            // Conversion to string failed, so construct from number
+            let m = 1n;
+            if (value < 0) {
+                value = -value;
+                m = -1n;
+            }
+            if (value === 0) {
+                this.i = 0n;
+                this.e = 0;
+            }
+            else {
+                // Multiply the number by 10 until it is an integer
+                let e = -Math.floor(Math.log10(value));
+                if (e > 0) {
+                    value *= Math.pow(10, e);
+                }
+                else {
+                    e = 0;
+                }
+                while (value !== Math.round(value)) {
+                    e++;
+                    value *= 10;
+                }
+                // Divide the number by 10 until the one's digit is non-zero
+                while (value % 10 === 0 && value > 0) {
+                    e--;
+                    value /= 10;
+                }
+                value = BigInt(value);
+                this.i = value * m;
+                this.e = -e;
+            }
+        }
+    }
+    /**
+     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
+     * @example
+  ```js
+  let a = decimal('5')
+  a.negated()  // -5
+  ```
+     * @returns {Decimal}
+     */
+    negated() {
+        const negated = new Decimal();
+        negated.i = -this.i;
+        negated.e = this.e;
+        return negated;
+    }
+    /**
+     * Returns a new `Decimal` that is the sum of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('50000000000')
+  let b = decimal('0.000000005')
+  a.add(b)  // 50000000000.000000005
+  ```
+     * @returns {Decimal}
+     */
+    add(x) {
+        let a = new Decimal(this);
+        let b = new Decimal(x);
+        // a+b = a.i * 10^a.e + b.i * 10^b.e
+        // a+b = ( a.i * 10^(a.e-b.e) + b.i ) * 10^b.e
+        const result = new Decimal();
+        // Order arguments so that a.e >= b.e
+        if (a.e < b.e) {
+            const c = a;
+            a = b;
+            b = c;
+        }
+        const intPart = exp(a.i, a.e - b.e);
+        result.i = intPart + b.i;
+        result.e = b.e;
+        result._normalize();
+        return result;
+    }
+    /**
+     * Returns a new `Decimal` that is the difference between this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('0.0000000000000000001')
+  a.sub(b)  // 0.9999999999999999999
+  ```
+     * @returns {Decimal}
+     */
+    sub(x) {
+        return this.add(decimal(x).negated());
+    }
+    /**
+     * Returns a new `Decimal` that is the product of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('0.0000000000000000000025')
+  let b = decimal('400000000000000000000')
+  a.mul(b)  // 1
+  ```
+     * @returns {Decimal}
+     */
+    mul(x) {
+        const a = new Decimal(this);
+        const b = new Decimal(x);
+        // a * b = (a.i * b.i) * 10^(a.e + b.e)
+        const result = new Decimal();
+        result.i = a.i * b.i;
+        result.e = a.e + b.e;
+        result._normalize();
+        return result;
+    }
+    /**
+     * Returns a new `Decimal` that is the quotient of this and `x`
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('3')
+  a.div(b)  // 0.333333333333333333333333333333
+  ```
+     * @returns {Decimal}
+     */
+    div(x) {
+        const a = new Decimal(this);
+        const b = new Decimal(x);
+        // We need to increase the number of digits of a and b so that a / b will have the desired precision.
+        // In order for the integer quotient to have the correct precision, a.e - b.e must be greater than that precision.
+        // So we need only to increase a.e.
+        // TODO: Revisit the value of increaseA. Is it correct in every circumstance?
+        const increaseA = Math.max(Decimal.precision - (a.e + b.e), 0);
+        const intIncrease = new Decimal();
+        intIncrease.i = exp(a.i, increaseA);
+        const quotient = new Decimal();
+        quotient.i = intIncrease.i / b.i;
+        quotient.e = a.e - b.e - increaseA;
+        // No need to truncate since we already increased the number of digits before dividing
+        quotient._normalize();
+        return quotient;
+    }
+    /**
+     * Returns the square root of this `Decimal`.
+     * @returns {TDecimal}
+     */
+    sqrt() {
+        Decimal.PRECISION++;
+        // Let the guess value be 10^(e/2), where e is this.e
+        let x = new Decimal();
+        x.i = 1n;
+        x.e = Math.floor(this.e / 2);
+        const onehalf = new Decimal('0.5');
+        let xt = x.clone();
+        xt._truncate();
+        xt._normalize();
+        let lastxt;
+        let i;
+        for (i = 0; i < 100; i++) {
+            lastxt = xt;
+            x = this.div(x).add(x).mul(onehalf);
+            xt = x.clone();
+            xt._truncate();
+            xt._normalize();
+            if (xt.i === lastxt.i && xt.e === lastxt.e)
+                break;
+        }
+        if (i >= 100) {
+            console.log('Warning: sqrt exceeded maximum iterations. (Did it enter a cycle?)');
+        }
+        Decimal.PRECISION--;
+        xt._truncate();
+        xt._normalize();
+        return xt;
+    }
+    /** Returns a new copy of this Decimal value. */
+    clone() {
+        const a = new Decimal();
+        a.i = this.i;
+        a.e = this.e;
+        return a;
+    }
+    /**
+     * Remove zeroes in the least-significant digit of this `Decimal`
+     */
+    _normalize() {
+        while (this.i % 10n === 0n && this.i !== 0n) {
+            this.i /= 10n;
+            this.e++;
+        }
+        return this;
+    }
+    /**
+     * Truncate this `Decimal` to the configured precision
+     */
+    _truncate() {
+        // TODO: Make this better
+        // TODO: Rounding
+        const trunc = -this.e - Decimal.PRECISION;
+        if (trunc > 0) {
+            this.i /= 10n ** BigInt(trunc - 1);
+            this.e += trunc;
+            const nextDigit = this.i % 10n;
+            if (nextDigit >= 5) {
+                this.i += 10n;
+            }
+            this.i /= 10n;
+        }
+        // while(-this.e > Decimal.PRECISION) {
+        //   this.i /= 10n;
+        //   this.e++;
+        // }
+        return this;
+    }
+    /**
+     * Returns a string representation of this decimal.
+     * @returns {Decimal}
+     */
+    toString() {
+        let s = this.i.toString();
+        let m = '';
+        if (s[0] === '-') {
+            s = s.substring(1, s.length);
+            m = '-';
+        }
+        if (this.e > 0) {
+            return m + s + '0'.repeat(this.e);
+        }
+        else if (this.e < 0) {
+            if (-this.e >= s.length) {
+                return m + '0.' + '0'.repeat(-this.e - s.length) + s;
+            }
+            return m + s.slice(0, s.length + this.e) + '.' + s.slice(s.length + this.e, s.length);
+        }
+        else {
+            return m + s;
+        }
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
+    /**
+     * Converts this decimal to the `Number` value
+     * @returns {number}
+     */
+    toNumber() {
+        return Number(Decimal.prototype.toString.call(this));
+    }
+    static get precision() {
+        return Decimal.PRECISION;
+    }
+    static set precision(value) {
+        Decimal.PRECISION = value;
+    }
+    /**
+     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
+     * @param {*} x other
+     * @returns {boolean}
+     */
+    eq(x) {
+        const other = decimal(x);
+        return this.i === other.i && this.e === other.e;
+    }
+    /**
+     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lt(x) {
+        const other = decimal(x);
+        if (this.e === other.e)
+            return this.i < other.i;
+        const e = this.e - other.e;
+        if (e > 0) {
+            return exp(this.i, e) < other.i;
+        }
+        return this.i < exp(other.i, -e);
+    }
+    /**
+     * Returns a comparison value representing the ordering of this value in respect to `x`.
+     *   * `-1` if this < x
+     *   * `1` if this > x
+     *   * `0` if this == x
+     * @param {*} x
+     * @returns {number}
+     */
+    compare(x) {
+        if (this.eq(x))
+            return 0;
+        if (this.lt(x))
+            return -1;
+        return 1;
+    }
+    /**
+     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gt(x) {
+        return this.compare(x) > 0;
+    }
+    /**
+     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lte(x) {
+        return this.compare(x) <= 0;
+    }
+    /**
+     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gte(x) {
+        return this.compare(x) >= 0;
+    }
+}
+/** Returns a BigInt that is equal to `i` times `10^e` */
+function exp(i, e) {
+    // TODO: Make this better
+    // The implementation is faster than 10n ** BigInt(e). But could we make it faster still?
+    let ii = i;
+    for (let j = 0; j < e; j++) {
+        ii *= 10n;
+    }
+    return ii;
+}

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';
 /**
@@ -16,10 +16,9 @@ export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => a
 /**
  * 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.
- * @param {number} [arity=func.length]
  * @returns Returns the new curried function.
  */
-export declare const curry: (func: Function, arity?: number) => Function<any>;
+export declare const 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.
@@ -39,6 +38,11 @@ export declare const flow: (...args: any[]) => (x: any) => any;
  * @see {@link flow}
  */
 export declare const pipe: (...args: any[]) => (x: 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 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;
 /**
  * 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.
@@ -97,26 +101,30 @@ 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}.
+ * Wraps a function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
  * @template T,E
- * @param {Function} fun The function to wrap and catch if it throws.
- * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
- * @returns {Function} A new function that wraps `fun`.
+ * @param {Function<T>} fn The function to wrap.
+ * @returns {Function} A new function that wraps `fn` and returns the result tuple.
  */
-export declare function result<T = any, E = unknown>(fun: Function<T>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Result<T, E>;
+export declare function result<T = any, E = unknown>(fn: Function<T>): Function<Result<T, E>>;
 /**
- * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
+ * Wraps an async function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
  * @template T,E
- * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
- * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
- * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
+ * @param {Function<Promise<T>>} fn The async function to await.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the given function and returns the result tuple.
  */
-export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T> | Function<Promise<T>>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Promise<any[]>;
+export declare function resultAsync<T = any, E = unknown>(fn: Function<Promise<T>>): Function<Promise<Result<T, E>>>;
 /**
- * Converts a function that expects a node-style callback argument like `(err, result)` to return a Promise instead.
+ * Converts a function that expects a node-style callback argument like `(err, result)` to return a `Promise` instead.
  * @template T
- * @param {Function<T>} fun The given function to convert from callback style to Promise.
+ * @param {Function<T>} fun The given function to convert from callback style to `Promise`.
  * @param {*} thisArg
- * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
+ * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a `Promise`.
  */
 export declare function promisify<T>(fun: Function, thisArg?: any): Function<Promise<T>>;
+/**
+ * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
+ * @param {Function} fn A function that accepts callback arguments for success, error.
+ * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
+ */
+export declare function callAsync<T = any>(fn: (successCallback: (data: T) => any, errorCallback: Function) => any): Promise<T>;

package/dist/functools/index.js

@@ -1,9 +1,8 @@
 /**
  * This module includes functions that promote a more functional programming style.
  *
- * @module Functions
+ * @module functools
  */
-import { isPromise } from '../globals/index.js';
 /**
  * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
  * @param {Function} fn The function to bind.
@@ -16,34 +15,17 @@ export const bind = (fn, thisArg, ...partials) => 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.
- * @param {number} [arity=func.length]
  * @returns Returns the new curried function.
  */
-export const curry = (func, arity) => {
-    if (typeof func !== 'function' || func.length < 2)
-        return func;
-    if (typeof arity !== 'number')
-        arity = func.length;
-    switch (arity) {
-        case 2:
-            return (arg0) => (arg1) => func(arg0, arg1);
-        case 3:
-            return (arg0) => (arg1) => (arg2) => func(arg0, arg1, arg2);
-        case 4:
-            return (arg0) => (arg1) => (arg2) => (arg3) => func(arg0, arg1, arg2, arg3);
-        case 5:
-            return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => func(arg0, arg1, arg2, arg3, arg4);
-        case 6:
-            return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => func(arg0, arg1, arg2, arg3, arg4, arg5);
-        case 7:
-            return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => (arg6) => func(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
-        case 8:
-            return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => (arg6) => (arg7) => func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-        case 9:
-            return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => (arg6) => (arg7) => (arg8) => func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-        default:
-            throw Error('The specified function uses too many arguments. Consider refactoring it.');
-    }
+export const curry = (func) => {
+    return function curried(...args) {
+        if (args.length >= func.length) {
+            return func.apply(this, args);
+        }
+        return (...args2) => {
+            return curried.apply(this, args.concat(args2));
+        };
+    };
 };
 /**
  * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
@@ -69,6 +51,11 @@ export const flow = (...args) => (x) => {
  * @see {@link flow}
  */
 export const pipe = 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 const compose = (...args) => 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.
@@ -178,56 +165,47 @@ export function once(func) {
     };
 }
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
+ * Wraps a function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
  * @template T,E
- * @param {Function} fun The function to wrap and catch if it throws.
- * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
- * @returns {Function} A new function that wraps `fun`.
+ * @param {Function<T>} fn The function to wrap.
+ * @returns {Function} A new function that wraps `fn` and returns the result tuple.
  */
-export function result(fun, onFinally) {
+export function result(fn) {
     return (...args) => {
         let value, err;
         try {
-            value = fun(...args);
+            value = fn(...args);
         }
         catch (error) {
             err = error;
         }
-        finally {
-            onFinally?.(err, value);
-        }
         return [value, err];
     };
 }
 /**
- * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
+ * Wraps an async function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
  * @template T,E
- * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
- * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
- * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
+ * @param {Function<Promise<T>>} fn The async function to await.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the given function and returns the result tuple.
  */
-export function resultAsync(awaitable, onFinally) {
+export function resultAsync(fn) {
     return async (...args) => {
         let value, err;
         try {
-            const promise = isPromise(awaitable) ? awaitable : awaitable(...args);
-            value = await promise;
+            value = await fn(...args);
         }
         catch (error) {
             err = error;
         }
-        finally {
-            onFinally?.(err, value);
-        }
         return [value, err];
     };
 }
 /**
- * Converts a function that expects a node-style callback argument like `(err, result)` to return a Promise instead.
+ * Converts a function that expects a node-style callback argument like `(err, result)` to return a `Promise` instead.
  * @template T
- * @param {Function<T>} fun The given function to convert from callback style to Promise.
+ * @param {Function<T>} fun The given function to convert from callback style to `Promise`.
  * @param {*} thisArg
- * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
+ * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a `Promise`.
  */
 export function promisify(fun, thisArg) {
     const original = thisArg ? fun.bind(thisArg) : fun;
@@ -239,3 +217,11 @@ export function promisify(fun, thisArg) {
         }));
     };
 }
+/**
+ * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
+ * @param {Function} fn A function that accepts callback arguments for success, error.
+ * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
+ */
+export async function callAsync(fn) {
+    return await new Promise(fn);
+}

package/dist/globals/decimal.d.ts

@@ -7,8 +7,8 @@ export declare function decimal(x: any): Decimal;
  */
 export declare class Decimal {
     static PRECISION: number;
-    i: bigint;
-    e: number;
+    private i;
+    private e;
     /**
      * Returns a new `Decimal` instance from the value or `0`.
      * @param {*} value
@@ -83,11 +83,11 @@ export declare class Decimal {
     /**
      * Remove zeroes in the least-significant digit of this `Decimal`
      */
-    _normalize(): this;
+    private _normalize;
     /**
      * Truncate this `Decimal` to the configured precision
      */
-    _truncate(): this;
+    private _truncate;
     /**
      * Returns a string representation of this decimal.
      * @returns {Decimal}

package/dist/globals/index.d.ts

@@ -1,30 +1,14 @@
 /**
  * This module includes global functions and constants.
  *
- * @module Globals
+ * @module globals
  */
-export * from './decimal.js';
-/** This is just a noop function. */
-export declare const noop: () => void;
 /**
  * A generic function type with arbitrary arguments and return.
  */
 export declare type Function<TReturn = any> = (...args: any) => TReturn;
-/**
- * An iteratee function used for collection methods.
- * @see {@link Collections.filter}
- * @see {@link Collections.find}
- * @see {@link Collections.forEach}
- * @see {@link Collections.index}
- * @see {@link Collections.map}
- * @see {@link Collections.pick}
- * @see {@link Collections.omit}
- * @see {@link Collections.uniq}
- * @see {@link Collections.sortedUniq}
- * @see {@link Collections.groupBy}
- */
-export declare type Iteratee<T = any, K = any, TResult = any> = (value: T, key?: K, arr?: any) => TResult;
-export declare type Predicate<T = any, TReturn = any> = (value: T) => TReturn;
+/** This is just a noop function. */
+export declare const noop: () => void;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
 /** A function that always returns `false`. */
@@ -197,7 +181,7 @@ export declare const ord: (x: string) => number;
  * @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: (object: Object) => string[];
+export declare const keys: <T>(object: T) => (keyof T)[];
 /**
  * Returns an array of the own enumerable property values of `object`.
  * @param object The given object.

package/dist/globals/index.js

@@ -1,9 +1,8 @@
 /**
  * This module includes global functions and constants.
  *
- * @module Globals
+ * @module globals
  */
-export * from './decimal.js';
 /** This is just a noop function. */
 export const noop = () => { };
 /** A function that always returns `true`. */