summaryrefslogtreecommitdiffstats
path: root/node_modules/big.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/big.js')
-rw-r--r--node_modules/big.js/CHANGELOG.md146
-rw-r--r--node_modules/big.js/LICENCE23
-rw-r--r--node_modules/big.js/README.md201
-rw-r--r--node_modules/big.js/big.js941
-rw-r--r--node_modules/big.js/big.min.js2
-rw-r--r--node_modules/big.js/big.mjs924
-rw-r--r--node_modules/big.js/package.json77
7 files changed, 2314 insertions, 0 deletions
diff --git a/node_modules/big.js/CHANGELOG.md b/node_modules/big.js/CHANGELOG.md
new file mode 100644
index 0000000..8626255
--- /dev/null
+++ b/node_modules/big.js/CHANGELOG.md
@@ -0,0 +1,146 @@
+#### 5.2.2
+
+* 18/10/18
+* #109 Remove opencollective dependency.
+
+#### 5.2.1
+
+* Delete *bower.json*.
+
+#### 5.2.0
+
+* 09/10/18
+* #63 Allow negative argument for `round`.
+* #107 `sqrt` of large number.
+
+#### 5.1.2
+
+* 24/05/18
+* #95 Add `browser` field to *package.json*.
+* Restore named export to enable `import {Big}`.
+
+#### 5.1.1
+
+* 22/05/18
+* #95 Remove named export.
+
+#### 5.1.0
+
+* 22/05/18
+* Amend *.mjs* exports.
+* Remove extension from `main` field in *package.json*.
+
+#### 5.0.3
+
+* 23/10/17
+* #89 Optimisation of internal `round` function.
+
+#### 5.0.2
+
+* 13/10/17
+* Update *README.md*.
+
+#### 5.0.1
+
+* 13/10/17
+* Correct `Big.version` number.
+
+#### 5.0.0
+
+* 13/10/17
+* Return `-0` from `valueOf` for negative zero.
+* Refactor the methods which return a string.
+* Amend error messaging.
+* Update API document and change its colour scheme.
+* Add `Big.version`.
+* Remove bitcoin address.
+
+#### 4.0.2
+
+* 28/09/17
+* Add *big.mjs* for use with Node.js with `--experimental-modules` flag.
+
+#### 4.0.0
+
+* 27/09/17
+* Rename `Big.E_POS` to `Big.PE`, `Big.E_NEG` to `Big.NE`.
+* Refactor error messaging.
+* Throw if `null` is passed to `toFixed` etc.
+
+#### 3.2.0
+
+* 14/09/17 Aid ES6 import.
+
+#### 3.1.3
+
+* Minor documentation updates.
+
+#### 3.1.2
+
+* README typo.
+
+#### 3.1.1
+
+* API documentation update, including FAQ additions.
+
+#### 3.1.0
+
+* Renamed and exposed `TO_EXP_NEG` and `TO_EXP_POS` as `Big.E_NEG` and `Big.E_POS`.
+
+#### 3.0.2
+
+* Remove *.npmignore*, use `files` field in *package.json* instead.
+
+#### 3.0.1
+
+* Added `sub`, `add` and `mul` aliases.
+* Clean-up after lint.
+
+#### 3.0.0
+
+* 10/12/14 Added [multiple constructor functionality](http://mikemcl.github.io/big.js/#faq).
+* No breaking changes or other additions, but a major code reorganisation, so *v3* seemed appropiate.
+
+#### 2.5.2
+
+* 1/11/14 Added bower.json.
+
+#### 2.5.1
+
+* 8/06/14 Amend README requires.
+
+#### 2.5.0
+
+* 26/01/14 Added `toJSON` method so serialization uses `toString`.
+
+#### 2.4.1
+
+* 17/10/13 Conform signed zero to IEEEE 754 (2008).
+
+#### 2.4.0
+
+* 19/09/13 Throw instances of `Error`.
+
+#### 2.3.0
+
+* 16/09/13 Added `cmp` method.
+
+#### 2.2.0
+
+* 11/07/13 Added 'round up' mode.
+
+#### 2.1.0
+
+* 26/06/13 Allow e.g. `.1` and `2.`.
+
+#### 2.0.0
+
+* 12/05/13 Added `abs` method and replaced `cmp` with `eq`, `gt`, `gte`, `lt`, and `lte` methods.
+
+#### 1.0.1
+
+* Changed default value of MAX_DP to 1E6
+
+#### 1.0.0
+
+* 7/11/2012 Initial release
diff --git a/node_modules/big.js/LICENCE b/node_modules/big.js/LICENCE
new file mode 100644
index 0000000..f7e12c8
--- /dev/null
+++ b/node_modules/big.js/LICENCE
@@ -0,0 +1,23 @@
+The MIT Licence (Expat).
+
+Copyright (c) 2018 Michael Mclaughlin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/node_modules/big.js/README.md b/node_modules/big.js/README.md
new file mode 100644
index 0000000..8d103e6
--- /dev/null
+++ b/node_modules/big.js/README.md
@@ -0,0 +1,201 @@
+# big.js
+
+**A small, fast JavaScript library for arbitrary-precision decimal arithmetic.**
+
+The little sister to [bignumber.js](https://github.com/MikeMcl/bignumber.js/) and [decimal.js](https://github.com/MikeMcl/decimal.js/). See [here](https://github.com/MikeMcl/big.js/wiki) for some notes on the difference between them.
+
+## Features
+
+ - Faster, smaller and easier-to-use than JavaScript versions of Java's BigDecimal
+ - Only 5.9 KB minified and 2.7 KB gzipped
+ - Simple API
+ - Replicates the `toExponential`, `toFixed` and `toPrecision` methods of JavaScript's Number type
+ - Includes a `sqrt` method
+ - Stores values in an accessible decimal floating point format
+ - No dependencies
+ - Comprehensive [documentation](http://mikemcl.github.io/big.js/) and test set
+
+## Set up
+
+The library is the single JavaScript file *big.js* (or *big.min.js*, which is *big.js* minified).
+
+Browser:
+
+```html
+<script src='path/to/big.js'></script>
+```
+
+[Node.js](http://nodejs.org):
+
+```bash
+$ npm install big.js
+```
+
+```javascript
+const Big = require('big.js');
+```
+
+ES6 module:
+
+```javascript
+import Big from 'big.mjs';
+```
+## Use
+
+*In all examples below, `var`, semicolons and `toString` calls are not shown. If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*
+
+The library exports a single function, `Big`, the constructor of Big number instances.
+It accepts a value of type number, string or Big number object.
+
+ x = new Big(123.4567)
+ y = Big('123456.7e-3') // 'new' is optional
+ z = new Big(x)
+ x.eq(y) && x.eq(z) && y.eq(z) // true
+
+A Big number is immutable in the sense that it is not changed by its methods.
+
+ 0.3 - 0.1 // 0.19999999999999998
+ x = new Big(0.3)
+ x.minus(0.1) // "0.2"
+ x // "0.3"
+
+The methods that return a Big number can be chained.
+
+ x.div(y).plus(z).times(9).minus('1.234567801234567e+8').plus(976.54321).div('2598.11772')
+ x.sqrt().div(y).pow(3).gt(y.mod(z)) // true
+
+Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods.
+
+ x = new Big(255.5)
+ x.toExponential(5) // "2.55500e+2"
+ x.toFixed(5) // "255.50000"
+ x.toPrecision(5) // "255.50"
+
+The arithmetic methods always return the exact result except `div`, `sqrt` and `pow`
+(with negative exponent), as these methods involve division.
+
+The maximum number of decimal places and the rounding mode used to round the results of these methods is determined by the value of the `DP` and `RM` properties of the `Big` number constructor.
+
+ Big.DP = 10
+ Big.RM = 1
+
+ x = new Big(2);
+ y = new Big(3);
+ z = x.div(y) // "0.6666666667"
+ z.sqrt() // "0.8164965809"
+ z.pow(-3) // "3.3749999995"
+ z.times(z) // "0.44444444448888888889"
+ z.times(z).round(10) // "0.4444444445"
+
+Multiple Big number constructors can be created, each with an independent configuration.
+
+The value of a Big number is stored in a decimal floating point format in terms of a coefficient, exponent and sign.
+
+ x = new Big(-123.456);
+ x.c // [1,2,3,4,5,6] coefficient (i.e. significand)
+ x.e // 2 exponent
+ x.s // -1 sign
+
+For further information see the [API](http://mikemcl.github.io/big.js/) reference from the *doc* folder.
+
+## Test
+
+The *test* directory contains the test scripts for each Big number method.
+
+The tests can be run with Node.js or a browser.
+
+To run all the tests
+
+ $ npm test
+
+To test a single method
+
+ $ node test/toFixed
+
+For the browser, see *single-test.html* and *every-test.html* in the *test/browser* directory.
+
+*big-vs-number.html* is a simple application that enables some of the methods of big.js to be compared with those of JavaScript's Number type.
+
+## Performance
+
+The *perf* directory contains two legacy applications and a *lib* directory containing the BigDecimal libraries used by both.
+
+*big-vs-bigdecimal.html* tests the performance of big.js against the JavaScript translations of two versions of BigDecimal, its use should be more or less self-explanatory.
+
+* [GWT: java.math.BigDecimal](https://github.com/iriscouch/bigdecimal.js)
+* [ICU4J: com.ibm.icu.math.BigDecimal](https://github.com/dtrebbien/BigDecimal.js)
+
+The BigDecimal in the npm registry is the GWT version. It has some bugs, see the Node.js script *perf/lib/bigdecimal_GWT/bugs.js* for examples of flaws in its *remainder*, *divide* and *compareTo* methods.
+
+*bigtime.js* is a Node.js command-line application which tests the performance of big.js against the GWT version of
+BigDecimal from the npm registry.
+
+For example, to compare the time taken by the big.js `plus` method and the BigDecimal `add` method
+
+ $ node bigtime plus 10000 40
+
+This will time 10000 calls to each, using operands of up to 40 random digits and will check that the results match.
+
+For help
+
+ $ node bigtime -h
+
+## Build
+
+If [uglify-js](https://github.com/mishoo/UglifyJS2) is installed globally
+
+ $ npm install uglify-js -g
+
+then
+
+ $ npm run build
+
+will create *big.min.js*.
+
+## TypeScript
+
+The [DefinitelyTyped](https://github.com/borisyankov/DefinitelyTyped) project has a Typescript type definitions file for big.js.
+
+ $ npm install @types/big.js
+
+Any questions about the TypeScript type definitions file should be addressed to the DefinitelyTyped project.
+
+## Feedback
+
+Bugs/comments/questions?
+
+Open an issue, or email <a href="mailto:M8ch88l@gmail.com">Michael</a>
+
+## Licence
+
+[MIT](LICENCE)
+
+## Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+<a href="graphs/contributors"><img src="https://opencollective.com/bigjs/contributors.svg?width=890&button=false" /></a>
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/bigjs#backer)]
+
+<a href="https://opencollective.com/bigjs#backers" target="_blank"><img src="https://opencollective.com/bigjs/backers.svg?width=890"></a>
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/bigjs#sponsor)]
+
+<a href="https://opencollective.com/bigjs/sponsor/0/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/1/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/2/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/3/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/4/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/5/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/6/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/7/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/8/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/bigjs/sponsor/9/website" target="_blank"><img src="https://opencollective.com/bigjs/sponsor/9/avatar.svg"></a>
+
+
diff --git a/node_modules/big.js/big.js b/node_modules/big.js/big.js
new file mode 100644
index 0000000..a2f201a
--- /dev/null
+++ b/node_modules/big.js/big.js
@@ -0,0 +1,941 @@
+/*
+ * big.js v5.2.2
+ * A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
+ * Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
+ * https://github.com/MikeMcl/big.js/LICENCE
+ */
+;(function (GLOBAL) {
+ 'use strict';
+ var Big,
+
+
+/************************************** EDITABLE DEFAULTS *****************************************/
+
+
+ // The default values below must be integers within the stated ranges.
+
+ /*
+ * The maximum number of decimal places (DP) of the results of operations involving division:
+ * div and sqrt, and pow with negative exponents.
+ */
+ DP = 20, // 0 to MAX_DP
+
+ /*
+ * The rounding mode (RM) used when rounding to the above decimal places.
+ *
+ * 0 Towards zero (i.e. truncate, no rounding). (ROUND_DOWN)
+ * 1 To nearest neighbour. If equidistant, round up. (ROUND_HALF_UP)
+ * 2 To nearest neighbour. If equidistant, to even. (ROUND_HALF_EVEN)
+ * 3 Away from zero. (ROUND_UP)
+ */
+ RM = 1, // 0, 1, 2 or 3
+
+ // The maximum value of DP and Big.DP.
+ MAX_DP = 1E6, // 0 to 1000000
+
+ // The maximum magnitude of the exponent argument to the pow method.
+ MAX_POWER = 1E6, // 1 to 1000000
+
+ /*
+ * The negative exponent (NE) at and beneath which toString returns exponential notation.
+ * (JavaScript numbers: -7)
+ * -1000000 is the minimum recommended exponent value of a Big.
+ */
+ NE = -7, // 0 to -1000000
+
+ /*
+ * The positive exponent (PE) at and above which toString returns exponential notation.
+ * (JavaScript numbers: 21)
+ * 1000000 is the maximum recommended exponent value of a Big.
+ * (This limit is not enforced or checked.)
+ */
+ PE = 21, // 0 to 1000000
+
+
+/**************************************************************************************************/
+
+
+ // Error messages.
+ NAME = '[big.js] ',
+ INVALID = NAME + 'Invalid ',
+ INVALID_DP = INVALID + 'decimal places',
+ INVALID_RM = INVALID + 'rounding mode',
+ DIV_BY_ZERO = NAME + 'Division by zero',
+
+ // The shared prototype object.
+ P = {},
+ UNDEFINED = void 0,
+ NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+
+
+ /*
+ * Create and return a Big constructor.
+ *
+ */
+ function _Big_() {
+
+ /*
+ * The Big constructor and exported function.
+ * Create and return a new instance of a Big number object.
+ *
+ * n {number|string|Big} A numeric value.
+ */
+ function Big(n) {
+ var x = this;
+
+ // Enable constructor usage without new.
+ if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);
+
+ // Duplicate.
+ if (n instanceof Big) {
+ x.s = n.s;
+ x.e = n.e;
+ x.c = n.c.slice();
+ } else {
+ parse(x, n);
+ }
+
+ /*
+ * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
+ * points to Object.
+ */
+ x.constructor = Big;
+ }
+
+ Big.prototype = P;
+ Big.DP = DP;
+ Big.RM = RM;
+ Big.NE = NE;
+ Big.PE = PE;
+ Big.version = '5.2.2';
+
+ return Big;
+ }
+
+
+ /*
+ * Parse the number or string value passed to a Big constructor.
+ *
+ * x {Big} A Big number instance.
+ * n {number|string} A numeric value.
+ */
+ function parse(x, n) {
+ var e, i, nl;
+
+ // Minus zero?
+ if (n === 0 && 1 / n < 0) n = '-0';
+ else if (!NUMERIC.test(n += '')) throw Error(INVALID + 'number');
+
+ // Determine sign.
+ x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;
+
+ // Decimal point?
+ if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');
+
+ // Exponential form?
+ if ((i = n.search(/e/i)) > 0) {
+
+ // Determine exponent.
+ if (e < 0) e = i;
+ e += +n.slice(i + 1);
+ n = n.substring(0, i);
+ } else if (e < 0) {
+
+ // Integer.
+ e = n.length;
+ }
+
+ nl = n.length;
+
+ // Determine leading zeros.
+ for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
+
+ if (i == nl) {
+
+ // Zero.
+ x.c = [x.e = 0];
+ } else {
+
+ // Determine trailing zeros.
+ for (; nl > 0 && n.charAt(--nl) == '0';);
+ x.e = e - i - 1;
+ x.c = [];
+
+ // Convert string to array of digits without leading/trailing zeros.
+ for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
+ }
+
+ return x;
+ }
+
+
+ /*
+ * Round Big x to a maximum of dp decimal places using rounding mode rm.
+ * Called by stringify, P.div, P.round and P.sqrt.
+ *
+ * x {Big} The Big to round.
+ * dp {number} Integer, 0 to MAX_DP inclusive.
+ * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
+ * [more] {boolean} Whether the result of division was truncated.
+ */
+ function round(x, dp, rm, more) {
+ var xc = x.c,
+ i = x.e + dp + 1;
+
+ if (i < xc.length) {
+ if (rm === 1) {
+
+ // xc[i] is the digit after the digit that may be rounded up.
+ more = xc[i] >= 5;
+ } else if (rm === 2) {
+ more = xc[i] > 5 || xc[i] == 5 &&
+ (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);
+ } else if (rm === 3) {
+ more = more || !!xc[0];
+ } else {
+ more = false;
+ if (rm !== 0) throw Error(INVALID_RM);
+ }
+
+ if (i < 1) {
+ xc.length = 1;
+
+ if (more) {
+
+ // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+ x.e = -dp;
+ xc[0] = 1;
+ } else {
+
+ // Zero.
+ xc[0] = x.e = 0;
+ }
+ } else {
+
+ // Remove any digits after the required decimal places.
+ xc.length = i--;
+
+ // Round up?
+ if (more) {
+
+ // Rounding up may mean the previous digit has to be rounded up.
+ for (; ++xc[i] > 9;) {
+ xc[i] = 0;
+ if (!i--) {
+ ++x.e;
+ xc.unshift(1);
+ }
+ }
+ }
+
+ // Remove trailing zeros.
+ for (i = xc.length; !xc[--i];) xc.pop();
+ }
+ } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
+ throw Error(INVALID_RM);
+ }
+
+ return x;
+ }
+
+
+ /*
+ * Return a string representing the value of Big x in normal or exponential notation.
+ * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
+ *
+ * x {Big}
+ * id? {number} Caller id.
+ * 1 toExponential
+ * 2 toFixed
+ * 3 toPrecision
+ * 4 valueOf
+ * n? {number|undefined} Caller's argument.
+ * k? {number|undefined}
+ */
+ function stringify(x, id, n, k) {
+ var e, s,
+ Big = x.constructor,
+ z = !x.c[0];
+
+ if (n !== UNDEFINED) {
+ if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
+ throw Error(id == 3 ? INVALID + 'precision' : INVALID_DP);
+ }
+
+ x = new Big(x);
+
+ // The index of the digit that may be rounded up.
+ n = k - x.e;
+
+ // Round?
+ if (x.c.length > ++k) round(x, n, Big.RM);
+
+ // toFixed: recalculate k as x.e may have changed if value rounded up.
+ if (id == 2) k = x.e + n + 1;
+
+ // Append zeros?
+ for (; x.c.length < k;) x.c.push(0);
+ }
+
+ e = x.e;
+ s = x.c.join('');
+ n = s.length;
+
+ // Exponential notation?
+ if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {
+ s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
+
+ // Normal notation.
+ } else if (e < 0) {
+ for (; ++e;) s = '0' + s;
+ s = '0.' + s;
+ } else if (e > 0) {
+ if (++e > n) for (e -= n; e--;) s += '0';
+ else if (e < n) s = s.slice(0, e) + '.' + s.slice(e);
+ } else if (n > 1) {
+ s = s.charAt(0) + '.' + s.slice(1);
+ }
+
+ return x.s < 0 && (!z || id == 4) ? '-' + s : s;
+ }
+
+
+ // Prototype/instance methods
+
+
+ /*
+ * Return a new Big whose value is the absolute value of this Big.
+ */
+ P.abs = function () {
+ var x = new this.constructor(this);
+ x.s = 1;
+ return x;
+ };
+
+
+ /*
+ * Return 1 if the value of this Big is greater than the value of Big y,
+ * -1 if the value of this Big is less than the value of Big y, or
+ * 0 if they have the same value.
+ */
+ P.cmp = function (y) {
+ var isneg,
+ x = this,
+ xc = x.c,
+ yc = (y = new x.constructor(y)).c,
+ i = x.s,
+ j = y.s,
+ k = x.e,
+ l = y.e;
+
+ // Either zero?
+ if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
+
+ // Signs differ?
+ if (i != j) return i;
+
+ isneg = i < 0;
+
+ // Compare exponents.
+ if (k != l) return k > l ^ isneg ? 1 : -1;
+
+ j = (k = xc.length) < (l = yc.length) ? k : l;
+
+ // Compare digit by digit.
+ for (i = -1; ++i < j;) {
+ if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+ }
+
+ // Compare lengths.
+ return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
+ * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+ */
+ P.div = function (y) {
+ var x = this,
+ Big = x.constructor,
+ a = x.c, // dividend
+ b = (y = new Big(y)).c, // divisor
+ k = x.s == y.s ? 1 : -1,
+ dp = Big.DP;
+
+ if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+
+ // Divisor is zero?
+ if (!b[0]) throw Error(DIV_BY_ZERO);
+
+ // Dividend is 0? Return +-0.
+ if (!a[0]) return new Big(k * 0);
+
+ var bl, bt, n, cmp, ri,
+ bz = b.slice(),
+ ai = bl = b.length,
+ al = a.length,
+ r = a.slice(0, bl), // remainder
+ rl = r.length,
+ q = y, // quotient
+ qc = q.c = [],
+ qi = 0,
+ d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result
+
+ q.s = k;
+ k = d < 0 ? 0 : d;
+
+ // Create version of divisor with leading zero.
+ bz.unshift(0);
+
+ // Add zeros to make remainder as long as divisor.
+ for (; rl++ < bl;) r.push(0);
+
+ do {
+
+ // n is how many times the divisor goes into current remainder.
+ for (n = 0; n < 10; n++) {
+
+ // Compare divisor and remainder.
+ if (bl != (rl = r.length)) {
+ cmp = bl > rl ? 1 : -1;
+ } else {
+ for (ri = -1, cmp = 0; ++ri < bl;) {
+ if (b[ri] != r[ri]) {
+ cmp = b[ri] > r[ri] ? 1 : -1;
+ break;
+ }
+ }
+ }
+
+ // If divisor < remainder, subtract divisor from remainder.
+ if (cmp < 0) {
+
+ // Remainder can't be more than 1 digit longer than divisor.
+ // Equalise lengths using divisor with extra leading zero?
+ for (bt = rl == bl ? b : bz; rl;) {
+ if (r[--rl] < bt[rl]) {
+ ri = rl;
+ for (; ri && !r[--ri];) r[ri] = 9;
+ --r[ri];
+ r[rl] += 10;
+ }
+ r[rl] -= bt[rl];
+ }
+
+ for (; !r[0];) r.shift();
+ } else {
+ break;
+ }
+ }
+
+ // Add the digit n to the result array.
+ qc[qi++] = cmp ? n : ++n;
+
+ // Update the remainder.
+ if (r[0] && cmp) r[rl] = a[ai] || 0;
+ else r = [a[ai]];
+
+ } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+
+ // Leading zero? Do not remove if result is simply zero (qi == 1).
+ if (!qc[0] && qi != 1) {
+
+ // There can't be more than one zero.
+ qc.shift();
+ q.e--;
+ }
+
+ // Round?
+ if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);
+
+ return q;
+ };
+
+
+ /*
+ * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
+ */
+ P.eq = function (y) {
+ return !this.cmp(y);
+ };
+
+
+ /*
+ * Return true if the value of this Big is greater than the value of Big y, otherwise return
+ * false.
+ */
+ P.gt = function (y) {
+ return this.cmp(y) > 0;
+ };
+
+
+ /*
+ * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
+ * return false.
+ */
+ P.gte = function (y) {
+ return this.cmp(y) > -1;
+ };
+
+
+ /*
+ * Return true if the value of this Big is less than the value of Big y, otherwise return false.
+ */
+ P.lt = function (y) {
+ return this.cmp(y) < 0;
+ };
+
+
+ /*
+ * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
+ * return false.
+ */
+ P.lte = function (y) {
+ return this.cmp(y) < 1;
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big minus the value of Big y.
+ */
+ P.minus = P.sub = function (y) {
+ var i, j, t, xlty,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ // Signs differ?
+ if (a != b) {
+ y.s = -b;
+ return x.plus(y);
+ }
+
+ var xc = x.c.slice(),
+ xe = x.e,
+ yc = y.c,
+ ye = y.e;
+
+ // Either zero?
+ if (!xc[0] || !yc[0]) {
+
+ // y is non-zero? x is non-zero? Or both are zero.
+ return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);
+ }
+
+ // Determine which is the bigger number. Prepend zeros to equalise exponents.
+ if (a = xe - ye) {
+
+ if (xlty = a < 0) {
+ a = -a;
+ t = xc;
+ } else {
+ ye = xe;
+ t = yc;
+ }
+
+ t.reverse();
+ for (b = a; b--;) t.push(0);
+ t.reverse();
+ } else {
+
+ // Exponents equal. Check digit by digit.
+ j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+
+ for (a = b = 0; b < j; b++) {
+ if (xc[b] != yc[b]) {
+ xlty = xc[b] < yc[b];
+ break;
+ }
+ }
+ }
+
+ // x < y? Point xc to the array of the bigger number.
+ if (xlty) {
+ t = xc;
+ xc = yc;
+ yc = t;
+ y.s = -y.s;
+ }
+
+ /*
+ * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
+ * needs to start at yc.length.
+ */
+ if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;
+
+ // Subtract yc from xc.
+ for (b = i; j > a;) {
+ if (xc[--j] < yc[j]) {
+ for (i = j; i && !xc[--i];) xc[i] = 9;
+ --xc[i];
+ xc[j] += 10;
+ }
+
+ xc[j] -= yc[j];
+ }
+
+ // Remove trailing zeros.
+ for (; xc[--b] === 0;) xc.pop();
+
+ // Remove leading zeros and adjust exponent accordingly.
+ for (; xc[0] === 0;) {
+ xc.shift();
+ --ye;
+ }
+
+ if (!xc[0]) {
+
+ // n - n = +0
+ y.s = 1;
+
+ // Result must be zero.
+ xc = [ye = 0];
+ }
+
+ y.c = xc;
+ y.e = ye;
+
+ return y;
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big modulo the value of Big y.
+ */
+ P.mod = function (y) {
+ var ygtx,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ if (!y.c[0]) throw Error(DIV_BY_ZERO);
+
+ x.s = y.s = 1;
+ ygtx = y.cmp(x) == 1;
+ x.s = a;
+ y.s = b;
+
+ if (ygtx) return new Big(x);
+
+ a = Big.DP;
+ b = Big.RM;
+ Big.DP = Big.RM = 0;
+ x = x.div(y);
+ Big.DP = a;
+ Big.RM = b;
+
+ return this.minus(x.times(y));
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big plus the value of Big y.
+ */
+ P.plus = P.add = function (y) {
+ var t,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ // Signs differ?
+ if (a != b) {
+ y.s = -b;
+ return x.minus(y);
+ }
+
+ var xe = x.e,
+ xc = x.c,
+ ye = y.e,
+ yc = y.c;
+
+ // Either zero? y is non-zero? x is non-zero? Or both are zero.
+ if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);
+
+ xc = xc.slice();
+
+ // Prepend zeros to equalise exponents.
+ // Note: reverse faster than unshifts.
+ if (a = xe - ye) {
+ if (a > 0) {
+ ye = xe;
+ t = yc;
+ } else {
+ a = -a;
+ t = xc;
+ }
+
+ t.reverse();
+ for (; a--;) t.push(0);
+ t.reverse();
+ }
+
+ // Point xc to the longer array.
+ if (xc.length - yc.length < 0) {
+ t = yc;
+ yc = xc;
+ xc = t;
+ }
+
+ a = yc.length;
+
+ // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
+ for (b = 0; a; xc[a] %= 10) b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;
+
+ // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+
+ if (b) {
+ xc.unshift(b);
+ ++ye;
+ }
+
+ // Remove trailing zeros.
+ for (a = xc.length; xc[--a] === 0;) xc.pop();
+
+ y.c = xc;
+ y.e = ye;
+
+ return y;
+ };
+
+
+ /*
+ * Return a Big whose value is the value of this Big raised to the power n.
+ * If n is negative, round to a maximum of Big.DP decimal places using rounding
+ * mode Big.RM.
+ *
+ * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
+ */
+ P.pow = function (n) {
+ var x = this,
+ one = new x.constructor(1),
+ y = one,
+ isneg = n < 0;
+
+ if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + 'exponent');
+ if (isneg) n = -n;
+
+ for (;;) {
+ if (n & 1) y = y.times(x);
+ n >>= 1;
+ if (!n) break;
+ x = x.times(x);
+ }
+
+ return isneg ? one.div(y) : y;
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big rounded using rounding mode rm
+ * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
+ * multiple of 10**-dp.
+ * If dp is not specified, round to 0 decimal places.
+ * If rm is not specified, use Big.RM.
+ *
+ * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
+ * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
+ */
+ P.round = function (dp, rm) {
+ var Big = this.constructor;
+ if (dp === UNDEFINED) dp = 0;
+ else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
+ return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
+ };
+
+
+ /*
+ * Return a new Big whose value is the square root of the value of this Big, rounded, if
+ * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+ */
+ P.sqrt = function () {
+ var r, c, t,
+ x = this,
+ Big = x.constructor,
+ s = x.s,
+ e = x.e,
+ half = new Big(0.5);
+
+ // Zero?
+ if (!x.c[0]) return new Big(x);
+
+ // Negative?
+ if (s < 0) throw Error(NAME + 'No square root');
+
+ // Estimate.
+ s = Math.sqrt(x + '');
+
+ // Math.sqrt underflow/overflow?
+ // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
+ if (s === 0 || s === 1 / 0) {
+ c = x.c.join('');
+ if (!(c.length + e & 1)) c += '0';
+ s = Math.sqrt(c);
+ e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
+ r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
+ } else {
+ r = new Big(s);
+ }
+
+ e = r.e + (Big.DP += 4);
+
+ // Newton-Raphson iteration.
+ do {
+ t = r;
+ r = half.times(t.plus(x.div(t)));
+ } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
+
+ return round(r, Big.DP -= 4, Big.RM);
+ };
+
+
+ /*
+ * Return a new Big whose value is the value of this Big times the value of Big y.
+ */
+ P.times = P.mul = function (y) {
+ var c,
+ x = this,
+ Big = x.constructor,
+ xc = x.c,
+ yc = (y = new Big(y)).c,
+ a = xc.length,
+ b = yc.length,
+ i = x.e,
+ j = y.e;
+
+ // Determine sign of result.
+ y.s = x.s == y.s ? 1 : -1;
+
+ // Return signed 0 if either 0.
+ if (!xc[0] || !yc[0]) return new Big(y.s * 0);
+
+ // Initialise exponent of result as x.e + y.e.
+ y.e = i + j;
+
+ // If array xc has fewer digits than yc, swap xc and yc, and lengths.
+ if (a < b) {
+ c = xc;
+ xc = yc;
+ yc = c;
+ j = a;
+ a = b;
+ b = j;
+ }
+
+ // Initialise coefficient array of result with zeros.
+ for (c = new Array(j = a + b); j--;) c[j] = 0;
+
+ // Multiply.
+
+ // i is initially xc.length.
+ for (i = b; i--;) {
+ b = 0;
+
+ // a is yc.length.
+ for (j = a + i; j > i;) {
+
+ // Current sum of products at this digit position, plus carry.
+ b = c[j] + yc[i] * xc[j - i - 1] + b;
+ c[j--] = b % 10;
+
+ // carry
+ b = b / 10 | 0;
+ }
+
+ c[j] = (c[j] + b) % 10;
+ }
+
+ // Increment result exponent if there is a final carry, otherwise remove leading zero.
+ if (b) ++y.e;
+ else c.shift();
+
+ // Remove trailing zeros.
+ for (i = c.length; !c[--i];) c.pop();
+ y.c = c;
+
+ return y;
+ };
+
+
+ /*
+ * Return a string representing the value of this Big in exponential notation to dp fixed decimal
+ * places and rounded using Big.RM.
+ *
+ * dp? {number} Integer, 0 to MAX_DP inclusive.
+ */
+ P.toExponential = function (dp) {
+ return stringify(this, 1, dp, dp);
+ };
+
+
+ /*
+ * Return a string representing the value of this Big in normal notation to dp fixed decimal
+ * places and rounded using Big.RM.
+ *
+ * dp? {number} Integer, 0 to MAX_DP inclusive.
+ *
+ * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+ * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+ */
+ P.toFixed = function (dp) {
+ return stringify(this, 2, dp, this.e + dp);
+ };
+
+
+ /*
+ * Return a string representing the value of this Big rounded to sd significant digits using
+ * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
+ * the integer part of the value in normal notation.
+ *
+ * sd {number} Integer, 1 to MAX_DP inclusive.
+ */
+ P.toPrecision = function (sd) {
+ return stringify(this, 3, sd, sd - 1);
+ };
+
+
+ /*
+ * Return a string representing the value of this Big.
+ * Return exponential notation if this Big has a positive exponent equal to or greater than
+ * Big.PE, or a negative exponent equal to or less than Big.NE.
+ * Omit the sign for negative zero.
+ */
+ P.toString = function () {
+ return stringify(this);
+ };
+
+
+ /*
+ * Return a string representing the value of this Big.
+ * Return exponential notation if this Big has a positive exponent equal to or greater than
+ * Big.PE, or a negative exponent equal to or less than Big.NE.
+ * Include the sign for negative zero.
+ */
+ P.valueOf = P.toJSON = function () {
+ return stringify(this, 4);
+ };
+
+
+ // Export
+
+
+ Big = _Big_();
+
+ Big['default'] = Big.Big = Big;
+
+ //AMD.
+ if (typeof define === 'function' && define.amd) {
+ define(function () { return Big; });
+
+ // Node and other CommonJS-like environments that support module.exports.
+ } else if (typeof module !== 'undefined' && module.exports) {
+ module.exports = Big;
+
+ //Browser.
+ } else {
+ GLOBAL.Big = Big;
+ }
+})(this);
diff --git a/node_modules/big.js/big.min.js b/node_modules/big.js/big.min.js
new file mode 100644
index 0000000..0fb1b68
--- /dev/null
+++ b/node_modules/big.js/big.min.js
@@ -0,0 +1,2 @@
+/* big.js v5.2.2 https://github.com/MikeMcl/big.js/LICENCE */
+!function(e){"use strict";var r,i=20,s=1,P=1e6,o=-7,f=21,c="[big.js] ",u=c+"Invalid ",b=u+"decimal places",h=u+"rounding mode",x=c+"Division by zero",l={},D=void 0,a=/^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;function R(e,r,t,n){var i=e.c,s=e.e+r+1;if(s<i.length){if(1===t)n=5<=i[s];else if(2===t)n=5<i[s]||5==i[s]&&(n||s<0||i[s+1]!==D||1&i[s-1]);else if(3===t)n=n||!!i[0];else if(n=!1,0!==t)throw Error(h);if(s<1)i.length=1,i[0]=n?(e.e=-r,1):e.e=0;else{if(i.length=s--,n)for(;9<++i[s];)i[s]=0,s--||(++e.e,i.unshift(1));for(s=i.length;!i[--s];)i.pop()}}else if(t<0||3<t||t!==~~t)throw Error(h);return e}function t(e,r,t,n){var i,s,o=e.constructor,f=!e.c[0];if(t!==D){if(t!==~~t||t<(3==r)||P<t)throw Error(3==r?u+"precision":b);for(t=n-(e=new o(e)).e,e.c.length>++n&&R(e,t,o.RM),2==r&&(n=e.e+t+1);e.c.length<n;)e.c.push(0)}if(i=e.e,t=(s=e.c.join("")).length,2!=r&&(1==r||3==r&&n<=i||i<=o.NE||i>=o.PE))s=s.charAt(0)+(1<t?"."+s.slice(1):"")+(i<0?"e":"e+")+i;else if(i<0){for(;++i;)s="0"+s;s="0."+s}else if(0<i)if(++i>t)for(i-=t;i--;)s+="0";else i<t&&(s=s.slice(0,i)+"."+s.slice(i));else 1<t&&(s=s.charAt(0)+"."+s.slice(1));return e.s<0&&(!f||4==r)?"-"+s:s}l.abs=function(){var e=new this.constructor(this);return e.s=1,e},l.cmp=function(e){var r,t=this,n=t.c,i=(e=new t.constructor(e)).c,s=t.s,o=e.s,f=t.e,c=e.e;if(!n[0]||!i[0])return n[0]?s:i[0]?-o:0;if(s!=o)return s;if(r=s<0,f!=c)return c<f^r?1:-1;for(o=(f=n.length)<(c=i.length)?f:c,s=-1;++s<o;)if(n[s]!=i[s])return n[s]>i[s]^r?1:-1;return f==c?0:c<f^r?1:-1},l.div=function(e){var r=this,t=r.constructor,n=r.c,i=(e=new t(e)).c,s=r.s==e.s?1:-1,o=t.DP;if(o!==~~o||o<0||P<o)throw Error(b);if(!i[0])throw Error(x);if(!n[0])return new t(0*s);var f,c,u,h,l,a=i.slice(),g=f=i.length,p=n.length,w=n.slice(0,f),d=w.length,v=e,m=v.c=[],E=0,M=o+(v.e=r.e-e.e)+1;for(v.s=s,s=M<0?0:M,a.unshift(0);d++<f;)w.push(0);do{for(u=0;u<10;u++){if(f!=(d=w.length))h=d<f?1:-1;else for(l=-1,h=0;++l<f;)if(i[l]!=w[l]){h=i[l]>w[l]?1:-1;break}if(!(h<0))break;for(c=d==f?i:a;d;){if(w[--d]<c[d]){for(l=d;l&&!w[--l];)w[l]=9;--w[l],w[d]+=10}w[d]-=c[d]}for(;!w[0];)w.shift()}m[E++]=h?u:++u,w[0]&&h?w[d]=n[g]||0:w=[n[g]]}while((g++<p||w[0]!==D)&&s--);return m[0]||1==E||(m.shift(),v.e--),M<E&&R(v,o,t.RM,w[0]!==D),v},l.eq=function(e){return!this.cmp(e)},l.gt=function(e){return 0<this.cmp(e)},l.gte=function(e){return-1<this.cmp(e)},l.lt=function(e){return this.cmp(e)<0},l.lte=function(e){return this.cmp(e)<1},l.minus=l.sub=function(e){var r,t,n,i,s=this,o=s.constructor,f=s.s,c=(e=new o(e)).s;if(f!=c)return e.s=-c,s.plus(e);var u=s.c.slice(),h=s.e,l=e.c,a=e.e;if(!u[0]||!l[0])return l[0]?(e.s=-c,e):new o(u[0]?s:0);if(f=h-a){for((n=(i=f<0)?(f=-f,u):(a=h,l)).reverse(),c=f;c--;)n.push(0);n.reverse()}else for(t=((i=u.length<l.length)?u:l).length,f=c=0;c<t;c++)if(u[c]!=l[c]){i=u[c]<l[c];break}if(i&&(n=u,u=l,l=n,e.s=-e.s),0<(c=(t=l.length)-(r=u.length)))for(;c--;)u[r++]=0;for(c=r;f<t;){if(u[--t]<l[t]){for(r=t;r&&!u[--r];)u[r]=9;--u[r],u[t]+=10}u[t]-=l[t]}for(;0===u[--c];)u.pop();for(;0===u[0];)u.shift(),--a;return u[0]||(e.s=1,u=[a=0]),e.c=u,e.e=a,e},l.mod=function(e){var r,t=this,n=t.constructor,i=t.s,s=(e=new n(e)).s;if(!e.c[0])throw Error(x);return t.s=e.s=1,r=1==e.cmp(t),t.s=i,e.s=s,r?new n(t):(i=n.DP,s=n.RM,n.DP=n.RM=0,t=t.div(e),n.DP=i,n.RM=s,this.minus(t.times(e)))},l.plus=l.add=function(e){var r,t=this,n=t.constructor,i=t.s,s=(e=new n(e)).s;if(i!=s)return e.s=-s,t.minus(e);var o=t.e,f=t.c,c=e.e,u=e.c;if(!f[0]||!u[0])return u[0]?e:new n(f[0]?t:0*i);if(f=f.slice(),i=o-c){for((r=0<i?(c=o,u):(i=-i,f)).reverse();i--;)r.push(0);r.reverse()}for(f.length-u.length<0&&(r=u,u=f,f=r),i=u.length,s=0;i;f[i]%=10)s=(f[--i]=f[i]+u[i]+s)/10|0;for(s&&(f.unshift(s),++c),i=f.length;0===f[--i];)f.pop();return e.c=f,e.e=c,e},l.pow=function(e){var r=this,t=new r.constructor(1),n=t,i=e<0;if(e!==~~e||e<-1e6||1e6<e)throw Error(u+"exponent");for(i&&(e=-e);1&e&&(n=n.times(r)),e>>=1;)r=r.times(r);return i?t.div(n):n},l.round=function(e,r){var t=this.constructor;if(e===D)e=0;else if(e!==~~e||e<-P||P<e)throw Error(b);return R(new t(this),e,r===D?t.RM:r)},l.sqrt=function(){var e,r,t,n=this,i=n.constructor,s=n.s,o=n.e,f=new i(.5);if(!n.c[0])return new i(n);if(s<0)throw Error(c+"No square root");for(o=(e=0===(s=Math.sqrt(n+""))||s===1/0?((r=n.c.join("")).length+o&1||(r+="0"),o=((o+1)/2|0)-(o<0||1&o),new i(((s=Math.sqrt(r))==1/0?"1e":(s=s.toExponential()).slice(0,s.indexOf("e")+1))+o)):new i(s)).e+(i.DP+=4);t=e,e=f.times(t.plus(n.div(t))),t.c.slice(0,o).join("")!==e.c.slice(0,o).join(""););return R(e,i.DP-=4,i.RM)},l.times=l.mul=function(e){var r,t=this.constructor,n=this.c,i=(e=new t(e)).c,s=n.length,o=i.length,f=this.e,c=e.e;if(e.s=this.s==e.s?1:-1,!n[0]||!i[0])return new t(0*e.s);for(e.e=f+c,s<o&&(r=n,n=i,i=r,c=s,s=o,o=c),r=new Array(c=s+o);c--;)r[c]=0;for(f=o;f--;){for(o=0,c=s+f;f<c;)o=r[c]+i[f]*n[c-f-1]+o,r[c--]=o%10,o=o/10|0;r[c]=(r[c]+o)%10}for(o?++e.e:r.shift(),f=r.length;!r[--f];)r.pop();return e.c=r,e},l.toExponential=function(e){return t(this,1,e,e)},l.toFixed=function(e){return t(this,2,e,this.e+e)},l.toPrecision=function(e){return t(this,3,e,e-1)},l.toString=function(){return t(this)},l.valueOf=l.toJSON=function(){return t(this,4)},(r=function t(){function n(e){var r=this;if(!(r instanceof n))return e===D?t():new n(e);e instanceof n?(r.s=e.s,r.e=e.e,r.c=e.c.slice()):function(e,r){var t,n,i;if(0===r&&1/r<0)r="-0";else if(!a.test(r+=""))throw Error(u+"number");for(e.s="-"==r.charAt(0)?(r=r.slice(1),-1):1,-1<(t=r.indexOf("."))&&(r=r.replace(".","")),0<(n=r.search(/e/i))?(t<0&&(t=n),t+=+r.slice(n+1),r=r.substring(0,n)):t<0&&(t=r.length),i=r.length,n=0;n<i&&"0"==r.charAt(n);)++n;if(n==i)e.c=[e.e=0];else{for(;0<i&&"0"==r.charAt(--i););for(e.e=t-n-1,e.c=[],t=0;n<=i;)e.c[t++]=+r.charAt(n++)}}(r,e),r.constructor=n}return n.prototype=l,n.DP=i,n.RM=s,n.NE=o,n.PE=f,n.version="5.2.2",n}()).default=r.Big=r,"function"==typeof define&&define.amd?define(function(){return r}):"undefined"!=typeof module&&module.exports?module.exports=r:e.Big=r}(this); \ No newline at end of file
diff --git a/node_modules/big.js/big.mjs b/node_modules/big.js/big.mjs
new file mode 100644
index 0000000..5fe5f20
--- /dev/null
+++ b/node_modules/big.js/big.mjs
@@ -0,0 +1,924 @@
+/*
+ * big.js v5.2.2
+ * A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
+ * Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
+ * https://github.com/MikeMcl/big.js/LICENCE
+ */
+
+
+/************************************** EDITABLE DEFAULTS *****************************************/
+
+
+ // The default values below must be integers within the stated ranges.
+
+ /*
+ * The maximum number of decimal places (DP) of the results of operations involving division:
+ * div and sqrt, and pow with negative exponents.
+ */
+var DP = 20, // 0 to MAX_DP
+
+ /*
+ * The rounding mode (RM) used when rounding to the above decimal places.
+ *
+ * 0 Towards zero (i.e. truncate, no rounding). (ROUND_DOWN)
+ * 1 To nearest neighbour. If equidistant, round up. (ROUND_HALF_UP)
+ * 2 To nearest neighbour. If equidistant, to even. (ROUND_HALF_EVEN)
+ * 3 Away from zero. (ROUND_UP)
+ */
+ RM = 1, // 0, 1, 2 or 3
+
+ // The maximum value of DP and Big.DP.
+ MAX_DP = 1E6, // 0 to 1000000
+
+ // The maximum magnitude of the exponent argument to the pow method.
+ MAX_POWER = 1E6, // 1 to 1000000
+
+ /*
+ * The negative exponent (NE) at and beneath which toString returns exponential notation.
+ * (JavaScript numbers: -7)
+ * -1000000 is the minimum recommended exponent value of a Big.
+ */
+ NE = -7, // 0 to -1000000
+
+ /*
+ * The positive exponent (PE) at and above which toString returns exponential notation.
+ * (JavaScript numbers: 21)
+ * 1000000 is the maximum recommended exponent value of a Big.
+ * (This limit is not enforced or checked.)
+ */
+ PE = 21, // 0 to 1000000
+
+
+/**************************************************************************************************/
+
+
+ // Error messages.
+ NAME = '[big.js] ',
+ INVALID = NAME + 'Invalid ',
+ INVALID_DP = INVALID + 'decimal places',
+ INVALID_RM = INVALID + 'rounding mode',
+ DIV_BY_ZERO = NAME + 'Division by zero',
+
+ // The shared prototype object.
+ P = {},
+ UNDEFINED = void 0,
+ NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+
+
+/*
+ * Create and return a Big constructor.
+ *
+ */
+function _Big_() {
+
+ /*
+ * The Big constructor and exported function.
+ * Create and return a new instance of a Big number object.
+ *
+ * n {number|string|Big} A numeric value.
+ */
+ function Big(n) {
+ var x = this;
+
+ // Enable constructor usage without new.
+ if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);
+
+ // Duplicate.
+ if (n instanceof Big) {
+ x.s = n.s;
+ x.e = n.e;
+ x.c = n.c.slice();
+ } else {
+ parse(x, n);
+ }
+
+ /*
+ * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
+ * points to Object.
+ */
+ x.constructor = Big;
+ }
+
+ Big.prototype = P;
+ Big.DP = DP;
+ Big.RM = RM;
+ Big.NE = NE;
+ Big.PE = PE;
+ Big.version = '5.2.2';
+
+ return Big;
+}
+
+
+/*
+ * Parse the number or string value passed to a Big constructor.
+ *
+ * x {Big} A Big number instance.
+ * n {number|string} A numeric value.
+ */
+function parse(x, n) {
+ var e, i, nl;
+
+ // Minus zero?
+ if (n === 0 && 1 / n < 0) n = '-0';
+ else if (!NUMERIC.test(n += '')) throw Error(INVALID + 'number');
+
+ // Determine sign.
+ x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;
+
+ // Decimal point?
+ if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');
+
+ // Exponential form?
+ if ((i = n.search(/e/i)) > 0) {
+
+ // Determine exponent.
+ if (e < 0) e = i;
+ e += +n.slice(i + 1);
+ n = n.substring(0, i);
+ } else if (e < 0) {
+
+ // Integer.
+ e = n.length;
+ }
+
+ nl = n.length;
+
+ // Determine leading zeros.
+ for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
+
+ if (i == nl) {
+
+ // Zero.
+ x.c = [x.e = 0];
+ } else {
+
+ // Determine trailing zeros.
+ for (; nl > 0 && n.charAt(--nl) == '0';);
+ x.e = e - i - 1;
+ x.c = [];
+
+ // Convert string to array of digits without leading/trailing zeros.
+ for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
+ }
+
+ return x;
+}
+
+
+/*
+ * Round Big x to a maximum of dp decimal places using rounding mode rm.
+ * Called by stringify, P.div, P.round and P.sqrt.
+ *
+ * x {Big} The Big to round.
+ * dp {number} Integer, 0 to MAX_DP inclusive.
+ * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
+ * [more] {boolean} Whether the result of division was truncated.
+ */
+function round(x, dp, rm, more) {
+ var xc = x.c,
+ i = x.e + dp + 1;
+
+ if (i < xc.length) {
+ if (rm === 1) {
+
+ // xc[i] is the digit after the digit that may be rounded up.
+ more = xc[i] >= 5;
+ } else if (rm === 2) {
+ more = xc[i] > 5 || xc[i] == 5 &&
+ (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);
+ } else if (rm === 3) {
+ more = more || !!xc[0];
+ } else {
+ more = false;
+ if (rm !== 0) throw Error(INVALID_RM);
+ }
+
+ if (i < 1) {
+ xc.length = 1;
+
+ if (more) {
+
+ // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+ x.e = -dp;
+ xc[0] = 1;
+ } else {
+
+ // Zero.
+ xc[0] = x.e = 0;
+ }
+ } else {
+
+ // Remove any digits after the required decimal places.
+ xc.length = i--;
+
+ // Round up?
+ if (more) {
+
+ // Rounding up may mean the previous digit has to be rounded up.
+ for (; ++xc[i] > 9;) {
+ xc[i] = 0;
+ if (!i--) {
+ ++x.e;
+ xc.unshift(1);
+ }
+ }
+ }
+
+ // Remove trailing zeros.
+ for (i = xc.length; !xc[--i];) xc.pop();
+ }
+ } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
+ throw Error(INVALID_RM);
+ }
+
+ return x;
+}
+
+
+/*
+ * Return a string representing the value of Big x in normal or exponential notation.
+ * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
+ *
+ * x {Big}
+ * id? {number} Caller id.
+ * 1 toExponential
+ * 2 toFixed
+ * 3 toPrecision
+ * 4 valueOf
+ * n? {number|undefined} Caller's argument.
+ * k? {number|undefined}
+ */
+function stringify(x, id, n, k) {
+ var e, s,
+ Big = x.constructor,
+ z = !x.c[0];
+
+ if (n !== UNDEFINED) {
+ if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
+ throw Error(id == 3 ? INVALID + 'precision' : INVALID_DP);
+ }
+
+ x = new Big(x);
+
+ // The index of the digit that may be rounded up.
+ n = k - x.e;
+
+ // Round?
+ if (x.c.length > ++k) round(x, n, Big.RM);
+
+ // toFixed: recalculate k as x.e may have changed if value rounded up.
+ if (id == 2) k = x.e + n + 1;
+
+ // Append zeros?
+ for (; x.c.length < k;) x.c.push(0);
+ }
+
+ e = x.e;
+ s = x.c.join('');
+ n = s.length;
+
+ // Exponential notation?
+ if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {
+ s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
+
+ // Normal notation.
+ } else if (e < 0) {
+ for (; ++e;) s = '0' + s;
+ s = '0.' + s;
+ } else if (e > 0) {
+ if (++e > n) for (e -= n; e--;) s += '0';
+ else if (e < n) s = s.slice(0, e) + '.' + s.slice(e);
+ } else if (n > 1) {
+ s = s.charAt(0) + '.' + s.slice(1);
+ }
+
+ return x.s < 0 && (!z || id == 4) ? '-' + s : s;
+}
+
+
+// Prototype/instance methods
+
+
+/*
+ * Return a new Big whose value is the absolute value of this Big.
+ */
+P.abs = function () {
+ var x = new this.constructor(this);
+ x.s = 1;
+ return x;
+};
+
+
+/*
+ * Return 1 if the value of this Big is greater than the value of Big y,
+ * -1 if the value of this Big is less than the value of Big y, or
+ * 0 if they have the same value.
+*/
+P.cmp = function (y) {
+ var isneg,
+ x = this,
+ xc = x.c,
+ yc = (y = new x.constructor(y)).c,
+ i = x.s,
+ j = y.s,
+ k = x.e,
+ l = y.e;
+
+ // Either zero?
+ if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
+
+ // Signs differ?
+ if (i != j) return i;
+
+ isneg = i < 0;
+
+ // Compare exponents.
+ if (k != l) return k > l ^ isneg ? 1 : -1;
+
+ j = (k = xc.length) < (l = yc.length) ? k : l;
+
+ // Compare digit by digit.
+ for (i = -1; ++i < j;) {
+ if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+ }
+
+ // Compare lengths.
+ return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
+ * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+ */
+P.div = function (y) {
+ var x = this,
+ Big = x.constructor,
+ a = x.c, // dividend
+ b = (y = new Big(y)).c, // divisor
+ k = x.s == y.s ? 1 : -1,
+ dp = Big.DP;
+
+ if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+
+ // Divisor is zero?
+ if (!b[0]) throw Error(DIV_BY_ZERO);
+
+ // Dividend is 0? Return +-0.
+ if (!a[0]) return new Big(k * 0);
+
+ var bl, bt, n, cmp, ri,
+ bz = b.slice(),
+ ai = bl = b.length,
+ al = a.length,
+ r = a.slice(0, bl), // remainder
+ rl = r.length,
+ q = y, // quotient
+ qc = q.c = [],
+ qi = 0,
+ d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result
+
+ q.s = k;
+ k = d < 0 ? 0 : d;
+
+ // Create version of divisor with leading zero.
+ bz.unshift(0);
+
+ // Add zeros to make remainder as long as divisor.
+ for (; rl++ < bl;) r.push(0);
+
+ do {
+
+ // n is how many times the divisor goes into current remainder.
+ for (n = 0; n < 10; n++) {
+
+ // Compare divisor and remainder.
+ if (bl != (rl = r.length)) {
+ cmp = bl > rl ? 1 : -1;
+ } else {
+ for (ri = -1, cmp = 0; ++ri < bl;) {
+ if (b[ri] != r[ri]) {
+ cmp = b[ri] > r[ri] ? 1 : -1;
+ break;
+ }
+ }
+ }
+
+ // If divisor < remainder, subtract divisor from remainder.
+ if (cmp < 0) {
+
+ // Remainder can't be more than 1 digit longer than divisor.
+ // Equalise lengths using divisor with extra leading zero?
+ for (bt = rl == bl ? b : bz; rl;) {
+ if (r[--rl] < bt[rl]) {
+ ri = rl;
+ for (; ri && !r[--ri];) r[ri] = 9;
+ --r[ri];
+ r[rl] += 10;
+ }
+ r[rl] -= bt[rl];
+ }
+
+ for (; !r[0];) r.shift();
+ } else {
+ break;
+ }
+ }
+
+ // Add the digit n to the result array.
+ qc[qi++] = cmp ? n : ++n;
+
+ // Update the remainder.
+ if (r[0] && cmp) r[rl] = a[ai] || 0;
+ else r = [a[ai]];
+
+ } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+
+ // Leading zero? Do not remove if result is simply zero (qi == 1).
+ if (!qc[0] && qi != 1) {
+
+ // There can't be more than one zero.
+ qc.shift();
+ q.e--;
+ }
+
+ // Round?
+ if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);
+
+ return q;
+};
+
+
+/*
+ * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
+ */
+P.eq = function (y) {
+ return !this.cmp(y);
+};
+
+
+/*
+ * Return true if the value of this Big is greater than the value of Big y, otherwise return
+ * false.
+ */
+P.gt = function (y) {
+ return this.cmp(y) > 0;
+};
+
+
+/*
+ * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
+ * return false.
+ */
+P.gte = function (y) {
+ return this.cmp(y) > -1;
+};
+
+
+/*
+ * Return true if the value of this Big is less than the value of Big y, otherwise return false.
+ */
+P.lt = function (y) {
+ return this.cmp(y) < 0;
+};
+
+
+/*
+ * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
+ * return false.
+ */
+P.lte = function (y) {
+ return this.cmp(y) < 1;
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big minus the value of Big y.
+ */
+P.minus = P.sub = function (y) {
+ var i, j, t, xlty,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ // Signs differ?
+ if (a != b) {
+ y.s = -b;
+ return x.plus(y);
+ }
+
+ var xc = x.c.slice(),
+ xe = x.e,
+ yc = y.c,
+ ye = y.e;
+
+ // Either zero?
+ if (!xc[0] || !yc[0]) {
+
+ // y is non-zero? x is non-zero? Or both are zero.
+ return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);
+ }
+
+ // Determine which is the bigger number. Prepend zeros to equalise exponents.
+ if (a = xe - ye) {
+
+ if (xlty = a < 0) {
+ a = -a;
+ t = xc;
+ } else {
+ ye = xe;
+ t = yc;
+ }
+
+ t.reverse();
+ for (b = a; b--;) t.push(0);
+ t.reverse();
+ } else {
+
+ // Exponents equal. Check digit by digit.
+ j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+
+ for (a = b = 0; b < j; b++) {
+ if (xc[b] != yc[b]) {
+ xlty = xc[b] < yc[b];
+ break;
+ }
+ }
+ }
+
+ // x < y? Point xc to the array of the bigger number.
+ if (xlty) {
+ t = xc;
+ xc = yc;
+ yc = t;
+ y.s = -y.s;
+ }
+
+ /*
+ * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
+ * needs to start at yc.length.
+ */
+ if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;
+
+ // Subtract yc from xc.
+ for (b = i; j > a;) {
+ if (xc[--j] < yc[j]) {
+ for (i = j; i && !xc[--i];) xc[i] = 9;
+ --xc[i];
+ xc[j] += 10;
+ }
+
+ xc[j] -= yc[j];
+ }
+
+ // Remove trailing zeros.
+ for (; xc[--b] === 0;) xc.pop();
+
+ // Remove leading zeros and adjust exponent accordingly.
+ for (; xc[0] === 0;) {
+ xc.shift();
+ --ye;
+ }
+
+ if (!xc[0]) {
+
+ // n - n = +0
+ y.s = 1;
+
+ // Result must be zero.
+ xc = [ye = 0];
+ }
+
+ y.c = xc;
+ y.e = ye;
+
+ return y;
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big modulo the value of Big y.
+ */
+P.mod = function (y) {
+ var ygtx,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ if (!y.c[0]) throw Error(DIV_BY_ZERO);
+
+ x.s = y.s = 1;
+ ygtx = y.cmp(x) == 1;
+ x.s = a;
+ y.s = b;
+
+ if (ygtx) return new Big(x);
+
+ a = Big.DP;
+ b = Big.RM;
+ Big.DP = Big.RM = 0;
+ x = x.div(y);
+ Big.DP = a;
+ Big.RM = b;
+
+ return this.minus(x.times(y));
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big plus the value of Big y.
+ */
+P.plus = P.add = function (y) {
+ var t,
+ x = this,
+ Big = x.constructor,
+ a = x.s,
+ b = (y = new Big(y)).s;
+
+ // Signs differ?
+ if (a != b) {
+ y.s = -b;
+ return x.minus(y);
+ }
+
+ var xe = x.e,
+ xc = x.c,
+ ye = y.e,
+ yc = y.c;
+
+ // Either zero? y is non-zero? x is non-zero? Or both are zero.
+ if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);
+
+ xc = xc.slice();
+
+ // Prepend zeros to equalise exponents.
+ // Note: reverse faster than unshifts.
+ if (a = xe - ye) {
+ if (a > 0) {
+ ye = xe;
+ t = yc;
+ } else {
+ a = -a;
+ t = xc;
+ }
+
+ t.reverse();
+ for (; a--;) t.push(0);
+ t.reverse();
+ }
+
+ // Point xc to the longer array.
+ if (xc.length - yc.length < 0) {
+ t = yc;
+ yc = xc;
+ xc = t;
+ }
+
+ a = yc.length;
+
+ // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
+ for (b = 0; a; xc[a] %= 10) b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;
+
+ // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+
+ if (b) {
+ xc.unshift(b);
+ ++ye;
+ }
+
+ // Remove trailing zeros.
+ for (a = xc.length; xc[--a] === 0;) xc.pop();
+
+ y.c = xc;
+ y.e = ye;
+
+ return y;
+};
+
+
+/*
+ * Return a Big whose value is the value of this Big raised to the power n.
+ * If n is negative, round to a maximum of Big.DP decimal places using rounding
+ * mode Big.RM.
+ *
+ * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
+ */
+P.pow = function (n) {
+ var x = this,
+ one = new x.constructor(1),
+ y = one,
+ isneg = n < 0;
+
+ if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + 'exponent');
+ if (isneg) n = -n;
+
+ for (;;) {
+ if (n & 1) y = y.times(x);
+ n >>= 1;
+ if (!n) break;
+ x = x.times(x);
+ }
+
+ return isneg ? one.div(y) : y;
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big rounded using rounding mode rm
+ * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
+ * multiple of 10**-dp.
+ * If dp is not specified, round to 0 decimal places.
+ * If rm is not specified, use Big.RM.
+ *
+ * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
+ * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
+ */
+P.round = function (dp, rm) {
+ var Big = this.constructor;
+ if (dp === UNDEFINED) dp = 0;
+ else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
+ return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
+};
+
+
+/*
+ * Return a new Big whose value is the square root of the value of this Big, rounded, if
+ * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+ */
+P.sqrt = function () {
+ var r, c, t,
+ x = this,
+ Big = x.constructor,
+ s = x.s,
+ e = x.e,
+ half = new Big(0.5);
+
+ // Zero?
+ if (!x.c[0]) return new Big(x);
+
+ // Negative?
+ if (s < 0) throw Error(NAME + 'No square root');
+
+ // Estimate.
+ s = Math.sqrt(x + '');
+
+ // Math.sqrt underflow/overflow?
+ // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
+ if (s === 0 || s === 1 / 0) {
+ c = x.c.join('');
+ if (!(c.length + e & 1)) c += '0';
+ s = Math.sqrt(c);
+ e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
+ r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
+ } else {
+ r = new Big(s);
+ }
+
+ e = r.e + (Big.DP += 4);
+
+ // Newton-Raphson iteration.
+ do {
+ t = r;
+ r = half.times(t.plus(x.div(t)));
+ } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
+
+ return round(r, Big.DP -= 4, Big.RM);
+};
+
+
+/*
+ * Return a new Big whose value is the value of this Big times the value of Big y.
+ */
+P.times = P.mul = function (y) {
+ var c,
+ x = this,
+ Big = x.constructor,
+ xc = x.c,
+ yc = (y = new Big(y)).c,
+ a = xc.length,
+ b = yc.length,
+ i = x.e,
+ j = y.e;
+
+ // Determine sign of result.
+ y.s = x.s == y.s ? 1 : -1;
+
+ // Return signed 0 if either 0.
+ if (!xc[0] || !yc[0]) return new Big(y.s * 0);
+
+ // Initialise exponent of result as x.e + y.e.
+ y.e = i + j;
+
+ // If array xc has fewer digits than yc, swap xc and yc, and lengths.
+ if (a < b) {
+ c = xc;
+ xc = yc;
+ yc = c;
+ j = a;
+ a = b;
+ b = j;
+ }
+
+ // Initialise coefficient array of result with zeros.
+ for (c = new Array(j = a + b); j--;) c[j] = 0;
+
+ // Multiply.
+
+ // i is initially xc.length.
+ for (i = b; i--;) {
+ b = 0;
+
+ // a is yc.length.
+ for (j = a + i; j > i;) {
+
+ // Current sum of products at this digit position, plus carry.
+ b = c[j] + yc[i] * xc[j - i - 1] + b;
+ c[j--] = b % 10;
+
+ // carry
+ b = b / 10 | 0;
+ }
+
+ c[j] = (c[j] + b) % 10;
+ }
+
+ // Increment result exponent if there is a final carry, otherwise remove leading zero.
+ if (b) ++y.e;
+ else c.shift();
+
+ // Remove trailing zeros.
+ for (i = c.length; !c[--i];) c.pop();
+ y.c = c;
+
+ return y;
+};
+
+
+/*
+ * Return a string representing the value of this Big in exponential notation to dp fixed decimal
+ * places and rounded using Big.RM.
+ *
+ * dp? {number} Integer, 0 to MAX_DP inclusive.
+ */
+P.toExponential = function (dp) {
+ return stringify(this, 1, dp, dp);
+};
+
+
+/*
+ * Return a string representing the value of this Big in normal notation to dp fixed decimal
+ * places and rounded using Big.RM.
+ *
+ * dp? {number} Integer, 0 to MAX_DP inclusive.
+ *
+ * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+ * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+ */
+P.toFixed = function (dp) {
+ return stringify(this, 2, dp, this.e + dp);
+};
+
+
+/*
+ * Return a string representing the value of this Big rounded to sd significant digits using
+ * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
+ * the integer part of the value in normal notation.
+ *
+ * sd {number} Integer, 1 to MAX_DP inclusive.
+ */
+P.toPrecision = function (sd) {
+ return stringify(this, 3, sd, sd - 1);
+};
+
+
+/*
+ * Return a string representing the value of this Big.
+ * Return exponential notation if this Big has a positive exponent equal to or greater than
+ * Big.PE, or a negative exponent equal to or less than Big.NE.
+ * Omit the sign for negative zero.
+ */
+P.toString = function () {
+ return stringify(this);
+};
+
+
+/*
+ * Return a string representing the value of this Big.
+ * Return exponential notation if this Big has a positive exponent equal to or greater than
+ * Big.PE, or a negative exponent equal to or less than Big.NE.
+ * Include the sign for negative zero.
+ */
+P.valueOf = P.toJSON = function () {
+ return stringify(this, 4);
+};
+
+
+// Export
+
+
+export var Big = _Big_();
+
+export default Big;
diff --git a/node_modules/big.js/package.json b/node_modules/big.js/package.json
new file mode 100644
index 0000000..efd135a
--- /dev/null
+++ b/node_modules/big.js/package.json
@@ -0,0 +1,77 @@
+{
+ "_from": "big.js@^5.2.2",
+ "_id": "big.js@5.2.2",
+ "_inBundle": false,
+ "_integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==",
+ "_location": "/big.js",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "big.js@^5.2.2",
+ "name": "big.js",
+ "escapedName": "big.js",
+ "rawSpec": "^5.2.2",
+ "saveSpec": null,
+ "fetchSpec": "^5.2.2"
+ },
+ "_requiredBy": [
+ "/copy-webpack-plugin/loader-utils",
+ "/loader-utils"
+ ],
+ "_resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz",
+ "_shasum": "65f0af382f578bcdc742bd9c281e9cb2d7768328",
+ "_spec": "big.js@^5.2.2",
+ "_where": "/home/pruss/Dev/3-minute-website/node_modules/loader-utils",
+ "author": {
+ "name": "Michael Mclaughlin",
+ "email": "M8ch88l@gmail.com"
+ },
+ "browser": "big.js",
+ "bugs": {
+ "url": "https://github.com/MikeMcl/big.js/issues"
+ },
+ "bundleDependencies": false,
+ "collective": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/bigjs"
+ },
+ "deprecated": false,
+ "description": "A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic",
+ "engines": {
+ "node": "*"
+ },
+ "files": [
+ "big.js",
+ "big.mjs",
+ "big.min.js"
+ ],
+ "homepage": "https://github.com/MikeMcl/big.js#readme",
+ "keywords": [
+ "arbitrary",
+ "precision",
+ "arithmetic",
+ "big",
+ "number",
+ "decimal",
+ "float",
+ "biginteger",
+ "bigdecimal",
+ "bignumber",
+ "bigint",
+ "bignum"
+ ],
+ "license": "MIT",
+ "main": "big",
+ "module": "big.mjs",
+ "name": "big.js",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/MikeMcl/big.js.git"
+ },
+ "scripts": {
+ "build": "uglifyjs big.js --source-map -c -m -o big.min.js",
+ "test": "node ./test/every-test.js"
+ },
+ "version": "5.2.2"
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-23 12:26:58 +0000