{"version":3,"file":"big.js","sources":["../../../node_modules/big.js/big.mjs"],"sourcesContent":["/*\r\n * big.js v6.2.1\r\n * A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\r\n * Copyright (c) 2022 Michael Mclaughlin\r\n * https://github.com/MikeMcl/big.js/LICENCE.md\r\n */\r\n\r\n\r\n/************************************** EDITABLE DEFAULTS *****************************************/\r\n\r\n\r\n // The default values below must be integers within the stated ranges.\r\n\r\n /*\r\n * The maximum number of decimal places (DP) of the results of operations involving division:\r\n * div and sqrt, and pow with negative exponents.\r\n */\r\nvar DP = 20, // 0 to MAX_DP\r\n\r\n /*\r\n * The rounding mode (RM) used when rounding to the above decimal places.\r\n *\r\n * 0 Towards zero (i.e. truncate, no rounding). (ROUND_DOWN)\r\n * 1 To nearest neighbour. If equidistant, round up. (ROUND_HALF_UP)\r\n * 2 To nearest neighbour. If equidistant, to even. (ROUND_HALF_EVEN)\r\n * 3 Away from zero. (ROUND_UP)\r\n */\r\n RM = 1, // 0, 1, 2 or 3\r\n\r\n // The maximum value of DP and Big.DP.\r\n MAX_DP = 1E6, // 0 to 1000000\r\n\r\n // The maximum magnitude of the exponent argument to the pow method.\r\n MAX_POWER = 1E6, // 1 to 1000000\r\n\r\n /*\r\n * The negative exponent (NE) at and beneath which toString returns exponential notation.\r\n * (JavaScript numbers: -7)\r\n * -1000000 is the minimum recommended exponent value of a Big.\r\n */\r\n NE = -7, // 0 to -1000000\r\n\r\n /*\r\n * The positive exponent (PE) at and above which toString returns exponential notation.\r\n * (JavaScript numbers: 21)\r\n * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.\r\n */\r\n PE = 21, // 0 to 1000000\r\n\r\n /*\r\n * When true, an error will be thrown if a primitive number is passed to the Big constructor,\r\n * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a\r\n * primitive number without a loss of precision.\r\n */\r\n STRICT = false, // true or false\r\n\r\n\r\n/**************************************************************************************************/\r\n\r\n\r\n // Error messages.\r\n NAME = '[big.js] ',\r\n INVALID = NAME + 'Invalid ',\r\n INVALID_DP = INVALID + 'decimal places',\r\n INVALID_RM = INVALID + 'rounding mode',\r\n DIV_BY_ZERO = NAME + 'Division by zero',\r\n\r\n // The shared prototype object.\r\n P = {},\r\n UNDEFINED = void 0,\r\n NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\r\n\r\n\r\n/*\r\n * Create and return a Big constructor.\r\n */\r\nfunction _Big_() {\r\n\r\n /*\r\n * The Big constructor and exported function.\r\n * Create and return a new instance of a Big number object.\r\n *\r\n * n {number|string|Big} A numeric value.\r\n */\r\n function Big(n) {\r\n var x = this;\r\n\r\n // Enable constructor usage without new.\r\n if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);\r\n\r\n // Duplicate.\r\n if (n instanceof Big) {\r\n x.s = n.s;\r\n x.e = n.e;\r\n x.c = n.c.slice();\r\n } else {\r\n if (typeof n !== 'string') {\r\n if (Big.strict === true && typeof n !== 'bigint') {\r\n throw TypeError(INVALID + 'value');\r\n }\r\n\r\n // Minus zero?\r\n n = n === 0 && 1 / n < 0 ? '-0' : String(n);\r\n }\r\n\r\n parse(x, n);\r\n }\r\n\r\n // Retain a reference to this Big constructor.\r\n // Shadow Big.prototype.constructor which points to Object.\r\n x.constructor = Big;\r\n }\r\n\r\n Big.prototype = P;\r\n Big.DP = DP;\r\n Big.RM = RM;\r\n Big.NE = NE;\r\n Big.PE = PE;\r\n Big.strict = STRICT;\r\n Big.roundDown = 0;\r\n Big.roundHalfUp = 1;\r\n Big.roundHalfEven = 2;\r\n Big.roundUp = 3;\r\n\r\n return Big;\r\n}\r\n\r\n\r\n/*\r\n * Parse the number or string value passed to a Big constructor.\r\n *\r\n * x {Big} A Big number instance.\r\n * n {number|string} A numeric value.\r\n */\r\nfunction parse(x, n) {\r\n var e, i, nl;\r\n\r\n if (!NUMERIC.test(n)) {\r\n throw Error(INVALID + 'number');\r\n }\r\n\r\n // Determine sign.\r\n x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\r\n\r\n // Decimal point?\r\n if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');\r\n\r\n // Exponential form?\r\n if ((i = n.search(/e/i)) > 0) {\r\n\r\n // Determine exponent.\r\n if (e < 0) e = i;\r\n e += +n.slice(i + 1);\r\n n = n.substring(0, i);\r\n } else if (e < 0) {\r\n\r\n // Integer.\r\n e = n.length;\r\n }\r\n\r\n nl = n.length;\r\n\r\n // Determine leading zeros.\r\n for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\r\n\r\n if (i == nl) {\r\n\r\n // Zero.\r\n x.c = [x.e = 0];\r\n } else {\r\n\r\n // Determine trailing zeros.\r\n for (; nl > 0 && n.charAt(--nl) == '0';);\r\n x.e = e - i - 1;\r\n x.c = [];\r\n\r\n // Convert string to array of digits without leading/trailing zeros.\r\n for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\r\n }\r\n\r\n return x;\r\n}\r\n\r\n\r\n/*\r\n * Round Big x to a maximum of sd significant digits using rounding mode rm.\r\n *\r\n * x {Big} The Big to round.\r\n * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.\r\n * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n * [more] {boolean} Whether the result of division was truncated.\r\n */\r\nfunction round(x, sd, rm, more) {\r\n var xc = x.c;\r\n\r\n if (rm === UNDEFINED) rm = x.constructor.RM;\r\n if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {\r\n throw Error(INVALID_RM);\r\n }\r\n\r\n if (sd < 1) {\r\n more =\r\n rm === 3 && (more || !!xc[0]) || sd === 0 && (\r\n rm === 1 && xc[0] >= 5 ||\r\n rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED))\r\n );\r\n\r\n xc.length = 1;\r\n\r\n if (more) {\r\n\r\n // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n x.e = x.e - sd + 1;\r\n xc[0] = 1;\r\n } else {\r\n\r\n // Zero.\r\n xc[0] = x.e = 0;\r\n }\r\n } else if (sd < xc.length) {\r\n\r\n // xc[sd] is the digit after the digit that may be rounded up.\r\n more =\r\n rm === 1 && xc[sd] >= 5 ||\r\n rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&\r\n (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||\r\n rm === 3 && (more || !!xc[0]);\r\n\r\n // Remove any digits after the required precision.\r\n xc.length = sd;\r\n\r\n // Round up?\r\n if (more) {\r\n\r\n // Rounding up may mean the previous digit has to be rounded up.\r\n for (; ++xc[--sd] > 9;) {\r\n xc[sd] = 0;\r\n if (sd === 0) {\r\n ++x.e;\r\n xc.unshift(1);\r\n break;\r\n }\r\n }\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (sd = xc.length; !xc[--sd];) xc.pop();\r\n }\r\n\r\n return x;\r\n}\r\n\r\n\r\n/*\r\n * Return a string representing the value of Big x in normal or exponential notation.\r\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\r\n */\r\nfunction stringify(x, doExponential, isNonzero) {\r\n var e = x.e,\r\n s = x.c.join(''),\r\n n = s.length;\r\n\r\n // Exponential notation?\r\n if (doExponential) {\r\n s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\r\n\r\n // Normal notation.\r\n } else if (e < 0) {\r\n for (; ++e;) s = '0' + s;\r\n s = '0.' + s;\r\n } else if (e > 0) {\r\n if (++e > n) {\r\n for (e -= n; e--;) s += '0';\r\n } else if (e < n) {\r\n s = s.slice(0, e) + '.' + s.slice(e);\r\n }\r\n } else if (n > 1) {\r\n s = s.charAt(0) + '.' + s.slice(1);\r\n }\r\n\r\n return x.s < 0 && isNonzero ? '-' + s : s;\r\n}\r\n\r\n\r\n// Prototype/instance methods\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the absolute value of this Big.\r\n */\r\nP.abs = function () {\r\n var x = new this.constructor(this);\r\n x.s = 1;\r\n return x;\r\n};\r\n\r\n\r\n/*\r\n * Return 1 if the value of this Big is greater than the value of Big y,\r\n * -1 if the value of this Big is less than the value of Big y, or\r\n * 0 if they have the same value.\r\n */\r\nP.cmp = function (y) {\r\n var isneg,\r\n x = this,\r\n xc = x.c,\r\n yc = (y = new x.constructor(y)).c,\r\n i = x.s,\r\n j = y.s,\r\n k = x.e,\r\n l = y.e;\r\n\r\n // Either zero?\r\n if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;\r\n\r\n // Signs differ?\r\n if (i != j) return i;\r\n\r\n isneg = i < 0;\r\n\r\n // Compare exponents.\r\n if (k != l) return k > l ^ isneg ? 1 : -1;\r\n\r\n j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n // Compare digit by digit.\r\n for (i = -1; ++i < j;) {\r\n if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\r\n }\r\n\r\n // Compare lengths.\r\n return k == l ? 0 : k > l ^ isneg ? 1 : -1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\r\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.div = function (y) {\r\n var x = this,\r\n Big = x.constructor,\r\n a = x.c, // dividend\r\n b = (y = new Big(y)).c, // divisor\r\n k = x.s == y.s ? 1 : -1,\r\n dp = Big.DP;\r\n\r\n if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n throw Error(INVALID_DP);\r\n }\r\n\r\n // Divisor is zero?\r\n if (!b[0]) {\r\n throw Error(DIV_BY_ZERO);\r\n }\r\n\r\n // Dividend is 0? Return +-0.\r\n if (!a[0]) {\r\n y.s = k;\r\n y.c = [y.e = 0];\r\n return y;\r\n }\r\n\r\n var bl, bt, n, cmp, ri,\r\n bz = b.slice(),\r\n ai = bl = b.length,\r\n al = a.length,\r\n r = a.slice(0, bl), // remainder\r\n rl = r.length,\r\n q = y, // quotient\r\n qc = q.c = [],\r\n qi = 0,\r\n p = dp + (q.e = x.e - y.e) + 1; // precision of the result\r\n\r\n q.s = k;\r\n k = p < 0 ? 0 : p;\r\n\r\n // Create version of divisor with leading zero.\r\n bz.unshift(0);\r\n\r\n // Add zeros to make remainder as long as divisor.\r\n for (; rl++ < bl;) r.push(0);\r\n\r\n do {\r\n\r\n // n is how many times the divisor goes into current remainder.\r\n for (n = 0; n < 10; n++) {\r\n\r\n // Compare divisor and remainder.\r\n if (bl != (rl = r.length)) {\r\n cmp = bl > rl ? 1 : -1;\r\n } else {\r\n for (ri = -1, cmp = 0; ++ri < bl;) {\r\n if (b[ri] != r[ri]) {\r\n cmp = b[ri] > r[ri] ? 1 : -1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n // If divisor < remainder, subtract divisor from remainder.\r\n if (cmp < 0) {\r\n\r\n // Remainder can't be more than 1 digit longer than divisor.\r\n // Equalise lengths using divisor with extra leading zero?\r\n for (bt = rl == bl ? b : bz; rl;) {\r\n if (r[--rl] < bt[rl]) {\r\n ri = rl;\r\n for (; ri && !r[--ri];) r[ri] = 9;\r\n --r[ri];\r\n r[rl] += 10;\r\n }\r\n r[rl] -= bt[rl];\r\n }\r\n\r\n for (; !r[0];) r.shift();\r\n } else {\r\n break;\r\n }\r\n }\r\n\r\n // Add the digit n to the result array.\r\n qc[qi++] = cmp ? n : ++n;\r\n\r\n // Update the remainder.\r\n if (r[0] && cmp) r[rl] = a[ai] || 0;\r\n else r = [a[ai]];\r\n\r\n } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\r\n\r\n // Leading zero? Do not remove if result is simply zero (qi == 1).\r\n if (!qc[0] && qi != 1) {\r\n\r\n // There can't be more than one zero.\r\n qc.shift();\r\n q.e--;\r\n p--;\r\n }\r\n\r\n // Round?\r\n if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);\r\n\r\n return q;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\r\n */\r\nP.eq = function (y) {\r\n return this.cmp(y) === 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is greater than the value of Big y, otherwise return\r\n * false.\r\n */\r\nP.gt = function (y) {\r\n return this.cmp(y) > 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.gte = function (y) {\r\n return this.cmp(y) > -1;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\r\n */\r\nP.lt = function (y) {\r\n return this.cmp(y) < 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is less than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.lte = function (y) {\r\n return this.cmp(y) < 1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big minus the value of Big y.\r\n */\r\nP.minus = P.sub = function (y) {\r\n var i, j, t, xlty,\r\n x = this,\r\n Big = x.constructor,\r\n a = x.s,\r\n b = (y = new Big(y)).s;\r\n\r\n // Signs differ?\r\n if (a != b) {\r\n y.s = -b;\r\n return x.plus(y);\r\n }\r\n\r\n var xc = x.c.slice(),\r\n xe = x.e,\r\n yc = y.c,\r\n ye = y.e;\r\n\r\n // Either zero?\r\n if (!xc[0] || !yc[0]) {\r\n if (yc[0]) {\r\n y.s = -b;\r\n } else if (xc[0]) {\r\n y = new Big(x);\r\n } else {\r\n y.s = 1;\r\n }\r\n return y;\r\n }\r\n\r\n // Determine which is the bigger number. Prepend zeros to equalise exponents.\r\n if (a = xe - ye) {\r\n\r\n if (xlty = a < 0) {\r\n a = -a;\r\n t = xc;\r\n } else {\r\n ye = xe;\r\n t = yc;\r\n }\r\n\r\n t.reverse();\r\n for (b = a; b--;) t.push(0);\r\n t.reverse();\r\n } else {\r\n\r\n // Exponents equal. Check digit by digit.\r\n j = ((xlty = xc.length < yc.length) ? xc : yc).length;\r\n\r\n for (a = b = 0; b < j; b++) {\r\n if (xc[b] != yc[b]) {\r\n xlty = xc[b] < yc[b];\r\n break;\r\n }\r\n }\r\n }\r\n\r\n // x < y? Point xc to the array of the bigger number.\r\n if (xlty) {\r\n t = xc;\r\n xc = yc;\r\n yc = t;\r\n y.s = -y.s;\r\n }\r\n\r\n /*\r\n * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\r\n * needs to start at yc.length.\r\n */\r\n if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;\r\n\r\n // Subtract yc from xc.\r\n for (b = i; j > a;) {\r\n if (xc[--j] < yc[j]) {\r\n for (i = j; i && !xc[--i];) xc[i] = 9;\r\n --xc[i];\r\n xc[j] += 10;\r\n }\r\n\r\n xc[j] -= yc[j];\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (; xc[--b] === 0;) xc.pop();\r\n\r\n // Remove leading zeros and adjust exponent accordingly.\r\n for (; xc[0] === 0;) {\r\n xc.shift();\r\n --ye;\r\n }\r\n\r\n if (!xc[0]) {\r\n\r\n // n - n = +0\r\n y.s = 1;\r\n\r\n // Result must be zero.\r\n xc = [ye = 0];\r\n }\r\n\r\n y.c = xc;\r\n y.e = ye;\r\n\r\n return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\r\n */\r\nP.mod = function (y) {\r\n var ygtx,\r\n x = this,\r\n Big = x.constructor,\r\n a = x.s,\r\n b = (y = new Big(y)).s;\r\n\r\n if (!y.c[0]) {\r\n throw Error(DIV_BY_ZERO);\r\n }\r\n\r\n x.s = y.s = 1;\r\n ygtx = y.cmp(x) == 1;\r\n x.s = a;\r\n y.s = b;\r\n\r\n if (ygtx) return new Big(x);\r\n\r\n a = Big.DP;\r\n b = Big.RM;\r\n Big.DP = Big.RM = 0;\r\n x = x.div(y);\r\n Big.DP = a;\r\n Big.RM = b;\r\n\r\n return this.minus(x.times(y));\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big negated.\r\n */\r\nP.neg = function () {\r\n var x = new this.constructor(this);\r\n x.s = -x.s;\r\n return x;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big plus the value of Big y.\r\n */\r\nP.plus = P.add = function (y) {\r\n var e, k, t,\r\n x = this,\r\n Big = x.constructor;\r\n\r\n y = new Big(y);\r\n\r\n // Signs differ?\r\n if (x.s != y.s) {\r\n y.s = -y.s;\r\n return x.minus(y);\r\n }\r\n\r\n var xe = x.e,\r\n xc = x.c,\r\n ye = y.e,\r\n yc = y.c;\r\n\r\n // Either zero?\r\n if (!xc[0] || !yc[0]) {\r\n if (!yc[0]) {\r\n if (xc[0]) {\r\n y = new Big(x);\r\n } else {\r\n y.s = x.s;\r\n }\r\n }\r\n return y;\r\n }\r\n\r\n xc = xc.slice();\r\n\r\n // Prepend zeros to equalise exponents.\r\n // Note: reverse faster than unshifts.\r\n if (e = xe - ye) {\r\n if (e > 0) {\r\n ye = xe;\r\n t = yc;\r\n } else {\r\n e = -e;\r\n t = xc;\r\n }\r\n\r\n t.reverse();\r\n for (; e--;) t.push(0);\r\n t.reverse();\r\n }\r\n\r\n // Point xc to the longer array.\r\n if (xc.length - yc.length < 0) {\r\n t = yc;\r\n yc = xc;\r\n xc = t;\r\n }\r\n\r\n e = yc.length;\r\n\r\n // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\r\n for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;\r\n\r\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n\r\n if (k) {\r\n xc.unshift(k);\r\n ++ye;\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (e = xc.length; xc[--e] === 0;) xc.pop();\r\n\r\n y.c = xc;\r\n y.e = ye;\r\n\r\n return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a Big whose value is the value of this Big raised to the power n.\r\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\r\n * mode Big.RM.\r\n *\r\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\r\n */\r\nP.pow = function (n) {\r\n var x = this,\r\n one = new x.constructor('1'),\r\n y = one,\r\n isneg = n < 0;\r\n\r\n if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {\r\n throw Error(INVALID + 'exponent');\r\n }\r\n\r\n if (isneg) n = -n;\r\n\r\n for (;;) {\r\n if (n & 1) y = y.times(x);\r\n n >>= 1;\r\n if (!n) break;\r\n x = x.times(x);\r\n }\r\n\r\n return isneg ? one.div(y) : y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd\r\n * significant digits using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.prec = function (sd, rm) {\r\n if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n throw Error(INVALID + 'precision');\r\n }\r\n return round(new this.constructor(this), sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places\r\n * using rounding mode rm, or Big.RM if rm is not specified.\r\n * If dp is negative, round to an integer which is a multiple of 10**-dp.\r\n * If dp is not specified, round to 0 decimal places.\r\n *\r\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.round = function (dp, rm) {\r\n if (dp === UNDEFINED) dp = 0;\r\n else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {\r\n throw Error(INVALID_DP);\r\n }\r\n return round(new this.constructor(this), dp + this.e + 1, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\r\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.sqrt = function () {\r\n var r, c, t,\r\n x = this,\r\n Big = x.constructor,\r\n s = x.s,\r\n e = x.e,\r\n half = new Big('0.5');\r\n\r\n // Zero?\r\n if (!x.c[0]) return new Big(x);\r\n\r\n // Negative?\r\n if (s < 0) {\r\n throw Error(NAME + 'No square root');\r\n }\r\n\r\n // Estimate.\r\n s = Math.sqrt(x + '');\r\n\r\n // Math.sqrt underflow/overflow?\r\n // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\r\n if (s === 0 || s === 1 / 0) {\r\n c = x.c.join('');\r\n if (!(c.length + e & 1)) c += '0';\r\n s = Math.sqrt(c);\r\n e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\r\n r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\r\n } else {\r\n r = new Big(s + '');\r\n }\r\n\r\n e = r.e + (Big.DP += 4);\r\n\r\n // Newton-Raphson iteration.\r\n do {\r\n t = r;\r\n r = half.times(t.plus(x.div(t)));\r\n } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\r\n\r\n return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big times the value of Big y.\r\n */\r\nP.times = P.mul = function (y) {\r\n var c,\r\n x = this,\r\n Big = x.constructor,\r\n xc = x.c,\r\n yc = (y = new Big(y)).c,\r\n a = xc.length,\r\n b = yc.length,\r\n i = x.e,\r\n j = y.e;\r\n\r\n // Determine sign of result.\r\n y.s = x.s == y.s ? 1 : -1;\r\n\r\n // Return signed 0 if either 0.\r\n if (!xc[0] || !yc[0]) {\r\n y.c = [y.e = 0];\r\n return y;\r\n }\r\n\r\n // Initialise exponent of result as x.e + y.e.\r\n y.e = i + j;\r\n\r\n // If array xc has fewer digits than yc, swap xc and yc, and lengths.\r\n if (a < b) {\r\n c = xc;\r\n xc = yc;\r\n yc = c;\r\n j = a;\r\n a = b;\r\n b = j;\r\n }\r\n\r\n // Initialise coefficient array of result with zeros.\r\n for (c = new Array(j = a + b); j--;) c[j] = 0;\r\n\r\n // Multiply.\r\n\r\n // i is initially xc.length.\r\n for (i = b; i--;) {\r\n b = 0;\r\n\r\n // a is yc.length.\r\n for (j = a + i; j > i;) {\r\n\r\n // Current sum of products at this digit position, plus carry.\r\n b = c[j] + yc[i] * xc[j - i - 1] + b;\r\n c[j--] = b % 10;\r\n\r\n // carry\r\n b = b / 10 | 0;\r\n }\r\n\r\n c[j] = b;\r\n }\r\n\r\n // Increment result exponent if there is a final carry, otherwise remove leading zero.\r\n if (b) ++y.e;\r\n else c.shift();\r\n\r\n // Remove trailing zeros.\r\n for (i = c.length; !c[--i];) c.pop();\r\n y.c = c;\r\n\r\n return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in exponential notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toExponential = function (dp, rm) {\r\n var x = this,\r\n n = x.c[0];\r\n\r\n if (dp !== UNDEFINED) {\r\n if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n throw Error(INVALID_DP);\r\n }\r\n x = round(new x.constructor(x), ++dp, rm);\r\n for (; x.c.length < dp;) x.c.push(0);\r\n }\r\n\r\n return stringify(x, true, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in normal notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n *\r\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n */\r\nP.toFixed = function (dp, rm) {\r\n var x = this,\r\n n = x.c[0];\r\n\r\n if (dp !== UNDEFINED) {\r\n if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n throw Error(INVALID_DP);\r\n }\r\n x = round(new x.constructor(x), dp + x.e + 1, rm);\r\n\r\n // x.e may have changed if the value is rounded up.\r\n for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);\r\n }\r\n\r\n return stringify(x, false, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Omit the sign for negative zero.\r\n */\r\nP[Symbol.for('nodejs.util.inspect.custom')] = P.toJSON = P.toString = function () {\r\n var x = this,\r\n Big = x.constructor;\r\n return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);\r\n};\r\n\r\n\r\n/*\r\n * Return the value of this Big as a primitve number.\r\n */\r\nP.toNumber = function () {\r\n var n = Number(stringify(this, true, true));\r\n if (this.constructor.strict === true && !this.eq(n.toString())) {\r\n throw Error(NAME + 'Imprecise conversion');\r\n }\r\n return n;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big rounded to sd significant digits using\r\n * rounding mode rm, or Big.RM if rm is not specified.\r\n * Use exponential notation if sd is less than the number of digits necessary to represent\r\n * the integer part of the value in normal notation.\r\n *\r\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toPrecision = function (sd, rm) {\r\n var x = this,\r\n Big = x.constructor,\r\n n = x.c[0];\r\n\r\n if (sd !== UNDEFINED) {\r\n if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n throw Error(INVALID + 'precision');\r\n }\r\n x = round(new Big(x), sd, rm);\r\n for (; x.c.length < sd;) x.c.push(0);\r\n }\r\n\r\n return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Include the sign for negative zero.\r\n */\r\nP.valueOf = function () {\r\n var x = this,\r\n Big = x.constructor;\r\n if (Big.strict === true) {\r\n throw Error(NAME + 'valueOf disallowed');\r\n }\r\n return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);\r\n};\r\n\r\n\r\n// Export\r\n\r\n\r\nexport var Big = _Big_();\r\n\r\n/// \r\nexport default Big;\r\n"],"names":["MAX_DP","MAX_POWER","NAME","INVALID","INVALID_DP","DIV_BY_ZERO","P","UNDEFINED","NUMERIC","round","x","sd","rm","more","xc","c","constructor","RM","Error","length","e","unshift","pop","stringify","doExponential","isNonzero","s","join","n","charAt","slice","abs","this","cmp","y","isneg","yc","i","j","k","l","div","Big","a","b","dp","DP","bl","bt","ri","bz","ai","al","r","rl","q","qc","qi","p","push","shift","eq","gt","gte","lt","lte","minus","sub","t","xlty","plus","xe","ye","reverse","mod","ygtx","times","neg","add","pow","one","prec","sqrt","half","Math","toExponential","indexOf","mul","Array","toFixed","Symbol","for","toJSON","toString","NE","PE","toNumber","Number","strict","toPrecision","valueOf","_Big_","TypeError","String","nl","test","replace","search","substring","parse","prototype","roundDown","roundHalfUp","roundHalfEven","roundUp"],"mappings":"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"}