@agrozyme/numeric 1.0.31 → 1.0.32

package/lib/config.d.ts

@@ -0,0 +1,3 @@
+import { Decimal } from 'decimal.js';
+export declare const getNumericConfig: () => Required<Decimal.Config>;
+export declare const setupNumericConfig: () => void;

package/lib/constants.d.ts

@@ -0,0 +1,9 @@
+import { Numeric } from './numeric';
+export declare const NegativeOne: Numeric;
+export declare const Zero: Numeric;
+export declare const One: Numeric;
+export declare const Two: Numeric;
+export declare const WeiPerEther: Numeric;
+export declare const MaxUint256: Numeric;
+export declare const MaxInt256: Numeric;
+export declare const MinInt256: Numeric;

package/lib/format.d.ts

@@ -0,0 +1,18 @@
+import { NumericValue } from './numeric';
+export interface IFormatNumberOptions {
+    negativeType?: 'right' | 'left' | 'brackets' | 'none';
+    negativeLeftSymbol?: string;
+    negativeRightSymbol?: string;
+    negativeLeftOut?: boolean;
+    negativeRightOut?: boolean;
+    prefix?: string;
+    suffix?: string;
+    integerSeparator?: string;
+    decimalsSeparator?: string;
+    decimal?: string;
+    padLeft?: number;
+    padRight?: number;
+    round?: number;
+    truncate?: number;
+}
+export declare const formatValue: (value: NumericValue, options?: IFormatNumberOptions) => string;

package/lib/helper.d.ts

@@ -0,0 +1,11 @@
+import { Numeric, NumericValue } from './numeric';
+export interface RangeOptions {
+    includeMinimum?: boolean;
+    includeMaximum?: boolean;
+}
+export declare const isRange: (value: NumericValue, minimum: NumericValue, maximum: NumericValue, options?: RangeOptions) => boolean;
+export declare const tryParse: (value: NumericValue) => false | Numeric;
+export declare const isInteger: (value: NumericValue) => boolean;
+export declare const isUnsignedIntegerBits: (bits: bigint, value: NumericValue) => boolean;
+export declare const isSignedIntegerBits: (bits: bigint, value: NumericValue) => boolean;
+export declare const createArrayCompareFunction: (ascending?: boolean) => (left: NumericValue, right: NumericValue) => number;

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+export { Numeric, toBigInt, toBigInteger, toBigNumber, toBN, toIntegerString, toNumeric, toNumerics } from './numeric';
+export type { NumericValue } from './numeric';
+export { formatValue } from './format';
+export type { IFormatNumberOptions } from './format';
+export { getNumericConfig, setupNumericConfig } from './config';
+export { MaxInt256, MaxUint256, MinInt256, NegativeOne, One, Two, WeiPerEther, Zero } from './constants';
+export { createArrayCompareFunction, isInteger, isRange, isSignedIntegerBits, isUnsignedIntegerBits, tryParse, } from './helper';
+export type { RangeOptions } from './helper';
+/**
+ * - must use `@types/node@16` for Symbol typing
+ * - must put `@types/bn.js` in dependencies section of package.json
+ * - must set `rootDir` to `src` that in compilerOptions section of tscnfig.json (for bundler tools)
+ * - must import namespaces: `big-integer`, `bn.js`, `decimal.js`
+ * */

package/lib/index.js

@@ -0,0 +1,592 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isRange: ()=>isRange,
+    isUnsignedIntegerBits: ()=>isUnsignedIntegerBits,
+    WeiPerEther: ()=>WeiPerEther,
+    MinInt256: ()=>MinInt256,
+    isSignedIntegerBits: ()=>isSignedIntegerBits,
+    toBN: ()=>toBN,
+    toIntegerString: ()=>toIntegerString,
+    formatValue: ()=>formatValue,
+    Zero: ()=>Zero,
+    createArrayCompareFunction: ()=>createArrayCompareFunction,
+    toBigInteger: ()=>toBigInteger,
+    MaxInt256: ()=>MaxInt256,
+    MaxUint256: ()=>MaxUint256,
+    toNumerics: ()=>toNumerics,
+    toBigNumber: ()=>toBigNumber,
+    setupNumericConfig: ()=>setupNumericConfig,
+    toBigInt: ()=>toBigInt,
+    Numeric: ()=>Numeric,
+    Two: ()=>Two,
+    isInteger: ()=>isInteger,
+    toNumeric: ()=>toNumeric,
+    One: ()=>One,
+    NegativeOne: ()=>NegativeOne,
+    getNumericConfig: ()=>getNumericConfig,
+    tryParse: ()=>tryParse
+});
+const bignumber_namespaceObject = require("@ethersproject/bignumber");
+const bytes_namespaceObject = require("@ethersproject/bytes");
+const external_big_integer_namespaceObject = require("big-integer");
+var external_big_integer_default = /*#__PURE__*/ __webpack_require__.n(external_big_integer_namespaceObject);
+const external_bn_js_namespaceObject = require("bn.js");
+var external_bn_js_default = /*#__PURE__*/ __webpack_require__.n(external_bn_js_namespaceObject);
+const external_browser_or_node_namespaceObject = require("browser-or-node");
+const external_decimal_js_namespaceObject = require("decimal.js");
+const toNumeric = (value)=>new Numeric(value);
+const toNumerics = (values)=>values.map(toNumeric);
+const toIntegerString = (value)=>toNumeric(value).toFixed(0);
+const toBigInt = (value)=>BigInt(toIntegerString(value));
+const toBN = (value)=>new (external_bn_js_default())(toIntegerString(value));
+const toBigInteger = (value)=>external_big_integer_default()(toIntegerString(value));
+const toBigNumber = (value)=>bignumber_namespaceObject.BigNumber.from(toIntegerString(value));
+class Numeric extends external_decimal_js_namespaceObject.Decimal {
+    constructor(value){
+        if (value instanceof external_decimal_js_namespaceObject.Decimal) super(value);
+        else switch(typeof value){
+            case 'string':
+            case 'number':
+                super(value);
+                break;
+            case 'bigint':
+                super(value.toString());
+                break;
+            default:
+                if (external_big_integer_default().isInstance(value) || bignumber_namespaceObject.BigNumber.isBigNumber(value) || external_bn_js_default().isBN(value)) super(value.toString());
+                else if ((0, bytes_namespaceObject.isBytesLike)(value)) super((0, bytes_namespaceObject.hexlify)(value));
+                else super(value);
+                break;
+        }
+    }
+    static abs(value) {
+        return new Numeric(value).abs();
+    }
+    static acos(value) {
+        return new Numeric(value).acos();
+    }
+    static acosh(value) {
+        return new Numeric(value).acosh();
+    }
+    static add(x, y) {
+        return new Numeric(x).add(y);
+    }
+    static asin(value) {
+        return new Numeric(value).asin();
+    }
+    static asinh(value) {
+        return new Numeric(value).asinh();
+    }
+    static atan(value) {
+        return new Numeric(value).atan();
+    }
+    static atanh(value) {
+        return new Numeric(value).atanh();
+    }
+    static atan2(x, y) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.atan2(new Numeric(x), new Numeric(y)));
+    }
+    static cbrt(value) {
+        return new Numeric(value).cbrt();
+    }
+    static ceil(value) {
+        return new Numeric(value).ceil();
+    }
+    static clamp(value, min, max) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.clamp(new Numeric(value), new Numeric(min), new Numeric(max)));
+    }
+    static cos(value) {
+        return new Numeric(value).cos();
+    }
+    static cosh(value) {
+        return new Numeric(value).cosh();
+    }
+    static div(x, y) {
+        return new Numeric(x).div(y);
+    }
+    static exp(value) {
+        return new Numeric(value).exp();
+    }
+    static floor(value) {
+        return new Numeric(value).floor();
+    }
+    static hypot(...values) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.hypot(...toNumerics(values)));
+    }
+    static ln(value) {
+        return new Numeric(value).ln();
+    }
+    static log(value, base) {
+        return new Numeric(value).log(base);
+    }
+    static log2(value) {
+        return new Numeric(value).log(2);
+    }
+    static log10(value) {
+        return new Numeric(value).log(10);
+    }
+    static max(...values) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.max(...toNumerics(values)));
+    }
+    static min(...values) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.min(...toNumerics(values)));
+    }
+    static mod(x, y) {
+        return new Numeric(x).mod(y);
+    }
+    static mul(x, y) {
+        return new Numeric(x).mul(y);
+    }
+    static pow(base, exponent) {
+        return new Numeric(base).pow(exponent);
+    }
+    static random(significantDigits) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.random(significantDigits));
+    }
+    static round(value) {
+        return new Numeric(value).round();
+    }
+    static set(object) {
+        return external_decimal_js_namespaceObject.Decimal.set(object);
+    }
+    static sign(value) {
+        return external_decimal_js_namespaceObject.Decimal.sign(new Numeric(value));
+    }
+    static sin(value) {
+        return new Numeric(value).sin();
+    }
+    static sinh(value) {
+        return new Numeric(value).sinh();
+    }
+    static sqrt(value) {
+        return new Numeric(value).sqrt();
+    }
+    static sub(x, y) {
+        return new Numeric(x).sub(y);
+    }
+    static sum(...values) {
+        return new Numeric(external_decimal_js_namespaceObject.Decimal.sum(...toNumerics(values)));
+    }
+    static tan(value) {
+        return new Numeric(value).tan();
+    }
+    static tanh(value) {
+        return new Numeric(value).tanh();
+    }
+    static trunc(value) {
+        return new Numeric(value).trunc();
+    }
+    absoluteValue() {
+        return new Numeric(super.absoluteValue());
+    }
+    abs() {
+        return new Numeric(super.abs());
+    }
+    ceil() {
+        return new Numeric(super.ceil());
+    }
+    clampedTo(min, max) {
+        return new Numeric(super.clampedTo(new Numeric(min), new Numeric(max)));
+    }
+    clamp(min, max) {
+        return new Numeric(super.clamp(new Numeric(min), new Numeric(max)));
+    }
+    comparedTo(value) {
+        return super.comparedTo(new Numeric(value));
+    }
+    cmp(value) {
+        return super.cmp(new Numeric(value));
+    }
+    cosine() {
+        return new Numeric(super.cosine());
+    }
+    cos() {
+        return new Numeric(super.cos());
+    }
+    cubeRoot() {
+        return new Numeric(super.cubeRoot());
+    }
+    cbrt() {
+        return new Numeric(super.cbrt());
+    }
+    dividedBy(value) {
+        return new Numeric(super.dividedBy(new Numeric(value)));
+    }
+    div(value) {
+        return new Numeric(super.div(new Numeric(value)));
+    }
+    dividedToIntegerBy(value) {
+        return new Numeric(super.dividedToIntegerBy(new Numeric(value)));
+    }
+    divToInt(value) {
+        return new Numeric(super.divToInt(new Numeric(value)));
+    }
+    equals(value) {
+        return super.equals(new Numeric(value));
+    }
+    eq(value) {
+        return super.eq(new Numeric(value));
+    }
+    floor() {
+        return new Numeric(super.floor());
+    }
+    greaterThan(value) {
+        return super.greaterThan(new Numeric(value));
+    }
+    gt(value) {
+        return super.gt(new Numeric(value));
+    }
+    greaterThanOrEqualTo(value) {
+        return super.greaterThanOrEqualTo(new Numeric(value));
+    }
+    gte(value) {
+        return super.gte(new Numeric(value));
+    }
+    hyperbolicCosine() {
+        return new Numeric(super.hyperbolicCosine());
+    }
+    cosh() {
+        return new Numeric(super.cosh());
+    }
+    hyperbolicSine() {
+        return new Numeric(super.hyperbolicSine());
+    }
+    sinh() {
+        return new Numeric(super.sinh());
+    }
+    hyperbolicTangent() {
+        return new Numeric(super.hyperbolicTangent());
+    }
+    tanh() {
+        return new Numeric(super.tanh());
+    }
+    inverseCosine() {
+        return new Numeric(super.inverseCosine());
+    }
+    acos() {
+        return new Numeric(super.acos());
+    }
+    inverseHyperbolicCosine() {
+        return new Numeric(super.inverseHyperbolicCosine());
+    }
+    acosh() {
+        return new Numeric(super.acosh());
+    }
+    inverseHyperbolicSine() {
+        return new Numeric(super.inverseHyperbolicSine());
+    }
+    asinh() {
+        return new Numeric(super.asinh());
+    }
+    inverseHyperbolicTangent() {
+        return new Numeric(super.inverseHyperbolicTangent());
+    }
+    atanh() {
+        return new Numeric(super.atanh());
+    }
+    inverseSine() {
+        return new Numeric(super.inverseSine());
+    }
+    asin() {
+        return new Numeric(super.asin());
+    }
+    inverseTangent() {
+        return new Numeric(super.inverseTangent());
+    }
+    atan() {
+        return new Numeric(super.atan());
+    }
+    lessThan(value) {
+        return super.lessThan(new Numeric(value));
+    }
+    lt(value) {
+        return super.lt(new Numeric(value));
+    }
+    lessThanOrEqualTo(value) {
+        return super.lessThanOrEqualTo(new Numeric(value));
+    }
+    lte(value) {
+        return super.lte(new Numeric(value));
+    }
+    logarithm(value) {
+        return new Numeric(super.logarithm(void 0 === value ? void 0 : new Numeric(value)));
+    }
+    log(value) {
+        return new Numeric(super.log(void 0 === value ? void 0 : new Numeric(value)));
+    }
+    minus(value) {
+        return new Numeric(super.minus(new Numeric(value)));
+    }
+    sub(value) {
+        return new Numeric(super.sub(new Numeric(value)));
+    }
+    modulo(value) {
+        return new Numeric(super.modulo(new Numeric(value)));
+    }
+    mod(value) {
+        return new Numeric(super.mod(new Numeric(value)));
+    }
+    naturalExponential() {
+        return new Numeric(super.naturalExponential());
+    }
+    exp() {
+        return new Numeric(super.exp());
+    }
+    naturalLogarithm() {
+        return new Numeric(super.naturalLogarithm());
+    }
+    ln() {
+        return new Numeric(super.ln());
+    }
+    negated() {
+        return new Numeric(super.negated());
+    }
+    neg() {
+        return new Numeric(super.neg());
+    }
+    plus(value) {
+        return new Numeric(super.plus(new Numeric(value)));
+    }
+    add(value) {
+        return new Numeric(super.add(new Numeric(value)));
+    }
+    round() {
+        return new Numeric(super.round());
+    }
+    sine() {
+        return new Numeric(super.sine());
+    }
+    sin() {
+        return new Numeric(super.sin());
+    }
+    squareRoot() {
+        return new Numeric(super.squareRoot());
+    }
+    sqrt() {
+        return new Numeric(super.sqrt());
+    }
+    tangent() {
+        return new Numeric(super.tangent());
+    }
+    tan() {
+        return new Numeric(super.tan());
+    }
+    times(value) {
+        return new Numeric(super.times(new Numeric(value)));
+    }
+    mul(value) {
+        return new Numeric(super.mul(new Numeric(value)));
+    }
+    toDecimalPlaces(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toDecimalPlaces(decimalPlaces, rounding) : super.toDecimalPlaces(decimalPlaces));
+    }
+    toDP(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toDP(decimalPlaces, rounding) : super.toDP(decimalPlaces));
+    }
+    toFraction(maxDenominator) {
+        return toNumerics(super.toFraction(void 0 === maxDenominator ? void 0 : new Numeric(maxDenominator)));
+    }
+    toNearest(value, rounding) {
+        return new Numeric(super.toNearest(new Numeric(value), rounding));
+    }
+    toPower(value) {
+        return new Numeric(super.toPower(new Numeric(value)));
+    }
+    pow(value) {
+        return new Numeric(super.pow(new Numeric(value)));
+    }
+    toSignificantDigits(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toSignificantDigits(decimalPlaces, rounding) : super.toSignificantDigits(decimalPlaces));
+    }
+    toSD(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toSD(decimalPlaces, rounding) : super.toSD(decimalPlaces));
+    }
+    truncated() {
+        return new Numeric(super.truncated());
+    }
+    trunc() {
+        return new Numeric(super.trunc());
+    }
+    inspect(depth, options) {
+        const value = this.toFixed();
+        return external_browser_or_node_namespaceObject.isNode ? options.stylize(value, 'bigint') : value;
+    }
+}
+const external_format_number_namespaceObject = require("format-number");
+var external_format_number_default = /*#__PURE__*/ __webpack_require__.n(external_format_number_namespaceObject);
+const formatValue = (value, options)=>{
+    const format = external_format_number_default()(options);
+    const text = new Numeric(value).toFixed();
+    return format(text);
+};
+const getNumericConfig = ()=>{
+    const { precision, rounding, minE, maxE, toExpNeg, toExpPos, crypto, modulo } = Numeric;
+    const data = {
+        precision,
+        rounding,
+        minE,
+        maxE,
+        toExpNeg,
+        toExpPos,
+        crypto,
+        modulo,
+        defaults: false
+    };
+    return data;
+};
+const setupNumericConfig = ()=>{
+    const config = {
+        precision: 256,
+        toExpNeg: Numeric.minE,
+        toExpPos: Numeric.maxE,
+        crypto: false
+    };
+    Numeric.set({
+        defaults: true
+    });
+    Numeric.set(config);
+};
+const constants_namespaceObject = require("@ethersproject/constants");
+const NegativeOne = new Numeric(-1);
+const Zero = new Numeric(0);
+const One = new Numeric(1);
+const Two = new Numeric(2);
+const WeiPerEther = new Numeric(constants_namespaceObject.WeiPerEther);
+const MaxUint256 = new Numeric(constants_namespaceObject.MaxUint256);
+const MaxInt256 = new Numeric(constants_namespaceObject.MaxInt256);
+const MinInt256 = new Numeric(constants_namespaceObject.MinInt256);
+const isRange = (value, minimum, maximum, options)=>{
+    try {
+        const data = toNumeric(value);
+        const defaultOptions = {
+            includeMaximum: true,
+            includeMinimum: true
+        };
+        const { includeMaximum, includeMinimum } = options ? Object.assign({}, defaultOptions, options) : defaultOptions;
+        const isOverLower = includeMinimum ? data.lessThan(minimum) : data.lessThanOrEqualTo(minimum);
+        const isOverUpper = includeMaximum ? data.greaterThan(maximum) : data.greaterThanOrEqualTo(maximum);
+        return !(isOverLower || isOverUpper);
+    } catch (error) {
+        return false;
+    }
+};
+const tryParse = (value)=>{
+    try {
+        return toNumeric(value);
+    } catch (error) {
+        return false;
+    }
+};
+const isInteger = (value)=>{
+    const data = tryParse(value);
+    return false !== data && data.isInteger();
+};
+const isUnsignedIntegerBits = (bits, value)=>{
+    if (0n > bits || false === isInteger(value)) return false;
+    const maximum = Two.toPower(bits);
+    const minimum = Zero;
+    const options = {
+        includeMinimum: true,
+        includeMaximum: false
+    };
+    return isRange(value, minimum, maximum, options);
+};
+const isSignedIntegerBits = (bits, value)=>{
+    if (0n > bits || false === isInteger(value)) return false;
+    const maximum = Two.toPower(bits - 1n);
+    const minimum = NegativeOne.times(maximum);
+    const options = {
+        includeMinimum: true,
+        includeMaximum: false
+    };
+    return isRange(value, minimum, maximum, options);
+};
+const createArrayCompareFunction = (ascending = true)=>ascending ? (left, right)=>Numeric.sub(left, right).toNumber() : (left, right)=>Numeric.sub(right, left).toNumber();
+exports.MaxInt256 = __webpack_exports__.MaxInt256;
+exports.MaxUint256 = __webpack_exports__.MaxUint256;
+exports.MinInt256 = __webpack_exports__.MinInt256;
+exports.NegativeOne = __webpack_exports__.NegativeOne;
+exports.Numeric = __webpack_exports__.Numeric;
+exports.One = __webpack_exports__.One;
+exports.Two = __webpack_exports__.Two;
+exports.WeiPerEther = __webpack_exports__.WeiPerEther;
+exports.Zero = __webpack_exports__.Zero;
+exports.createArrayCompareFunction = __webpack_exports__.createArrayCompareFunction;
+exports.formatValue = __webpack_exports__.formatValue;
+exports.getNumericConfig = __webpack_exports__.getNumericConfig;
+exports.isInteger = __webpack_exports__.isInteger;
+exports.isRange = __webpack_exports__.isRange;
+exports.isSignedIntegerBits = __webpack_exports__.isSignedIntegerBits;
+exports.isUnsignedIntegerBits = __webpack_exports__.isUnsignedIntegerBits;
+exports.setupNumericConfig = __webpack_exports__.setupNumericConfig;
+exports.toBN = __webpack_exports__.toBN;
+exports.toBigInt = __webpack_exports__.toBigInt;
+exports.toBigInteger = __webpack_exports__.toBigInteger;
+exports.toBigNumber = __webpack_exports__.toBigNumber;
+exports.toIntegerString = __webpack_exports__.toIntegerString;
+exports.toNumeric = __webpack_exports__.toNumeric;
+exports.toNumerics = __webpack_exports__.toNumerics;
+exports.tryParse = __webpack_exports__.tryParse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MaxInt256",
+    "MaxUint256",
+    "MinInt256",
+    "NegativeOne",
+    "Numeric",
+    "One",
+    "Two",
+    "WeiPerEther",
+    "Zero",
+    "createArrayCompareFunction",
+    "formatValue",
+    "getNumericConfig",
+    "isInteger",
+    "isRange",
+    "isSignedIntegerBits",
+    "isUnsignedIntegerBits",
+    "setupNumericConfig",
+    "toBN",
+    "toBigInt",
+    "toBigInteger",
+    "toBigNumber",
+    "toIntegerString",
+    "toNumeric",
+    "toNumerics",
+    "tryParse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/index.mjs

@@ -0,0 +1,474 @@
+import { BigNumber } from "@ethersproject/bignumber";
+import { hexlify, isBytesLike } from "@ethersproject/bytes";
+import big_integer from "big-integer";
+import bn from "bn.js";
+import { isNode } from "browser-or-node";
+import { Decimal } from "decimal.js";
+import format_number from "format-number";
+import { MaxInt256, MaxUint256, MinInt256, WeiPerEther } from "@ethersproject/constants";
+const toNumeric = (value)=>new Numeric(value);
+const toNumerics = (values)=>values.map(toNumeric);
+const toIntegerString = (value)=>toNumeric(value).toFixed(0);
+const toBigInt = (value)=>BigInt(toIntegerString(value));
+const toBN = (value)=>new bn(toIntegerString(value));
+const toBigInteger = (value)=>big_integer(toIntegerString(value));
+const toBigNumber = (value)=>BigNumber.from(toIntegerString(value));
+class Numeric extends Decimal {
+    constructor(value){
+        if (value instanceof Decimal) super(value);
+        else switch(typeof value){
+            case 'string':
+            case 'number':
+                super(value);
+                break;
+            case 'bigint':
+                super(value.toString());
+                break;
+            default:
+                if (big_integer.isInstance(value) || BigNumber.isBigNumber(value) || bn.isBN(value)) super(value.toString());
+                else if (isBytesLike(value)) super(hexlify(value));
+                else super(value);
+                break;
+        }
+    }
+    static abs(value) {
+        return new Numeric(value).abs();
+    }
+    static acos(value) {
+        return new Numeric(value).acos();
+    }
+    static acosh(value) {
+        return new Numeric(value).acosh();
+    }
+    static add(x, y) {
+        return new Numeric(x).add(y);
+    }
+    static asin(value) {
+        return new Numeric(value).asin();
+    }
+    static asinh(value) {
+        return new Numeric(value).asinh();
+    }
+    static atan(value) {
+        return new Numeric(value).atan();
+    }
+    static atanh(value) {
+        return new Numeric(value).atanh();
+    }
+    static atan2(x, y) {
+        return new Numeric(Decimal.atan2(new Numeric(x), new Numeric(y)));
+    }
+    static cbrt(value) {
+        return new Numeric(value).cbrt();
+    }
+    static ceil(value) {
+        return new Numeric(value).ceil();
+    }
+    static clamp(value, min, max) {
+        return new Numeric(Decimal.clamp(new Numeric(value), new Numeric(min), new Numeric(max)));
+    }
+    static cos(value) {
+        return new Numeric(value).cos();
+    }
+    static cosh(value) {
+        return new Numeric(value).cosh();
+    }
+    static div(x, y) {
+        return new Numeric(x).div(y);
+    }
+    static exp(value) {
+        return new Numeric(value).exp();
+    }
+    static floor(value) {
+        return new Numeric(value).floor();
+    }
+    static hypot(...values) {
+        return new Numeric(Decimal.hypot(...toNumerics(values)));
+    }
+    static ln(value) {
+        return new Numeric(value).ln();
+    }
+    static log(value, base) {
+        return new Numeric(value).log(base);
+    }
+    static log2(value) {
+        return new Numeric(value).log(2);
+    }
+    static log10(value) {
+        return new Numeric(value).log(10);
+    }
+    static max(...values) {
+        return new Numeric(Decimal.max(...toNumerics(values)));
+    }
+    static min(...values) {
+        return new Numeric(Decimal.min(...toNumerics(values)));
+    }
+    static mod(x, y) {
+        return new Numeric(x).mod(y);
+    }
+    static mul(x, y) {
+        return new Numeric(x).mul(y);
+    }
+    static pow(base, exponent) {
+        return new Numeric(base).pow(exponent);
+    }
+    static random(significantDigits) {
+        return new Numeric(Decimal.random(significantDigits));
+    }
+    static round(value) {
+        return new Numeric(value).round();
+    }
+    static set(object) {
+        return Decimal.set(object);
+    }
+    static sign(value) {
+        return Decimal.sign(new Numeric(value));
+    }
+    static sin(value) {
+        return new Numeric(value).sin();
+    }
+    static sinh(value) {
+        return new Numeric(value).sinh();
+    }
+    static sqrt(value) {
+        return new Numeric(value).sqrt();
+    }
+    static sub(x, y) {
+        return new Numeric(x).sub(y);
+    }
+    static sum(...values) {
+        return new Numeric(Decimal.sum(...toNumerics(values)));
+    }
+    static tan(value) {
+        return new Numeric(value).tan();
+    }
+    static tanh(value) {
+        return new Numeric(value).tanh();
+    }
+    static trunc(value) {
+        return new Numeric(value).trunc();
+    }
+    absoluteValue() {
+        return new Numeric(super.absoluteValue());
+    }
+    abs() {
+        return new Numeric(super.abs());
+    }
+    ceil() {
+        return new Numeric(super.ceil());
+    }
+    clampedTo(min, max) {
+        return new Numeric(super.clampedTo(new Numeric(min), new Numeric(max)));
+    }
+    clamp(min, max) {
+        return new Numeric(super.clamp(new Numeric(min), new Numeric(max)));
+    }
+    comparedTo(value) {
+        return super.comparedTo(new Numeric(value));
+    }
+    cmp(value) {
+        return super.cmp(new Numeric(value));
+    }
+    cosine() {
+        return new Numeric(super.cosine());
+    }
+    cos() {
+        return new Numeric(super.cos());
+    }
+    cubeRoot() {
+        return new Numeric(super.cubeRoot());
+    }
+    cbrt() {
+        return new Numeric(super.cbrt());
+    }
+    dividedBy(value) {
+        return new Numeric(super.dividedBy(new Numeric(value)));
+    }
+    div(value) {
+        return new Numeric(super.div(new Numeric(value)));
+    }
+    dividedToIntegerBy(value) {
+        return new Numeric(super.dividedToIntegerBy(new Numeric(value)));
+    }
+    divToInt(value) {
+        return new Numeric(super.divToInt(new Numeric(value)));
+    }
+    equals(value) {
+        return super.equals(new Numeric(value));
+    }
+    eq(value) {
+        return super.eq(new Numeric(value));
+    }
+    floor() {
+        return new Numeric(super.floor());
+    }
+    greaterThan(value) {
+        return super.greaterThan(new Numeric(value));
+    }
+    gt(value) {
+        return super.gt(new Numeric(value));
+    }
+    greaterThanOrEqualTo(value) {
+        return super.greaterThanOrEqualTo(new Numeric(value));
+    }
+    gte(value) {
+        return super.gte(new Numeric(value));
+    }
+    hyperbolicCosine() {
+        return new Numeric(super.hyperbolicCosine());
+    }
+    cosh() {
+        return new Numeric(super.cosh());
+    }
+    hyperbolicSine() {
+        return new Numeric(super.hyperbolicSine());
+    }
+    sinh() {
+        return new Numeric(super.sinh());
+    }
+    hyperbolicTangent() {
+        return new Numeric(super.hyperbolicTangent());
+    }
+    tanh() {
+        return new Numeric(super.tanh());
+    }
+    inverseCosine() {
+        return new Numeric(super.inverseCosine());
+    }
+    acos() {
+        return new Numeric(super.acos());
+    }
+    inverseHyperbolicCosine() {
+        return new Numeric(super.inverseHyperbolicCosine());
+    }
+    acosh() {
+        return new Numeric(super.acosh());
+    }
+    inverseHyperbolicSine() {
+        return new Numeric(super.inverseHyperbolicSine());
+    }
+    asinh() {
+        return new Numeric(super.asinh());
+    }
+    inverseHyperbolicTangent() {
+        return new Numeric(super.inverseHyperbolicTangent());
+    }
+    atanh() {
+        return new Numeric(super.atanh());
+    }
+    inverseSine() {
+        return new Numeric(super.inverseSine());
+    }
+    asin() {
+        return new Numeric(super.asin());
+    }
+    inverseTangent() {
+        return new Numeric(super.inverseTangent());
+    }
+    atan() {
+        return new Numeric(super.atan());
+    }
+    lessThan(value) {
+        return super.lessThan(new Numeric(value));
+    }
+    lt(value) {
+        return super.lt(new Numeric(value));
+    }
+    lessThanOrEqualTo(value) {
+        return super.lessThanOrEqualTo(new Numeric(value));
+    }
+    lte(value) {
+        return super.lte(new Numeric(value));
+    }
+    logarithm(value) {
+        return new Numeric(super.logarithm(void 0 === value ? void 0 : new Numeric(value)));
+    }
+    log(value) {
+        return new Numeric(super.log(void 0 === value ? void 0 : new Numeric(value)));
+    }
+    minus(value) {
+        return new Numeric(super.minus(new Numeric(value)));
+    }
+    sub(value) {
+        return new Numeric(super.sub(new Numeric(value)));
+    }
+    modulo(value) {
+        return new Numeric(super.modulo(new Numeric(value)));
+    }
+    mod(value) {
+        return new Numeric(super.mod(new Numeric(value)));
+    }
+    naturalExponential() {
+        return new Numeric(super.naturalExponential());
+    }
+    exp() {
+        return new Numeric(super.exp());
+    }
+    naturalLogarithm() {
+        return new Numeric(super.naturalLogarithm());
+    }
+    ln() {
+        return new Numeric(super.ln());
+    }
+    negated() {
+        return new Numeric(super.negated());
+    }
+    neg() {
+        return new Numeric(super.neg());
+    }
+    plus(value) {
+        return new Numeric(super.plus(new Numeric(value)));
+    }
+    add(value) {
+        return new Numeric(super.add(new Numeric(value)));
+    }
+    round() {
+        return new Numeric(super.round());
+    }
+    sine() {
+        return new Numeric(super.sine());
+    }
+    sin() {
+        return new Numeric(super.sin());
+    }
+    squareRoot() {
+        return new Numeric(super.squareRoot());
+    }
+    sqrt() {
+        return new Numeric(super.sqrt());
+    }
+    tangent() {
+        return new Numeric(super.tangent());
+    }
+    tan() {
+        return new Numeric(super.tan());
+    }
+    times(value) {
+        return new Numeric(super.times(new Numeric(value)));
+    }
+    mul(value) {
+        return new Numeric(super.mul(new Numeric(value)));
+    }
+    toDecimalPlaces(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toDecimalPlaces(decimalPlaces, rounding) : super.toDecimalPlaces(decimalPlaces));
+    }
+    toDP(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toDP(decimalPlaces, rounding) : super.toDP(decimalPlaces));
+    }
+    toFraction(maxDenominator) {
+        return toNumerics(super.toFraction(void 0 === maxDenominator ? void 0 : new Numeric(maxDenominator)));
+    }
+    toNearest(value, rounding) {
+        return new Numeric(super.toNearest(new Numeric(value), rounding));
+    }
+    toPower(value) {
+        return new Numeric(super.toPower(new Numeric(value)));
+    }
+    pow(value) {
+        return new Numeric(super.pow(new Numeric(value)));
+    }
+    toSignificantDigits(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toSignificantDigits(decimalPlaces, rounding) : super.toSignificantDigits(decimalPlaces));
+    }
+    toSD(decimalPlaces, rounding) {
+        return new Numeric(void 0 !== rounding && void 0 !== decimalPlaces ? super.toSD(decimalPlaces, rounding) : super.toSD(decimalPlaces));
+    }
+    truncated() {
+        return new Numeric(super.truncated());
+    }
+    trunc() {
+        return new Numeric(super.trunc());
+    }
+    inspect(depth, options) {
+        const value = this.toFixed();
+        return isNode ? options.stylize(value, 'bigint') : value;
+    }
+}
+const formatValue = (value, options)=>{
+    const format = format_number(options);
+    const text = new Numeric(value).toFixed();
+    return format(text);
+};
+const getNumericConfig = ()=>{
+    const { precision, rounding, minE, maxE, toExpNeg, toExpPos, crypto, modulo } = Numeric;
+    const data = {
+        precision,
+        rounding,
+        minE,
+        maxE,
+        toExpNeg,
+        toExpPos,
+        crypto,
+        modulo,
+        defaults: false
+    };
+    return data;
+};
+const setupNumericConfig = ()=>{
+    const config = {
+        precision: 256,
+        toExpNeg: Numeric.minE,
+        toExpPos: Numeric.maxE,
+        crypto: false
+    };
+    Numeric.set({
+        defaults: true
+    });
+    Numeric.set(config);
+};
+const NegativeOne = new Numeric(-1);
+const Zero = new Numeric(0);
+const One = new Numeric(1);
+const Two = new Numeric(2);
+const constants_WeiPerEther = new Numeric(WeiPerEther);
+const constants_MaxUint256 = new Numeric(MaxUint256);
+const constants_MaxInt256 = new Numeric(MaxInt256);
+const constants_MinInt256 = new Numeric(MinInt256);
+const isRange = (value, minimum, maximum, options)=>{
+    try {
+        const data = toNumeric(value);
+        const defaultOptions = {
+            includeMaximum: true,
+            includeMinimum: true
+        };
+        const { includeMaximum, includeMinimum } = options ? Object.assign({}, defaultOptions, options) : defaultOptions;
+        const isOverLower = includeMinimum ? data.lessThan(minimum) : data.lessThanOrEqualTo(minimum);
+        const isOverUpper = includeMaximum ? data.greaterThan(maximum) : data.greaterThanOrEqualTo(maximum);
+        return !(isOverLower || isOverUpper);
+    } catch (error) {
+        return false;
+    }
+};
+const tryParse = (value)=>{
+    try {
+        return toNumeric(value);
+    } catch (error) {
+        return false;
+    }
+};
+const isInteger = (value)=>{
+    const data = tryParse(value);
+    return false !== data && data.isInteger();
+};
+const isUnsignedIntegerBits = (bits, value)=>{
+    if (0n > bits || false === isInteger(value)) return false;
+    const maximum = Two.toPower(bits);
+    const minimum = Zero;
+    const options = {
+        includeMinimum: true,
+        includeMaximum: false
+    };
+    return isRange(value, minimum, maximum, options);
+};
+const isSignedIntegerBits = (bits, value)=>{
+    if (0n > bits || false === isInteger(value)) return false;
+    const maximum = Two.toPower(bits - 1n);
+    const minimum = NegativeOne.times(maximum);
+    const options = {
+        includeMinimum: true,
+        includeMaximum: false
+    };
+    return isRange(value, minimum, maximum, options);
+};
+const createArrayCompareFunction = (ascending = true)=>ascending ? (left, right)=>Numeric.sub(left, right).toNumber() : (left, right)=>Numeric.sub(right, left).toNumber();
+export { NegativeOne, Numeric, One, Two, Zero, constants_MaxInt256 as MaxInt256, constants_MaxUint256 as MaxUint256, constants_MinInt256 as MinInt256, constants_WeiPerEther as WeiPerEther, createArrayCompareFunction, formatValue, getNumericConfig, isInteger, isRange, isSignedIntegerBits, isUnsignedIntegerBits, setupNumericConfig, toBN, toBigInt, toBigInteger, toBigNumber, toIntegerString, toNumeric, toNumerics, tryParse };

package/lib/numeric.d.ts

@@ -0,0 +1,136 @@
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import 'big-integer';
+import bigInt from 'big-integer';
+import 'bn.js';
+import BN from 'bn.js';
+import 'decimal.js';
+import { Decimal } from 'decimal.js';
+import { InspectOptionsStylized } from 'util';
+export type NumericValue = Numeric | Decimal.Value | bigInt.BigNumber | BigNumberish;
+export declare const toNumeric: (value: NumericValue) => Numeric;
+export declare const toNumerics: (values: NumericValue[]) => Numeric[];
+export declare const toIntegerString: (value: NumericValue) => string;
+export declare const toBigInt: (value: NumericValue) => bigint;
+export declare const toBN: (value: NumericValue) => BN;
+export declare const toBigInteger: (value: NumericValue) => bigInt.BigInteger;
+export declare const toBigNumber: (value: NumericValue) => BigNumber;
+export declare class Numeric extends Decimal {
+    constructor(value: NumericValue);
+    static abs(value: NumericValue): Numeric;
+    static acos(value: NumericValue): Numeric;
+    static acosh(value: NumericValue): Numeric;
+    static add(x: NumericValue, y: NumericValue): Numeric;
+    static asin(value: NumericValue): Numeric;
+    static asinh(value: NumericValue): Numeric;
+    static atan(value: NumericValue): Numeric;
+    static atanh(value: NumericValue): Numeric;
+    static atan2(x: NumericValue, y: NumericValue): Numeric;
+    static cbrt(value: NumericValue): Numeric;
+    static ceil(value: NumericValue): Numeric;
+    static clamp(value: NumericValue, min: NumericValue, max: NumericValue): Numeric;
+    static cos(value: NumericValue): Numeric;
+    static cosh(value: NumericValue): Numeric;
+    static div(x: NumericValue, y: NumericValue): Numeric;
+    static exp(value: NumericValue): Numeric;
+    static floor(value: NumericValue): Numeric;
+    static hypot(...values: NumericValue[]): Numeric;
+    static ln(value: NumericValue): Numeric;
+    static log(value: NumericValue, base?: NumericValue): Numeric;
+    static log2(value: NumericValue): Numeric;
+    static log10(value: NumericValue): Numeric;
+    static max(...values: NumericValue[]): Numeric;
+    static min(...values: NumericValue[]): Numeric;
+    static mod(x: NumericValue, y: NumericValue): Numeric;
+    static mul(x: NumericValue, y: NumericValue): Numeric;
+    static pow(base: NumericValue, exponent: NumericValue): Numeric;
+    static random(significantDigits?: number): Numeric;
+    static round(value: NumericValue): Numeric;
+    static set(object: Decimal.Config): typeof Decimal;
+    static sign(value: NumericValue): number;
+    static sin(value: NumericValue): Numeric;
+    static sinh(value: NumericValue): Numeric;
+    static sqrt(value: NumericValue): Numeric;
+    static sub(x: NumericValue, y: NumericValue): Numeric;
+    static sum(...values: NumericValue[]): Numeric;
+    static tan(value: NumericValue): Numeric;
+    static tanh(value: NumericValue): Numeric;
+    static trunc(value: NumericValue): Numeric;
+    absoluteValue(): Numeric;
+    abs(): Numeric;
+    ceil(): Numeric;
+    clampedTo(min: NumericValue, max: NumericValue): Numeric;
+    clamp(min: NumericValue, max: NumericValue): Numeric;
+    comparedTo(value: NumericValue): number;
+    cmp(value: NumericValue): number;
+    cosine(): Numeric;
+    cos(): Numeric;
+    cubeRoot(): Numeric;
+    cbrt(): Numeric;
+    dividedBy(value: NumericValue): Numeric;
+    div(value: NumericValue): Numeric;
+    dividedToIntegerBy(value: NumericValue): Numeric;
+    divToInt(value: NumericValue): Numeric;
+    equals(value: NumericValue): boolean;
+    eq(value: NumericValue): boolean;
+    floor(): Numeric;
+    greaterThan(value: NumericValue): boolean;
+    gt(value: NumericValue): boolean;
+    greaterThanOrEqualTo(value: NumericValue): boolean;
+    gte(value: NumericValue): boolean;
+    hyperbolicCosine(): Numeric;
+    cosh(): Numeric;
+    hyperbolicSine(): Numeric;
+    sinh(): Numeric;
+    hyperbolicTangent(): Numeric;
+    tanh(): Numeric;
+    inverseCosine(): Numeric;
+    acos(): Numeric;
+    inverseHyperbolicCosine(): Numeric;
+    acosh(): Numeric;
+    inverseHyperbolicSine(): Numeric;
+    asinh(): Numeric;
+    inverseHyperbolicTangent(): Numeric;
+    atanh(): Numeric;
+    inverseSine(): Numeric;
+    asin(): Numeric;
+    inverseTangent(): Numeric;
+    atan(): Numeric;
+    lessThan(value: NumericValue): boolean;
+    lt(value: NumericValue): boolean;
+    lessThanOrEqualTo(value: NumericValue): boolean;
+    lte(value: NumericValue): boolean;
+    logarithm(value?: NumericValue): Numeric;
+    log(value?: NumericValue): Numeric;
+    minus(value: NumericValue): Numeric;
+    sub(value: NumericValue): Numeric;
+    modulo(value: NumericValue): Numeric;
+    mod(value: NumericValue): Numeric;
+    naturalExponential(): Numeric;
+    exp(): Numeric;
+    naturalLogarithm(): Numeric;
+    ln(): Numeric;
+    negated(): Numeric;
+    neg(): Numeric;
+    plus(value: NumericValue): Numeric;
+    add(value: NumericValue): Numeric;
+    round(): Numeric;
+    sine(): Numeric;
+    sin(): Numeric;
+    squareRoot(): Numeric;
+    sqrt(): Numeric;
+    tangent(): Numeric;
+    tan(): Numeric;
+    times(value: NumericValue): Numeric;
+    mul(value: NumericValue): Numeric;
+    toDecimalPlaces(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
+    toDP(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
+    toFraction(maxDenominator?: NumericValue): Numeric[];
+    toNearest(value: NumericValue, rounding?: Decimal.Rounding): Numeric;
+    toPower(value: NumericValue): Numeric;
+    pow(value: NumericValue): Numeric;
+    toSignificantDigits(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
+    toSD(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
+    truncated(): Numeric;
+    trunc(): Numeric;
+    inspect(depth: number, options: InspectOptionsStylized): string;
+}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@agrozyme/numeric",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "import": "./lib/index.mjs"
     }
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib/index.mjs",
+  "types": "./lib/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@gitlab.com:agrozyme-package/TypeScript/numeric.git"
@@ -43,7 +43,7 @@
     "tslib": "^2.8.1"
   },
   "scripts": {
-    "clean": "shx rm -rf dist",
+    "clean": "shx rm -rf dist lib",
     "build": "rslib build"
   }
 }