{"version":3,"file":"static/chunks/3012-467b4f9d85a12e3d.js","mappings":"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","sources":["webpack://_N_E/./node_modules/big.js/big.mjs","webpack://_N_E/"],"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":["NAME","INVALID","INVALID_DP","INVALID_RM","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","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","toFixed","Symbol","for","toJSON","toString","NE","PE","toNumber","Number","strict","toPrecision","valueOf","_Big_","TypeError","String","parse","nl","test","replace","search","substring","prototype","roundDown","roundHalfUp","roundHalfEven","roundUp","__webpack_exports__"],"sourceRoot":""}