{"version":3,"file":"big.mjs","sources":["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":["DP","RM","MAX_DP","MAX_POWER","NE","PE","STRICT","NAME","INVALID","INVALID_DP","INVALID_RM","DIV_BY_ZERO","P","UNDEFINED","NUMERIC","_Big_","Big","n","x","this","s","e","c","slice","strict","TypeError","String","parse","constructor","prototype","roundDown","roundHalfUp","roundHalfEven","roundUp","i","nl","test","Error","charAt","indexOf","replace","search","substring","length","round","sd","rm","more","xc","unshift","pop","stringify","doExponential","isNonzero","join","abs","cmp","y","isneg","yc","j","k","l","div","a","b","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","mul","Array","toFixed","Symbol","for","toJSON","toString","toNumber","Number","toPrecision","valueOf"],"mappings":"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"}