{"version":3,"file":"js/45720-06b8301539f7111f7ec0.js","mappings":"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","sources":["webpack://StravaModern/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://StravaModern/./node_modules/classnames/index.js","webpack://StravaModern/./node_modules/decimal.js-light/decimal.js","webpack://StravaModern/./node_modules/dom-helpers/class/addClass.js","webpack://StravaModern/./node_modules/dom-helpers/class/hasClass.js","webpack://StravaModern/./node_modules/dom-helpers/class/removeClass.js","webpack://StravaModern/./node_modules/lodash/_Symbol.js","webpack://StravaModern/./node_modules/lodash/_baseGetTag.js","webpack://StravaModern/./node_modules/lodash/_freeGlobal.js","webpack://StravaModern/./node_modules/lodash/_getRawTag.js","webpack://StravaModern/./node_modules/lodash/_objectToString.js","webpack://StravaModern/./node_modules/lodash/_root.js","webpack://StravaModern/./node_modules/lodash/isObject.js","webpack://StravaModern/./node_modules/lodash/isObjectLike.js","webpack://StravaModern/./node_modules/lodash/isSymbol.js","webpack://StravaModern/./node_modules/react-lifecycles-compat/react-lifecycles-compat.es.js","webpack://StravaModern/./node_modules/recharts-scale/es6/util/utils.js","webpack://StravaModern/./node_modules/recharts-scale/es6/util/arithmetic.js","webpack://StravaModern/./node_modules/recharts-scale/es6/getNiceTickValues.js"],"sourcesContent":["function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/*!\n  Copyright (c) 2018 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames() {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString === Object.prototype.toString) {\n\t\t\t\t\tfor (var key in arg) {\n\t\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","/*! decimal.js-light v2.5.1 https://github.com/MikeMcl/decimal.js-light/LICENCE */\r\n;(function (globalScope) {\r\n  'use strict';\r\n\r\n\r\n  /*\r\n   *  decimal.js-light v2.5.1\r\n   *  An arbitrary-precision Decimal type for JavaScript.\r\n   *  https://github.com/MikeMcl/decimal.js-light\r\n   *  Copyright (c) 2020 Michael Mclaughlin <M8ch88l@gmail.com>\r\n   *  MIT Expat Licence\r\n   */\r\n\r\n\r\n  // -----------------------------------  EDITABLE DEFAULTS  ------------------------------------ //\r\n\r\n\r\n    // The limit on the value of `precision`, and on the value of the first argument to\r\n    // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n  var MAX_DIGITS = 1e9,                        // 0 to 1e9\r\n\r\n\r\n    // The initial configuration properties of the Decimal constructor.\r\n    Decimal = {\r\n\r\n      // These values must be integers within the stated ranges (inclusive).\r\n      // Most of these values can be changed during run-time using `Decimal.config`.\r\n\r\n      // The maximum number of significant digits of the result of a calculation or base conversion.\r\n      // E.g. `Decimal.config({ precision: 20 });`\r\n      precision: 20,                         // 1 to MAX_DIGITS\r\n\r\n      // The rounding mode used by default by `toInteger`, `toDecimalPlaces`, `toExponential`,\r\n      // `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n      //\r\n      // ROUND_UP         0 Away from zero.\r\n      // ROUND_DOWN       1 Towards zero.\r\n      // ROUND_CEIL       2 Towards +Infinity.\r\n      // ROUND_FLOOR      3 Towards -Infinity.\r\n      // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      //\r\n      // E.g.\r\n      // `Decimal.rounding = 4;`\r\n      // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n      rounding: 4,                           // 0 to 8\r\n\r\n      // The exponent value at and beneath which `toString` returns exponential notation.\r\n      // JavaScript numbers: -7\r\n      toExpNeg: -7,                          // 0 to -MAX_E\r\n\r\n      // The exponent value at and above which `toString` returns exponential notation.\r\n      // JavaScript numbers: 21\r\n      toExpPos:  21,                         // 0 to MAX_E\r\n\r\n      // The natural logarithm of 10.\r\n      // 115 digits\r\n      LN10: '2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298341967784042286'\r\n    },\r\n\r\n\r\n  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n    external = true,\r\n\r\n    decimalError = '[DecimalError] ',\r\n    invalidArgument = decimalError + 'Invalid argument: ',\r\n    exponentOutOfRange = decimalError + 'Exponent out of range: ',\r\n\r\n    mathfloor = Math.floor,\r\n    mathpow = Math.pow,\r\n\r\n    isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n    ONE,\r\n    BASE = 1e7,\r\n    LOG_BASE = 7,\r\n    MAX_SAFE_INTEGER = 9007199254740991,\r\n    MAX_E = mathfloor(MAX_SAFE_INTEGER / LOG_BASE),    // 1286742750677284\r\n\r\n    // Decimal.prototype object\r\n    P = {};\r\n\r\n\r\n  // Decimal prototype methods\r\n\r\n\r\n  /*\r\n   *  absoluteValue                       abs\r\n   *  comparedTo                          cmp\r\n   *  decimalPlaces                       dp\r\n   *  dividedBy                           div\r\n   *  dividedToIntegerBy                  idiv\r\n   *  equals                              eq\r\n   *  exponent\r\n   *  greaterThan                         gt\r\n   *  greaterThanOrEqualTo                gte\r\n   *  isInteger                           isint\r\n   *  isNegative                          isneg\r\n   *  isPositive                          ispos\r\n   *  isZero\r\n   *  lessThan                            lt\r\n   *  lessThanOrEqualTo                   lte\r\n   *  logarithm                           log\r\n   *  minus                               sub\r\n   *  modulo                              mod\r\n   *  naturalExponential                  exp\r\n   *  naturalLogarithm                    ln\r\n   *  negated                             neg\r\n   *  plus                                add\r\n   *  precision                           sd\r\n   *  squareRoot                          sqrt\r\n   *  times                               mul\r\n   *  toDecimalPlaces                     todp\r\n   *  toExponential\r\n   *  toFixed\r\n   *  toInteger                           toint\r\n   *  toNumber\r\n   *  toPower                             pow\r\n   *  toPrecision\r\n   *  toSignificantDigits                 tosd\r\n   *  toString\r\n   *  valueOf                             val\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the absolute value of this Decimal.\r\n   *\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new this.constructor(this);\r\n    if (x.s) x.s = 1;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1    if the value of this Decimal is greater than the value of `y`,\r\n   *  -1    if the value of this Decimal is less than the value of `y`,\r\n   *   0    if they have the same value\r\n   *\r\n   */\r\n  P.comparedTo = P.cmp = function (y) {\r\n    var i, j, xdL, ydL,\r\n      x = this;\r\n\r\n    y = new x.constructor(y);\r\n\r\n    // Signs differ?\r\n    if (x.s !== y.s) return x.s || -y.s;\r\n\r\n    // Compare exponents.\r\n    if (x.e !== y.e) return x.e > y.e ^ x.s < 0 ? 1 : -1;\r\n\r\n    xdL = x.d.length;\r\n    ydL = y.d.length;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n      if (x.d[i] !== y.d[i]) return x.d[i] > y.d[i] ^ x.s < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Compare lengths.\r\n    return xdL === ydL ? 0 : xdL > ydL ^ x.s < 0 ? 1 : -1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of decimal places of the value of this Decimal.\r\n   *\r\n   */\r\n  P.decimalPlaces = P.dp = function () {\r\n    var x = this,\r\n      w = x.d.length - 1,\r\n      dp = (w - x.e) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last word.\r\n    w = x.d[w];\r\n    if (w) for (; w % 10 == 0; w /= 10) dp--;\r\n\r\n    return dp < 0 ? 0 : dp;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.dividedBy = P.div = function (y) {\r\n    return divide(this, new this.constructor(y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n   * by the value of `y`, truncated to `precision` significant digits.\r\n   *\r\n   */\r\n  P.dividedToIntegerBy = P.idiv = function (y) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return round(divide(x, new Ctor(y), 0, 1), Ctor.precision);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.equals = P.eq = function (y) {\r\n    return !this.cmp(y);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the (base 10) exponent value of this Decimal (this.e is the base 10000000 exponent).\r\n   *\r\n   */\r\n  P.exponent = function () {\r\n    return getBase10Exponent(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n   * false.\r\n   *\r\n   */\r\n  P.greaterThan = P.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 Decimal is greater than or equal to the value of `y`,\r\n   * otherwise return false.\r\n   *\r\n   */\r\n  P.greaterThanOrEqualTo = P.gte = 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 Decimal is an integer, otherwise return false.\r\n   *\r\n   */\r\n  P.isInteger = P.isint = function () {\r\n    return this.e > this.d.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is negative, otherwise return false.\r\n   *\r\n   */\r\n  P.isNegative = P.isneg = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is positive, otherwise return false.\r\n   *\r\n   */\r\n  P.isPositive = P.ispos = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is 0, otherwise return false.\r\n   *\r\n   */\r\n  P.isZero = function () {\r\n    return this.s === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThan = P.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 Decimal is less than or equal to `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThanOrEqualTo = P.lte = function (y) {\r\n    return this.cmp(y) < 1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the logarithm of the value of this Decimal to the specified base, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   * If no base is specified, return log[10](x).\r\n   *\r\n   * log[base](x) = ln(x) / ln(base)\r\n   *\r\n   * The maximum error of the result is 1 ulp (unit in the last place).\r\n   *\r\n   * [base] {number|string|Decimal} The base of the logarithm.\r\n   *\r\n   */\r\n  P.logarithm = P.log = function (base) {\r\n    var r,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision,\r\n      wpr = pr + 5;\r\n\r\n    // Default base is 10.\r\n    if (base === void 0) {\r\n      base = new Ctor(10);\r\n    } else {\r\n      base = new Ctor(base);\r\n\r\n      // log[-b](x) = NaN\r\n      // log[0](x)  = NaN\r\n      // log[1](x)  = NaN\r\n      if (base.s < 1 || base.eq(ONE)) throw Error(decimalError + 'NaN');\r\n    }\r\n\r\n    // log[b](-x) = NaN\r\n    // log[b](0) = -Infinity\r\n    if (x.s < 1) throw Error(decimalError + (x.s ? 'NaN' : '-Infinity'));\r\n\r\n    // log[b](1) = 0\r\n    if (x.eq(ONE)) return new Ctor(0);\r\n\r\n    external = false;\r\n    r = divide(ln(x, wpr), ln(base, wpr), wpr);\r\n    external = true;\r\n\r\n    return round(r, pr);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.minus = P.sub = function (y) {\r\n    var x = this;\r\n    y = new x.constructor(y);\r\n    return x.s == y.s ? subtract(x, y) : add(x, (y.s = -y.s, y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.modulo = P.mod = function (y) {\r\n    var q,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // x % 0 = NaN\r\n    if (!y.s) throw Error(decimalError + 'NaN');\r\n\r\n    // Return x if x is 0.\r\n    if (!x.s) return round(new Ctor(x), pr);\r\n\r\n    // Prevent rounding of intermediate calculations.\r\n    external = false;\r\n    q = divide(x, y, 0, 1).times(y);\r\n    external = true;\r\n\r\n    return x.minus(q);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n   * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`\r\n   * significant digits.\r\n   *\r\n   */\r\n  P.naturalExponential = P.exp = function () {\r\n    return exp(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n   * truncated to `precision` significant digits.\r\n   *\r\n   */\r\n  P.naturalLogarithm = P.ln = function () {\r\n    return ln(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n   * -1.\r\n   *\r\n   */\r\n  P.negated = P.neg = function () {\r\n    var x = new this.constructor(this);\r\n    x.s = -x.s || 0;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.plus = P.add = function (y) {\r\n    var x = this;\r\n    y = new x.constructor(y);\r\n    return x.s == y.s ? add(x, y) : subtract(x, (y.s = -y.s, y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of significant digits of the value of this Decimal.\r\n   *\r\n   * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n   *\r\n   */\r\n  P.precision = P.sd = function (z) {\r\n    var e, sd, w,\r\n      x = this;\r\n\r\n    if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n    e = getBase10Exponent(x) + 1;\r\n    w = x.d.length - 1;\r\n    sd = w * LOG_BASE + 1;\r\n    w = x.d[w];\r\n\r\n    // If non-zero...\r\n    if (w) {\r\n\r\n      // Subtract the number of trailing zeros of the last word.\r\n      for (; w % 10 == 0; w /= 10) sd--;\r\n\r\n      // Add the number of digits of the first word.\r\n      for (w = x.d[0]; w >= 10; w /= 10) sd++;\r\n    }\r\n\r\n    return z && e > sd ? e : sd;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`\r\n   * significant digits.\r\n   *\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var e, n, pr, r, s, t, wpr,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    // Negative or zero?\r\n    if (x.s < 1) {\r\n      if (!x.s) return new Ctor(0);\r\n\r\n      // sqrt(-x) = NaN\r\n      throw Error(decimalError + 'NaN');\r\n    }\r\n\r\n    e = getBase10Exponent(x);\r\n    external = false;\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+x);\r\n\r\n    // Math.sqrt underflow/overflow?\r\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n    if (s == 0 || s == 1 / 0) {\r\n      n = digitsToString(x.d);\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(n);\r\n      e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n      if (s == 1 / 0) {\r\n        n = '5e' + e;\r\n      } else {\r\n        n = s.toExponential();\r\n        n = n.slice(0, n.indexOf('e') + 1) + e;\r\n      }\r\n\r\n      r = new Ctor(n);\r\n    } else {\r\n      r = new Ctor(s.toString());\r\n    }\r\n\r\n    pr = Ctor.precision;\r\n    s = wpr = pr + 3;\r\n\r\n    // Newton-Raphson iteration.\r\n    for (;;) {\r\n      t = r;\r\n      r = t.plus(divide(x, t, wpr + 2)).times(0.5);\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === (n = digitsToString(r.d)).slice(0, wpr)) {\r\n        n = n.slice(wpr - 3, wpr + 1);\r\n\r\n        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n        // 4999, i.e. approaching a rounding boundary, continue the iteration.\r\n        if (s == wpr && n == '4999') {\r\n\r\n          // On the first iteration only, check to see if rounding up gives the exact result as the\r\n          // nines may infinitely repeat.\r\n          round(t, pr + 1, 0);\r\n\r\n          if (t.times(t).eq(x)) {\r\n            r = t;\r\n            break;\r\n          }\r\n        } else if (n != '9999') {\r\n          break;\r\n        }\r\n\r\n        wpr += 4;\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return round(r, pr);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.times = P.mul = function (y) {\r\n    var carry, e, i, k, r, rL, t, xdL, ydL,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      xd = x.d,\r\n      yd = (y = new Ctor(y)).d;\r\n\r\n    // Return 0 if either is 0.\r\n    if (!x.s || !y.s) return new Ctor(0);\r\n\r\n    y.s *= x.s;\r\n    e = x.e + y.e;\r\n    xdL = xd.length;\r\n    ydL = yd.length;\r\n\r\n    // Ensure xd points to the longer array.\r\n    if (xdL < ydL) {\r\n      r = xd;\r\n      xd = yd;\r\n      yd = r;\r\n      rL = xdL;\r\n      xdL = ydL;\r\n      ydL = rL;\r\n    }\r\n\r\n    // Initialise the result array with zeros.\r\n    r = [];\r\n    rL = xdL + ydL;\r\n    for (i = rL; i--;) r.push(0);\r\n\r\n    // Multiply!\r\n    for (i = ydL; --i >= 0;) {\r\n      carry = 0;\r\n      for (k = xdL + i; k > i;) {\r\n        t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n        r[k--] = t % BASE | 0;\r\n        carry = t / BASE | 0;\r\n      }\r\n\r\n      r[k] = (r[k] + carry) % BASE | 0;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; !r[--rL];) r.pop();\r\n\r\n    if (carry) ++e;\r\n    else r.shift();\r\n\r\n    y.d = r;\r\n    y.e = e;\r\n\r\n    return external ? round(y, Ctor.precision) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n   * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n   *\r\n   * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toDecimalPlaces = P.todp = function (dp, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    x = new Ctor(x);\r\n    if (dp === void 0) return x;\r\n\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    return round(x, dp + getBase10Exponent(x) + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in exponential notation rounded to\r\n   * `dp` fixed decimal places using rounding mode `rounding`.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    var str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) {\r\n      str = toString(x, true);\r\n    } else {\r\n      checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = round(new Ctor(x), dp + 1, rm);\r\n      str = toString(x, true, dp + 1);\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n   * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n   * omitted.\r\n   *\r\n   * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\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   * (-0).toFixed(3) is '0.000'.\r\n   * (-0.5).toFixed(0) is '-0'.\r\n   *\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    var str, y,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) return toString(x);\r\n\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    y = round(new Ctor(x), dp + getBase10Exponent(x) + 1, rm);\r\n    str = toString(y.abs(), false, dp + getBase10Exponent(y) + 1);\r\n\r\n    // To determine whether to add the minus sign look at the value before it was rounded,\r\n    // i.e. look at `x` rather than `y`.\r\n    return x.isneg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n   * rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.toInteger = P.toint = function () {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return round(new Ctor(x), getBase10Exponent(x) + 1, Ctor.rounding);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this Decimal converted to a number primitive.\r\n   *\r\n   */\r\n  P.toNumber = function () {\r\n    return +this;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,\r\n   * truncated to `precision` significant digits.\r\n   *\r\n   * For non-integer or very large exponents pow(x, y) is calculated using\r\n   *\r\n   *   x^y = exp(y*ln(x))\r\n   *\r\n   * The maximum error is 1 ulp (unit in last place).\r\n   *\r\n   * y {number|string|Decimal} The power to which to raise this Decimal.\r\n   *\r\n   */\r\n  P.toPower = P.pow = function (y) {\r\n    var e, k, pr, r, sign, yIsInt,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      guard = 12,\r\n      yn = +(y = new Ctor(y));\r\n\r\n    // pow(x, 0) = 1\r\n    if (!y.s) return new Ctor(ONE);\r\n\r\n    x = new Ctor(x);\r\n\r\n    // pow(0, y > 0) = 0\r\n    // pow(0, y < 0) = Infinity\r\n    if (!x.s) {\r\n      if (y.s < 1) throw Error(decimalError + 'Infinity');\r\n      return x;\r\n    }\r\n\r\n    // pow(1, y) = 1\r\n    if (x.eq(ONE)) return x;\r\n\r\n    pr = Ctor.precision;\r\n\r\n    // pow(x, 1) = x\r\n    if (y.eq(ONE)) return round(x, pr);\r\n\r\n    e = y.e;\r\n    k = y.d.length - 1;\r\n    yIsInt = e >= k;\r\n    sign = x.s;\r\n\r\n    if (!yIsInt) {\r\n\r\n      // pow(x < 0, y non-integer) = NaN\r\n      if (sign < 0) throw Error(decimalError + 'NaN');\r\n\r\n    // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n    } else if ((k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n      r = new Ctor(ONE);\r\n\r\n      // Max k of 9007199254740991 takes 53 loop iterations.\r\n      // Maximum digits array length; leaves [28, 34] guard digits.\r\n      e = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n      external = false;\r\n\r\n      for (;;) {\r\n        if (k % 2) {\r\n          r = r.times(x);\r\n          truncate(r.d, e);\r\n        }\r\n\r\n        k = mathfloor(k / 2);\r\n        if (k === 0) break;\r\n\r\n        x = x.times(x);\r\n        truncate(x.d, e);\r\n      }\r\n\r\n      external = true;\r\n\r\n      return y.s < 0 ? new Ctor(ONE).div(r) : round(r, pr);\r\n    }\r\n\r\n    // Result is negative if x is negative and the last digit of integer y is odd.\r\n    sign = sign < 0 && y.d[Math.max(e, k)] & 1 ? -1 : 1;\r\n\r\n    x.s = 1;\r\n    external = false;\r\n    r = y.times(ln(x, pr + guard));\r\n    external = true;\r\n    r = exp(r);\r\n    r.s = sign;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * Return 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_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    var e, str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      e = getBase10Exponent(x);\r\n      str = toString(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = round(new Ctor(x), sd, rm);\r\n      e = getBase10Exponent(x);\r\n      str = toString(x, sd <= e || e <= Ctor.toExpNeg, sd);\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n   * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n   * omitted.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toSignificantDigits = P.tosd = function (sd, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      sd = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n    }\r\n\r\n    return round(new Ctor(x), sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal.\r\n   *\r\n   * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n   * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n   *\r\n   */\r\n  P.toString = P.valueOf = P.val = P.toJSON = function () {\r\n    var x = this,\r\n      e = getBase10Exponent(x),\r\n      Ctor = x.constructor;\r\n\r\n    return toString(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);\r\n  };\r\n\r\n\r\n  // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n  /*\r\n   *  add                 P.minus, P.plus\r\n   *  checkInt32          P.todp, P.toExponential, P.toFixed, P.toPrecision, P.tosd\r\n   *  digitsToString      P.log, P.sqrt, P.pow, toString, exp, ln\r\n   *  divide              P.div, P.idiv, P.log, P.mod, P.sqrt, exp, ln\r\n   *  exp                 P.exp, P.pow\r\n   *  getBase10Exponent   P.exponent, P.sd, P.toint, P.sqrt, P.todp, P.toFixed, P.toPrecision,\r\n   *                      P.toString, divide, round, toString, exp, ln\r\n   *  getLn10             P.log, ln\r\n   *  getZeroString       digitsToString, toString\r\n   *  ln                  P.log, P.ln, P.pow, exp\r\n   *  parseDecimal        Decimal\r\n   *  round               P.abs, P.idiv, P.log, P.minus, P.mod, P.neg, P.plus, P.toint, P.sqrt,\r\n   *                      P.times, P.todp, P.toExponential, P.toFixed, P.pow, P.toPrecision, P.tosd,\r\n   *                      divide, getLn10, exp, ln\r\n   *  subtract            P.minus, P.plus\r\n   *  toString            P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf\r\n   *  truncate            P.pow\r\n   *\r\n   *  Throws:             P.log, P.mod, P.sd, P.sqrt, P.pow,  checkInt32, divide, round,\r\n   *                      getLn10, exp, ln, parseDecimal, Decimal, config\r\n   */\r\n\r\n\r\n  function add(x, y) {\r\n    var carry, d, e, i, k, len, xd, yd,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // If either is zero...\r\n    if (!x.s || !y.s) {\r\n\r\n      // Return x if y is zero.\r\n      // Return y if y is non-zero.\r\n      if (!y.s) y = new Ctor(x);\r\n      return external ? round(y, pr) : y;\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    k = x.e;\r\n    e = y.e;\r\n    xd = xd.slice();\r\n    i = k - e;\r\n\r\n    // If base 1e7 exponents differ...\r\n    if (i) {\r\n      if (i < 0) {\r\n        d = xd;\r\n        i = -i;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = k;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n      k = Math.ceil(pr / LOG_BASE);\r\n      len = k > len ? k + 1 : len + 1;\r\n\r\n      if (i > len) {\r\n        i = len;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n      d.reverse();\r\n      for (; i--;) d.push(0);\r\n      d.reverse();\r\n    }\r\n\r\n    len = xd.length;\r\n    i = yd.length;\r\n\r\n    // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n    if (len - i < 0) {\r\n      i = len;\r\n      d = yd;\r\n      yd = xd;\r\n      xd = d;\r\n    }\r\n\r\n    // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n    for (carry = 0; i;) {\r\n      carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n      xd[i] %= BASE;\r\n    }\r\n\r\n    if (carry) {\r\n      xd.unshift(carry);\r\n      ++e;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n    y.d = xd;\r\n    y.e = e;\r\n\r\n    return external ? round(y, pr) : y;\r\n  }\r\n\r\n\r\n  function checkInt32(i, min, max) {\r\n    if (i !== ~~i || i < min || i > max) {\r\n      throw Error(invalidArgument + i);\r\n    }\r\n  }\r\n\r\n\r\n  function digitsToString(d) {\r\n    var i, k, ws,\r\n      indexOfLastWord = d.length - 1,\r\n      str = '',\r\n      w = d[0];\r\n\r\n    if (indexOfLastWord > 0) {\r\n      str += w;\r\n      for (i = 1; i < indexOfLastWord; i++) {\r\n        ws = d[i] + '';\r\n        k = LOG_BASE - ws.length;\r\n        if (k) str += getZeroString(k);\r\n        str += ws;\r\n      }\r\n\r\n      w = d[i];\r\n      ws = w + '';\r\n      k = LOG_BASE - ws.length;\r\n      if (k) str += getZeroString(k);\r\n    } else if (w === 0) {\r\n      return '0';\r\n    }\r\n\r\n    // Remove trailing zeros of last w.\r\n    for (; w % 10 === 0;) w /= 10;\r\n\r\n    return str + w;\r\n  }\r\n\r\n\r\n  var divide = (function () {\r\n\r\n    // Assumes non-zero x and k, and hence non-zero result.\r\n    function multiplyInteger(x, k) {\r\n      var temp,\r\n        carry = 0,\r\n        i = x.length;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        temp = x[i] * k + carry;\r\n        x[i] = temp % BASE | 0;\r\n        carry = temp / BASE | 0;\r\n      }\r\n\r\n      if (carry) x.unshift(carry);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, r;\r\n\r\n      if (aL != bL) {\r\n        r = aL > bL ? 1 : -1;\r\n      } else {\r\n        for (i = r = 0; i < aL; i++) {\r\n          if (a[i] != b[i]) {\r\n            r = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return r;\r\n    }\r\n\r\n    function subtract(a, b, aL) {\r\n      var i = 0;\r\n\r\n      // Subtract b from a.\r\n      for (; aL--;) {\r\n        a[aL] -= i;\r\n        i = a[aL] < b[aL] ? 1 : 0;\r\n        a[aL] = i * BASE + a[aL] - b[aL];\r\n      }\r\n\r\n      // Remove leading zeros.\r\n      for (; !a[0] && a.length > 1;) a.shift();\r\n    }\r\n\r\n    return function (x, y, pr, dp) {\r\n      var cmp, e, i, k, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz,\r\n        Ctor = x.constructor,\r\n        sign = x.s == y.s ? 1 : -1,\r\n        xd = x.d,\r\n        yd = y.d;\r\n\r\n      // Either 0?\r\n      if (!x.s) return new Ctor(x);\r\n      if (!y.s) throw Error(decimalError + 'Division by zero');\r\n\r\n      e = x.e - y.e;\r\n      yL = yd.length;\r\n      xL = xd.length;\r\n      q = new Ctor(sign);\r\n      qd = q.d = [];\r\n\r\n      // Result exponent may be one less than e.\r\n      for (i = 0; yd[i] == (xd[i] || 0); ) ++i;\r\n      if (yd[i] > (xd[i] || 0)) --e;\r\n\r\n      if (pr == null) {\r\n        sd = pr = Ctor.precision;\r\n      } else if (dp) {\r\n        sd = pr + (getBase10Exponent(x) - getBase10Exponent(y)) + 1;\r\n      } else {\r\n        sd = pr;\r\n      }\r\n\r\n      if (sd < 0) return new Ctor(0);\r\n\r\n      // Convert precision in number of base 10 digits to base 1e7 digits.\r\n      sd = sd / LOG_BASE + 2 | 0;\r\n      i = 0;\r\n\r\n      // divisor < 1e7\r\n      if (yL == 1) {\r\n        k = 0;\r\n        yd = yd[0];\r\n        sd++;\r\n\r\n        // k is the carry.\r\n        for (; (i < xL || k) && sd--; i++) {\r\n          t = k * BASE + (xd[i] || 0);\r\n          qd[i] = t / yd | 0;\r\n          k = t % yd | 0;\r\n        }\r\n\r\n      // divisor >= 1e7\r\n      } else {\r\n\r\n        // Normalise xd and yd so highest order digit of yd is >= BASE/2\r\n        k = BASE / (yd[0] + 1) | 0;\r\n\r\n        if (k > 1) {\r\n          yd = multiplyInteger(yd, k);\r\n          xd = multiplyInteger(xd, k);\r\n          yL = yd.length;\r\n          xL = xd.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xd.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL;) rem[remL++] = 0;\r\n\r\n        yz = yd.slice();\r\n        yz.unshift(0);\r\n        yd0 = yd[0];\r\n\r\n        if (yd[1] >= BASE / 2) ++yd0;\r\n\r\n        do {\r\n          k = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yd, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, k.\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * BASE + (rem[1] || 0);\r\n\r\n            // k will be how many times the divisor goes into the current remainder.\r\n            k = rem0 / yd0 | 0;\r\n\r\n            //  Algorithm:\r\n            //  1. product = divisor * trial digit (k)\r\n            //  2. if product > remainder: product -= divisor, k--\r\n            //  3. remainder -= product\r\n            //  4. if product was < remainder at 2:\r\n            //    5. compare new remainder and divisor\r\n            //    6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n            if (k > 1) {\r\n              if (k >= BASE) k = BASE - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiplyInteger(yd, k);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              cmp = compare(prod, rem, prodL, remL);\r\n\r\n              // product > remainder.\r\n              if (cmp == 1) {\r\n                k--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yd, prodL);\r\n              }\r\n            } else {\r\n\r\n              // cmp is -1.\r\n              // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n              // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n              if (k == 0) cmp = k = 1;\r\n              prod = yd.slice();\r\n            }\r\n\r\n            prodL = prod.length;\r\n            if (prodL < remL) prod.unshift(0);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL);\r\n\r\n            // If product was < previous remainder.\r\n            if (cmp == -1) {\r\n              remL = rem.length;\r\n\r\n              // Compare divisor and new remainder.\r\n              cmp = compare(yd, rem, yL, remL);\r\n\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              if (cmp < 1) {\r\n                k++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yd, remL);\r\n              }\r\n            }\r\n\r\n            remL = rem.length;\r\n          } else if (cmp === 0) {\r\n            k++;\r\n            rem = [0];\r\n          }    // if cmp === 1, k will be 0\r\n\r\n          // Add the next digit, k, to the result array.\r\n          qd[i++] = k;\r\n\r\n          // Update the remainder.\r\n          if (cmp && rem[0]) {\r\n            rem[remL++] = xd[xi] || 0;\r\n          } else {\r\n            rem = [xd[xi]];\r\n            remL = 1;\r\n          }\r\n\r\n        } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n      }\r\n\r\n      // Leading zero?\r\n      if (!qd[0]) qd.shift();\r\n\r\n      q.e = e;\r\n\r\n      return round(q, dp ? pr + getBase10Exponent(q) + 1 : pr);\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x` truncated to `sd`\r\n   * significant digits.\r\n   *\r\n   * Taylor/Maclaurin series.\r\n   *\r\n   * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n   *\r\n   * Argument reduction:\r\n   *   Repeat x = x / 32, k += 5, until |x| < 0.1\r\n   *   exp(x) = exp(x / 2^k)^(2^k)\r\n   *\r\n   * Previously, the argument was initially reduced by\r\n   * exp(x) = exp(r) * 10^k  where r = x - k * ln10, k = floor(x / ln10)\r\n   * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n   * found to be slower than just dividing repeatedly by 32 as above.\r\n   *\r\n   * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n   *\r\n   *  exp(x) is non-terminating for any finite, non-zero x.\r\n   *\r\n   */\r\n  function exp(x, sd) {\r\n    var denominator, guard, pow, sum, t, wpr,\r\n      i = 0,\r\n      k = 0,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    if (getBase10Exponent(x) > 16) throw Error(exponentOutOfRange + getBase10Exponent(x));\r\n\r\n    // exp(0) = 1\r\n    if (!x.s) return new Ctor(ONE);\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    t = new Ctor(0.03125);\r\n\r\n    while (x.abs().gte(0.1)) {\r\n      x = x.times(t);    // x = x / 2^5\r\n      k += 5;\r\n    }\r\n\r\n    // Estimate the precision increase necessary to ensure the first 4 rounding digits are correct.\r\n    guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n    wpr += guard;\r\n    denominator = pow = sum = new Ctor(ONE);\r\n    Ctor.precision = wpr;\r\n\r\n    for (;;) {\r\n      pow = round(pow.times(x), wpr);\r\n      denominator = denominator.times(++i);\r\n      t = sum.plus(divide(pow, denominator, wpr));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        while (k--) sum = round(sum.times(sum), wpr);\r\n        Ctor.precision = pr;\r\n        return sd == null ? (external = true, round(sum, pr)) : sum;\r\n      }\r\n\r\n      sum = t;\r\n    }\r\n  }\r\n\r\n\r\n  // Calculate the base 10 exponent from the base 1e7 exponent.\r\n  function getBase10Exponent(x) {\r\n    var e = x.e * LOG_BASE,\r\n      w = x.d[0];\r\n\r\n    // Add the number of digits of the first word of the digits array.\r\n    for (; w >= 10; w /= 10) e++;\r\n    return e;\r\n  }\r\n\r\n\r\n  function getLn10(Ctor, sd, pr) {\r\n\r\n    if (sd > Ctor.LN10.sd()) {\r\n\r\n\r\n      // Reset global state in case the exception is caught.\r\n      external = true;\r\n      if (pr) Ctor.precision = pr;\r\n      throw Error(decimalError + 'LN10 precision limit exceeded');\r\n    }\r\n\r\n    return round(new Ctor(Ctor.LN10), sd);\r\n  }\r\n\r\n\r\n  function getZeroString(k) {\r\n    var zs = '';\r\n    for (; k--;) zs += '0';\r\n    return zs;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x` truncated to `sd` significant\r\n   * digits.\r\n   *\r\n   *  ln(n) is non-terminating (n != 1)\r\n   *\r\n   */\r\n  function ln(y, sd) {\r\n    var c, c0, denominator, e, numerator, sum, t, wpr, x2,\r\n      n = 1,\r\n      guard = 10,\r\n      x = y,\r\n      xd = x.d,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // ln(-x) = NaN\r\n    // ln(0) = -Infinity\r\n    if (x.s < 1) throw Error(decimalError + (x.s ? 'NaN' : '-Infinity'));\r\n\r\n    // ln(1) = 0\r\n    if (x.eq(ONE)) return new Ctor(0);\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    if (x.eq(10)) {\r\n      if (sd == null) external = true;\r\n      return getLn10(Ctor, wpr);\r\n    }\r\n\r\n    wpr += guard;\r\n    Ctor.precision = wpr;\r\n    c = digitsToString(xd);\r\n    c0 = c.charAt(0);\r\n    e = getBase10Exponent(x);\r\n\r\n    if (Math.abs(e) < 1.5e15) {\r\n\r\n      // Argument reduction.\r\n      // The series converges faster the closer the argument is to 1, so using\r\n      // ln(a^b) = b * ln(a),   ln(a) = ln(a^b) / b\r\n      // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n      // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n      // later be divided by this number, then separate out the power of 10 using\r\n      // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n      // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n      //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n      // max n is 6 (gives 0.7 - 1.3)\r\n      while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n        x = x.times(y);\r\n        c = digitsToString(x.d);\r\n        c0 = c.charAt(0);\r\n        n++;\r\n      }\r\n\r\n      e = getBase10Exponent(x);\r\n\r\n      if (c0 > 1) {\r\n        x = new Ctor('0.' + c);\r\n        e++;\r\n      } else {\r\n        x = new Ctor(c0 + '.' + c.slice(1));\r\n      }\r\n    } else {\r\n\r\n      // The argument reduction method above may result in overflow if the argument y is a massive\r\n      // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n      // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n      t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n      x = ln(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n\r\n      Ctor.precision = pr;\r\n      return sd == null ? (external = true, round(x, pr)) : x;\r\n    }\r\n\r\n    // x is reduced to a value near 1.\r\n\r\n    // Taylor series.\r\n    // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n    // where x = (y - 1)/(y + 1)    (|x| < 1)\r\n    sum = numerator = x = divide(x.minus(ONE), x.plus(ONE), wpr);\r\n    x2 = round(x.times(x), wpr);\r\n    denominator = 3;\r\n\r\n    for (;;) {\r\n      numerator = round(numerator.times(x2), wpr);\r\n      t = sum.plus(divide(numerator, new Ctor(denominator), wpr));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        sum = sum.times(2);\r\n\r\n        // Reverse the argument reduction.\r\n        if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n        sum = divide(sum, new Ctor(n), wpr);\r\n\r\n        Ctor.precision = pr;\r\n        return sd == null ? (external = true, round(sum, pr)) : sum;\r\n      }\r\n\r\n      sum = t;\r\n      denominator += 2;\r\n    }\r\n  }\r\n\r\n\r\n  /*\r\n   * Parse the value of a new Decimal `x` from string `str`.\r\n   */\r\n  function parseDecimal(x, str) {\r\n    var e, i, len;\r\n\r\n    // Decimal point?\r\n    if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n    // Exponential form?\r\n    if ((i = str.search(/e/i)) > 0) {\r\n\r\n      // Determine exponent.\r\n      if (e < 0) e = i;\r\n      e += +str.slice(i + 1);\r\n      str = str.substring(0, i);\r\n    } else if (e < 0) {\r\n\r\n      // Integer.\r\n      e = str.length;\r\n    }\r\n\r\n    // Determine leading zeros.\r\n    for (i = 0; str.charCodeAt(i) === 48;) ++i;\r\n\r\n    // Determine trailing zeros.\r\n    for (len = str.length; str.charCodeAt(len - 1) === 48;) --len;\r\n    str = str.slice(i, len);\r\n\r\n    if (str) {\r\n      len -= i;\r\n      e = e - i - 1;\r\n      x.e = mathfloor(e / LOG_BASE);\r\n      x.d = [];\r\n\r\n      // Transform base\r\n\r\n      // e is the base 10 exponent.\r\n      // i is where to slice str to get the first word of the digits array.\r\n      i = (e + 1) % LOG_BASE;\r\n      if (e < 0) i += LOG_BASE;\r\n\r\n      if (i < len) {\r\n        if (i) x.d.push(+str.slice(0, i));\r\n        for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n        str = str.slice(i);\r\n        i = LOG_BASE - str.length;\r\n      } else {\r\n        i -= len;\r\n      }\r\n\r\n      for (; i--;) str += '0';\r\n      x.d.push(+str);\r\n\r\n      if (external && (x.e > MAX_E || x.e < -MAX_E)) throw Error(exponentOutOfRange + e);\r\n    } else {\r\n\r\n      // Zero.\r\n      x.s = 0;\r\n      x.e = 0;\r\n      x.d = [0];\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Round `x` to `sd` significant digits, using rounding mode `rm` if present (truncate otherwise).\r\n   */\r\n   function round(x, sd, rm) {\r\n    var i, j, k, n, rd, doRound, w, xdi,\r\n      xd = x.d;\r\n\r\n    // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n    // w: the word of xd which contains the rounding digit, a base 1e7 number.\r\n    // xdi: the index of w within xd.\r\n    // n: the number of digits of w.\r\n    // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n    // they had leading zeros)\r\n    // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n    // Get the length of the first word of the digits array xd.\r\n    for (n = 1, k = xd[0]; k >= 10; k /= 10) n++;\r\n    i = sd - n;\r\n\r\n    // Is the rounding digit in the first word of xd?\r\n    if (i < 0) {\r\n      i += LOG_BASE;\r\n      j = sd;\r\n      w = xd[xdi = 0];\r\n    } else {\r\n      xdi = Math.ceil((i + 1) / LOG_BASE);\r\n      k = xd.length;\r\n      if (xdi >= k) return x;\r\n      w = k = xd[xdi];\r\n\r\n      // Get the number of digits of w.\r\n      for (n = 1; k >= 10; k /= 10) n++;\r\n\r\n      // Get the index of rd within w.\r\n      i %= LOG_BASE;\r\n\r\n      // Get the index of rd within w, adjusted for leading zeros.\r\n      // The number of leading zeros of w is given by LOG_BASE - n.\r\n      j = i - LOG_BASE + n;\r\n    }\r\n\r\n    if (rm !== void 0) {\r\n      k = mathpow(10, n - j - 1);\r\n\r\n      // Get the rounding digit at index j of w.\r\n      rd = w / k % 10 | 0;\r\n\r\n      // Are there any non-zero digits after the rounding digit?\r\n      doRound = sd < 0 || xd[xdi + 1] !== void 0 || w % k;\r\n\r\n      // The expression `w % mathpow(10, n - j - 1)` returns all the digits of w to the right of the\r\n      // digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression will give\r\n      // 714.\r\n\r\n      doRound = rm < 4\r\n        ? (rd || doRound) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n        : rd > 5 || rd == 5 && (rm == 4 || doRound || rm == 6 &&\r\n\r\n          // Check whether the digit to the left of the rounding digit is odd.\r\n          ((i > 0 ? j > 0 ? w / mathpow(10, n - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n            rm == (x.s < 0 ? 8 : 7));\r\n    }\r\n\r\n    if (sd < 1 || !xd[0]) {\r\n      if (doRound) {\r\n        k = getBase10Exponent(x);\r\n        xd.length = 1;\r\n\r\n        // Convert sd to decimal places.\r\n        sd = sd - k - 1;\r\n\r\n        // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n        xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n        x.e = mathfloor(-sd / LOG_BASE) || 0;\r\n      } else {\r\n        xd.length = 1;\r\n\r\n        // Zero.\r\n        xd[0] = x.e = x.s = 0;\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n    // Remove excess digits.\r\n    if (i == 0) {\r\n      xd.length = xdi;\r\n      k = 1;\r\n      xdi--;\r\n    } else {\r\n      xd.length = xdi + 1;\r\n      k = mathpow(10, LOG_BASE - i);\r\n\r\n      // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n      // j > 0 means i > number of leading zeros of w.\r\n      xd[xdi] = j > 0 ? (w / mathpow(10, n - j) % mathpow(10, j) | 0) * k : 0;\r\n    }\r\n\r\n    if (doRound) {\r\n      for (;;) {\r\n\r\n        // Is the digit to be rounded up in the first word of xd?\r\n        if (xdi == 0) {\r\n          if ((xd[0] += k) == BASE) {\r\n            xd[0] = 1;\r\n            ++x.e;\r\n          }\r\n\r\n          break;\r\n        } else {\r\n          xd[xdi] += k;\r\n          if (xd[xdi] != BASE) break;\r\n          xd[xdi--] = 0;\r\n          k = 1;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n\r\n    if (external && (x.e > MAX_E || x.e < -MAX_E)) {\r\n      throw Error(exponentOutOfRange + getBase10Exponent(x));\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function subtract(x, y) {\r\n    var d, e, i, j, k, len, xd, xe, xLTy, yd,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // Return y negated if x is zero.\r\n    // Return x if y is zero and x is non-zero.\r\n    if (!x.s || !y.s) {\r\n      if (y.s) y.s = -y.s;\r\n      else y = new Ctor(x);\r\n      return external ? round(y, pr) : y;\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n\r\n    // x and y are non-zero numbers with the same sign.\r\n\r\n    e = y.e;\r\n    xe = x.e;\r\n    xd = xd.slice();\r\n    k = xe - e;\r\n\r\n    // If exponents differ...\r\n    if (k) {\r\n      xLTy = k < 0;\r\n\r\n      if (xLTy) {\r\n        d = xd;\r\n        k = -k;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = xe;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Numbers with massively different exponents would result in a very high number of zeros\r\n      // needing to be prepended, but this can be avoided while still ensuring correct rounding by\r\n      // limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n      i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n      if (k > i) {\r\n        k = i;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      d.reverse();\r\n      for (i = k; i--;) d.push(0);\r\n      d.reverse();\r\n\r\n    // Base 1e7 exponents equal.\r\n    } else {\r\n\r\n      // Check digits to determine which is the bigger number.\r\n\r\n      i = xd.length;\r\n      len = yd.length;\r\n      xLTy = i < len;\r\n      if (xLTy) len = i;\r\n\r\n      for (i = 0; i < len; i++) {\r\n        if (xd[i] != yd[i]) {\r\n          xLTy = xd[i] < yd[i];\r\n          break;\r\n        }\r\n      }\r\n\r\n      k = 0;\r\n    }\r\n\r\n    if (xLTy) {\r\n      d = xd;\r\n      xd = yd;\r\n      yd = d;\r\n      y.s = -y.s;\r\n    }\r\n\r\n    len = xd.length;\r\n\r\n    // Append zeros to xd if shorter.\r\n    // Don't add zeros to yd if shorter as subtraction only needs to start at yd length.\r\n    for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n    // Subtract yd from xd.\r\n    for (i = yd.length; i > k;) {\r\n      if (xd[--i] < yd[i]) {\r\n        for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n        --xd[j];\r\n        xd[i] += BASE;\r\n      }\r\n\r\n      xd[i] -= yd[i];\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; xd[--len] === 0;) xd.pop();\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n    // Zero?\r\n    if (!xd[0]) return new Ctor(0);\r\n\r\n    y.d = xd;\r\n    y.e = e;\r\n\r\n    //return external && xd.length >= pr / LOG_BASE ? round(y, pr) : y;\r\n    return external ? round(y, pr) : y;\r\n  }\r\n\r\n\r\n  function toString(x, isExp, sd) {\r\n    var k,\r\n      e = getBase10Exponent(x),\r\n      str = digitsToString(x.d),\r\n      len = str.length;\r\n\r\n    if (isExp) {\r\n      if (sd && (k = sd - len) > 0) {\r\n        str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n      } else if (len > 1) {\r\n        str = str.charAt(0) + '.' + str.slice(1);\r\n      }\r\n\r\n      str = str + (e < 0 ? 'e' : 'e+') + e;\r\n    } else if (e < 0) {\r\n      str = '0.' + getZeroString(-e - 1) + str;\r\n      if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n    } else if (e >= len) {\r\n      str += getZeroString(e + 1 - len);\r\n      if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n    } else {\r\n      if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n      if (sd && (k = sd - len) > 0) {\r\n        if (e + 1 === len) str += '.';\r\n        str += getZeroString(k);\r\n      }\r\n    }\r\n\r\n    return x.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Does not strip trailing zeros.\r\n  function truncate(arr, len) {\r\n    if (arr.length > len) {\r\n      arr.length = len;\r\n      return true;\r\n    }\r\n  }\r\n\r\n\r\n  // Decimal methods\r\n\r\n\r\n  /*\r\n   *  clone\r\n   *  config/set\r\n   */\r\n\r\n\r\n  /*\r\n   * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n   * constructor.\r\n   *\r\n   */\r\n  function clone(obj) {\r\n    var i, p, ps;\r\n\r\n    /*\r\n     * The Decimal constructor and exported function.\r\n     * Return a new Decimal instance.\r\n     *\r\n     * value {number|string|Decimal} A numeric value.\r\n     *\r\n     */\r\n    function Decimal(value) {\r\n      var x = this;\r\n\r\n      // Decimal called without new.\r\n      if (!(x instanceof Decimal)) return new Decimal(value);\r\n\r\n      // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n      // which points to Object.\r\n      x.constructor = Decimal;\r\n\r\n      // Duplicate.\r\n      if (value instanceof Decimal) {\r\n        x.s = value.s;\r\n        x.e = value.e;\r\n        x.d = (value = value.d) ? value.slice() : value;\r\n        return;\r\n      }\r\n\r\n      if (typeof value === 'number') {\r\n\r\n        // Reject Infinity/NaN.\r\n        if (value * 0 !== 0) {\r\n          throw Error(invalidArgument + value);\r\n        }\r\n\r\n        if (value > 0) {\r\n          x.s = 1;\r\n        } else if (value < 0) {\r\n          value = -value;\r\n          x.s = -1;\r\n        } else {\r\n          x.s = 0;\r\n          x.e = 0;\r\n          x.d = [0];\r\n          return;\r\n        }\r\n\r\n        // Fast path for small integers.\r\n        if (value === ~~value && value < 1e7) {\r\n          x.e = 0;\r\n          x.d = [value];\r\n          return;\r\n        }\r\n\r\n        return parseDecimal(x, value.toString());\r\n      } else if (typeof value !== 'string') {\r\n        throw Error(invalidArgument + value);\r\n      }\r\n\r\n      // Minus sign?\r\n      if (value.charCodeAt(0) === 45) {\r\n        value = value.slice(1);\r\n        x.s = -1;\r\n      } else {\r\n        x.s = 1;\r\n      }\r\n\r\n      if (isDecimal.test(value)) parseDecimal(x, value);\r\n      else throw Error(invalidArgument + value);\r\n    }\r\n\r\n    Decimal.prototype = P;\r\n\r\n    Decimal.ROUND_UP = 0;\r\n    Decimal.ROUND_DOWN = 1;\r\n    Decimal.ROUND_CEIL = 2;\r\n    Decimal.ROUND_FLOOR = 3;\r\n    Decimal.ROUND_HALF_UP = 4;\r\n    Decimal.ROUND_HALF_DOWN = 5;\r\n    Decimal.ROUND_HALF_EVEN = 6;\r\n    Decimal.ROUND_HALF_CEIL = 7;\r\n    Decimal.ROUND_HALF_FLOOR = 8;\r\n\r\n    Decimal.clone = clone;\r\n    Decimal.config = Decimal.set = config;\r\n\r\n    if (obj === void 0) obj = {};\r\n    if (obj) {\r\n      ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'LN10'];\r\n      for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n    }\r\n\r\n    Decimal.config(obj);\r\n\r\n    return Decimal;\r\n  }\r\n\r\n\r\n  /*\r\n   * Configure global settings for a Decimal constructor.\r\n   *\r\n   * `obj` is an object with one or more of the following properties,\r\n   *\r\n   *   precision  {number}\r\n   *   rounding   {number}\r\n   *   toExpNeg   {number}\r\n   *   toExpPos   {number}\r\n   *\r\n   * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n   *\r\n   */\r\n  function config(obj) {\r\n    if (!obj || typeof obj !== 'object') {\r\n      throw Error(decimalError + 'Object expected');\r\n    }\r\n    var i, p, v,\r\n      ps = [\r\n        'precision', 1, MAX_DIGITS,\r\n        'rounding', 0, 8,\r\n        'toExpNeg', -1 / 0, 0,\r\n        'toExpPos', 0, 1 / 0\r\n      ];\r\n\r\n    for (i = 0; i < ps.length; i += 3) {\r\n      if ((v = obj[p = ps[i]]) !== void 0) {\r\n        if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n        else throw Error(invalidArgument + p + ': ' + v);\r\n      }\r\n    }\r\n\r\n    if ((v = obj[p = 'LN10']) !== void 0) {\r\n        if (v == Math.LN10) this[p] = new this(v);\r\n        else throw Error(invalidArgument + p + ': ' + v);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n\r\n  // Create and configure initial Decimal constructor.\r\n  Decimal = clone(Decimal);\r\n\r\n  Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n  // Internal constant.\r\n  ONE = new Decimal(1);\r\n\r\n\r\n  // Export.\r\n\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () {\r\n      return Decimal;\r\n    });\r\n\r\n  // Node and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = Decimal;\r\n\r\n    // Browser.\r\n  } else {\r\n    if (!globalScope) {\r\n      globalScope = typeof self != 'undefined' && self && self.self == self\r\n        ? self : Function('return this')();\r\n    }\r\n\r\n    globalScope.Decimal = Decimal;\r\n  }\r\n})(this);\r\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = addClass;\n\nvar _hasClass = _interopRequireDefault(require(\"./hasClass\"));\n\nfunction addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);\n}\n\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nexports.__esModule = true;\nexports.default = hasClass;\n\nfunction hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);else return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}\n\nmodule.exports = exports[\"default\"];","'use strict';\n\nfunction replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp('(^|\\\\s)' + classToRemove + '(?:\\\\s|$)', 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n\nmodule.exports = function removeClass(element, className) {\n  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n};","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nfunction componentWillMount() {\n  // Call this.constructor.gDSFP to support sub-classes.\n  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);\n  if (state !== null && state !== undefined) {\n    this.setState(state);\n  }\n}\n\nfunction componentWillReceiveProps(nextProps) {\n  // Call this.constructor.gDSFP to support sub-classes.\n  // Use the setState() updater to ensure state isn't stale in certain edge cases.\n  function updater(prevState) {\n    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);\n    return state !== null && state !== undefined ? state : null;\n  }\n  // Binding \"this\" is important for shallow renderer support.\n  this.setState(updater.bind(this));\n}\n\nfunction componentWillUpdate(nextProps, nextState) {\n  try {\n    var prevProps = this.props;\n    var prevState = this.state;\n    this.props = nextProps;\n    this.state = nextState;\n    this.__reactInternalSnapshotFlag = true;\n    this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(\n      prevProps,\n      prevState\n    );\n  } finally {\n    this.props = prevProps;\n    this.state = prevState;\n  }\n}\n\n// React may warn about cWM/cWRP/cWU methods being deprecated.\n// Add a flag to suppress these warnings for this special case.\ncomponentWillMount.__suppressDeprecationWarning = true;\ncomponentWillReceiveProps.__suppressDeprecationWarning = true;\ncomponentWillUpdate.__suppressDeprecationWarning = true;\n\nfunction polyfill(Component) {\n  var prototype = Component.prototype;\n\n  if (!prototype || !prototype.isReactComponent) {\n    throw new Error('Can only polyfill class components');\n  }\n\n  if (\n    typeof Component.getDerivedStateFromProps !== 'function' &&\n    typeof prototype.getSnapshotBeforeUpdate !== 'function'\n  ) {\n    return Component;\n  }\n\n  // If new component APIs are defined, \"unsafe\" lifecycles won't be called.\n  // Error if any of these lifecycles are present,\n  // Because they would work differently between older and newer (16.3+) versions of React.\n  var foundWillMountName = null;\n  var foundWillReceivePropsName = null;\n  var foundWillUpdateName = null;\n  if (typeof prototype.componentWillMount === 'function') {\n    foundWillMountName = 'componentWillMount';\n  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {\n    foundWillMountName = 'UNSAFE_componentWillMount';\n  }\n  if (typeof prototype.componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'componentWillReceiveProps';\n  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';\n  }\n  if (typeof prototype.componentWillUpdate === 'function') {\n    foundWillUpdateName = 'componentWillUpdate';\n  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {\n    foundWillUpdateName = 'UNSAFE_componentWillUpdate';\n  }\n  if (\n    foundWillMountName !== null ||\n    foundWillReceivePropsName !== null ||\n    foundWillUpdateName !== null\n  ) {\n    var componentName = Component.displayName || Component.name;\n    var newApiName =\n      typeof Component.getDerivedStateFromProps === 'function'\n        ? 'getDerivedStateFromProps()'\n        : 'getSnapshotBeforeUpdate()';\n\n    throw Error(\n      'Unsafe legacy lifecycles will not be called for components using new component APIs.\\n\\n' +\n        componentName +\n        ' uses ' +\n        newApiName +\n        ' but also contains the following legacy lifecycles:' +\n        (foundWillMountName !== null ? '\\n  ' + foundWillMountName : '') +\n        (foundWillReceivePropsName !== null\n          ? '\\n  ' + foundWillReceivePropsName\n          : '') +\n        (foundWillUpdateName !== null ? '\\n  ' + foundWillUpdateName : '') +\n        '\\n\\nThe above lifecycles should be removed. Learn more about this warning here:\\n' +\n        'https://fb.me/react-async-component-lifecycle-hooks'\n    );\n  }\n\n  // React <= 16.2 does not support static getDerivedStateFromProps.\n  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.\n  // Newer versions of React will ignore these lifecycles if gDSFP exists.\n  if (typeof Component.getDerivedStateFromProps === 'function') {\n    prototype.componentWillMount = componentWillMount;\n    prototype.componentWillReceiveProps = componentWillReceiveProps;\n  }\n\n  // React <= 16.2 does not support getSnapshotBeforeUpdate.\n  // As a workaround, use cWU to invoke the new lifecycle.\n  // Newer versions of React will ignore that lifecycle if gSBU exists.\n  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {\n    if (typeof prototype.componentDidUpdate !== 'function') {\n      throw new Error(\n        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'\n      );\n    }\n\n    prototype.componentWillUpdate = componentWillUpdate;\n\n    var componentDidUpdate = prototype.componentDidUpdate;\n\n    prototype.componentDidUpdate = function componentDidUpdatePolyfill(\n      prevProps,\n      prevState,\n      maybeSnapshot\n    ) {\n      // 16.3+ will not execute our will-update method;\n      // It will pass a snapshot value to did-update though.\n      // Older versions will require our polyfilled will-update value.\n      // We need to handle both cases, but can't just check for the presence of \"maybeSnapshot\",\n      // Because for <= 15.x versions this might be a \"prevContext\" object.\n      // We also can't just check \"__reactInternalSnapshot\",\n      // Because get-snapshot might return a falsy value.\n      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.\n      var snapshot = this.__reactInternalSnapshotFlag\n        ? this.__reactInternalSnapshot\n        : maybeSnapshot;\n\n      componentDidUpdate.call(this, prevProps, prevState, snapshot);\n    };\n  }\n\n  return Component;\n}\n\nexport { polyfill };\n","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar identity = function identity(i) {\n  return i;\n};\n\nexport var PLACE_HOLDER = {\n  '@@functional/placeholder': true\n};\n\nvar isPlaceHolder = function isPlaceHolder(val) {\n  return val === PLACE_HOLDER;\n};\n\nvar curry0 = function curry0(fn) {\n  return function _curried() {\n    if (arguments.length === 0 || arguments.length === 1 && isPlaceHolder(arguments.length <= 0 ? undefined : arguments[0])) {\n      return _curried;\n    }\n\n    return fn.apply(void 0, arguments);\n  };\n};\n\nvar curryN = function curryN(n, fn) {\n  if (n === 1) {\n    return fn;\n  }\n\n  return curry0(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var argsLength = args.filter(function (arg) {\n      return arg !== PLACE_HOLDER;\n    }).length;\n\n    if (argsLength >= n) {\n      return fn.apply(void 0, args);\n    }\n\n    return curryN(n - argsLength, curry0(function () {\n      for (var _len2 = arguments.length, restArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        restArgs[_key2] = arguments[_key2];\n      }\n\n      var newArgs = args.map(function (arg) {\n        return isPlaceHolder(arg) ? restArgs.shift() : arg;\n      });\n      return fn.apply(void 0, _toConsumableArray(newArgs).concat(restArgs));\n    }));\n  });\n};\n\nexport var curry = function curry(fn) {\n  return curryN(fn.length, fn);\n};\nexport var range = function range(begin, end) {\n  var arr = [];\n\n  for (var i = begin; i < end; ++i) {\n    arr[i - begin] = i;\n  }\n\n  return arr;\n};\nexport var map = curry(function (fn, arr) {\n  if (Array.isArray(arr)) {\n    return arr.map(fn);\n  }\n\n  return Object.keys(arr).map(function (key) {\n    return arr[key];\n  }).map(fn);\n});\nexport var compose = function compose() {\n  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n    args[_key3] = arguments[_key3];\n  }\n\n  if (!args.length) {\n    return identity;\n  }\n\n  var fns = args.reverse(); // first function can receive multiply arguments\n\n  var firstFn = fns[0];\n  var tailsFn = fns.slice(1);\n  return function () {\n    return tailsFn.reduce(function (res, fn) {\n      return fn(res);\n    }, firstFn.apply(void 0, arguments));\n  };\n};\nexport var reverse = function reverse(arr) {\n  if (Array.isArray(arr)) {\n    return arr.reverse();\n  } // can be string\n\n\n  return arr.split('').reverse.join('');\n};\nexport var memoize = function memoize(fn) {\n  var lastArgs = null;\n  var lastResult = null;\n  return function () {\n    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n      args[_key4] = arguments[_key4];\n    }\n\n    if (lastArgs && args.every(function (val, i) {\n      return val === lastArgs[i];\n    })) {\n      return lastResult;\n    }\n\n    lastArgs = args;\n    lastResult = fn.apply(void 0, args);\n    return lastResult;\n  };\n};","/**\n * @fileOverview 一些公用的运算方法\n * @author xile611\n * @date 2015-09-17\n */\nimport Decimal from 'decimal.js-light';\nimport { curry } from './utils';\n/**\n * 获取数值的位数\n * 其中绝对值属于区间[0.1, 1)， 得到的值为0\n * 绝对值属于区间[0.01, 0.1)，得到的位数为 -1\n * 绝对值属于区间[0.001, 0.01)，得到的位数为 -2\n *\n * @param  {Number} value 数值\n * @return {Integer} 位数\n */\n\nfunction getDigitCount(value) {\n  var result;\n\n  if (value === 0) {\n    result = 1;\n  } else {\n    result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;\n  }\n\n  return result;\n}\n/**\n * 按照固定的步长获取[start, end)这个区间的数据\n * 并且需要处理js计算精度的问题\n *\n * @param  {Decimal} start 起点\n * @param  {Decimal} end   终点，不包含该值\n * @param  {Decimal} step  步长\n * @return {Array}         若干数值\n */\n\n\nfunction rangeStep(start, end, step) {\n  var num = new Decimal(start);\n  var i = 0;\n  var result = []; // magic number to prevent infinite loop\n\n  while (num.lt(end) && i < 100000) {\n    result.push(num.toNumber());\n    num = num.add(step);\n    i++;\n  }\n\n  return result;\n}\n/**\n * 对数值进行线性插值\n *\n * @param  {Number} a  定义域的极点\n * @param  {Number} b  定义域的极点\n * @param  {Number} t  [0, 1]内的某个值\n * @return {Number}    定义域内的某个值\n */\n\n\nvar interpolateNumber = curry(function (a, b, t) {\n  var newA = +a;\n  var newB = +b;\n  return newA + t * (newB - newA);\n});\n/**\n * 线性插值的逆运算\n *\n * @param  {Number} a 定义域的极点\n * @param  {Number} b 定义域的极点\n * @param  {Number} x 可以认为是插值后的一个输出值\n * @return {Number}   当x在 a ~ b这个范围内时，返回值属于[0, 1]\n */\n\nvar uninterpolateNumber = curry(function (a, b, x) {\n  var diff = b - +a;\n  diff = diff || Infinity;\n  return (x - a) / diff;\n});\n/**\n * 线性插值的逆运算，并且有截断的操作\n *\n * @param  {Number} a 定义域的极点\n * @param  {Number} b 定义域的极点\n * @param  {Number} x 可以认为是插值后的一个输出值\n * @return {Number}   当x在 a ~ b这个区间内时，返回值属于[0, 1]，\n * 当x不在 a ~ b这个区间时，会截断到 a ~ b 这个区间\n */\n\nvar uninterpolateTruncation = curry(function (a, b, x) {\n  var diff = b - +a;\n  diff = diff || Infinity;\n  return Math.max(0, Math.min(1, (x - a) / diff));\n});\nexport default {\n  rangeStep: rangeStep,\n  getDigitCount: getDigitCount,\n  interpolateNumber: interpolateNumber,\n  uninterpolateNumber: uninterpolateNumber,\n  uninterpolateTruncation: uninterpolateTruncation\n};","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\n * @fileOverview calculate tick values of scale\n * @author xile611, arcthur\n * @date 2015-09-17\n */\nimport Decimal from 'decimal.js-light';\nimport { compose, range, memoize, map, reverse } from './util/utils';\nimport Arithmetic from './util/arithmetic';\n/**\n * Calculate a interval of a minimum value and a maximum value\n *\n * @param  {Number} min       The minimum value\n * @param  {Number} max       The maximum value\n * @return {Array} An interval\n */\n\nfunction getValidInterval(_ref) {\n  var _ref2 = _slicedToArray(_ref, 2),\n      min = _ref2[0],\n      max = _ref2[1];\n\n  var validMin = min,\n      validMax = max; // exchange\n\n  if (min > max) {\n    validMin = max;\n    validMax = min;\n  }\n\n  return [validMin, validMax];\n}\n/**\n * Calculate the step which is easy to understand between ticks, like 10, 20, 25\n *\n * @param  {Decimal} roughStep        The rough step calculated by deviding the\n * difference by the tickCount\n * @param  {Boolean} allowDecimals    Allow the ticks to be decimals or not\n * @param  {Integer} correctionFactor A correction factor\n * @return {Decimal} The step which is easy to understand between two ticks\n */\n\n\nfunction getFormatStep(roughStep, allowDecimals, correctionFactor) {\n  if (roughStep.lte(0)) {\n    return new Decimal(0);\n  }\n\n  var digitCount = Arithmetic.getDigitCount(roughStep.toNumber()); // The ratio between the rough step and the smallest number which has a bigger\n  // order of magnitudes than the rough step\n\n  var digitCountValue = new Decimal(10).pow(digitCount);\n  var stepRatio = roughStep.div(digitCountValue); // When an integer and a float multiplied, the accuracy of result may be wrong\n\n  var stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;\n  var amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber())).add(correctionFactor).mul(stepRatioScale);\n  var formatStep = amendStepRatio.mul(digitCountValue);\n  return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep));\n}\n/**\n * calculate the ticks when the minimum value equals to the maximum value\n *\n * @param  {Number}  value         The minimum valuue which is also the maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}                 ticks\n */\n\n\nfunction getTickOfSingleValue(value, tickCount, allowDecimals) {\n  var step = 1; // calculate the middle value of ticks\n\n  var middle = new Decimal(value);\n\n  if (!middle.isint() && allowDecimals) {\n    var absVal = Math.abs(value);\n\n    if (absVal < 1) {\n      // The step should be a float number when the difference is smaller than 1\n      step = new Decimal(10).pow(Arithmetic.getDigitCount(value) - 1);\n      middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);\n    } else if (absVal > 1) {\n      // Return the maximum integer which is smaller than 'value' when 'value' is greater than 1\n      middle = new Decimal(Math.floor(value));\n    }\n  } else if (value === 0) {\n    middle = new Decimal(Math.floor((tickCount - 1) / 2));\n  } else if (!allowDecimals) {\n    middle = new Decimal(Math.floor(value));\n  }\n\n  var middleIndex = Math.floor((tickCount - 1) / 2);\n  var fn = compose(map(function (n) {\n    return middle.add(new Decimal(n - middleIndex).mul(step)).toNumber();\n  }), range);\n  return fn(0, tickCount);\n}\n/**\n * Calculate the step\n *\n * @param  {Number}  min              The minimum value of an interval\n * @param  {Number}  max              The maximum value of an interval\n * @param  {Integer} tickCount        The count of ticks\n * @param  {Boolean} allowDecimals    Allow the ticks to be decimals or not\n * @param  {Number}  correctionFactor A correction factor\n * @return {Object}  The step, minimum value of ticks, maximum value of ticks\n */\n\n\nfunction calculateStep(min, max, tickCount, allowDecimals) {\n  var correctionFactor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;\n\n  // dirty hack (for recharts' test)\n  if (!Number.isFinite((max - min) / (tickCount - 1))) {\n    return {\n      step: new Decimal(0),\n      tickMin: new Decimal(0),\n      tickMax: new Decimal(0)\n    };\n  } // The step which is easy to understand between two ticks\n\n\n  var step = getFormatStep(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor); // A medial value of ticks\n\n  var middle; // When 0 is inside the interval, 0 should be a tick\n\n  if (min <= 0 && max >= 0) {\n    middle = new Decimal(0);\n  } else {\n    // calculate the middle value\n    middle = new Decimal(min).add(max).div(2); // minus modulo value\n\n    middle = middle.sub(new Decimal(middle).mod(step));\n  }\n\n  var belowCount = Math.ceil(middle.sub(min).div(step).toNumber());\n  var upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());\n  var scaleCount = belowCount + upCount + 1;\n\n  if (scaleCount > tickCount) {\n    // When more ticks need to cover the interval, step should be bigger.\n    return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1);\n  }\n\n  if (scaleCount < tickCount) {\n    // When less ticks can cover the interval, we should add some additional ticks\n    upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;\n    belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);\n  }\n\n  return {\n    step: step,\n    tickMin: middle.sub(new Decimal(belowCount).mul(step)),\n    tickMax: middle.add(new Decimal(upCount).mul(step))\n  };\n}\n/**\n * Calculate the ticks of an interval, the count of ticks will be guraranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getNiceTickValuesFn(_ref3) {\n  var _ref4 = _slicedToArray(_ref3, 2),\n      min = _ref4[0],\n      max = _ref4[1];\n\n  var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  // More than two ticks should be return\n  var count = Math.max(tickCount, 2);\n\n  var _getValidInterval = getValidInterval([min, max]),\n      _getValidInterval2 = _slicedToArray(_getValidInterval, 2),\n      cormin = _getValidInterval2[0],\n      cormax = _getValidInterval2[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    var _values = cormax === Infinity ? [cormin].concat(_toConsumableArray(range(0, tickCount - 1).map(function () {\n      return Infinity;\n    }))) : [].concat(_toConsumableArray(range(0, tickCount - 1).map(function () {\n      return -Infinity;\n    })), [cormax]);\n\n    return min > max ? reverse(_values) : _values;\n  }\n\n  if (cormin === cormax) {\n    return getTickOfSingleValue(cormin, tickCount, allowDecimals);\n  } // Get the step between two ticks\n\n\n  var _calculateStep = calculateStep(cormin, cormax, count, allowDecimals),\n      step = _calculateStep.step,\n      tickMin = _calculateStep.tickMin,\n      tickMax = _calculateStep.tickMax;\n\n  var values = Arithmetic.rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);\n  return min > max ? reverse(values) : values;\n}\n/**\n * Calculate the ticks of an interval, the count of ticks won't be guraranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getTickValuesFn(_ref5) {\n  var _ref6 = _slicedToArray(_ref5, 2),\n      min = _ref6[0],\n      max = _ref6[1];\n\n  var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  // More than two ticks should be return\n  var count = Math.max(tickCount, 2);\n\n  var _getValidInterval3 = getValidInterval([min, max]),\n      _getValidInterval4 = _slicedToArray(_getValidInterval3, 2),\n      cormin = _getValidInterval4[0],\n      cormax = _getValidInterval4[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    return [min, max];\n  }\n\n  if (cormin === cormax) {\n    return getTickOfSingleValue(cormin, tickCount, allowDecimals);\n  }\n\n  var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);\n  var fn = compose(map(function (n) {\n    return new Decimal(cormin).add(new Decimal(n).mul(step)).toNumber();\n  }), range);\n  var values = fn(0, count).filter(function (entry) {\n    return entry >= cormin && entry <= cormax;\n  });\n  return min > max ? reverse(values) : values;\n}\n/**\n * Calculate the ticks of an interval, the count of ticks won't be guraranteed,\n * but the domain will be guaranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getTickValuesFixedDomainFn(_ref7, tickCount) {\n  var _ref8 = _slicedToArray(_ref7, 2),\n      min = _ref8[0],\n      max = _ref8[1];\n\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n  // More than two ticks should be return\n  var _getValidInterval5 = getValidInterval([min, max]),\n      _getValidInterval6 = _slicedToArray(_getValidInterval5, 2),\n      cormin = _getValidInterval6[0],\n      cormax = _getValidInterval6[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    return [min, max];\n  }\n\n  if (cormin === cormax) {\n    return [cormin];\n  }\n\n  var count = Math.max(tickCount, 2);\n  var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);\n  var values = [].concat(_toConsumableArray(Arithmetic.rangeStep(new Decimal(cormin), new Decimal(cormax).sub(new Decimal(0.99).mul(step)), step)), [cormax]);\n  return min > max ? reverse(values) : values;\n}\n\nexport var getNiceTickValues = memoize(getNiceTickValuesFn);\nexport var getTickValues = memoize(getTickValuesFn);\nexport var getTickValuesFixedDomain = memoize(getTickValuesFixedDomainFn);"],"names":["module","exports","obj","__esModule","hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","toString","Object","prototype","key","call","join","default","globalScope","ONE","MAX_DIGITS","Decimal","precision","rounding","toExpNeg","toExpPos","LN10","external","decimalError","invalidArgument","exponentOutOfRange","mathfloor","Math","floor","mathpow","pow","isDecimal","BASE","MAX_SAFE_INTEGER","MAX_E","P","add","x","y","carry","d","e","k","len","xd","yd","Ctor","constructor","pr","s","round","slice","ceil","reverse","unshift","pop","checkInt32","min","max","Error","digitsToString","ws","indexOfLastWord","str","w","getZeroString","absoluteValue","abs","this","comparedTo","cmp","j","xdL","ydL","decimalPlaces","dp","dividedBy","div","divide","dividedToIntegerBy","idiv","equals","eq","exponent","getBase10Exponent","greaterThan","gt","greaterThanOrEqualTo","gte","isInteger","isint","isNegative","isneg","isPositive","ispos","isZero","lessThan","lt","lessThanOrEqualTo","lte","logarithm","log","base","r","wpr","ln","minus","sub","subtract","modulo","mod","q","times","naturalExponential","exp","naturalLogarithm","negated","neg","plus","sd","z","squareRoot","sqrt","n","t","toExponential","indexOf","mul","rL","shift","toDecimalPlaces","todp","rm","toFixed","toInteger","toint","toNumber","toPower","sign","yIsInt","yn","truncate","toPrecision","toSignificantDigits","tosd","valueOf","val","toJSON","multiplyInteger","temp","compare","a","b","aL","bL","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","denominator","sum","getLn10","zs","c","c0","numerator","x2","charAt","parseDecimal","replace","search","substring","charCodeAt","rd","doRound","xdi","xe","xLTy","isExp","arr","config","p","v","ps","clone","value","test","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","set","_interopRequireDefault","element","className","classList","_hasClass","setAttribute","baseVal","contains","replaceClassName","origClass","classToRemove","RegExp","remove","Symbol","getRawTag","objectToString","symToStringTag","toStringTag","undefined","freeGlobal","g","objectProto","nativeObjectToString","isOwn","tag","unmasked","result","freeSelf","self","root","Function","type","baseGetTag","isObjectLike","componentWillMount","state","getDerivedStateFromProps","props","setState","componentWillReceiveProps","nextProps","prevState","bind","componentWillUpdate","nextState","prevProps","__reactInternalSnapshotFlag","__reactInternalSnapshot","getSnapshotBeforeUpdate","polyfill","Component","isReactComponent","foundWillMountName","foundWillReceivePropsName","foundWillUpdateName","UNSAFE_componentWillMount","UNSAFE_componentWillReceiveProps","UNSAFE_componentWillUpdate","componentName","displayName","name","newApiName","componentDidUpdate","maybeSnapshot","snapshot","__suppressDeprecationWarning","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","iter","iterator","from","_iterableToArray","o","minLen","_unsupportedIterableToArray","TypeError","_nonIterableSpread","arr2","identity","PLACE_HOLDER","isPlaceHolder","curry0","fn","_curried","curryN","_len","args","_key","argsLength","filter","_len2","restArgs","_key2","newArgs","map","concat","curry","range","begin","end","keys","compose","_len3","_key3","fns","firstFn","tailsFn","reduce","res","split","memoize","lastArgs","lastResult","_len4","_key4","every","rangeStep","start","step","num","getDigitCount","interpolateNumber","newA","uninterpolateNumber","diff","Infinity","uninterpolateTruncation","_slicedToArray","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","err","_iterableToArrayLimit","_nonIterableRest","getValidInterval","_ref","_ref2","validMin","validMax","getFormatStep","roughStep","allowDecimals","correctionFactor","digitCount","digitCountValue","stepRatio","stepRatioScale","formatStep","getTickOfSingleValue","tickCount","middle","absVal","middleIndex","calculateStep","Number","isFinite","tickMin","tickMax","belowCount","upCount","scaleCount","getNiceTickValues","_ref3","_ref4","count","_getValidInterval","_getValidInterval2","cormin","cormax","_values","_calculateStep","values","getTickValuesFixedDomain","_ref5","_ref6","_getValidInterval3","_getValidInterval4","entry","_ref7","_ref8","_getValidInterval5","_getValidInterval6"],"sourceRoot":""}