@agrozyme/numeric 1.0.12 → 1.0.13

package/root/index.ts

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols
+
 import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
 import { hexlify, isBytesLike } from '@ethersproject/bytes';
 import * as constants from '@ethersproject/constants';
@@ -6,7 +8,7 @@ import BN from 'bn.js';
 import { isNode } from 'browser-or-node';
 import { Decimal } from 'decimal.js';
 import formatter from 'format-number';
-import { InspectOptionsStylized } from 'util';
+import { InspectOptionsStylized } from 'node:util';
 
 // const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -29,7 +31,7 @@ export interface IFormatNumberOptions {
   truncate?: number;
 }
 
-//noinspection FunctionNamingConventionJS
+// noinspection LocalVariableNamingConventionJS
 export class Numeric extends Decimal {
   // private readonly toStringTag: string = 'Decimal';
 
@@ -62,510 +64,277 @@ export class Numeric extends Decimal {
     return 'Numeric';
   }
 
-  static abs(value: NumericValue) {
-    return new Numeric(value).abs();
-  }
+  static abs = (value: NumericValue) => new Numeric(value).abs();
 
-  static acos(value: NumericValue) {
-    return new Numeric(value).acos();
-  }
+  static acos = (value: NumericValue) => new Numeric(value).acos();
 
-  static acosh(value: NumericValue) {
-    return new Numeric(value).acosh();
-  }
+  static acosh = (value: NumericValue) => new Numeric(value).acosh();
 
-  static add(x: NumericValue, y: NumericValue) {
-    return new Numeric(x).add(y);
-  }
+  static add = (x: NumericValue, y: NumericValue) => new Numeric(x).add(y);
 
-  static asin(value: NumericValue) {
-    return new Numeric(value).asin();
-  }
+  static asin = (value: NumericValue) => new Numeric(value).asin();
 
-  static asinh(value: NumericValue) {
-    return new Numeric(value).asinh();
-  }
+  static asinh = (value: NumericValue) => new Numeric(value).asinh();
 
-  static atan(value: NumericValue) {
-    return new Numeric(value).atan();
-  }
+  static atan = (value: NumericValue) => new Numeric(value).atan();
 
-  static atan2(x: NumericValue, y: NumericValue) {
-    return new Numeric(Decimal.atan2(new Numeric(x), new Numeric(y)));
-  }
+  static atan2 = (x: NumericValue, y: NumericValue) => new Numeric(Decimal.atan2(new Numeric(x), new Numeric(y)));
 
-  static atanh(value: NumericValue) {
-    return new Numeric(value).atanh();
-  }
+  static atanh = (value: NumericValue) => new Numeric(value).atanh();
 
-  static cbrt(value: NumericValue) {
-    return new Numeric(value).cbrt();
-  }
+  static cbrt = (value: NumericValue) => new Numeric(value).cbrt();
 
-  static ceil(value: NumericValue) {
-    return new Numeric(value).ceil();
-  }
+  static ceil = (value: NumericValue) => new Numeric(value).ceil();
 
-  static cos(value: NumericValue) {
-    return new Numeric(value).cos();
-  }
+  static cos = (value: NumericValue) => new Numeric(value).cos();
 
-  static cosh(value: NumericValue) {
-    return new Numeric(value).cosh();
-  }
+  static cosh = (value: NumericValue) => new Numeric(value).cosh();
 
-  static div(x: NumericValue, y: NumericValue) {
-    return new Numeric(x).div(y);
-  }
+  static div = (x: NumericValue, y: NumericValue) => new Numeric(x).div(y);
 
-  static exp(value: NumericValue) {
-    return new Numeric(value).exp();
-  }
+  static exp = (value: NumericValue) => new Numeric(value).exp();
 
-  static floor(value: NumericValue) {
-    return new Numeric(value).floor();
-  }
+  static floor = (value: NumericValue) => new Numeric(value).floor();
 
-  static hypot(...values: NumericValue[]) {
-    return new Numeric(Decimal.hypot(...toNumerics(values)));
-  }
+  static hypot = (...values: NumericValue[]) => new Numeric(Decimal.hypot(...toNumerics(values)));
 
-  static ln(value: NumericValue) {
-    return new Numeric(value).ln();
-  }
+  static ln = (value: NumericValue) => new Numeric(value).ln();
 
-  static log(value: NumericValue, base?: NumericValue) {
-    return new Numeric(value).log(base);
-  }
+  static log = (value: NumericValue, base?: NumericValue) => new Numeric(value).log(base);
 
-  static log10(value: NumericValue) {
-    return new Numeric(value).log(10);
-  }
+  static log10 = (value: NumericValue) => new Numeric(value).log(10);
 
-  static log2(value: NumericValue) {
-    return new Numeric(value).log(2);
-  }
+  static log2 = (value: NumericValue) => new Numeric(value).log(2);
 
-  static max(...values: NumericValue[]) {
-    return new Numeric(Decimal.max(...toNumerics(values)));
-  }
+  static max = (...values: NumericValue[]) => new Numeric(Decimal.max(...toNumerics(values)));
 
-  static min(...values: NumericValue[]) {
-    return new Numeric(Decimal.min(...toNumerics(values)));
-  }
+  static min = (...values: NumericValue[]) => new Numeric(Decimal.min(...toNumerics(values)));
 
-  static mod(x: NumericValue, y: NumericValue) {
-    return new Numeric(x).mod(y);
-  }
+  static mod = (x: NumericValue, y: NumericValue) => new Numeric(x).mod(y);
 
-  static mul(x: NumericValue, y: NumericValue) {
-    return new Numeric(x).mul(y);
-  }
+  static mul = (x: NumericValue, y: NumericValue) => new Numeric(x).mul(y);
 
-  static pow(base: NumericValue, exponent: NumericValue) {
-    return new Numeric(base).pow(exponent);
-  }
+  static pow = (base: NumericValue, exponent: NumericValue) => new Numeric(base).pow(exponent);
 
-  static random(significantDigits?: number) {
-    return new Numeric(Decimal.random(significantDigits));
-  }
+  static random = (significantDigits?: number) => new Numeric(Decimal.random(significantDigits));
 
-  static round(value: NumericValue) {
-    return new Numeric(value).round();
-  }
+  static round = (value: NumericValue) => new Numeric(value).round();
 
-  static set(object: Decimal.Config) {
-    return Decimal.set(object);
-  }
+  static set = (object: Decimal.Config) => Decimal.set(object);
 
-  static sign(value: NumericValue) {
-    return new Numeric(Decimal.sign(new Numeric(value)));
-  }
+  static sign = (value: NumericValue) => Decimal.sign(new Numeric(value));
 
-  static sin(value: NumericValue) {
-    return new Numeric(value).sin();
-  }
+  static sin = (value: NumericValue) => new Numeric(value).sin();
 
-  static sinh(value: NumericValue) {
-    return new Numeric(value).sinh();
-  }
+  static sinh = (value: NumericValue) => new Numeric(value).sinh();
 
-  static sqrt(value: NumericValue) {
-    return new Numeric(value).sqrt();
-  }
+  static sqrt = (value: NumericValue) => new Numeric(value).sqrt();
 
-  static sub(x: NumericValue, y: NumericValue) {
-    return new Numeric(x).sub(y);
-  }
+  static sub = (x: NumericValue, y: NumericValue) => new Numeric(x).sub(y);
 
-  static tan(value: NumericValue) {
-    return new Numeric(value).tan();
-  }
+  static tan = (value: NumericValue) => new Numeric(value).tan();
 
-  static tanh(value: NumericValue) {
-    return new Numeric(value).tanh();
-  }
+  static tanh = (value: NumericValue) => new Numeric(value).tanh();
 
-  static trunc(value: NumericValue) {
-    return new Numeric(value).trunc();
-  }
+  static trunc = (value: NumericValue) => new Numeric(value).trunc();
 
-  abs() {
-    return new Numeric(super.abs());
-  }
+  abs = () => new Numeric(super.abs());
 
-  absoluteValue() {
-    return new Numeric(super.absoluteValue());
-  }
+  absoluteValue = () => new Numeric(super.absoluteValue());
 
-  acos() {
-    return new Numeric(super.acos());
-  }
+  acos = () => new Numeric(super.acos());
 
-  acosh() {
-    return new Numeric(super.acosh());
-  }
+  acosh = () => new Numeric(super.acosh());
 
-  add(value: NumericValue) {
-    return new Numeric(super.add(new Numeric(value)));
-  }
+  add = (value: NumericValue) => new Numeric(super.add(new Numeric(value)));
 
-  asin() {
-    return new Numeric(super.asin());
-  }
+  asin = () => new Numeric(super.asin());
 
-  asinh() {
-    return new Numeric(super.asinh());
-  }
+  asinh = () => new Numeric(super.asinh());
 
-  atan() {
-    return new Numeric(super.atan());
-  }
+  atan = () => new Numeric(super.atan());
 
-  atanh() {
-    return new Numeric(super.atanh());
-  }
+  atanh = () => new Numeric(super.atanh());
 
-  cbrt() {
-    return new Numeric(super.cbrt());
-  }
+  cbrt = () => new Numeric(super.cbrt());
 
-  ceil() {
-    return new Numeric(super.ceil());
-  }
+  ceil = () => new Numeric(super.ceil());
 
-  cmp(value: NumericValue) {
-    return super.cmp(new Numeric(value));
-  }
+  cmp = (value: NumericValue) => super.cmp(new Numeric(value));
 
-  comparedTo(value: NumericValue) {
-    return super.comparedTo(new Numeric(value));
-  }
+  comparedTo = (value: NumericValue) => super.comparedTo(new Numeric(value));
 
-  cos() {
-    return new Numeric(super.cos());
-  }
+  cos = () => new Numeric(super.cos());
 
-  cosh() {
-    return new Numeric(super.cosh());
-  }
+  cosh = () => new Numeric(super.cosh());
 
-  cosine() {
-    return new Numeric(super.cosine());
-  }
+  cosine = () => new Numeric(super.cosine());
 
-  cubeRoot() {
-    return new Numeric(super.cubeRoot());
-  }
+  cubeRoot = () => new Numeric(super.cubeRoot());
 
-  div(value: NumericValue) {
-    return new Numeric(super.div(new Numeric(value)));
-  }
+  div = (value: NumericValue) => new Numeric(super.div(new Numeric(value)));
 
-  divToInt(value: NumericValue) {
-    return new Numeric(super.divToInt(new Numeric(value)));
-  }
+  divToInt = (value: NumericValue) => new Numeric(super.divToInt(new Numeric(value)));
 
-  dividedBy(value: NumericValue) {
-    return new Numeric(super.dividedBy(new Numeric(value)));
-  }
+  dividedBy = (value: NumericValue) => new Numeric(super.dividedBy(new Numeric(value)));
 
-  dividedToIntegerBy(value: NumericValue) {
-    return new Numeric(super.dividedToIntegerBy(new Numeric(value)));
-  }
+  dividedToIntegerBy = (value: NumericValue) => new Numeric(super.dividedToIntegerBy(new Numeric(value)));
 
-  eq(value: NumericValue) {
-    return super.eq(new Numeric(value));
-  }
+  eq = (value: NumericValue) => super.eq(new Numeric(value));
 
-  equals(value: NumericValue) {
-    return super.equals(new Numeric(value));
-  }
+  equals = (value: NumericValue) => super.equals(new Numeric(value));
 
-  exp() {
-    return new Numeric(super.exp());
-  }
+  exp = () => new Numeric(super.exp());
 
-  floor() {
-    return new Numeric(super.floor());
-  }
+  floor = () => new Numeric(super.floor());
 
-  greaterThan(value: NumericValue) {
-    return super.greaterThan(new Numeric(value));
-  }
+  greaterThan = (value: NumericValue) => super.greaterThan(new Numeric(value));
 
-  greaterThanOrEqualTo(value: NumericValue) {
-    return super.greaterThanOrEqualTo(new Numeric(value));
-  }
+  greaterThanOrEqualTo = (value: NumericValue) => super.greaterThanOrEqualTo(new Numeric(value));
 
-  gt(value: NumericValue) {
-    return super.gt(new Numeric(value));
-  }
+  gt = (value: NumericValue) => super.gt(new Numeric(value));
 
-  gte(value: NumericValue) {
-    return super.gte(new Numeric(value));
-  }
+  gte = (value: NumericValue) => super.gte(new Numeric(value));
 
-  hyperbolicCosine() {
-    return new Numeric(super.hyperbolicCosine());
-  }
+  hyperbolicCosine = () => new Numeric(super.hyperbolicCosine());
 
-  hyperbolicSine() {
-    return new Numeric(super.hyperbolicSine());
-  }
+  hyperbolicSine = () => new Numeric(super.hyperbolicSine());
 
-  hyperbolicTangent() {
-    return new Numeric(super.hyperbolicTangent());
-  }
+  hyperbolicTangent = () => new Numeric(super.hyperbolicTangent());
 
-  inverseCosine() {
-    return new Numeric(super.inverseCosine());
-  }
+  inverseCosine = () => new Numeric(super.inverseCosine());
 
-  inverseHyperbolicCosine() {
-    return new Numeric(super.inverseHyperbolicCosine());
-  }
+  inverseHyperbolicCosine = () => new Numeric(super.inverseHyperbolicCosine());
 
-  inverseHyperbolicSine() {
-    return new Numeric(super.inverseHyperbolicSine());
-  }
+  inverseHyperbolicSine = () => new Numeric(super.inverseHyperbolicSine());
 
-  inverseHyperbolicTangent() {
-    return new Numeric(super.inverseHyperbolicTangent());
-  }
+  inverseHyperbolicTangent = () => new Numeric(super.inverseHyperbolicTangent());
 
-  inverseSine() {
-    return new Numeric(super.inverseSine());
-  }
+  inverseSine = () => new Numeric(super.inverseSine());
 
-  inverseTangent() {
-    return new Numeric(super.inverseTangent());
-  }
+  inverseTangent = () => new Numeric(super.inverseTangent());
 
-  lessThan(value: NumericValue) {
-    return super.lessThan(new Numeric(value));
-  }
+  lessThan = (value: NumericValue) => super.lessThan(new Numeric(value));
 
-  lessThanOrEqualTo(value: NumericValue) {
-    return super.lessThanOrEqualTo(new Numeric(value));
-  }
+  lessThanOrEqualTo = (value: NumericValue) => super.lessThanOrEqualTo(new Numeric(value));
 
-  ln() {
-    return new Numeric(super.ln());
-  }
+  ln = () => new Numeric(super.ln());
 
-  log(value?: NumericValue) {
-    return new Numeric(super.log(undefined === value ? undefined : new Numeric(value)));
-  }
+  log = (value?: NumericValue) => new Numeric(super.log(undefined === value ? undefined : new Numeric(value)));
 
-  logarithm(value?: NumericValue) {
-    return new Numeric(super.logarithm(undefined === value ? undefined : new Numeric(value)));
-  }
+  logarithm = (value?: NumericValue) =>
+    new Numeric(super.logarithm(undefined === value ? undefined : new Numeric(value)));
 
-  lt(value: NumericValue) {
-    return super.lt(new Numeric(value));
-  }
+  lt = (value: NumericValue) => super.lt(new Numeric(value));
 
-  lte(value: NumericValue) {
-    return super.lte(new Numeric(value));
-  }
+  lte = (value: NumericValue) => super.lte(new Numeric(value));
 
-  minus(value: NumericValue) {
-    return new Numeric(super.minus(new Numeric(value)));
-  }
+  minus = (value: NumericValue) => new Numeric(super.minus(new Numeric(value)));
 
-  mod(value: NumericValue) {
-    return new Numeric(super.mod(new Numeric(value)));
-  }
+  mod = (value: NumericValue) => new Numeric(super.mod(new Numeric(value)));
 
-  modulo(value: NumericValue) {
-    return new Numeric(super.modulo(new Numeric(value)));
-  }
+  modulo = (value: NumericValue) => new Numeric(super.modulo(new Numeric(value)));
 
-  mul(value: NumericValue) {
-    return new Numeric(super.mul(new Numeric(value)));
-  }
+  mul = (value: NumericValue) => new Numeric(super.mul(new Numeric(value)));
 
-  naturalExponential() {
-    return new Numeric(super.naturalExponential());
-  }
+  naturalExponential = () => new Numeric(super.naturalExponential());
 
-  naturalLogarithm() {
-    return new Numeric(super.naturalLogarithm());
-  }
+  naturalLogarithm = () => new Numeric(super.naturalLogarithm());
 
-  neg() {
-    return new Numeric(super.neg());
-  }
+  neg = () => new Numeric(super.neg());
 
-  negated() {
-    return new Numeric(super.negated());
-  }
+  negated = () => new Numeric(super.negated());
 
-  plus(value: NumericValue) {
-    return new Numeric(super.plus(new Numeric(value)));
-  }
+  plus = (value: NumericValue) => new Numeric(super.plus(new Numeric(value)));
 
-  pow(value: NumericValue) {
-    return new Numeric(super.pow(new Numeric(value)));
-  }
+  pow = (value: NumericValue) => new Numeric(super.pow(new Numeric(value)));
 
-  round() {
-    return new Numeric(super.round());
-  }
+  round = () => new Numeric(super.round());
 
-  sin() {
-    return new Numeric(super.sin());
-  }
+  sin = () => new Numeric(super.sin());
 
-  sine() {
-    return new Numeric(super.sine());
-  }
+  sine = () => new Numeric(super.sine());
 
-  sinh() {
-    return new Numeric(super.sinh());
-  }
+  sinh = () => new Numeric(super.sinh());
 
-  sqrt() {
-    return new Numeric(super.sqrt());
-  }
+  sqrt = () => new Numeric(super.sqrt());
 
-  squareRoot() {
-    return new Numeric(super.squareRoot());
-  }
+  squareRoot = () => new Numeric(super.squareRoot());
 
-  sub(value: NumericValue) {
-    return new Numeric(super.sub(new Numeric(value)));
-  }
+  sub = (value: NumericValue) => new Numeric(super.sub(new Numeric(value)));
 
-  tan() {
-    return new Numeric(super.tan());
-  }
+  tan = () => new Numeric(super.tan());
 
-  tangent() {
-    return new Numeric(super.tangent());
-  }
+  tangent = () => new Numeric(super.tangent());
 
-  tanh() {
-    return new Numeric(super.tanh());
-  }
+  tanh = () => new Numeric(super.tanh());
 
-  times(value: NumericValue) {
-    return new Numeric(super.times(new Numeric(value)));
-  }
+  times = (value: NumericValue) => new Numeric(super.times(new Numeric(value)));
 
-  toDP(decimalPlaces?: number, rounding?: Decimal.Rounding) {
-    return new Numeric(
+  toDP = (decimalPlaces?: number, rounding?: Decimal.Rounding) =>
+    new Numeric(
       undefined !== rounding && undefined !== decimalPlaces
         ? super.toDP(decimalPlaces, rounding)
         : super.toDP(decimalPlaces)
     );
-  }
 
-  toDecimalPlaces(decimalPlaces?: number, rounding?: Decimal.Rounding) {
-    return new Numeric(
+  toDecimalPlaces = (decimalPlaces?: number, rounding?: Decimal.Rounding) =>
+    new Numeric(
       undefined !== rounding && undefined !== decimalPlaces
         ? super.toDecimalPlaces(decimalPlaces, rounding)
         : super.toDecimalPlaces(decimalPlaces)
     );
-  }
 
-  toFraction(maxDenominator?: NumericValue) {
-    return toNumerics(super.toFraction(undefined === maxDenominator ? undefined : new Numeric(maxDenominator)));
-  }
+  toFraction = (maxDenominator?: NumericValue) =>
+    toNumerics(super.toFraction(undefined === maxDenominator ? undefined : new Numeric(maxDenominator)));
 
-  toNearest(value: NumericValue, rounding?: Decimal.Rounding) {
-    return new Numeric(super.toNearest(new Numeric(value), rounding));
-  }
+  toNearest = (value: NumericValue, rounding?: Decimal.Rounding) =>
+    new Numeric(super.toNearest(new Numeric(value), rounding));
 
-  toPower(value: NumericValue) {
-    return new Numeric(super.toPower(new Numeric(value)));
-  }
+  toPower = (value: NumericValue) => new Numeric(super.toPower(new Numeric(value)));
 
-  toSD(decimalPlaces?: number, rounding?: Decimal.Rounding) {
-    return new Numeric(
+  toSD = (decimalPlaces?: number, rounding?: Decimal.Rounding) =>
+    new Numeric(
       undefined !== rounding && undefined !== decimalPlaces
         ? super.toSD(decimalPlaces, rounding)
         : super.toSD(decimalPlaces)
     );
-  }
 
-  toSignificantDigits(decimalPlaces?: number, rounding?: Decimal.Rounding) {
-    return new Numeric(
+  toSignificantDigits = (decimalPlaces?: number, rounding?: Decimal.Rounding) =>
+    new Numeric(
       undefined !== rounding && undefined !== decimalPlaces
         ? super.toSignificantDigits(decimalPlaces, rounding)
         : super.toSignificantDigits(decimalPlaces)
     );
-  }
 
-  trunc() {
-    return new Numeric(super.trunc());
-  }
+  trunc = () => new Numeric(super.trunc());
 
-  truncated() {
-    return new Numeric(super.truncated());
-  }
+  truncated = () => new Numeric(super.truncated());
 
-  inspect(depth: number, options: InspectOptionsStylized) {
+  inspect = (depth: number, options: InspectOptionsStylized) => {
     const value = this.toFixed();
     return isNode ? options.stylize(value, 'bigint') : value;
-  }
+  };
 }
 
-export const toNumeric = (value: NumericValue) => {
-  return new Numeric(value);
-};
+export const toNumeric = (value: NumericValue) => new Numeric(value);
 
-export const toNumerics = (values: NumericValue[]) => {
-  return values.map(toNumeric);
-};
+export const toNumerics = (values: NumericValue[]) => values.map(toNumeric);
 
-export const toIntegerString = (value: NumericValue) => {
-  return toNumeric(value).toFixed(0);
-};
+export const toIntegerString = (value: NumericValue) => toNumeric(value).toFixed(0);
 
-export const toBigInt = (value: NumericValue) => {
-  return BigInt(toIntegerString(value));
-};
+export const toBigInt = (value: NumericValue) => BigInt(toIntegerString(value));
 
-export const toBN = (value: NumericValue) => {
-  return new BN(toIntegerString(value));
-};
+export const toBN = (value: NumericValue) => new BN(toIntegerString(value));
 
-export const toBigInteger = (value: NumericValue) => {
-  return bigInt(toIntegerString(value));
-};
+export const toBigInteger = (value: NumericValue) => bigInt(toIntegerString(value));
 
-export const toBigNumber = (value: NumericValue) => {
-  return BigNumber.from(toIntegerString(value));
-};
+export const toBigNumber = (value: NumericValue) => BigNumber.from(toIntegerString(value));
 
-export const createArrayCompareFunction = (ascending: boolean = true) => {
-  //noinspection JSSuspiciousNameCombination
-  return ascending
+export const createArrayCompareFunction = (ascending: boolean = true) =>
+  ascending
     ? (left: NumericValue, right: NumericValue) => Numeric.sub(left, right).toNumber()
     : (left: NumericValue, right: NumericValue) => Numeric.sub(right, left).toNumber();
-};
 
 export const formatValue = (value: NumericValue, options?: IFormatNumberOptions) => {
   const format = formatter(options);

package/tsc-multi.json

@@ -1,6 +1,7 @@
 {
   "targets": [
-    { "extname": ".mjs", "module": "esnext" },
-    { "extname": ".js", "module": "commonjs" }
-  ]
+    { "extname": ".mjs", "module": "ESNext", "moduleResolution": "NodeNext" },
+    { "extname": ".js", "module": "CommonJS", "moduleResolution": "Node" }
+  ],
+  "projects": ["."]
 }