@agrozyme/numeric 1.0.11 → 1.0.13

package/tsconfig.json

@@ -1,21 +1,34 @@
 {
-  "compileOnSave": true,
+  "compileOnSave": false,
   "compilerOptions": {
-    "composite": true,
+    //  Type Checking
+    "strict": true,
+
+    //  Modules
+    "module": "ESNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "root",
+
+    //  Emit
     "downlevelIteration": true,
     "importHelpers": true,
-    "isolatedModules": true,
-    "module": "ESNext",
+    "newLine": "LF",
     "outDir": "out",
-    "rootDir": "root",
-    "target": "ES2015",
-    "strict": true,
+    "sourceMap": true,
+
+    //  Interop Constraints
     "esModuleInterop": true,
-    "moduleResolution": "Node",
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "forceConsistentCasingInFileNames": true,
-    "newLine": "LF",
+    "isolatedModules": true,
+
+    //  Language and Environment
+    "jsx": "preserve",
+    "target": "ESNext",
+
+    //  Projects
+    "composite": true,
+
+    //  Completeness
     "skipLibCheck": true
   },
   "include": ["root/**/*.ts", "test/**/*.ts"]

package/out/index.d.ts

@@ -1,158 +0,0 @@
-/// <reference types="node" />
-import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
-import bigInt from 'big-integer';
-import BN from 'bn.js';
-import { Decimal } from 'decimal.js';
-import { InspectOptionsStylized } from 'util';
-export declare type NumericValue = Numeric | Decimal.Value | bigInt.BigNumber | BigNumberish;
-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 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 atan2(x: NumericValue, y: NumericValue): Numeric;
-    static atanh(value: NumericValue): Numeric;
-    static cbrt(value: NumericValue): Numeric;
-    static ceil(value: 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 log10(value: NumericValue): Numeric;
-    static log2(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): Numeric;
-    static sin(value: NumericValue): Numeric;
-    static sinh(value: NumericValue): Numeric;
-    static sqrt(value: NumericValue): Numeric;
-    static sub(x: NumericValue, y: NumericValue): Numeric;
-    static tan(value: NumericValue): Numeric;
-    static tanh(value: NumericValue): Numeric;
-    static trunc(value: NumericValue): Numeric;
-    abs(): Numeric;
-    absoluteValue(): Numeric;
-    acos(): Numeric;
-    acosh(): Numeric;
-    add(value: NumericValue): Numeric;
-    asin(): Numeric;
-    asinh(): Numeric;
-    atan(): Numeric;
-    atanh(): Numeric;
-    cbrt(): Numeric;
-    ceil(): Numeric;
-    cmp(value: NumericValue): number;
-    comparedTo(value: NumericValue): number;
-    cos(): Numeric;
-    cosh(): Numeric;
-    cosine(): Numeric;
-    cubeRoot(): Numeric;
-    div(value: NumericValue): Numeric;
-    divToInt(value: NumericValue): Numeric;
-    dividedBy(value: NumericValue): Numeric;
-    dividedToIntegerBy(value: NumericValue): Numeric;
-    eq(value: NumericValue): boolean;
-    equals(value: NumericValue): boolean;
-    exp(): Numeric;
-    floor(): Numeric;
-    greaterThan(value: NumericValue): boolean;
-    greaterThanOrEqualTo(value: NumericValue): boolean;
-    gt(value: NumericValue): boolean;
-    gte(value: NumericValue): boolean;
-    hyperbolicCosine(): Numeric;
-    hyperbolicSine(): Numeric;
-    hyperbolicTangent(): Numeric;
-    inverseCosine(): Numeric;
-    inverseHyperbolicCosine(): Numeric;
-    inverseHyperbolicSine(): Numeric;
-    inverseHyperbolicTangent(): Numeric;
-    inverseSine(): Numeric;
-    inverseTangent(): Numeric;
-    lessThan(value: NumericValue): boolean;
-    lessThanOrEqualTo(value: NumericValue): boolean;
-    ln(): Numeric;
-    log(value?: NumericValue): Numeric;
-    logarithm(value?: NumericValue): Numeric;
-    lt(value: NumericValue): boolean;
-    lte(value: NumericValue): boolean;
-    minus(value: NumericValue): Numeric;
-    mod(value: NumericValue): Numeric;
-    modulo(value: NumericValue): Numeric;
-    mul(value: NumericValue): Numeric;
-    naturalExponential(): Numeric;
-    naturalLogarithm(): Numeric;
-    neg(): Numeric;
-    negated(): Numeric;
-    plus(value: NumericValue): Numeric;
-    pow(value: NumericValue): Numeric;
-    round(): Numeric;
-    sin(): Numeric;
-    sine(): Numeric;
-    sinh(): Numeric;
-    sqrt(): Numeric;
-    squareRoot(): Numeric;
-    sub(value: NumericValue): Numeric;
-    tan(): Numeric;
-    tangent(): Numeric;
-    tanh(): Numeric;
-    times(value: NumericValue): Numeric;
-    toDP(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
-    toDecimalPlaces(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
-    toFraction(maxDenominator?: NumericValue): Numeric[];
-    toNearest(value: NumericValue, rounding?: Decimal.Rounding): Numeric;
-    toPower(value: NumericValue): Numeric;
-    toSD(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
-    toSignificantDigits(decimalPlaces?: number, rounding?: Decimal.Rounding): Numeric;
-    trunc(): Numeric;
-    truncated(): Numeric;
-    inspect(depth: number, options: InspectOptionsStylized): string;
-}
-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 const createArrayCompareFunction: (ascending?: boolean) => (left: NumericValue, right: NumericValue) => number;
-export declare const formatValue: (value: NumericValue, options?: IFormatNumberOptions | undefined) => string;
-export declare const getNumericConfig: () => Required<Decimal.Config>;
-export declare const setupNumericConfig: () => void;
-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/out/index.js

@@ -1,471 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MinInt256 = exports.MaxInt256 = exports.MaxUint256 = exports.WeiPerEther = exports.Two = exports.One = exports.Zero = exports.NegativeOne = exports.setupNumericConfig = exports.getNumericConfig = exports.formatValue = exports.createArrayCompareFunction = exports.toBigNumber = exports.toBigInteger = exports.toBN = exports.toBigInt = exports.toIntegerString = exports.toNumerics = exports.toNumeric = exports.Numeric = void 0;
-const tslib_1 = require("tslib");
-const bignumber_1 = require("@ethersproject/bignumber");
-const bytes_1 = require("@ethersproject/bytes");
-const constants = tslib_1.__importStar(require("@ethersproject/constants"));
-const big_integer_1 = tslib_1.__importDefault(require("big-integer"));
-const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
-const browser_or_node_1 = require("browser-or-node");
-const decimal_js_1 = require("decimal.js");
-const format_number_1 = tslib_1.__importDefault(require("format-number"));
-//noinspection FunctionNamingConventionJS
-class Numeric extends decimal_js_1.Decimal {
-    constructor(value) {
-        if (value instanceof decimal_js_1.Decimal) {
-            super(value);
-        }
-        else {
-            switch (typeof value) {
-                case 'string':
-                case 'number':
-                    super(value);
-                    break;
-                case 'bigint':
-                    super(value.toString());
-                    break;
-                default:
-                    if (big_integer_1.default.isInstance(value) || bignumber_1.BigNumber.isBigNumber(value) || bn_js_1.default.isBN(value)) {
-                        super(value.toString());
-                    }
-                    else if ((0, bytes_1.isBytesLike)(value)) {
-                        super((0, bytes_1.hexlify)(value));
-                    }
-                    else {
-                        super(value);
-                    }
-                    break;
-            }
-        }
-    }
-    // get [Symbol.toStringTag]() {
-    //   return 'Numeric';
-    // }
-    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 atan2(x, y) {
-        return new Numeric(decimal_js_1.Decimal.atan2(new Numeric(x), new Numeric(y)));
-    }
-    static atanh(value) {
-        return new Numeric(value).atanh();
-    }
-    static cbrt(value) {
-        return new Numeric(value).cbrt();
-    }
-    static ceil(value) {
-        return new Numeric(value).ceil();
-    }
-    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_js_1.Decimal.hypot(...(0, exports.toNumerics)(values)));
-    }
-    static ln(value) {
-        return new Numeric(value).ln();
-    }
-    static log(value, base) {
-        return new Numeric(value).log(base);
-    }
-    static log10(value) {
-        return new Numeric(value).log(10);
-    }
-    static log2(value) {
-        return new Numeric(value).log(2);
-    }
-    static max(...values) {
-        return new Numeric(decimal_js_1.Decimal.max(...(0, exports.toNumerics)(values)));
-    }
-    static min(...values) {
-        return new Numeric(decimal_js_1.Decimal.min(...(0, exports.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_js_1.Decimal.random(significantDigits));
-    }
-    static round(value) {
-        return new Numeric(value).round();
-    }
-    static set(object) {
-        return decimal_js_1.Decimal.set(object);
-    }
-    static sign(value) {
-        return new Numeric(decimal_js_1.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 tan(value) {
-        return new Numeric(value).tan();
-    }
-    static tanh(value) {
-        return new Numeric(value).tanh();
-    }
-    static trunc(value) {
-        return new Numeric(value).trunc();
-    }
-    abs() {
-        return new Numeric(super.abs());
-    }
-    absoluteValue() {
-        return new Numeric(super.absoluteValue());
-    }
-    acos() {
-        return new Numeric(super.acos());
-    }
-    acosh() {
-        return new Numeric(super.acosh());
-    }
-    add(value) {
-        return new Numeric(super.add(new Numeric(value)));
-    }
-    asin() {
-        return new Numeric(super.asin());
-    }
-    asinh() {
-        return new Numeric(super.asinh());
-    }
-    atan() {
-        return new Numeric(super.atan());
-    }
-    atanh() {
-        return new Numeric(super.atanh());
-    }
-    cbrt() {
-        return new Numeric(super.cbrt());
-    }
-    ceil() {
-        return new Numeric(super.ceil());
-    }
-    cmp(value) {
-        return super.cmp(new Numeric(value));
-    }
-    comparedTo(value) {
-        return super.comparedTo(new Numeric(value));
-    }
-    cos() {
-        return new Numeric(super.cos());
-    }
-    cosh() {
-        return new Numeric(super.cosh());
-    }
-    cosine() {
-        return new Numeric(super.cosine());
-    }
-    cubeRoot() {
-        return new Numeric(super.cubeRoot());
-    }
-    div(value) {
-        return new Numeric(super.div(new Numeric(value)));
-    }
-    divToInt(value) {
-        return new Numeric(super.divToInt(new Numeric(value)));
-    }
-    dividedBy(value) {
-        return new Numeric(super.dividedBy(new Numeric(value)));
-    }
-    dividedToIntegerBy(value) {
-        return new Numeric(super.dividedToIntegerBy(new Numeric(value)));
-    }
-    eq(value) {
-        return super.eq(new Numeric(value));
-    }
-    equals(value) {
-        return super.equals(new Numeric(value));
-    }
-    exp() {
-        return new Numeric(super.exp());
-    }
-    floor() {
-        return new Numeric(super.floor());
-    }
-    greaterThan(value) {
-        return super.greaterThan(new Numeric(value));
-    }
-    greaterThanOrEqualTo(value) {
-        return super.greaterThanOrEqualTo(new Numeric(value));
-    }
-    gt(value) {
-        return super.gt(new Numeric(value));
-    }
-    gte(value) {
-        return super.gte(new Numeric(value));
-    }
-    hyperbolicCosine() {
-        return new Numeric(super.hyperbolicCosine());
-    }
-    hyperbolicSine() {
-        return new Numeric(super.hyperbolicSine());
-    }
-    hyperbolicTangent() {
-        return new Numeric(super.hyperbolicTangent());
-    }
-    inverseCosine() {
-        return new Numeric(super.inverseCosine());
-    }
-    inverseHyperbolicCosine() {
-        return new Numeric(super.inverseHyperbolicCosine());
-    }
-    inverseHyperbolicSine() {
-        return new Numeric(super.inverseHyperbolicSine());
-    }
-    inverseHyperbolicTangent() {
-        return new Numeric(super.inverseHyperbolicTangent());
-    }
-    inverseSine() {
-        return new Numeric(super.inverseSine());
-    }
-    inverseTangent() {
-        return new Numeric(super.inverseTangent());
-    }
-    lessThan(value) {
-        return super.lessThan(new Numeric(value));
-    }
-    lessThanOrEqualTo(value) {
-        return super.lessThanOrEqualTo(new Numeric(value));
-    }
-    ln() {
-        return new Numeric(super.ln());
-    }
-    log(value) {
-        return new Numeric(super.log(undefined === value ? undefined : new Numeric(value)));
-    }
-    logarithm(value) {
-        return new Numeric(super.logarithm(undefined === value ? undefined : new Numeric(value)));
-    }
-    lt(value) {
-        return super.lt(new Numeric(value));
-    }
-    lte(value) {
-        return super.lte(new Numeric(value));
-    }
-    minus(value) {
-        return new Numeric(super.minus(new Numeric(value)));
-    }
-    mod(value) {
-        return new Numeric(super.mod(new Numeric(value)));
-    }
-    modulo(value) {
-        return new Numeric(super.modulo(new Numeric(value)));
-    }
-    mul(value) {
-        return new Numeric(super.mul(new Numeric(value)));
-    }
-    naturalExponential() {
-        return new Numeric(super.naturalExponential());
-    }
-    naturalLogarithm() {
-        return new Numeric(super.naturalLogarithm());
-    }
-    neg() {
-        return new Numeric(super.neg());
-    }
-    negated() {
-        return new Numeric(super.negated());
-    }
-    plus(value) {
-        return new Numeric(super.plus(new Numeric(value)));
-    }
-    pow(value) {
-        return new Numeric(super.pow(new Numeric(value)));
-    }
-    round() {
-        return new Numeric(super.round());
-    }
-    sin() {
-        return new Numeric(super.sin());
-    }
-    sine() {
-        return new Numeric(super.sine());
-    }
-    sinh() {
-        return new Numeric(super.sinh());
-    }
-    sqrt() {
-        return new Numeric(super.sqrt());
-    }
-    squareRoot() {
-        return new Numeric(super.squareRoot());
-    }
-    sub(value) {
-        return new Numeric(super.sub(new Numeric(value)));
-    }
-    tan() {
-        return new Numeric(super.tan());
-    }
-    tangent() {
-        return new Numeric(super.tangent());
-    }
-    tanh() {
-        return new Numeric(super.tanh());
-    }
-    times(value) {
-        return new Numeric(super.times(new Numeric(value)));
-    }
-    toDP(decimalPlaces, rounding) {
-        return new Numeric(undefined !== rounding && undefined !== decimalPlaces
-            ? super.toDP(decimalPlaces, rounding)
-            : super.toDP(decimalPlaces));
-    }
-    toDecimalPlaces(decimalPlaces, rounding) {
-        return new Numeric(undefined !== rounding && undefined !== decimalPlaces
-            ? super.toDecimalPlaces(decimalPlaces, rounding)
-            : super.toDecimalPlaces(decimalPlaces));
-    }
-    toFraction(maxDenominator) {
-        return (0, exports.toNumerics)(super.toFraction(undefined === maxDenominator ? undefined : 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)));
-    }
-    toSD(decimalPlaces, rounding) {
-        return new Numeric(undefined !== rounding && undefined !== decimalPlaces
-            ? super.toSD(decimalPlaces, rounding)
-            : super.toSD(decimalPlaces));
-    }
-    toSignificantDigits(decimalPlaces, rounding) {
-        return new Numeric(undefined !== rounding && undefined !== decimalPlaces
-            ? super.toSignificantDigits(decimalPlaces, rounding)
-            : super.toSignificantDigits(decimalPlaces));
-    }
-    trunc() {
-        return new Numeric(super.trunc());
-    }
-    truncated() {
-        return new Numeric(super.truncated());
-    }
-    inspect(depth, options) {
-        const value = this.toFixed();
-        return browser_or_node_1.isNode ? options.stylize(value, 'bigint') : value;
-    }
-}
-exports.Numeric = Numeric;
-const toNumeric = (value) => {
-    return new Numeric(value);
-};
-exports.toNumeric = toNumeric;
-const toNumerics = (values) => {
-    return values.map(exports.toNumeric);
-};
-exports.toNumerics = toNumerics;
-const toIntegerString = (value) => {
-    return (0, exports.toNumeric)(value).toFixed(0);
-};
-exports.toIntegerString = toIntegerString;
-const toBigInt = (value) => {
-    return BigInt((0, exports.toIntegerString)(value));
-};
-exports.toBigInt = toBigInt;
-const toBN = (value) => {
-    return new bn_js_1.default((0, exports.toIntegerString)(value));
-};
-exports.toBN = toBN;
-const toBigInteger = (value) => {
-    return (0, big_integer_1.default)((0, exports.toIntegerString)(value));
-};
-exports.toBigInteger = toBigInteger;
-const toBigNumber = (value) => {
-    return bignumber_1.BigNumber.from((0, exports.toIntegerString)(value));
-};
-exports.toBigNumber = toBigNumber;
-const createArrayCompareFunction = (ascending = true) => {
-    //noinspection JSSuspiciousNameCombination
-    return ascending
-        ? (left, right) => Numeric.sub(left, right).toNumber()
-        : (left, right) => Numeric.sub(right, left).toNumber();
-};
-exports.createArrayCompareFunction = createArrayCompareFunction;
-const formatValue = (value, options) => {
-    const format = (0, format_number_1.default)(options);
-    const text = new Numeric(value).toFixed();
-    return format(text);
-};
-exports.formatValue = formatValue;
-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;
-};
-exports.getNumericConfig = getNumericConfig;
-const setupNumericConfig = () => {
-    const config = {
-        precision: 256,
-        //rounding: Numeric.ROUND_FLOOR,
-        toExpNeg: Numeric.minE,
-        toExpPos: Numeric.maxE,
-        crypto: false,
-    };
-    Numeric.set({ defaults: true });
-    Numeric.set(config);
-};
-exports.setupNumericConfig = setupNumericConfig;
-exports.NegativeOne = new Numeric(-1);
-exports.Zero = new Numeric(0);
-exports.One = new Numeric(1);
-exports.Two = new Numeric(2);
-exports.WeiPerEther = new Numeric(constants.WeiPerEther);
-exports.MaxUint256 = new Numeric(constants.MaxUint256);
-exports.MaxInt256 = new Numeric(constants.MaxInt256);
-exports.MinInt256 = new Numeric(constants.MinInt256);