{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/bignumber.js/bignumber.js","src/en-US.js","src/formatting.js","src/globalState.js","src/loading.js","src/manipulating.js","src/numbro.js","src/parsing.js","src/unformatting.js","src/validating.js"],"names":["f","exports","module","define","amd","window","global","self","this","numbro","r","e","n","t","o","i","c","require","u","a","Error","code","p","call","length","1","globalObject","BigNumber","isNumeric","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","s","z","j","charCodeAt","slice","compare","x","y","b","xc","yc","k","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","prototype","constructor","toString","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","alphabet","caseChanged","isNum","test","indexOf","replace","search","substring","round","DEBUG","toUpperCase","toLowerCase","push","format","rm","id","c0","ne","maxOrMin","args","method","m","normalise","pop","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","obj","v","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","_isBigNumber","maximum","arguments","lt","minimum","gt","random","dp","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","arr","reverse","sign","callerIsToString","pow","concat","multiply","base","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","Symbol","iterator","toStringTag","for","languageTag","delimiters","thousands","abbreviations","thousand","million","billion","trillion","spaceSeparated","ordinal","number","currency","symbol","position","currencyFormat","thousandSeparated","totalLength","formats","fourDigits","fullWithTwoDecimals","output","mantissa","fullWithTwoDecimalsNoCurrency","fullWithNoDecimals","globalState","validating","parsing","decimalSuffixes","bytes","general","scale","suffixes","marker","binary","defaultOptions","characteristic","forceAverage","average","optionalMantissa","negative","forceSign","_format","instance","providedFormat","undefined","parseFormat","validateFormat","postfix","formatOrDefault","currentCurrencyDefaultFormat","state","currentCurrency","options","Object","assign","space","currencyPosition","currencySymbol","formatNumber","_value","formatCurrency","currentPercentageDefaultFormat","prefixSymbol","formatPercentage","currentByteDefaultFormat","baseInfo","_getFormatByteUnits","getFormatByteUnits","value","defaults","currentAbbreviations","spaced","currentTimeDefaultFormat","hours","minutes","seconds","currentOrdinalDefaultFormat","ordinalFn","currentOrdinal","formatNumbro","power","zeroes","result","_result$split2","_slicedToArray","_base$split2","_base$split2$","toFixedLarge","_ref3","_ref3$state","_ref3$defaults","currentDefaults","hasZeroFormat","getZeroFormat","_ref2","_ref2$characteristicP","characteristicPrecision","_value$toExponential$2","numberString","exponential","optionalCharacteristic","mantissaPrecision","trimMantissa","abbreviation","data","_ref","_ref$spaceSeparated","_ref$totalLength","computeAverage","_data","trim","_result$toString$spli2","currentCharacteristic","_result$toString$spli3","currentMantissa","match","hasTrailingZeroes","index","setMantissaPrecision","currentDelimiters","thousandSeparator","thousandsSize","counter","unshift","indexesOfGroupSpaces","forEach","replaceDelimiters","_result$toString$spli5","missingZeros","setCharacteristicPrecision","defaultFormat","keys","_len","Array","_key","apply","getByteUnit","_len2","_key2","getBinaryByteUnit","_len3","_key3","getDecimalByteUnit","_len4","_key4","enUS","currentLanguageTag","languages","zeroFormat","globalDefaults","chooseLanguage","tag","currentLanguageData","currentLanguage","ordinalFormat","byteFormat","percentageFormat","timeFormat","setDefaults","setZeroFormat","string","languageData","registerLanguage","useLanguage","validateLanguage","setLanguage","fallbackTag","matchingLanguageTag","find","each","loadLanguagesInNode","tags","console","error","_subtract","other","otherValue","isNumbro","add","divide","difference","validator","loader","unformatter","formatter","manipulate","Numbro","_classCallCheck","input","normalizeInput","unformat","version","object","language","defaultCurrencyFormat","validate","parseOutput","parseOptionalCharacteristic","parseMantissa","allSuffixes","key","factor","escapeRegExp","unformatValue","inputString","computeUnformattedValue","stripped","newInput","possibleOrdinalValue","parseFloat","ordinalString","inversedAbbreviations","abbreviationValues","sort","numberOfAbbreviations","_i","removeFormattingSymbols","segments","matchesTime","bcp47RegExp","validFormat","type","validValues","restriction","message","mandatory","restrictions","children","validLanguage","timeDefaults","validateInput","validateSpec","toValidate","spec","skipMandatoryCheck","results","map","_typeof","_data$restrictions$i","JSON","stringify","_toConsumableArray","reduce","acc","current","validInput","isFormatValid"],"mappings":"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","file":"numbro.min.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v8.0.2\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2019 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\n  var BigNumber,\r\n    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                    // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * n {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(n, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor usage without new.\r\n      if (!(x instanceof BigNumber)) {\r\n\r\n        // Don't throw on constructor call without new (#81).\r\n        // '[BigNumber Error] Constructor call without new: {n}'\r\n        //throw Error(bignumberError + ' Constructor call without new: ' + n);\r\n        return new BigNumber(n, b);\r\n      }\r\n\r\n      if (b == null) {\r\n\r\n        // Duplicate.\r\n        if (n instanceof BigNumber) {\r\n          x.s = n.s;\r\n          x.e = n.e;\r\n          x.c = (n = n.c) ? n.slice() : n;\r\n          return;\r\n        }\r\n\r\n        isNum = typeof n == 'number';\r\n\r\n        if (isNum && n * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / n < 0 ? (n = -n, -1) : 1;\r\n\r\n          // Faster path for integers.\r\n          if (n === ~~n) {\r\n            for (e = 0, i = n; i >= 10; i /= 10, e++);\r\n            x.e = e;\r\n            x.c = [n];\r\n            return;\r\n          }\r\n\r\n          str = String(n);\r\n        } else {\r\n          str = String(n);\r\n          if (!isNumeric.test(str)) return parseNumeric(x, str, isNum);\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\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      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n        str = String(n);\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10) {\r\n          x = new BigNumber(n instanceof BigNumber ? n : str);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        isNum = typeof n == 'number';\r\n\r\n        if (isNum) {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (n * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + n);\r\n          }\r\n\r\n          // Prevent later check for length on converted number.\r\n          isNum = false;\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(n), isNum, b);\r\n          }\r\n        }\r\n\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else 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) === 48;);\r\n\r\n      str = str.slice(i, ++len);\r\n\r\n      if (str) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * n));\r\n        }\r\n\r\n        e = e - i - 1;\r\n\r\n         // Overflow?\r\n        if (e > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\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 element of the coefficient 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.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\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.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if only one character,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.$|[+-.\\s]|(.).*\\1/.test(v)) {\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * v {any}\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      return v instanceof BigNumber || v && v._isBigNumber === true || false;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, P.lt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, P.gt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\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.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.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          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    function maxOrMin(args, method) {\r\n      var n,\r\n        i = 1,\r\n        m = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        n = new BigNumber(args[i]);\r\n\r\n        // If any number is NaN, return NaN.\r\n        if (!n.s) {\r\n          m = n;\r\n          break;\r\n        } else if (method.call(m, n)) {\r\n          m = n;\r\n        }\r\n      }\r\n\r\n      return m;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n          x.c = x.e = null;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.c = x.e = x.s = null;\r\n        }\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = n / pows10[d - j - 1] % 10 | 0;\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || 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 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 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            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[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 n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) 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 BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(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 = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '1e' + 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 BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n      P[Symbol.toStringTag] = 'BigNumber';\r\n      // Node.js v10.12.0+\r\n      P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\r\n    }\r\n\r\n    if (configObject != null) BigNumber.set(configObject);\r\n\r\n    return BigNumber;\r\n  }\r\n\r\n\r\n  // PRIVATE HELPER FUNCTIONS\r\n\r\n\r\n  function bitFloor(n) {\r\n    var i = n | 0;\r\n    return n > 0 || n === i ? i : i - 1;\r\n  }\r\n\r\n\r\n  // Return a coefficient array as a string of base 10 digits.\r\n  function coeffToString(a) {\r\n    var s, z,\r\n      i = 1,\r\n      j = a.length,\r\n      r = a[0] + '';\r\n\r\n    for (; i < j;) {\r\n      s = a[i++] + '';\r\n      z = LOG_BASE - s.length;\r\n      for (; z--; s = '0' + s);\r\n      r += s;\r\n    }\r\n\r\n    // Determine trailing zeros.\r\n    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n    return r.slice(0, j + 1 || 1);\r\n  }\r\n\r\n\r\n  // Compare the value of BigNumbers x and y.\r\n  function compare(x, y) {\r\n    var a, b,\r\n      xc = x.c,\r\n      yc = y.c,\r\n      i = x.s,\r\n      j = y.s,\r\n      k = x.e,\r\n      l = y.e;\r\n\r\n    // Either NaN?\r\n    if (!i || !j) return null;\r\n\r\n    a = xc && !xc[0];\r\n    b = yc && !yc[0];\r\n\r\n    // Either zero?\r\n    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n    // Signs differ?\r\n    if (i != j) return i;\r\n\r\n    a = i < 0;\r\n    b = k == l;\r\n\r\n    // Either Infinity?\r\n    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n    // Compare exponents.\r\n    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n    // Compare lengths.\r\n    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n   */\r\n  function intCheck(n, min, max, name) {\r\n    if (n < min || n > max || n !== (n < 0 ? mathceil(n) : mathfloor(n))) {\r\n      throw Error\r\n       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n         : ' not a primitive number: ') + String(n));\r\n    }\r\n  }\r\n\r\n\r\n  // Assumes finite n.\r\n  function isOdd(n) {\r\n    var k = n.c.length - 1;\r\n    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n  }\r\n\r\n\r\n  function toExponential(str, e) {\r\n    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n     (e < 0 ? 'e' : 'e+') + e;\r\n  }\r\n\r\n\r\n  function toFixedPoint(str, e, z) {\r\n    var len, zs;\r\n\r\n    // Negative exponent?\r\n    if (e < 0) {\r\n\r\n      // Prepend zeros.\r\n      for (zs = z + '.'; ++e; zs += z);\r\n      str = zs + str;\r\n\r\n    // Positive exponent\r\n    } else {\r\n      len = str.length;\r\n\r\n      // Append zeros.\r\n      if (++e > len) {\r\n        for (zs = z, e -= len; --e; zs += z);\r\n        str += zs;\r\n      } else if (e < len) {\r\n        str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // EXPORT\r\n\r\n\r\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nmodule.exports = {\n    languageTag: \"en-US\",\n    delimiters: {\n        thousands: \",\",\n        decimal: \".\"\n    },\n    abbreviations: {\n        thousand: \"k\",\n        million: \"m\",\n        billion: \"b\",\n        trillion: \"t\"\n    },\n    spaceSeparated: false,\n    ordinal: function(number) {\n        let b = number % 10;\n        return (~~(number % 100 / 10) === 1) ? \"th\" : (b === 1) ? \"st\" : (b === 2) ? \"nd\" : (b === 3) ? \"rd\" : \"th\";\n    },\n    currency: {\n        symbol: \"$\",\n        position: \"prefix\",\n        code: \"USD\"\n    },\n    currencyFormat: {\n        thousandSeparated: true,\n        totalLength: 4,\n        spaceSeparated: true\n    },\n    formats: {\n        fourDigits: {\n            totalLength: 4,\n            spaceSeparated: true\n        },\n        fullWithTwoDecimals: {\n            output: \"currency\",\n            thousandSeparated: true,\n            mantissa: 2\n        },\n        fullWithTwoDecimalsNoCurrency: {\n            thousandSeparated: true,\n            mantissa: 2\n        },\n        fullWithNoDecimals: {\n            output: \"currency\",\n            thousandSeparated: true,\n            mantissa: 0\n        }\n    }\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst globalState = require(\"./globalState\");\nconst validating = require(\"./validating\");\nconst parsing = require(\"./parsing\");\n\nconst binarySuffixes = [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\"];\nconst decimalSuffixes = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"];\nconst bytes = {\n    general: {scale: 1024, suffixes: decimalSuffixes, marker: \"bd\"},\n    binary: {scale: 1024, suffixes: binarySuffixes, marker: \"b\"},\n    decimal: {scale: 1000, suffixes: decimalSuffixes, marker: \"d\"}\n};\n\nconst defaultOptions = {\n    totalLength: 0,\n    characteristic: 0,\n    forceAverage: false,\n    average: false,\n    mantissa: -1,\n    optionalMantissa: true,\n    thousandSeparated: false,\n    spaceSeparated: false,\n    negative: \"sign\",\n    forceSign: false\n};\n\n/**\n * Entry point. Format the provided INSTANCE according to the PROVIDEDFORMAT.\n * This method ensure the prefix and postfix are added as the last step.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {NumbroFormat|string} [providedFormat] - specification for formatting\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction format(instance, providedFormat = {}, numbro) {\n    if (typeof providedFormat === \"string\") {\n        providedFormat = parsing.parseFormat(providedFormat);\n    }\n\n    let valid = validating.validateFormat(providedFormat);\n\n    if (!valid) {\n        return \"ERROR: invalid format\";\n    }\n\n    let prefix = providedFormat.prefix || \"\";\n    let postfix = providedFormat.postfix || \"\";\n\n    let output = formatNumbro(instance, providedFormat, numbro);\n    output = insertPrefix(output, prefix);\n    output = insertPostfix(output, postfix);\n    return output;\n}\n\n/**\n * Format the provided INSTANCE according to the PROVIDEDFORMAT.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatNumbro(instance, providedFormat, numbro) {\n    switch (providedFormat.output) {\n        case \"currency\": {\n            providedFormat = formatOrDefault(providedFormat, globalState.currentCurrencyDefaultFormat());\n            return formatCurrency(instance, providedFormat, globalState, numbro);\n        }\n        case \"percent\": {\n            providedFormat = formatOrDefault(providedFormat, globalState.currentPercentageDefaultFormat());\n            return formatPercentage(instance, providedFormat, globalState, numbro);\n        }\n        case \"byte\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentByteDefaultFormat());\n            return formatByte(instance, providedFormat, globalState, numbro);\n        case \"time\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentTimeDefaultFormat());\n            return formatTime(instance, providedFormat, globalState, numbro);\n        case \"ordinal\":\n            providedFormat = formatOrDefault(providedFormat, globalState.currentOrdinalDefaultFormat());\n            return formatOrdinal(instance, providedFormat, globalState, numbro);\n        case \"number\":\n        default:\n            return formatNumber({\n                instance,\n                providedFormat,\n                numbro\n            });\n    }\n}\n\n/**\n * Get the decimal byte unit (MB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1000).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getDecimalByteUnit(instance) {\n    let data = bytes.decimal;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Get the binary byte unit (MiB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1024).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getBinaryByteUnit(instance) {\n    let data = bytes.binary;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Get the decimal byte unit (MB) for the provided numbro INSTANCE.\n * We go from one unit to another using the decimal system (1024).\n *\n * @param {Numbro} instance - numbro instance to compute\n * @return {String}\n */\nfunction getByteUnit(instance) {\n    let data = bytes.general;\n    return getFormatByteUnits(instance._value, data.suffixes, data.scale).suffix;\n}\n\n/**\n * Return the value and the suffix computed in byte.\n * It uses the SUFFIXES and the SCALE provided.\n *\n * @param {number} value - Number to format\n * @param {[String]} suffixes - List of suffixes\n * @param {number} scale - Number in-between two units\n * @return {{value: Number, suffix: String}}\n */\nfunction getFormatByteUnits(value, suffixes, scale) {\n    let suffix = suffixes[0];\n    let abs = Math.abs(value);\n\n    if (abs >= scale) {\n        for (let power = 1; power < suffixes.length; ++power) {\n            let min = Math.pow(scale, power);\n            let max = Math.pow(scale, power + 1);\n\n            if (abs >= min && abs < max) {\n                suffix = suffixes[power];\n                value = value / min;\n                break;\n            }\n        }\n\n        // values greater than or equal to [scale] YB never set the suffix\n        if (suffix === suffixes[0]) {\n            value = value / Math.pow(scale, suffixes.length - 1);\n            suffix = suffixes[suffixes.length - 1];\n        }\n    }\n\n    return {value, suffix};\n}\n\n/**\n * Format the provided INSTANCE as bytes using the PROVIDEDFORMAT, and STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatByte(instance, providedFormat, state, numbro) {\n    let base = providedFormat.base || \"binary\";\n    let baseInfo = bytes[base];\n\n    let {value, suffix} = getFormatByteUnits(instance._value, baseInfo.suffixes, baseInfo.scale);\n    let output = formatNumber({\n        instance: numbro(value),\n        providedFormat,\n        state,\n        defaults: state.currentByteDefaultFormat()\n    });\n    let abbreviations = state.currentAbbreviations();\n    return `${output}${abbreviations.spaced ? \" \" : \"\"}${suffix}`;\n}\n\n/**\n * Format the provided INSTANCE as an ordinal using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @return {string}\n */\nfunction formatOrdinal(instance, providedFormat, state) {\n    let ordinalFn = state.currentOrdinal();\n    let options = Object.assign({}, defaultOptions, providedFormat);\n\n    let output = formatNumber({\n        instance,\n        providedFormat,\n        state\n    });\n    let ordinal = ordinalFn(instance._value);\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}${ordinal}`;\n}\n\n/**\n * Format the provided INSTANCE as a time HH:MM:SS.\n *\n * @param {Numbro} instance - numbro instance to format\n * @return {string}\n */\nfunction formatTime(instance) {\n    let hours = Math.floor(instance._value / 60 / 60);\n    let minutes = Math.floor((instance._value - (hours * 60 * 60)) / 60);\n    let seconds = Math.round(instance._value - (hours * 60 * 60) - (minutes * 60));\n    return `${hours}:${(minutes < 10) ? \"0\" : \"\"}${minutes}:${(seconds < 10) ? \"0\" : \"\"}${seconds}`;\n}\n\n/**\n * Format the provided INSTANCE as a percentage using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param numbro - the numbro singleton\n * @return {string}\n */\nfunction formatPercentage(instance, providedFormat, state, numbro) {\n    let prefixSymbol = providedFormat.prefixSymbol;\n\n    let output = formatNumber({\n        instance: numbro(instance._value * 100),\n        providedFormat,\n        state\n    });\n    let options = Object.assign({}, defaultOptions, providedFormat);\n\n    if (prefixSymbol) {\n        return `%${options.spaceSeparated ? \" \" : \"\"}${output}`;\n    }\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}%`;\n}\n\n/**\n * Format the provided INSTANCE as a percentage using the PROVIDEDFORMAT,\n * and the STATE.\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} providedFormat - specification for formatting\n * @param {globalState} state - shared state of the library\n * @return {string}\n */\nfunction formatCurrency(instance, providedFormat, state) {\n    const currentCurrency = state.currentCurrency();\n    let options = Object.assign({}, defaultOptions, providedFormat);\n    let decimalSeparator = undefined;\n    let space = \"\";\n    let average = !!options.totalLength || !!options.forceAverage || options.average;\n    let position = providedFormat.currencyPosition || currentCurrency.position;\n    let symbol = providedFormat.currencySymbol || currentCurrency.symbol;\n\n    if (options.spaceSeparated) {\n        space = \" \";\n    }\n\n    if (position === \"infix\") {\n        decimalSeparator = space + symbol + space;\n    }\n\n    let output = formatNumber({\n        instance,\n        providedFormat,\n        state,\n        decimalSeparator\n    });\n\n    if (position === \"prefix\") {\n        if (instance._value < 0 && options.negative === \"sign\") {\n            output = `-${space}${symbol}${output.slice(1)}`;\n        } else {\n            output = symbol + space + output;\n        }\n    }\n\n    if (!position || position === \"postfix\") {\n        space = average ? \"\" : space;\n        output = output + space + symbol;\n    }\n\n    return output;\n}\n\n/**\n * Compute the average value out of VALUE.\n * The other parameters are computation options.\n *\n * @param {number} value - value to compute\n * @param {string} [forceAverage] - forced unit used to compute\n * @param {{}} abbreviations - part of the language specification\n * @param {boolean} spaceSeparated - `true` if a space must be inserted between the value and the abbreviation\n * @param {number} [totalLength] - total length of the output including the characteristic and the mantissa\n * @return {{value: number, abbreviation: string, mantissaPrecision: number}}\n */\nfunction computeAverage({value, forceAverage, abbreviations, spaceSeparated = false, totalLength = 0}) {\n    let abbreviation = \"\";\n    let abs = Math.abs(value);\n    let mantissaPrecision = -1;\n\n    if ((abs >= Math.pow(10, 12) && !forceAverage) || (forceAverage === \"trillion\")) {\n        // trillion\n        abbreviation = abbreviations.trillion;\n        value = value / Math.pow(10, 12);\n    } else if ((abs < Math.pow(10, 12) && abs >= Math.pow(10, 9) && !forceAverage) || (forceAverage === \"billion\")) {\n        // billion\n        abbreviation = abbreviations.billion;\n        value = value / Math.pow(10, 9);\n    } else if ((abs < Math.pow(10, 9) && abs >= Math.pow(10, 6) && !forceAverage) || (forceAverage === \"million\")) {\n        // million\n        abbreviation = abbreviations.million;\n        value = value / Math.pow(10, 6);\n    } else if ((abs < Math.pow(10, 6) && abs >= Math.pow(10, 3) && !forceAverage) || (forceAverage === \"thousand\")) {\n        // thousand\n        abbreviation = abbreviations.thousand;\n        value = value / Math.pow(10, 3);\n    }\n\n    let optionalSpace = spaceSeparated ? \" \" : \"\";\n\n    if (abbreviation) {\n        abbreviation = optionalSpace + abbreviation;\n    }\n\n    if (totalLength) {\n        let characteristic = value.toString().split(\".\")[0];\n        mantissaPrecision = Math.max(totalLength - characteristic.length, 0);\n    }\n\n    return {value, abbreviation, mantissaPrecision};\n}\n\n/**\n * Compute an exponential form for VALUE, taking into account CHARACTERISTIC\n * if provided.\n * @param {number} value - value to compute\n * @param {number} [characteristicPrecision] - optional characteristic length\n * @return {{value: number, abbreviation: string}}\n */\nfunction computeExponential({value, characteristicPrecision = 0}) {\n    let [numberString, exponential] = value.toExponential().split(\"e\");\n    let number = +numberString;\n\n    if (!characteristicPrecision) {\n        return {\n            value: number,\n            abbreviation: `e${exponential}`\n        };\n    }\n\n    let characteristicLength = 1; // see `toExponential`\n\n    if (characteristicLength < characteristicPrecision) {\n        number = number * Math.pow(10, characteristicPrecision - characteristicLength);\n        exponential = +exponential - (characteristicPrecision - characteristicLength);\n        exponential = exponential >= 0 ? `+${exponential}` : exponential;\n    }\n\n    return {\n        value: number,\n        abbreviation: `e${exponential}`\n    };\n}\n\n/**\n * Return a string of NUMBER zero.\n *\n * @param {number} number - Length of the output\n * @return {string}\n */\nfunction zeroes(number) {\n    let result = \"\";\n    for (let i = 0; i < number; i++) {\n        result += \"0\";\n    }\n\n    return result;\n}\n\n/**\n * Return a string representing VALUE with a PRECISION-long mantissa.\n * This method is for large/small numbers only (a.k.a. including a \"e\").\n *\n * @param {number} value - number to precise\n * @param {number} precision - desired length for the mantissa\n * @return {string}\n */\nfunction toFixedLarge(value, precision) {\n    let result = value.toString();\n\n    let [base, exp] = result.split(\"e\");\n\n    let [characteristic, mantissa = \"\"] = base.split(\".\");\n\n    if (+exp > 0) {\n        result = characteristic + mantissa + zeroes(exp - mantissa.length);\n    } else {\n        let prefix = \".\";\n\n        if (+characteristic < 0) {\n            prefix = `-0${prefix}`;\n        } else {\n            prefix = `0${prefix}`;\n        }\n\n        let suffix = (zeroes(-exp - 1) + Math.abs(characteristic) + mantissa).substr(0, precision);\n        if (suffix.length < precision) {\n            suffix += zeroes(precision - suffix.length);\n        }\n        result = prefix + suffix;\n    }\n\n    if (+exp > 0 && precision > 0) {\n        result += `.${zeroes(precision)}`;\n    }\n\n    return result;\n}\n\n/**\n * Return a string representing VALUE with a PRECISION-long mantissa.\n *\n * @param {number} value - number to precise\n * @param {number} precision - desired length for the mantissa\n * @return {string}\n */\nfunction toFixed(value, precision) {\n    if (value.toString().indexOf(\"e\") !== -1) {\n        return toFixedLarge(value, precision);\n    }\n\n    return (Math.round(+`${value}e+${precision}`) / (Math.pow(10, precision))).toFixed(precision);\n}\n\n/**\n * Return the current OUTPUT with a mantissa precision of PRECISION.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} optionalMantissa - if `true`, the mantissa is omitted when it's only zeroes\n * @param {number} precision - desired precision of the mantissa\n * @param {boolean} trim - if `true`, trailing zeroes are removed from the mantissa\n * @return {string}\n */\nfunction setMantissaPrecision(output, value, optionalMantissa, precision, trim) {\n    if (precision === -1) {\n        return output;\n    }\n\n    let result = toFixed(value, precision);\n    let [currentCharacteristic, currentMantissa = \"\"] = result.toString().split(\".\");\n\n    if (currentMantissa.match(/^0+$/) && (optionalMantissa || trim)) {\n        return currentCharacteristic;\n    }\n\n    let hasTrailingZeroes = currentMantissa.match(/0+$/);\n    if (trim && hasTrailingZeroes) {\n        return `${currentCharacteristic}.${currentMantissa.toString().slice(0, hasTrailingZeroes.index)}`;\n    }\n\n    return result.toString();\n}\n\n/**\n * Return the current OUTPUT with a characteristic precision of PRECISION.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} optionalCharacteristic - `true` if the characteristic is omitted when it's only zeroes\n * @param {number} precision - desired precision of the characteristic\n * @return {string}\n */\nfunction setCharacteristicPrecision(output, value, optionalCharacteristic, precision) {\n    let result = output;\n    let [currentCharacteristic, currentMantissa] = result.toString().split(\".\");\n\n    if (currentCharacteristic.match(/^-?0$/) && optionalCharacteristic) {\n        if (!currentMantissa) {\n            return currentCharacteristic.replace(\"0\", \"\");\n        }\n\n        return `${currentCharacteristic.replace(\"0\", \"\")}.${currentMantissa}`;\n    }\n\n    if (currentCharacteristic.length < precision) {\n        let missingZeros = precision - currentCharacteristic.length;\n        for (let i = 0; i < missingZeros; i++) {\n            result = `0${result}`;\n        }\n    }\n\n    return result.toString();\n}\n\n/**\n * Return the indexes where are the group separations after splitting\n * `totalLength` in group of `groupSize` size.\n * Important: we start grouping from the right hand side.\n *\n * @param {number} totalLength - total length of the characteristic to split\n * @param {number} groupSize - length of each group\n * @return {[number]}\n */\nfunction indexesOfGroupSpaces(totalLength, groupSize) {\n    let result = [];\n    let counter = 0;\n    for (let i = totalLength; i > 0; i--) {\n        if (counter === groupSize) {\n            result.unshift(i);\n            counter = 0;\n        }\n        counter++;\n    }\n\n    return result;\n}\n\n/**\n * Replace the decimal separator with DECIMALSEPARATOR and insert thousand\n * separators.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {boolean} thousandSeparated - `true` if the characteristic must be separated\n * @param {globalState} state - shared state of the library\n * @param {string} decimalSeparator - string to use as decimal separator\n * @return {string}\n */\nfunction replaceDelimiters(output, value, thousandSeparated, state, decimalSeparator) {\n    let delimiters = state.currentDelimiters();\n    let thousandSeparator = delimiters.thousands;\n    decimalSeparator = decimalSeparator || delimiters.decimal;\n    let thousandsSize = delimiters.thousandsSize || 3;\n\n    let result = output.toString();\n    let characteristic = result.split(\".\")[0];\n    let mantissa = result.split(\".\")[1];\n\n    if (thousandSeparated) {\n        if (value < 0) {\n            // Remove the minus sign\n            characteristic = characteristic.slice(1);\n        }\n\n        let indexesToInsertThousandDelimiters = indexesOfGroupSpaces(characteristic.length, thousandsSize);\n        indexesToInsertThousandDelimiters.forEach((position, index) => {\n            characteristic = characteristic.slice(0, position + index) + thousandSeparator + characteristic.slice(position + index);\n        });\n\n        if (value < 0) {\n            // Add back the minus sign\n            characteristic = `-${characteristic}`;\n        }\n    }\n\n    if (!mantissa) {\n        result = characteristic;\n    } else {\n        result = characteristic + decimalSeparator + mantissa;\n    }\n    return result;\n}\n\n/**\n * Insert the provided ABBREVIATION at the end of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} abbreviation - abbreviation to append\n * @return {*}\n */\nfunction insertAbbreviation(output, abbreviation) {\n    return output + abbreviation;\n}\n\n/**\n * Insert the positive/negative sign according to the NEGATIVE flag.\n * If the value is negative but still output as 0, the negative sign is removed.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {number} value - number being currently formatted\n * @param {string} negative - flag for the negative form (\"sign\" or \"parenthesis\")\n * @return {*}\n */\nfunction insertSign(output, value, negative) {\n    if (value === 0) {\n        return output;\n    }\n\n    if (+output === 0) {\n        return output.replace(\"-\", \"\");\n    }\n\n    if (value > 0) {\n        return `+${output}`;\n    }\n\n    if (negative === \"sign\") {\n        return output;\n    }\n\n    return `(${output.replace(\"-\", \"\")})`;\n}\n\n/**\n * Insert the provided PREFIX at the start of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} prefix - abbreviation to prepend\n * @return {*}\n */\nfunction insertPrefix(output, prefix) {\n    return prefix + output;\n}\n\n/**\n * Insert the provided POSTFIX at the end of OUTPUT.\n *\n * @param {string} output - output being build in the process of formatting\n * @param {string} postfix - abbreviation to append\n * @return {*}\n */\nfunction insertPostfix(output, postfix) {\n    return output + postfix;\n}\n\n/**\n * Format the provided INSTANCE as a number using the PROVIDEDFORMAT,\n * and the STATE.\n * This is the key method of the framework!\n *\n * @param {Numbro} instance - numbro instance to format\n * @param {{}} [providedFormat] - specification for formatting\n * @param {globalState} state - shared state of the library\n * @param {string} decimalSeparator - string to use as decimal separator\n * @param {{}} defaults - Set of default values used for formatting\n * @return {string}\n */\nfunction formatNumber({instance, providedFormat, state = globalState, decimalSeparator, defaults = state.currentDefaults()}) {\n    let value = instance._value;\n\n    if (value === 0 && state.hasZeroFormat()) {\n        return state.getZeroFormat();\n    }\n\n    if (!isFinite(value)) {\n        return value.toString();\n    }\n\n    let options = Object.assign({}, defaultOptions, defaults, providedFormat);\n\n    let totalLength = options.totalLength;\n    let characteristicPrecision = totalLength ? 0 : options.characteristic;\n    let optionalCharacteristic = options.optionalCharacteristic;\n    let forceAverage = options.forceAverage;\n    let average = !!totalLength || !!forceAverage || options.average;\n\n    // default when averaging is to chop off decimals\n    let mantissaPrecision = totalLength ? -1 : (average && providedFormat.mantissa === undefined ? 0 : options.mantissa);\n    let optionalMantissa = totalLength ? false : (providedFormat.optionalMantissa === undefined ? mantissaPrecision === -1 : options.optionalMantissa);\n    let trimMantissa = options.trimMantissa;\n    let thousandSeparated = options.thousandSeparated;\n    let spaceSeparated = options.spaceSeparated;\n    let negative = options.negative;\n    let forceSign = options.forceSign;\n    let exponential = options.exponential;\n\n    let abbreviation = \"\";\n\n    if (average) {\n        let data = computeAverage({\n            value,\n            forceAverage,\n            abbreviations: state.currentAbbreviations(),\n            spaceSeparated: spaceSeparated,\n            totalLength\n        });\n\n        value = data.value;\n        abbreviation += data.abbreviation;\n\n        if (totalLength) {\n            mantissaPrecision = data.mantissaPrecision;\n        }\n    }\n\n    if (exponential) {\n        let data = computeExponential({\n            value,\n            characteristicPrecision\n        });\n\n        value = data.value;\n        abbreviation = data.abbreviation + abbreviation;\n    }\n\n    let output = setMantissaPrecision(value.toString(), value, optionalMantissa, mantissaPrecision, trimMantissa);\n    output = setCharacteristicPrecision(output, value, optionalCharacteristic, characteristicPrecision);\n    output = replaceDelimiters(output, value, thousandSeparated, state, decimalSeparator);\n\n    if (average || exponential) {\n        output = insertAbbreviation(output, abbreviation);\n    }\n\n    if (forceSign || value < 0) {\n        output = insertSign(output, value, negative);\n    }\n\n    return output;\n}\n\n/**\n * If FORMAT is non-null and not just an output, return FORMAT.\n * Return DEFAULTFORMAT otherwise.\n *\n * @param providedFormat\n * @param defaultFormat\n */\nfunction formatOrDefault(providedFormat, defaultFormat) {\n    if (!providedFormat) {\n        return defaultFormat;\n    }\n\n    let keys = Object.keys(providedFormat);\n    if (keys.length === 1 && keys[0] === \"output\") {\n        return defaultFormat;\n    }\n\n    return providedFormat;\n}\n\nmodule.exports = (numbro) => ({\n    format: (...args) => format(...args, numbro),\n    getByteUnit: (...args) => getByteUnit(...args, numbro),\n    getBinaryByteUnit: (...args) => getBinaryByteUnit(...args, numbro),\n    getDecimalByteUnit: (...args) => getDecimalByteUnit(...args, numbro),\n    formatOrDefault\n});\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst enUS = require(\"./en-US\");\nconst validating = require(\"./validating\");\nconst parsing = require(\"./parsing\");\n\nlet state = {};\n\nlet currentLanguageTag = undefined;\nlet languages = {};\n\nlet zeroFormat = null;\n\nlet globalDefaults = {};\n\nfunction chooseLanguage(tag) { currentLanguageTag = tag; }\n\nfunction currentLanguageData() { return languages[currentLanguageTag]; }\n\n/**\n * Return all the register languages\n *\n * @return {{}}\n */\nstate.languages = () => Object.assign({}, languages);\n\n//\n// Current language accessors\n//\n\n/**\n * Return the current language tag\n *\n * @return {string}\n */\nstate.currentLanguage = () => currentLanguageTag;\n\n/**\n * Return the current language currency data\n *\n * @return {{}}\n */\nstate.currentCurrency = () => currentLanguageData().currency;\n\n/**\n * Return the current language abbreviations data\n *\n * @return {{}}\n */\nstate.currentAbbreviations = () => currentLanguageData().abbreviations;\n\n/**\n * Return the current language delimiters data\n *\n * @return {{}}\n */\nstate.currentDelimiters = () => currentLanguageData().delimiters;\n\n/**\n * Return the current language ordinal function\n *\n * @return {function}\n */\nstate.currentOrdinal = () => currentLanguageData().ordinal;\n\n//\n// Defaults\n//\n\n/**\n * Return the current formatting defaults.\n * Use first uses the current language default, then fallback to the globally defined defaults.\n *\n * @return {{}}\n */\nstate.currentDefaults = () => Object.assign({}, currentLanguageData().defaults, globalDefaults);\n\n/**\n * Return the ordinal default-format.\n * Use first uses the current language ordinal default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentOrdinalDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().ordinalFormat);\n\n/**\n * Return the byte default-format.\n * Use first uses the current language byte default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentByteDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().byteFormat);\n\n/**\n * Return the percentage default-format.\n * Use first uses the current language percentage default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentPercentageDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().percentageFormat);\n\n/**\n * Return the currency default-format.\n * Use first uses the current language currency default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentCurrencyDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().currencyFormat);\n\n/**\n * Return the time default-format.\n * Use first uses the current language currency default, then fallback to the regular defaults.\n *\n * @return {{}}\n */\nstate.currentTimeDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().timeFormat);\n\n/**\n * Set the global formatting defaults.\n *\n * @param {{}|string} format - formatting options to use as defaults\n */\nstate.setDefaults = (format) => {\n    format = parsing.parseFormat(format);\n    if (validating.validateFormat(format)) {\n        globalDefaults = format;\n    }\n};\n\n//\n// Zero format\n//\n\n/**\n * Return the format string for 0.\n *\n * @return {string}\n */\nstate.getZeroFormat = () => zeroFormat;\n\n/**\n * Set a STRING to output when the value is 0.\n *\n * @param {{}|string} string - string to set\n */\nstate.setZeroFormat = (string) => zeroFormat = typeof(string) === \"string\" ? string : null;\n\n/**\n * Return true if a format for 0 has been set already.\n *\n * @return {boolean}\n */\nstate.hasZeroFormat = () => zeroFormat !== null;\n\n//\n// Getters/Setters\n//\n\n/**\n * Return the language data for the provided TAG.\n * Return the current language data if no tag is provided.\n *\n * Throw an error if the tag doesn't match any registered language.\n *\n * @param {string} [tag] - language tag of a registered language\n * @return {{}}\n */\nstate.languageData = (tag) => {\n    if (tag) {\n        if (languages[tag]) {\n            return languages[tag];\n        }\n        throw new Error(`Unknown tag \"${tag}\"`);\n    }\n\n    return currentLanguageData();\n};\n\n/**\n * Register the provided DATA as a language if and only if the data is valid.\n * If the data is not valid, an error is thrown.\n *\n * When USELANGUAGE is true, the registered language is then used.\n *\n * @param {{}} data - language data to register\n * @param {boolean} [useLanguage] - `true` if the provided data should become the current language\n */\nstate.registerLanguage = (data, useLanguage = false) => {\n    if (!validating.validateLanguage(data)) {\n        throw new Error(\"Invalid language data\");\n    }\n\n    languages[data.languageTag] = data;\n\n    if (useLanguage) {\n        chooseLanguage(data.languageTag);\n    }\n};\n\n/**\n * Set the current language according to TAG.\n * If TAG doesn't match a registered language, another language matching\n * the \"language\" part of the tag (according to BCP47: https://tools.ietf.org/rfc/bcp/bcp47.txt).\n * If none, the FALLBACKTAG is used. If the FALLBACKTAG doesn't match a register language,\n * `en-US` is finally used.\n *\n * @param tag\n * @param fallbackTag\n */\nstate.setLanguage = (tag, fallbackTag = enUS.languageTag) => {\n    if (!languages[tag]) {\n        let suffix = tag.split(\"-\")[0];\n\n        let matchingLanguageTag = Object.keys(languages).find(each => {\n            return each.split(\"-\")[0] === suffix;\n        });\n\n        if (!languages[matchingLanguageTag]) {\n            chooseLanguage(fallbackTag);\n            return;\n        }\n\n        chooseLanguage(matchingLanguageTag);\n        return;\n    }\n\n    chooseLanguage(tag);\n};\n\nstate.registerLanguage(enUS);\ncurrentLanguageTag = enUS.languageTag;\n\nmodule.exports = state;\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * Load languages matching TAGS. Silently pass over the failing load.\n *\n * We assume here that we are in a node environment, so we don't check for it.\n * @param {[String]} tags - list of tags to load\n * @param {Numbro} numbro - the numbro singleton\n */\nfunction loadLanguagesInNode(tags, numbro) {\n    tags.forEach((tag) => {\n        let data = undefined;\n        try {\n            data = require(`../languages/${tag}`);\n        } catch (e) {\n            console.error(`Unable to load \"${tag}\". No matching language file found.`); // eslint-disable-line no-console\n        }\n\n        if (data) {\n            numbro.registerLanguage(data);\n        }\n    });\n}\n\nmodule.exports = (numbro) => ({\n    loadLanguagesInNode: (tags) => loadLanguagesInNode(tags, numbro)\n});\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst BigNumber = require(\"bignumber.js\");\n\n/**\n * Add a number or a numbro to N.\n *\n * @param {Numbro} n - augend\n * @param {number|Numbro} other - addend\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction add(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.plus(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Subtract a number or a numbro from N.\n *\n * @param {Numbro} n - minuend\n * @param {number|Numbro} other - subtrahend\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction subtract(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.minus(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Multiply N by a number or a numbro.\n *\n * @param {Numbro} n - multiplicand\n * @param {number|Numbro} other - multiplier\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction multiply(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.times(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Divide N by a number or a numbro.\n *\n * @param {Numbro} n - dividend\n * @param {number|Numbro} other - divisor\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction divide(n, other, numbro) {\n    let value = new BigNumber(n._value);\n    let otherValue = other;\n\n    if (numbro.isNumbro(other)) {\n        otherValue = other._value;\n    }\n\n    otherValue = new BigNumber(otherValue);\n\n    n._value = value.dividedBy(otherValue).toNumber();\n    return n;\n}\n\n/**\n * Set N to the OTHER (or the value of OTHER when it's a numbro instance).\n *\n * @param {Numbro} n - numbro instance to mutate\n * @param {number|Numbro} other - new value to assign to N\n * @param {numbro} numbro - numbro singleton\n * @return {Numbro} n\n */\nfunction set (n, other, numbro) {\n    let value = other;\n\n    if (numbro.isNumbro(other)) {\n        value = other._value;\n    }\n\n    n._value = value;\n    return n;\n}\n\n/**\n * Return the distance between N and OTHER.\n *\n * @param {Numbro} n\n * @param {number|Numbro} other\n * @param {numbro} numbro - numbro singleton\n * @return {number}\n */\nfunction difference(n, other, numbro) {\n    let clone = numbro(n._value);\n    subtract(clone, other, numbro);\n\n    return Math.abs(clone._value);\n}\n\nmodule.exports = numbro => ({\n    add: (n, other) => add(n, other, numbro),\n    subtract: (n, other) => subtract(n, other, numbro),\n    multiply: (n, other) => multiply(n, other, numbro),\n    divide: (n, other) => divide(n, other, numbro),\n    set: (n, other) => set(n, other, numbro),\n    difference: (n, other) => difference(n, other, numbro)\n});\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst VERSION = \"2.1.2\";\n\nconst globalState = require(\"./globalState\");\nconst validator = require(\"./validating\");\nconst loader = require(\"./loading\")(numbro);\nconst unformatter = require(\"./unformatting\");\nlet formatter = require(\"./formatting\")(numbro);\nlet manipulate = require(\"./manipulating\")(numbro);\nconst parsing = require(\"./parsing\");\n\nclass Numbro {\n    constructor(number) {\n        this._value = number;\n    }\n\n    clone() { return numbro(this._value); }\n\n    format(format = {}) { return formatter.format(this, format); }\n\n    formatCurrency(format) {\n        if (typeof format === \"string\") {\n            format = parsing.parseFormat(format);\n        }\n        format = formatter.formatOrDefault(format, globalState.currentCurrencyDefaultFormat());\n        format.output = \"currency\";\n        return formatter.format(this, format);\n    }\n\n    formatTime(format = {}) {\n        format.output = \"time\";\n        return formatter.format(this, format);\n    }\n\n    binaryByteUnits() { return formatter.getBinaryByteUnit(this);}\n\n    decimalByteUnits() { return formatter.getDecimalByteUnit(this);}\n\n    byteUnits() { return formatter.getByteUnit(this);}\n\n    difference(other) { return manipulate.difference(this, other); }\n\n    add(other) { return manipulate.add(this, other); }\n\n    subtract(other) { return manipulate.subtract(this, other); }\n\n    multiply(other) { return manipulate.multiply(this, other); }\n\n    divide(other) { return manipulate.divide(this, other); }\n\n    set(input) { return manipulate.set(this, normalizeInput(input)); }\n\n    value() { return this._value; }\n\n    valueOf() { return this._value; }\n}\n\n/**\n * Make its best to convert input into a number.\n *\n * @param {numbro|string|number} input - Input to convert\n * @return {number}\n */\nfunction normalizeInput(input) {\n    let result = input;\n    if (numbro.isNumbro(input)) {\n        result = input._value;\n    } else if (typeof input === \"string\") {\n        result = numbro.unformat(input);\n    } else if (isNaN(input)) {\n        result = NaN;\n    }\n\n    return result;\n}\n\nfunction numbro(input) {\n    return new Numbro(normalizeInput(input));\n}\n\nnumbro.version = VERSION;\n\nnumbro.isNumbro = function(object) {\n    return object instanceof Numbro;\n};\n\n//\n// `numbro` static methods\n//\n\nnumbro.language = globalState.currentLanguage;\nnumbro.registerLanguage = globalState.registerLanguage;\nnumbro.setLanguage = globalState.setLanguage;\nnumbro.languages = globalState.languages;\nnumbro.languageData = globalState.languageData;\nnumbro.zeroFormat = globalState.setZeroFormat;\nnumbro.defaultFormat = globalState.currentDefaults;\nnumbro.setDefaults = globalState.setDefaults;\nnumbro.defaultCurrencyFormat = globalState.currentCurrencyDefaultFormat;\nnumbro.validate = validator.validate;\nnumbro.loadLanguagesInNode = loader.loadLanguagesInNode;\nnumbro.unformat = unformatter.unformat;\n\nmodule.exports = numbro;\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * Parse the format STRING looking for a prefix. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parsePrefix(string, result) {\n    let match = string.match(/^{([^}]*)}/);\n    if (match) {\n        result.prefix = match[1];\n        return string.slice(match[0].length);\n    }\n\n    return string;\n}\n\n/**\n * Parse the format STRING looking for a postfix. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parsePostfix(string, result) {\n    let match = string.match(/{([^}]*)}$/);\n    if (match) {\n        result.postfix = match[1];\n\n        return string.slice(0, -match[0].length);\n    }\n\n    return string;\n}\n\n/**\n * Parse the format STRING looking for the output value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseOutput(string, result) {\n    if (string.indexOf(\"$\") !== -1) {\n        result.output = \"currency\";\n        return;\n    }\n\n    if (string.indexOf(\"%\") !== -1) {\n        result.output = \"percent\";\n        return;\n    }\n\n    if (string.indexOf(\"bd\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"general\";\n        return;\n    }\n\n    if (string.indexOf(\"b\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"binary\";\n        return;\n\n    }\n\n    if (string.indexOf(\"d\") !== -1) {\n        result.output = \"byte\";\n        result.base = \"decimal\";\n        return;\n\n    }\n\n    if (string.indexOf(\":\") !== -1) {\n        result.output = \"time\";\n        return;\n    }\n\n    if (string.indexOf(\"o\") !== -1) {\n        result.output = \"ordinal\";\n    }\n}\n\n/**\n * Parse the format STRING looking for the thousand separated value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseThousandSeparated(string, result) {\n    if (string.indexOf(\",\") !== -1) {\n        result.thousandSeparated = true;\n    }\n}\n\n/**\n * Parse the format STRING looking for the space separated value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseSpaceSeparated(string, result) {\n    if (string.indexOf(\" \") !== -1) {\n        result.spaceSeparated = true;\n    }\n}\n\n/**\n * Parse the format STRING looking for the total length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseTotalLength(string, result) {\n    let match = string.match(/[1-9]+[0-9]*/);\n\n    if (match) {\n        result.totalLength = +match[0];\n    }\n}\n\n/**\n * Parse the format STRING looking for the characteristic length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseCharacteristic(string, result) {\n    let characteristic = string.split(\".\")[0];\n    let match = characteristic.match(/0+/);\n    if (match) {\n        result.characteristic = match[0].length;\n    }\n}\n\n/**\n * Parse the format STRING looking for the mantissa length. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseMantissa(string, result) {\n    let mantissa = string.split(\".\")[1];\n    if (mantissa) {\n        let match = mantissa.match(/0+/);\n        if (match) {\n            result.mantissa = match[0].length;\n        }\n    }\n}\n\n/**\n * Parse the format STRING looking for the average value. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseAverage(string, result) {\n    if (string.indexOf(\"a\") !== -1) {\n        result.average = true;\n    }\n}\n\n/**\n * Parse the format STRING looking for a forced average precision. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseForceAverage(string, result) {\n    if (string.indexOf(\"K\") !== -1) {\n        result.forceAverage = \"thousand\";\n    } else if (string.indexOf(\"M\") !== -1) {\n        result.forceAverage = \"million\";\n    } else if (string.indexOf(\"B\") !== -1) {\n        result.forceAverage = \"billion\";\n    } else if (string.indexOf(\"T\") !== -1) {\n        result.forceAverage = \"trillion\";\n    }\n}\n\n/**\n * Parse the format STRING finding if the mantissa is optional. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseOptionalMantissa(string, result) {\n    if (string.match(/\\[\\.]/)) {\n        result.optionalMantissa = true;\n    } else if (string.match(/\\./)) {\n        result.optionalMantissa = false;\n    }\n}\n\n/**\n * Parse the format STRING finding if the characteristic is optional. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseOptionalCharacteristic(string, result) {\n    if (string.indexOf(\".\") !== -1) {\n        let characteristic = string.split(\".\")[0];\n        result.optionalCharacteristic = characteristic.indexOf(\"0\") === -1;\n    }\n}\n\n/**\n * Parse the format STRING looking for the negative format. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {string} - format\n */\nfunction parseNegative(string, result) {\n    if (string.match(/^\\+?\\([^)]*\\)$/)) {\n        result.negative = \"parenthesis\";\n    }\n    if (string.match(/^\\+?-/)) {\n        result.negative = \"sign\";\n    }\n}\n\n/**\n * Parse the format STRING finding if the sign is mandatory. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseForceSign(string, result) {\n    if (string.match(/^\\+/)) {\n        result.forceSign = true;\n    }\n}\n\n/**\n * Parse the format STRING and accumulating the values ie RESULT.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n * @return {NumbroFormat} - format\n */\nfunction parseFormat(string, result = {}) {\n    if (typeof string !== \"string\") {\n        return string;\n    }\n\n    string = parsePrefix(string, result);\n    string = parsePostfix(string, result);\n    parseOutput(string, result);\n    parseTotalLength(string, result);\n    parseCharacteristic(string, result);\n    parseOptionalCharacteristic(string, result);\n    parseAverage(string, result);\n    parseForceAverage(string, result);\n    parseMantissa(string, result);\n    parseOptionalMantissa(string, result);\n    parseThousandSeparated(string, result);\n    parseSpaceSeparated(string, result);\n    parseNegative(string, result);\n    parseForceSign(string, result);\n\n    return result;\n}\n\nmodule.exports = {\n    parseFormat\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nconst allSuffixes = [\n    {key: \"ZiB\", factor: Math.pow(1024, 7)},\n    {key: \"ZB\", factor: Math.pow(1000, 7)},\n    {key: \"YiB\", factor: Math.pow(1024, 8)},\n    {key: \"YB\", factor: Math.pow(1000, 8)},\n    {key: \"TiB\", factor: Math.pow(1024, 4)},\n    {key: \"TB\", factor: Math.pow(1000, 4)},\n    {key: \"PiB\", factor: Math.pow(1024, 5)},\n    {key: \"PB\", factor: Math.pow(1000, 5)},\n    {key: \"MiB\", factor: Math.pow(1024, 2)},\n    {key: \"MB\", factor: Math.pow(1000, 2)},\n    {key: \"KiB\", factor: Math.pow(1024, 1)},\n    {key: \"KB\", factor: Math.pow(1000, 1)},\n    {key: \"GiB\", factor: Math.pow(1024, 3)},\n    {key: \"GB\", factor: Math.pow(1000, 3)},\n    {key: \"EiB\", factor: Math.pow(1024, 6)},\n    {key: \"EB\", factor: Math.pow(1000, 6)},\n    {key: \"B\", factor: 1}\n];\n\n/**\n * Generate a RegExp where S get all RegExp specific characters escaped.\n *\n * @param {string} s - string representing a RegExp\n * @return {string}\n */\nfunction escapeRegExp(s) {\n    return s.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, \"\\\\$&\");\n}\n\n/**\n * Recursively compute the unformatted value.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @param {function} ordinal - function used to generate an ordinal out of a number\n * @param {string} zeroFormat - string representing zero\n * @param {*} abbreviations - abbreviations used while generating the inputString\n * @param {NumbroFormat} format - format used while generating the inputString\n * @return {number|undefined}\n */\nfunction computeUnformattedValue(inputString, delimiters, currencySymbol = \"\", ordinal, zeroFormat, abbreviations, format) {\n    if (!isNaN(+inputString)) {\n        return +inputString;\n    }\n\n    let stripped = \"\";\n    // Negative\n\n    let newInput = inputString.replace(/(^[^(]*)\\((.*)\\)([^)]*$)/, \"$1$2$3\");\n\n    if (newInput !== inputString) {\n        return -1 * computeUnformattedValue(newInput, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n    }\n\n    // Byte\n\n    for (let i = 0; i < allSuffixes.length; i++) {\n        let suffix = allSuffixes[i];\n        stripped = inputString.replace(suffix.key, \"\");\n\n        if (stripped !== inputString) {\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) * suffix.factor;\n        }\n    }\n\n    // Percent\n\n    stripped = inputString.replace(\"%\", \"\");\n\n    if (stripped !== inputString) {\n        return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) / 100;\n    }\n\n    // Ordinal\n\n    let possibleOrdinalValue = parseFloat(inputString);\n\n    if (isNaN(possibleOrdinalValue)) {\n        return undefined;\n    }\n\n    let ordinalString = ordinal(possibleOrdinalValue);\n    if (ordinalString && ordinalString !== \".\") { // if ordinal is \".\" it will be caught next round in the +inputString\n        stripped = inputString.replace(new RegExp(`${escapeRegExp(ordinalString)}$`), \"\");\n\n        if (stripped !== inputString) {\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n        }\n    }\n\n    // Average\n\n    let inversedAbbreviations = {};\n    Object.keys(abbreviations).forEach((key) => {\n        inversedAbbreviations[abbreviations[key]] = key;\n    });\n\n    let abbreviationValues = Object.keys(inversedAbbreviations).sort().reverse();\n    let numberOfAbbreviations = abbreviationValues.length;\n\n    for (let i = 0; i < numberOfAbbreviations; i++) {\n        let value = abbreviationValues[i];\n        let key = inversedAbbreviations[value];\n\n        stripped = inputString.replace(value, \"\");\n        if (stripped !== inputString) {\n            let factor = undefined;\n            switch (key) { // eslint-disable-line default-case\n                case \"thousand\":\n                    factor = Math.pow(10, 3);\n                    break;\n                case \"million\":\n                    factor = Math.pow(10, 6);\n                    break;\n                case \"billion\":\n                    factor = Math.pow(10, 9);\n                    break;\n                case \"trillion\":\n                    factor = Math.pow(10, 12);\n                    break;\n            }\n            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) * factor;\n        }\n    }\n\n    return undefined;\n}\n\n/**\n * Removes in one pass all formatting symbols.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @return {string}\n */\nfunction removeFormattingSymbols(inputString, delimiters, currencySymbol = \"\") {\n    // Currency\n\n    let stripped = inputString.replace(currencySymbol, \"\");\n\n    // Thousand separators\n\n    stripped = stripped.replace(new RegExp(`([0-9])${escapeRegExp(delimiters.thousands)}([0-9])`, \"g\"), \"$1$2\");\n\n    // Decimal\n\n    stripped = stripped.replace(delimiters.decimal, \".\");\n\n    return stripped;\n}\n\n/**\n * Unformat a numbro-generated string to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @param {*} delimiters - Delimiters used to generate the inputString\n * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n * @param {function} ordinal - function used to generate an ordinal out of a number\n * @param {string} zeroFormat - string representing zero\n * @param {*} abbreviations - abbreviations used while generating the inputString\n * @param {NumbroFormat} format - format used while generating the inputString\n * @return {number|undefined}\n */\nfunction unformatValue(inputString, delimiters, currencySymbol = \"\", ordinal, zeroFormat, abbreviations, format) {\n    if (inputString === \"\") {\n        return undefined;\n    }\n\n    // Zero Format\n\n    if (inputString === zeroFormat) {\n        return 0;\n    }\n\n    let value = removeFormattingSymbols(inputString, delimiters, currencySymbol);\n    return computeUnformattedValue(value, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n}\n\n/**\n * Check if the INPUTSTRING represents a time.\n *\n * @param {string} inputString - string to check\n * @param {*} delimiters - Delimiters used while generating the inputString\n * @return {boolean}\n */\nfunction matchesTime(inputString, delimiters) {\n    let separators = inputString.indexOf(\":\") && delimiters.thousands !== \":\";\n\n    if (!separators) {\n        return false;\n    }\n\n    let segments = inputString.split(\":\");\n    if (segments.length !== 3) {\n        return false;\n    }\n\n    let hours = +segments[0];\n    let minutes = +segments[1];\n    let seconds = +segments[2];\n\n    return !isNaN(hours) && !isNaN(minutes) && !isNaN(seconds);\n}\n\n/**\n * Unformat a numbro-generated string representing a time to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @return {number}\n */\nfunction unformatTime(inputString) {\n    let segments = inputString.split(\":\");\n\n    let hours = +segments[0];\n    let minutes = +segments[1];\n    let seconds = +segments[2];\n\n    return seconds + 60 * minutes + 3600 * hours;\n}\n\n/**\n * Unformat a numbro-generated string to retrieve the original value.\n *\n * @param {string} inputString - string to unformat\n * @param {NumbroFormat} format - format used  while generating the inputString\n * @return {number}\n */\nfunction unformat(inputString, format) {\n    // Avoid circular references\n    const globalState = require(\"./globalState\");\n\n    let delimiters = globalState.currentDelimiters();\n    let currencySymbol = globalState.currentCurrency().symbol;\n    let ordinal = globalState.currentOrdinal();\n    let zeroFormat = globalState.getZeroFormat();\n    let abbreviations = globalState.currentAbbreviations();\n\n    let value = undefined;\n\n    if (typeof inputString === \"string\") {\n        if (matchesTime(inputString, delimiters)) {\n            value = unformatTime(inputString);\n        } else {\n            value = unformatValue(inputString, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format);\n        }\n    } else if (typeof inputString === \"number\") {\n        value = inputString;\n    } else {\n        return undefined;\n    }\n\n    if (value === undefined) {\n        return undefined;\n    }\n\n    return value;\n}\n\nmodule.exports = {\n    unformat\n};\n","/*!\n * Copyright (c) 2017 Benjamin Van Ryseghem<benjamin@vanryseghem.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nlet unformatter = require(\"./unformatting\");\n\n// Simplified regexp supporting only `language`, `script`, and `region`\nconst bcp47RegExp = /^[a-z]{2,3}(-[a-zA-Z]{4})?(-([A-Z]{2}|[0-9]{3}))?$/;\n\nconst validOutputValues = [\n    \"currency\",\n    \"percent\",\n    \"byte\",\n    \"time\",\n    \"ordinal\",\n    \"number\"\n];\n\nconst validForceAverageValues = [\n    \"trillion\",\n    \"billion\",\n    \"million\",\n    \"thousand\"\n];\n\nconst validCurrencyPosition = [\n    \"prefix\",\n    \"infix\",\n    \"postfix\"\n];\n\nconst validNegativeValues = [\n    \"sign\",\n    \"parenthesis\"\n];\n\nconst validMandatoryAbbreviations = {\n    type: \"object\",\n    children: {\n        thousand: {\n            type: \"string\",\n            mandatory: true\n        },\n        million: {\n            type: \"string\",\n            mandatory: true\n        },\n        billion: {\n            type: \"string\",\n            mandatory: true\n        },\n        trillion: {\n            type: \"string\",\n            mandatory: true\n        }\n    },\n    mandatory: true\n};\n\nconst validAbbreviations = {\n    type: \"object\",\n    children: {\n        thousand: \"string\",\n        million: \"string\",\n        billion: \"string\",\n        trillion: \"string\"\n    }\n};\n\nconst validBaseValues = [\n    \"decimal\",\n    \"binary\",\n    \"general\"\n];\n\nconst validFormat = {\n    output: {\n        type: \"string\",\n        validValues: validOutputValues\n    },\n    base: {\n        type: \"string\",\n        validValues: validBaseValues,\n        restriction: (number, format) => format.output === \"byte\",\n        message: \"`base` must be provided only when the output is `byte`\",\n        mandatory: (format) => format.output === \"byte\"\n    },\n    characteristic: {\n        type: \"number\",\n        restriction: (number) => number >= 0,\n        message: \"value must be positive\"\n    },\n    prefix: \"string\",\n    postfix: \"string\",\n    forceAverage: {\n        type: \"string\",\n        validValues: validForceAverageValues\n    },\n    average: \"boolean\",\n    currencyPosition: {\n        type: \"string\",\n        validValues: validCurrencyPosition\n    },\n    currencySymbol: \"string\",\n    totalLength: {\n        type: \"number\",\n        restrictions: [\n            {\n                restriction: (number) => number >= 0,\n                message: \"value must be positive\"\n            },\n            {\n                restriction: (number, format) => !format.exponential,\n                message: \"`totalLength` is incompatible with `exponential`\"\n            }\n        ]\n    },\n    mantissa: {\n        type: \"number\",\n        restriction: (number) => number >= 0,\n        message: \"value must be positive\"\n    },\n    optionalMantissa: \"boolean\",\n    trimMantissa: \"boolean\",\n    optionalCharacteristic: \"boolean\",\n    thousandSeparated: \"boolean\",\n    spaceSeparated: \"boolean\",\n    abbreviations: validAbbreviations,\n    negative: {\n        type: \"string\",\n        validValues: validNegativeValues\n    },\n    forceSign: \"boolean\",\n    exponential: {\n        type: \"boolean\"\n    },\n    prefixSymbol: {\n        type: \"boolean\",\n        restriction: (number, format) => format.output === \"percent\",\n        message: \"`prefixSymbol` can be provided only when the output is `percent`\"\n    }\n};\n\nconst validLanguage = {\n    languageTag: {\n        type: \"string\",\n        mandatory: true,\n        restriction: (tag) => {\n            return tag.match(bcp47RegExp);\n        },\n        message: \"the language tag must follow the BCP 47 specification (see https://tools.ieft.org/html/bcp47)\"\n    },\n    delimiters: {\n        type: \"object\",\n        children: {\n            thousands: \"string\",\n            decimal: \"string\",\n            thousandsSize: \"number\"\n        },\n        mandatory: true\n    },\n    abbreviations: validMandatoryAbbreviations,\n    spaceSeparated: \"boolean\",\n    ordinal: {\n        type: \"function\",\n        mandatory: true\n    },\n    currency: {\n        type: \"object\",\n        children: {\n            symbol: \"string\",\n            position: \"string\",\n            code: \"string\"\n        },\n        mandatory: true\n    },\n    defaults: \"format\",\n    ordinalFormat: \"format\",\n    byteFormat: \"format\",\n    percentageFormat: \"format\",\n    currencyFormat: \"format\",\n    timeDefaults: \"format\",\n    formats: {\n        type: \"object\",\n        children: {\n            fourDigits: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithTwoDecimals: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithTwoDecimalsNoCurrency: {\n                type: \"format\",\n                mandatory: true\n            },\n            fullWithNoDecimals: {\n                type: \"format\",\n                mandatory: true\n            }\n        }\n    }\n};\n\n/**\n * Check the validity of the provided input and format.\n * The check is NOT lazy.\n *\n * @param {string|number|Numbro} input - input to check\n * @param {NumbroFormat} format - format to check\n * @return {boolean} True when everything is correct\n */\nfunction validate(input, format) {\n    let validInput = validateInput(input);\n    let isFormatValid = validateFormat(format);\n\n    return validInput && isFormatValid;\n}\n\n/**\n * Check the validity of the numbro input.\n *\n * @param {string|number|Numbro} input - input to check\n * @return {boolean} True when everything is correct\n */\nfunction validateInput(input) {\n    let value = unformatter.unformat(input);\n\n    return !!value;\n}\n\n/**\n * Check the validity of the provided format TOVALIDATE against SPEC.\n *\n * @param {NumbroFormat} toValidate - format to check\n * @param {*} spec - specification against which to check\n * @param {string} prefix - prefix use for error messages\n * @param {boolean} skipMandatoryCheck - `true` when the check for mandatory key must be skipped\n * @return {boolean} True when everything is correct\n */\nfunction validateSpec(toValidate, spec, prefix, skipMandatoryCheck = false) {\n    let results = Object.keys(toValidate).map((key) => {\n        if (!spec[key]) {\n            console.error(`${prefix} Invalid key: ${key}`); // eslint-disable-line no-console\n            return false;\n        }\n\n        let value = toValidate[key];\n        let data = spec[key];\n\n        if (typeof data === \"string\") {\n            data = {type: data};\n        }\n\n        if (data.type === \"format\") { // all formats are partial (a.k.a will be merged with some default values) thus no need to check mandatory values\n            let valid = validateSpec(value, validFormat, `[Validate ${key}]`, true);\n\n            if (!valid) {\n                return false;\n            }\n        } else if (typeof value !== data.type) {\n            console.error(`${prefix} ${key} type mismatched: \"${data.type}\" expected, \"${typeof value}\" provided`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.restrictions && data.restrictions.length) {\n            let length = data.restrictions.length;\n            for (let i = 0; i < length; i++) {\n                let {restriction, message} = data.restrictions[i];\n                if (!restriction(value, toValidate)) {\n                    console.error(`${prefix} ${key} invalid value: ${message}`); // eslint-disable-line no-console\n                    return false;\n                }\n            }\n        }\n\n        if (data.restriction && !data.restriction(value, toValidate)) {\n            console.error(`${prefix} ${key} invalid value: ${data.message}`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.validValues && data.validValues.indexOf(value) === -1) {\n            console.error(`${prefix} ${key} invalid value: must be among ${JSON.stringify(data.validValues)}, \"${value}\" provided`); // eslint-disable-line no-console\n            return false;\n        }\n\n        if (data.children) {\n            let valid = validateSpec(value, data.children, `[Validate ${key}]`);\n\n            if (!valid) {\n                return false;\n            }\n        }\n\n        return true;\n    });\n\n    if (!skipMandatoryCheck) {\n        results.push(...Object.keys(spec).map((key) => {\n            let data = spec[key];\n            if (typeof data === \"string\") {\n                data = {type: data};\n            }\n\n            if (data.mandatory) {\n                let mandatory = data.mandatory;\n                if (typeof mandatory === \"function\") {\n                    mandatory = mandatory(toValidate);\n                }\n\n                if (mandatory && toValidate[key] === undefined) {\n                    console.error(`${prefix} Missing mandatory key \"${key}\"`); // eslint-disable-line no-console\n                    return false;\n                }\n            }\n\n            return true;\n        }));\n    }\n\n    return results.reduce((acc, current) => {\n        return acc && current;\n    }, true);\n}\n\n/**\n * Check the provided FORMAT.\n *\n * @param {NumbroFormat} format - format to check\n * @return {boolean}\n */\nfunction validateFormat(format) {\n    return validateSpec(format, validFormat, \"[Validate format]\");\n}\n\n/**\n * Check the provided LANGUAGE.\n *\n * @param {NumbroLanguage} language - language to check\n * @return {boolean}\n */\nfunction validateLanguage(language) {\n    return validateSpec(language, validLanguage, \"[Validate language]\");\n}\n\nmodule.exports = {\n    validate,\n    validateFormat,\n    validateInput,\n    validateLanguage\n};\n"]}