From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001 From: Piotr Russ Date: Mon, 16 Nov 2020 00:10:28 +0100 Subject: api, login, auth --- node_modules/big.js/CHANGELOG.md | 146 ++++++ node_modules/big.js/LICENCE | 23 + node_modules/big.js/README.md | 201 +++++++++ node_modules/big.js/big.js | 941 +++++++++++++++++++++++++++++++++++++++ node_modules/big.js/big.min.js | 2 + node_modules/big.js/big.mjs | 924 ++++++++++++++++++++++++++++++++++++++ node_modules/big.js/package.json | 77 ++++ 7 files changed, 2314 insertions(+) create mode 100644 node_modules/big.js/CHANGELOG.md create mode 100644 node_modules/big.js/LICENCE create mode 100644 node_modules/big.js/README.md create mode 100644 node_modules/big.js/big.js create mode 100644 node_modules/big.js/big.min.js create mode 100644 node_modules/big.js/big.mjs create mode 100644 node_modules/big.js/package.json (limited to 'node_modules/big.js') 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 + +``` + +[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 Michael + +## Licence + +[MIT](LICENCE) + +## Contributors + +This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]. + + + +## Backers + +Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/bigjs#backer)] + + + + +## 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)] + + + + + + + + + + + + + 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 + * 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++n&&R(e,t,o.RM),2==r&&(n=e.e+t+1);e.c.length=o.PE))s=s.charAt(0)+(1t)for(i-=t;i--;)s+="0";else ii[s]^r?1:-1;return f==c?0:cw[l]?1:-1;break}if(!(h<0))break;for(c=d==f?i:a;d;){if(w[--d]>=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 + * 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" +} -- cgit v1.2.3