feat:node-modules

node_modules/mathjs/lib/cjs/utils/bignumber/constants.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBigNumberTau = exports.createBigNumberPi = exports.createBigNumberPhi = exports.createBigNumberE = void 0;
+var _function = require("../function.js");
+/**
+ * Calculate BigNumber e
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns e
+ */
+const createBigNumberE = exports.createBigNumberE = (0, _function.memoize)(function (BigNumber) {
+  return new BigNumber(1).exp();
+}, {
+  hasher
+});
+
+/**
+ * Calculate BigNumber golden ratio, phi = (1+sqrt(5))/2
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns phi
+ */
+const createBigNumberPhi = exports.createBigNumberPhi = (0, _function.memoize)(function (BigNumber) {
+  return new BigNumber(1).plus(new BigNumber(5).sqrt()).div(2);
+}, {
+  hasher
+});
+
+/**
+ * Calculate BigNumber pi.
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns pi
+ */
+const createBigNumberPi = exports.createBigNumberPi = (0, _function.memoize)(function (BigNumber) {
+  return BigNumber.acos(-1);
+}, {
+  hasher
+});
+
+/**
+ * Calculate BigNumber tau, tau = 2 * pi
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns tau
+ */
+const createBigNumberTau = exports.createBigNumberTau = (0, _function.memoize)(function (BigNumber) {
+  return createBigNumberPi(BigNumber).times(2);
+}, {
+  hasher
+});
+
+/**
+ * Create a hash for a BigNumber constructor function. The created has is
+ * the configured precision
+ * @param {Array} args         Supposed to contain a single entry with
+ *                             a BigNumber constructor
+ * @return {number} precision
+ * @private
+ */
+function hasher(args) {
+  return args[0].precision;
+}

node_modules/mathjs/lib/cjs/utils/bignumber/nearlyEqual.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nearlyEqual = nearlyEqual;
+/**
+ * Compares two BigNumbers.
+ * @param {BigNumber} a - First value to compare
+ * @param {BigNumber} b - Second value to compare
+ * @param {number} [relTol=1e-09] - The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param {number} [absTol=0] - The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @returns {boolean} whether the two numbers are nearly equal
+ * @throws {Error} If `relTol` is less than or equal to 0.
+ * @throws {Error} If `absTol` is less than 0.
+ *
+ * @example
+ * nearlyEqual(1.000000001, 1.0, 1e-9);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);            // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.02);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
+ */
+function nearlyEqual(a, b) {
+  let relTol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1e-9;
+  let absTol = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  if (relTol <= 0) {
+    throw new Error('Relative tolerance must be greater than 0');
+  }
+  if (absTol < 0) {
+    throw new Error('Absolute tolerance must be at least 0');
+  }
+  // NaN
+  if (a.isNaN() || b.isNaN()) {
+    return false;
+  }
+  if (!a.isFinite() || !b.isFinite()) {
+    return a.eq(b);
+  }
+  // use "==" operator, handles infinities
+  if (a.eq(b)) {
+    return true;
+  }
+  // abs(a-b) <= max(relTol * max(abs(a), abs(b)), absTol)
+  return a.minus(b).abs().lte(a.constructor.max(a.constructor.max(a.abs(), b.abs()).mul(relTol), absTol));
+}

node_modules/mathjs/lib/cjs/utils/complex.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.complexEquals = complexEquals;
+var _number = require("./number.js");
+/**
+ * Test whether two complex values are equal provided a given relTol and absTol.
+ * Does not use or change the global Complex.EPSILON setting
+ * @param {Complex} x - The first complex number for comparison.
+ * @param {Complex} y - The second complex number for comparison.
+ * @param {number} relTol - The relative tolerance for comparison.
+ * @param {number} absTol - The absolute tolerance for comparison.
+ * @returns {boolean} - Returns true if the two complex numbers are equal within the given tolerances, otherwise returns false.
+ */
+function complexEquals(x, y, relTol, absTol) {
+  return (0, _number.nearlyEqual)(x.re, y.re, relTol, absTol) && (0, _number.nearlyEqual)(x.im, y.im, relTol, absTol);
+}

node_modules/mathjs/lib/cjs/utils/emitter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mixin = mixin;
+var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
+/**
+ * Extend given object with emitter functions `on`, `off`, `once`, `emit`
+ * @param {Object} obj
+ * @return {Object} obj
+ */
+function mixin(obj) {
+  // create event emitter
+  const emitter = new _tinyEmitter.default();
+
+  // bind methods to obj (we don't want to expose the emitter.e Array...)
+  obj.on = emitter.on.bind(emitter);
+  obj.off = emitter.off.bind(emitter);
+  obj.once = emitter.once.bind(emitter);
+  obj.emit = emitter.emit.bind(emitter);
+  return obj;
+}