feat:node-modules

node_modules/mathjs/lib/cjs/plain/bignumber/arithmetic.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.absBigNumber = absBigNumber;
+exports.addBigNumber = addBigNumber;
+exports.divideBigNumber = divideBigNumber;
+exports.multiplyBigNumber = multiplyBigNumber;
+exports.subtractBigNumber = subtractBigNumber;
+const signature1 = 'BigNumber';
+const signature2 = 'BigNumber, BigNumber';
+function absBigNumber(a) {
+  return a.abs();
+}
+absBigNumber.signature = signature1;
+function addBigNumber(a, b) {
+  return a.add(b);
+}
+addBigNumber.signature = signature2;
+function subtractBigNumber(a, b) {
+  return a.sub(b);
+}
+subtractBigNumber.signature = signature2;
+function multiplyBigNumber(a, b) {
+  return a.mul(b);
+}
+multiplyBigNumber.signature = signature2;
+function divideBigNumber(a, b) {
+  return a.div(b);
+}
+divideBigNumber.signature = signature2;

node_modules/mathjs/lib/cjs/plain/bignumber/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  bignumber: true
+};
+exports.bignumber = bignumber;
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _arithmetic = require("./arithmetic.js");
+Object.keys(_arithmetic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _arithmetic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _arithmetic[key];
+    }
+  });
+});
+// TODO: this is ugly. Instead, be able to pass your own isBigNumber function to typed?
+const BigNumber = _decimal.default.clone();
+BigNumber.prototype.isBigNumber = true;
+function bignumber(x) {
+  return new BigNumber(x);
+}

node_modules/mathjs/lib/cjs/plain/number/arithmetic.js

@@ -0,0 +1,334 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.absNumber = absNumber;
+exports.addNumber = addNumber;
+exports.cbrtNumber = cbrtNumber;
+exports.cubeNumber = cubeNumber;
+exports.divideNumber = divideNumber;
+exports.expNumber = expNumber;
+exports.expm1Number = expm1Number;
+exports.gcdNumber = gcdNumber;
+exports.lcmNumber = lcmNumber;
+exports.log10Number = log10Number;
+exports.log1pNumber = log1pNumber;
+exports.log2Number = log2Number;
+exports.logNumber = logNumber;
+exports.modNumber = modNumber;
+exports.multiplyNumber = multiplyNumber;
+exports.normNumber = normNumber;
+exports.nthRootNumber = nthRootNumber;
+exports.powNumber = powNumber;
+exports.roundNumber = roundNumber;
+exports.signNumber = signNumber;
+exports.sqrtNumber = sqrtNumber;
+exports.squareNumber = squareNumber;
+exports.subtractNumber = subtractNumber;
+exports.unaryMinusNumber = unaryMinusNumber;
+exports.unaryPlusNumber = unaryPlusNumber;
+exports.xgcdNumber = xgcdNumber;
+var _number = require("../../utils/number.js");
+const n1 = 'number';
+const n2 = 'number, number';
+function absNumber(a) {
+  return Math.abs(a);
+}
+absNumber.signature = n1;
+function addNumber(a, b) {
+  return a + b;
+}
+addNumber.signature = n2;
+function subtractNumber(a, b) {
+  return a - b;
+}
+subtractNumber.signature = n2;
+function multiplyNumber(a, b) {
+  return a * b;
+}
+multiplyNumber.signature = n2;
+function divideNumber(a, b) {
+  return a / b;
+}
+divideNumber.signature = n2;
+function unaryMinusNumber(x) {
+  return -x;
+}
+unaryMinusNumber.signature = n1;
+function unaryPlusNumber(x) {
+  return x;
+}
+unaryPlusNumber.signature = n1;
+function cbrtNumber(x) {
+  return (0, _number.cbrt)(x);
+}
+cbrtNumber.signature = n1;
+function cubeNumber(x) {
+  return x * x * x;
+}
+cubeNumber.signature = n1;
+function expNumber(x) {
+  return Math.exp(x);
+}
+expNumber.signature = n1;
+function expm1Number(x) {
+  return (0, _number.expm1)(x);
+}
+expm1Number.signature = n1;
+
+/**
+ * Calculate gcd for numbers
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} Returns the greatest common denominator of a and b
+ */
+function gcdNumber(a, b) {
+  if (!(0, _number.isInteger)(a) || !(0, _number.isInteger)(b)) {
+    throw new Error('Parameters in function gcd must be integer numbers');
+  }
+
+  // https://en.wikipedia.org/wiki/Euclidean_algorithm
+  let r;
+  while (b !== 0) {
+    r = a % b;
+    a = b;
+    b = r;
+  }
+  return a < 0 ? -a : a;
+}
+gcdNumber.signature = n2;
+
+/**
+ * Calculate lcm for two numbers
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} Returns the least common multiple of a and b
+ */
+function lcmNumber(a, b) {
+  if (!(0, _number.isInteger)(a) || !(0, _number.isInteger)(b)) {
+    throw new Error('Parameters in function lcm must be integer numbers');
+  }
+  if (a === 0 || b === 0) {
+    return 0;
+  }
+
+  // https://en.wikipedia.org/wiki/Euclidean_algorithm
+  // evaluate lcm here inline to reduce overhead
+  let t;
+  const prod = a * b;
+  while (b !== 0) {
+    t = b;
+    b = a % t;
+    a = t;
+  }
+  return Math.abs(prod / a);
+}
+lcmNumber.signature = n2;
+
+/**
+ * Calculate the logarithm of a value, optionally to a given base.
+ * @param {number} x
+ * @param {number | null | undefined} base
+ * @return {number}
+ */
+function logNumber(x, y) {
+  if (y) {
+    return Math.log(x) / Math.log(y);
+  }
+  return Math.log(x);
+}
+
+/**
+ * Calculate the 10-base logarithm of a number
+ * @param {number} x
+ * @return {number}
+ */
+function log10Number(x) {
+  return (0, _number.log10)(x);
+}
+log10Number.signature = n1;
+
+/**
+ * Calculate the 2-base logarithm of a number
+ * @param {number} x
+ * @return {number}
+ */
+function log2Number(x) {
+  return (0, _number.log2)(x);
+}
+log2Number.signature = n1;
+
+/**
+ * Calculate the natural logarithm of a `number+1`
+ * @param {number} x
+ * @returns {number}
+ */
+function log1pNumber(x) {
+  return (0, _number.log1p)(x);
+}
+log1pNumber.signature = n1;
+
+/**
+ * Calculate the modulus of two numbers
+ * @param {number} x
+ * @param {number} y
+ * @returns {number} res
+ * @private
+ */
+function modNumber(x, y) {
+  // We don't use JavaScript's % operator here as this doesn't work
+  // correctly for x < 0 and x === 0
+  // see https://en.wikipedia.org/wiki/Modulo_operation
+  return y === 0 ? x : x - y * Math.floor(x / y);
+}
+modNumber.signature = n2;
+
+/**
+ * Calculate the nth root of a, solve x^root == a
+ * http://rosettacode.org/wiki/Nth_root#JavaScript
+ * @param {number} a
+ * @param {number} [2] root
+ * @private
+ */
+function nthRootNumber(a) {
+  let root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  const inv = root < 0;
+  if (inv) {
+    root = -root;
+  }
+  if (root === 0) {
+    throw new Error('Root must be non-zero');
+  }
+  if (a < 0 && Math.abs(root) % 2 !== 1) {
+    throw new Error('Root must be odd when a is negative.');
+  }
+
+  // edge cases zero and infinity
+  if (a === 0) {
+    return inv ? Infinity : 0;
+  }
+  if (!isFinite(a)) {
+    return inv ? 0 : a;
+  }
+  let x = Math.pow(Math.abs(a), 1 / root);
+  // If a < 0, we require that root is an odd integer,
+  // so (-1) ^ (1/root) = -1
+  x = a < 0 ? -x : x;
+  return inv ? 1 / x : x;
+
+  // Very nice algorithm, but fails with nthRoot(-2, 3).
+  // Newton's method has some well-known problems at times:
+  // https://en.wikipedia.org/wiki/Newton%27s_method#Failure_analysis
+  /*
+  let x = 1 // Initial guess
+  let xPrev = 1
+  let i = 0
+  const iMax = 10000
+  do {
+    const delta = (a / Math.pow(x, root - 1) - x) / root
+    xPrev = x
+    x = x + delta
+    i++
+  }
+  while (xPrev !== x && i < iMax)
+   if (xPrev !== x) {
+    throw new Error('Function nthRoot failed to converge')
+  }
+   return inv ? 1 / x : x
+  */
+}
+function signNumber(x) {
+  return (0, _number.sign)(x);
+}
+signNumber.signature = n1;
+function sqrtNumber(x) {
+  return Math.sqrt(x);
+}
+sqrtNumber.signature = n1;
+function squareNumber(x) {
+  return x * x;
+}
+squareNumber.signature = n1;
+
+/**
+ * Calculate xgcd for two numbers
+ * @param {number} a
+ * @param {number} b
+ * @return {number} result
+ * @private
+ */
+function xgcdNumber(a, b) {
+  // source: https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+  let t; // used to swap two variables
+  let q; // quotient
+  let r; // remainder
+  let x = 0;
+  let lastx = 1;
+  let y = 1;
+  let lasty = 0;
+  if (!(0, _number.isInteger)(a) || !(0, _number.isInteger)(b)) {
+    throw new Error('Parameters in function xgcd must be integer numbers');
+  }
+  while (b) {
+    q = Math.floor(a / b);
+    r = a - q * b;
+    t = x;
+    x = lastx - q * x;
+    lastx = t;
+    t = y;
+    y = lasty - q * y;
+    lasty = t;
+    a = b;
+    b = r;
+  }
+  let res;
+  if (a < 0) {
+    res = [-a, -lastx, -lasty];
+  } else {
+    res = [a, a ? lastx : 0, lasty];
+  }
+  return res;
+}
+xgcdNumber.signature = n2;
+
+/**
+ * Calculates the power of x to y, x^y, for two numbers.
+ * @param {number} x
+ * @param {number} y
+ * @return {number} res
+ */
+function powNumber(x, y) {
+  // x^Infinity === 0 if -1 < x < 1
+  // A real number 0 is returned instead of complex(0)
+  if (x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity) {
+    return 0;
+  }
+  return Math.pow(x, y);
+}
+powNumber.signature = n2;
+
+/**
+ * round a number to the given number of decimals, or to zero if decimals is
+ * not provided
+ * @param {number} value
+ * @param {number} decimals       number of decimals, between 0 and 15 (0 by default)
+ * @return {number} roundedValue
+ */
+function roundNumber(value) {
+  let decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (!(0, _number.isInteger)(decimals) || decimals < 0 || decimals > 15) {
+    throw new Error('Number of decimals in function round must be an integer from 0 to 15 inclusive');
+  }
+  return parseFloat((0, _number.toFixed)(value, decimals));
+}
+
+/**
+ * Calculate the norm of a number, the absolute value.
+ * @param {number} x
+ * @return {number}
+ */
+function normNumber(x) {
+  return Math.abs(x);
+}
+normNumber.signature = n1;

node_modules/mathjs/lib/cjs/plain/number/bitwise.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitAndNumber = bitAndNumber;
+exports.bitNotNumber = bitNotNumber;
+exports.bitOrNumber = bitOrNumber;
+exports.bitXorNumber = bitXorNumber;
+exports.leftShiftNumber = leftShiftNumber;
+exports.rightArithShiftNumber = rightArithShiftNumber;
+exports.rightLogShiftNumber = rightLogShiftNumber;
+var _number = require("../../utils/number.js");
+const n1 = 'number';
+const n2 = 'number, number';
+function bitAndNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function bitAnd');
+  }
+  return x & y;
+}
+bitAndNumber.signature = n2;
+function bitNotNumber(x) {
+  if (!(0, _number.isInteger)(x)) {
+    throw new Error('Integer expected in function bitNot');
+  }
+  return ~x;
+}
+bitNotNumber.signature = n1;
+function bitOrNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function bitOr');
+  }
+  return x | y;
+}
+bitOrNumber.signature = n2;
+function bitXorNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function bitXor');
+  }
+  return x ^ y;
+}
+bitXorNumber.signature = n2;
+function leftShiftNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function leftShift');
+  }
+  return x << y;
+}
+leftShiftNumber.signature = n2;
+function rightArithShiftNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function rightArithShift');
+  }
+  return x >> y;
+}
+rightArithShiftNumber.signature = n2;
+function rightLogShiftNumber(x, y) {
+  if (!(0, _number.isInteger)(x) || !(0, _number.isInteger)(y)) {
+    throw new Error('Integers expected in function rightLogShift');
+  }
+  return x >>> y;
+}
+rightLogShiftNumber.signature = n2;

node_modules/mathjs/lib/cjs/plain/number/combinations.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinationsNumber = combinationsNumber;
+var _number = require("../../utils/number.js");
+var _product = require("../../utils/product.js");
+function combinationsNumber(n, k) {
+  if (!(0, _number.isInteger)(n) || n < 0) {
+    throw new TypeError('Positive integer value expected in function combinations');
+  }
+  if (!(0, _number.isInteger)(k) || k < 0) {
+    throw new TypeError('Positive integer value expected in function combinations');
+  }
+  if (k > n) {
+    throw new TypeError('k must be less than or equal to n');
+  }
+  const nMinusk = n - k;
+  let answer = 1;
+  const firstnumerator = k < nMinusk ? nMinusk + 1 : k + 1;
+  let nextdivisor = 2;
+  const lastdivisor = k < nMinusk ? k : nMinusk;
+  // balance multiplications and divisions to try to keep intermediate values
+  // in exact-integer range as long as possible
+  for (let nextnumerator = firstnumerator; nextnumerator <= n; ++nextnumerator) {
+    answer *= nextnumerator;
+    while (nextdivisor <= lastdivisor && answer % nextdivisor === 0) {
+      answer /= nextdivisor;
+      ++nextdivisor;
+    }
+  }
+  // for big n, k, floating point may have caused weirdness in remainder
+  if (nextdivisor <= lastdivisor) {
+    answer /= (0, _product.product)(nextdivisor, lastdivisor);
+  }
+  return answer;
+}
+combinationsNumber.signature = 'number, number';

node_modules/mathjs/lib/cjs/plain/number/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tau = exports.pi = exports.phi = exports.e = void 0;
+const pi = exports.pi = Math.PI;
+const tau = exports.tau = 2 * Math.PI;
+const e = exports.e = Math.E;
+const phi = exports.phi = 1.6180339887498948; // eslint-disable-line no-loss-of-precision

node_modules/mathjs/lib/cjs/plain/number/index.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _arithmetic = require("./arithmetic.js");
+Object.keys(_arithmetic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _arithmetic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _arithmetic[key];
+    }
+  });
+});
+var _bitwise = require("./bitwise.js");
+Object.keys(_bitwise).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitwise[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bitwise[key];
+    }
+  });
+});
+var _combinations = require("./combinations.js");
+Object.keys(_combinations).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _combinations[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _combinations[key];
+    }
+  });
+});
+var _constants = require("./constants.js");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+var _logical = require("./logical.js");
+Object.keys(_logical).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _logical[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _logical[key];
+    }
+  });
+});
+var _relational = require("./relational.js");
+Object.keys(_relational).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _relational[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _relational[key];
+    }
+  });
+});
+var _probability = require("./probability.js");
+Object.keys(_probability).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _probability[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _probability[key];
+    }
+  });
+});
+var _trigonometry = require("./trigonometry.js");
+Object.keys(_trigonometry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _trigonometry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _trigonometry[key];
+    }
+  });
+});
+var _utils = require("./utils.js");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});

node_modules/mathjs/lib/cjs/plain/number/logical.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.andNumber = andNumber;
+exports.notNumber = notNumber;
+exports.orNumber = orNumber;
+exports.xorNumber = xorNumber;
+const n1 = 'number';
+const n2 = 'number, number';
+function notNumber(x) {
+  return !x;
+}
+notNumber.signature = n1;
+function orNumber(x, y) {
+  return !!(x || y);
+}
+orNumber.signature = n2;
+function xorNumber(x, y) {
+  return !!x !== !!y;
+}
+xorNumber.signature = n2;
+function andNumber(x, y) {
+  return !!(x && y);
+}
+andNumber.signature = n2;

node_modules/mathjs/lib/cjs/plain/number/probability.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gammaG = void 0;
+exports.gammaNumber = gammaNumber;
+exports.lgammaN = exports.lgammaG = exports.gammaP = void 0;
+exports.lgammaNumber = lgammaNumber;
+exports.lnSqrt2PI = exports.lgammaSeries = void 0;
+var _number = require("../../utils/number.js");
+var _product = require("../../utils/product.js");
+/* eslint-disable no-loss-of-precision */
+
+function gammaNumber(n) {
+  let x;
+  if ((0, _number.isInteger)(n)) {
+    if (n <= 0) {
+      return isFinite(n) ? Infinity : NaN;
+    }
+    if (n > 171) {
+      return Infinity; // Will overflow
+    }
+    return (0, _product.product)(1, n - 1);
+  }
+  if (n < 0.5) {
+    return Math.PI / (Math.sin(Math.PI * n) * gammaNumber(1 - n));
+  }
+  if (n >= 171.35) {
+    return Infinity; // will overflow
+  }
+  if (n > 85.0) {
+    // Extended Stirling Approx
+    const twoN = n * n;
+    const threeN = twoN * n;
+    const fourN = threeN * n;
+    const fiveN = fourN * n;
+    return Math.sqrt(2 * Math.PI / n) * Math.pow(n / Math.E, n) * (1 + 1 / (12 * n) + 1 / (288 * twoN) - 139 / (51840 * threeN) - 571 / (2488320 * fourN) + 163879 / (209018880 * fiveN) + 5246819 / (75246796800 * fiveN * n));
+  }
+  --n;
+  x = gammaP[0];
+  for (let i = 1; i < gammaP.length; ++i) {
+    x += gammaP[i] / (n + i);
+  }
+  const t = n + gammaG + 0.5;
+  return Math.sqrt(2 * Math.PI) * Math.pow(t, n + 0.5) * Math.exp(-t) * x;
+}
+gammaNumber.signature = 'number';
+
+// TODO: comment on the variables g and p
+
+const gammaG = exports.gammaG = 4.7421875;
+const gammaP = exports.gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5];
+
+// lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
+
+// log(2 * pi) / 2
+const lnSqrt2PI = exports.lnSqrt2PI = 0.91893853320467274178;
+const lgammaG = exports.lgammaG = 5; // Lanczos parameter "g"
+const lgammaN = exports.lgammaN = 7; // Range of coefficients "n"
+
+const lgammaSeries = exports.lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+function lgammaNumber(n) {
+  if (n < 0) return NaN;
+  if (n === 0) return Infinity;
+  if (!isFinite(n)) return n;
+  if (n < 0.5) {
+    // Use Euler's reflection formula:
+    // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))
+    return Math.log(Math.PI / Math.sin(Math.PI * n)) - lgammaNumber(1 - n);
+  }
+
+  // Compute the logarithm of the Gamma function using the Lanczos method
+
+  n = n - 1;
+  const base = n + lgammaG + 0.5; // Base of the Lanczos exponential
+  let sum = lgammaSeries[0];
+
+  // We start with the terms that have the smallest coefficients and largest denominator
+  for (let i = lgammaN - 1; i >= 1; i--) {
+    sum += lgammaSeries[i] / (n + i);
+  }
+  return lnSqrt2PI + (n + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+lgammaNumber.signature = 'number';

node_modules/mathjs/lib/cjs/plain/number/relational.js

@@ -0,0 +1 @@
+"use strict";

node_modules/mathjs/lib/cjs/plain/number/trigonometry.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acosNumber = acosNumber;
+exports.acoshNumber = acoshNumber;
+exports.acotNumber = acotNumber;
+exports.acothNumber = acothNumber;
+exports.acscNumber = acscNumber;
+exports.acschNumber = acschNumber;
+exports.asecNumber = asecNumber;
+exports.asechNumber = asechNumber;
+exports.asinNumber = asinNumber;
+exports.asinhNumber = asinhNumber;
+exports.atan2Number = atan2Number;
+exports.atanNumber = atanNumber;
+exports.atanhNumber = atanhNumber;
+exports.cosNumber = cosNumber;
+exports.coshNumber = coshNumber;
+exports.cotNumber = cotNumber;
+exports.cothNumber = cothNumber;
+exports.cscNumber = cscNumber;
+exports.cschNumber = cschNumber;
+exports.secNumber = secNumber;
+exports.sechNumber = sechNumber;
+exports.sinNumber = sinNumber;
+exports.sinhNumber = sinhNumber;
+exports.tanNumber = tanNumber;
+exports.tanhNumber = tanhNumber;
+var _number = require("../../utils/number.js");
+const n1 = 'number';
+const n2 = 'number, number';
+function acosNumber(x) {
+  return Math.acos(x);
+}
+acosNumber.signature = n1;
+function acoshNumber(x) {
+  return (0, _number.acosh)(x);
+}
+acoshNumber.signature = n1;
+function acotNumber(x) {
+  return Math.atan(1 / x);
+}
+acotNumber.signature = n1;
+function acothNumber(x) {
+  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+}
+acothNumber.signature = n1;
+function acscNumber(x) {
+  return Math.asin(1 / x);
+}
+acscNumber.signature = n1;
+function acschNumber(x) {
+  const xInv = 1 / x;
+  return Math.log(xInv + Math.sqrt(xInv * xInv + 1));
+}
+acschNumber.signature = n1;
+function asecNumber(x) {
+  return Math.acos(1 / x);
+}
+asecNumber.signature = n1;
+function asechNumber(x) {
+  const xInv = 1 / x;
+  const ret = Math.sqrt(xInv * xInv - 1);
+  return Math.log(ret + xInv);
+}
+asechNumber.signature = n1;
+function asinNumber(x) {
+  return Math.asin(x);
+}
+asinNumber.signature = n1;
+function asinhNumber(x) {
+  return (0, _number.asinh)(x);
+}
+asinhNumber.signature = n1;
+function atanNumber(x) {
+  return Math.atan(x);
+}
+atanNumber.signature = n1;
+function atan2Number(y, x) {
+  return Math.atan2(y, x);
+}
+atan2Number.signature = n2;
+function atanhNumber(x) {
+  return (0, _number.atanh)(x);
+}
+atanhNumber.signature = n1;
+function cosNumber(x) {
+  return Math.cos(x);
+}
+cosNumber.signature = n1;
+function coshNumber(x) {
+  return (0, _number.cosh)(x);
+}
+coshNumber.signature = n1;
+function cotNumber(x) {
+  return 1 / Math.tan(x);
+}
+cotNumber.signature = n1;
+function cothNumber(x) {
+  const e = Math.exp(2 * x);
+  return (e + 1) / (e - 1);
+}
+cothNumber.signature = n1;
+function cscNumber(x) {
+  return 1 / Math.sin(x);
+}
+cscNumber.signature = n1;
+function cschNumber(x) {
+  // consider values close to zero (+/-)
+  if (x === 0) {
+    return Number.POSITIVE_INFINITY;
+  } else {
+    return Math.abs(2 / (Math.exp(x) - Math.exp(-x))) * (0, _number.sign)(x);
+  }
+}
+cschNumber.signature = n1;
+function secNumber(x) {
+  return 1 / Math.cos(x);
+}
+secNumber.signature = n1;
+function sechNumber(x) {
+  return 2 / (Math.exp(x) + Math.exp(-x));
+}
+sechNumber.signature = n1;
+function sinNumber(x) {
+  return Math.sin(x);
+}
+sinNumber.signature = n1;
+function sinhNumber(x) {
+  return (0, _number.sinh)(x);
+}
+sinhNumber.signature = n1;
+function tanNumber(x) {
+  return Math.tan(x);
+}
+tanNumber.signature = n1;
+function tanhNumber(x) {
+  return (0, _number.tanh)(x);
+}
+tanhNumber.signature = n1;

node_modules/mathjs/lib/cjs/plain/number/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIntegerNumber = isIntegerNumber;
+exports.isNaNNumber = isNaNNumber;
+exports.isNegativeNumber = isNegativeNumber;
+exports.isPositiveNumber = isPositiveNumber;
+exports.isZeroNumber = isZeroNumber;
+var _number = require("../../utils/number.js");
+const n1 = 'number';
+function isIntegerNumber(x) {
+  return (0, _number.isInteger)(x);
+}
+isIntegerNumber.signature = n1;
+function isNegativeNumber(x) {
+  return x < 0;
+}
+isNegativeNumber.signature = n1;
+function isPositiveNumber(x) {
+  return x > 0;
+}
+isPositiveNumber.signature = n1;
+function isZeroNumber(x) {
+  return x === 0;
+}
+isZeroNumber.signature = n1;
+function isNaNNumber(x) {
+  return Number.isNaN(x);
+}
+isNaNNumber.signature = n1;