{"version":3,"file":"static/chunks/7342-dcb888e00974b210.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":""}