{"version":3,"sources":["jsdelivr-header.js","/npm/numbro@2.5.0/dist/es/numbro.js"],"names":[],"mappings":"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","file":"/npm/numbro@2.5.0/dist/es/numbro.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/numbro@2.5.0/dist/es/numbro.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\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\nvar enUS;\nvar hasRequiredEnUS;\n\nfunction requireEnUS () {\n\tif (hasRequiredEnUS) return enUS;\n\thasRequiredEnUS = 1;\n\tenUS = {\n\t    languageTag: \"en-US\",\n\t    delimiters: {\n\t        thousands: \",\",\n\t        decimal: \".\"\n\t    },\n\t    abbreviations: {\n\t        thousand: \"k\",\n\t        million: \"m\",\n\t        billion: \"b\",\n\t        trillion: \"t\"\n\t    },\n\t    spaceSeparated: false,\n\t    ordinal: function(number) {\n\t        let b = number % 10;\n\t        return (~~(number % 100 / 10) === 1) ? \"th\" : (b === 1) ? \"st\" : (b === 2) ? \"nd\" : (b === 3) ? \"rd\" : \"th\";\n\t    },\n\t    bytes: {\n\t        binarySuffixes: [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\"],\n\t        decimalSuffixes: [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"]\n\t    },\n\t    currency: {\n\t        symbol: \"$\",\n\t        position: \"prefix\",\n\t        code: \"USD\"\n\t    },\n\t    currencyFormat: {\n\t        thousandSeparated: true,\n\t        totalLength: 4,\n\t        spaceSeparated: true,\n\t        spaceSeparatedCurrency: true\n\t    },\n\t    formats: {\n\t        fourDigits: {\n\t            totalLength: 4,\n\t            spaceSeparated: true\n\t        },\n\t        fullWithTwoDecimals: {\n\t            output: \"currency\",\n\t            thousandSeparated: true,\n\t            mantissa: 2\n\t        },\n\t        fullWithTwoDecimalsNoCurrency: {\n\t            thousandSeparated: true,\n\t            mantissa: 2\n\t        },\n\t        fullWithNoDecimals: {\n\t            output: \"currency\",\n\t            thousandSeparated: true,\n\t            mantissa: 0\n\t        }\n\t    }\n\t};\n\treturn enUS;\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\nvar unformatting;\nvar hasRequiredUnformatting;\n\nfunction requireUnformatting () {\n\tif (hasRequiredUnformatting) return unformatting;\n\thasRequiredUnformatting = 1;\n\tconst allSuffixes = [\n\t    {key: \"ZiB\", factor: Math.pow(1024, 7)},\n\t    {key: \"ZB\", factor: Math.pow(1000, 7)},\n\t    {key: \"YiB\", factor: Math.pow(1024, 8)},\n\t    {key: \"YB\", factor: Math.pow(1000, 8)},\n\t    {key: \"TiB\", factor: Math.pow(1024, 4)},\n\t    {key: \"TB\", factor: Math.pow(1000, 4)},\n\t    {key: \"PiB\", factor: Math.pow(1024, 5)},\n\t    {key: \"PB\", factor: Math.pow(1000, 5)},\n\t    {key: \"MiB\", factor: Math.pow(1024, 2)},\n\t    {key: \"MB\", factor: Math.pow(1000, 2)},\n\t    {key: \"KiB\", factor: Math.pow(1024, 1)},\n\t    {key: \"KB\", factor: Math.pow(1000, 1)},\n\t    {key: \"GiB\", factor: Math.pow(1024, 3)},\n\t    {key: \"GB\", factor: Math.pow(1000, 3)},\n\t    {key: \"EiB\", factor: Math.pow(1024, 6)},\n\t    {key: \"EB\", factor: Math.pow(1000, 6)},\n\t    {key: \"B\", factor: 1}\n\t];\n\n\t/**\n\t * Generate a RegExp where S get all RegExp specific characters escaped.\n\t *\n\t * @param {string} s - string representing a RegExp\n\t * @return {string}\n\t */\n\tfunction escapeRegExp(s) {\n\t    return s.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, \"\\\\$&\");\n\t}\n\n\t/**\n\t * Recursively compute the unformatted value.\n\t *\n\t * @param {string} inputString - string to unformat\n\t * @param {*} delimiters - Delimiters used to generate the inputString\n\t * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n\t * @param {function} ordinal - function used to generate an ordinal out of a number\n\t * @param {string} zeroFormat - string representing zero\n\t * @param {*} abbreviations - abbreviations used while generating the inputString\n\t * @param {NumbroFormat} format - format used while generating the inputString\n\t * @return {number|undefined}\n\t */\n\tfunction computeUnformattedValue(inputString, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations, format) {\n\t    if (!isNaN(+inputString)) {\n\t        return +inputString;\n\t    }\n\n\t    let stripped = \"\";\n\t    // Negative\n\n\t    let newInput = inputString.replace(/(^[^(]*)\\((.*)\\)([^)]*$)/, \"$1$2$3\");\n\n\t    if (newInput !== inputString) {\n\t        return -1 * computeUnformattedValue(newInput, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations);\n\t    }\n\n\t    // Byte\n\n\t    for (let i = 0; i < allSuffixes.length; i++) {\n\t        let suffix = allSuffixes[i];\n\t        stripped = inputString.replace(RegExp(`([0-9 ])(${suffix.key})$`), \"$1\");\n\n\t        if (stripped !== inputString) {\n\t            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations) * suffix.factor;\n\t        }\n\t    }\n\n\t    // Percent\n\n\t    stripped = inputString.replace(\"%\", \"\");\n\n\t    if (stripped !== inputString) {\n\t        return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations) / 100;\n\t    }\n\n\t    // Ordinal\n\n\t    let possibleOrdinalValue = parseFloat(inputString);\n\n\t    if (isNaN(possibleOrdinalValue)) {\n\t        return undefined;\n\t    }\n\n\t    let ordinalString = ordinal(possibleOrdinalValue);\n\t    if (ordinalString && ordinalString !== \".\") { // if ordinal is \".\" it will be caught next round in the +inputString\n\t        stripped = inputString.replace(new RegExp(`${escapeRegExp(ordinalString)}$`), \"\");\n\n\t        if (stripped !== inputString) {\n\t            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations);\n\t        }\n\t    }\n\n\t    // Average\n\n\t    let inversedAbbreviations = {};\n\t    Object.keys(abbreviations).forEach((key) => {\n\t        inversedAbbreviations[abbreviations[key]] = key;\n\t    });\n\n\t    let abbreviationValues = Object.keys(inversedAbbreviations).sort().reverse();\n\t    let numberOfAbbreviations = abbreviationValues.length;\n\n\t    for (let i = 0; i < numberOfAbbreviations; i++) {\n\t        let value = abbreviationValues[i];\n\t        let key = inversedAbbreviations[value];\n\n\t        stripped = inputString.replace(value, \"\");\n\t        if (stripped !== inputString) {\n\t            let factor = undefined;\n\t            switch (key) { // eslint-disable-line default-case\n\t                case \"thousand\":\n\t                    factor = Math.pow(10, 3);\n\t                    break;\n\t                case \"million\":\n\t                    factor = Math.pow(10, 6);\n\t                    break;\n\t                case \"billion\":\n\t                    factor = Math.pow(10, 9);\n\t                    break;\n\t                case \"trillion\":\n\t                    factor = Math.pow(10, 12);\n\t                    break;\n\t            }\n\t            return computeUnformattedValue(stripped, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations) * factor;\n\t        }\n\t    }\n\n\t    return undefined;\n\t}\n\n\t/**\n\t * Removes in one pass all formatting symbols.\n\t *\n\t * @param {string} inputString - string to unformat\n\t * @param {*} delimiters - Delimiters used to generate the inputString\n\t * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n\t * @return {string}\n\t */\n\tfunction removeFormattingSymbols(inputString, delimiters, currencySymbol) {\n\t    // Currency\n\n\t    let stripped = inputString.replace(currencySymbol, \"\");\n\n\t    // Thousand separators\n\n\t    stripped = stripped.replace(new RegExp(`([0-9])${escapeRegExp(delimiters.thousands)}([0-9])`, \"g\"), \"$1$2\");\n\n\t    // Decimal\n\n\t    stripped = stripped.replace(delimiters.decimal, \".\");\n\n\t    return stripped;\n\t}\n\n\t/**\n\t * Unformat a numbro-generated string to retrieve the original value.\n\t *\n\t * @param {string} inputString - string to unformat\n\t * @param {*} delimiters - Delimiters used to generate the inputString\n\t * @param {string} [currencySymbol] - symbol used for currency while generating the inputString\n\t * @param {function} ordinal - function used to generate an ordinal out of a number\n\t * @param {string} zeroFormat - string representing zero\n\t * @param {*} abbreviations - abbreviations used while generating the inputString\n\t * @param {NumbroFormat} format - format used while generating the inputString\n\t * @return {number|undefined}\n\t */\n\tfunction unformatValue(inputString, delimiters, currencySymbol = \"\", ordinal, zeroFormat, abbreviations, format) {\n\t    if (inputString === \"\") {\n\t        return undefined;\n\t    }\n\n\t    // Zero Format\n\n\t    if (inputString === zeroFormat) {\n\t        return 0;\n\t    }\n\n\t    let value = removeFormattingSymbols(inputString, delimiters, currencySymbol);\n\t    return computeUnformattedValue(value, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations);\n\t}\n\n\t/**\n\t * Check if the INPUTSTRING represents a time.\n\t *\n\t * @param {string} inputString - string to check\n\t * @param {*} delimiters - Delimiters used while generating the inputString\n\t * @return {boolean}\n\t */\n\tfunction matchesTime(inputString, delimiters) {\n\t    let separators = inputString.indexOf(\":\") && delimiters.thousands !== \":\";\n\n\t    if (!separators) {\n\t        return false;\n\t    }\n\n\t    let segments = inputString.split(\":\");\n\t    if (segments.length !== 3) {\n\t        return false;\n\t    }\n\n\t    let hours = +segments[0];\n\t    let minutes = +segments[1];\n\t    let seconds = +segments[2];\n\n\t    return !isNaN(hours) && !isNaN(minutes) && !isNaN(seconds);\n\t}\n\n\t/**\n\t * Unformat a numbro-generated string representing a time to retrieve the original value.\n\t *\n\t * @param {string} inputString - string to unformat\n\t * @return {number}\n\t */\n\tfunction unformatTime(inputString) {\n\t    let segments = inputString.split(\":\");\n\n\t    let hours = +segments[0];\n\t    let minutes = +segments[1];\n\t    let seconds = +segments[2];\n\n\t    return seconds + 60 * minutes + 3600 * hours;\n\t}\n\n\t/**\n\t * Unformat a numbro-generated string to retrieve the original value.\n\t *\n\t * @param {string} inputString - string to unformat\n\t * @param {NumbroFormat} format - format used  while generating the inputString\n\t * @return {number}\n\t */\n\tfunction unformat(inputString, format) {\n\t    // Avoid circular references\n\t    const globalState = requireGlobalState();\n\n\t    let delimiters = globalState.currentDelimiters();\n\t    let currencySymbol = globalState.currentCurrency().symbol;\n\t    let ordinal = globalState.currentOrdinal();\n\t    let zeroFormat = globalState.getZeroFormat();\n\t    let abbreviations = globalState.currentAbbreviations();\n\n\t    let value = undefined;\n\n\t    if (typeof inputString === \"string\") {\n\t        if (matchesTime(inputString, delimiters)) {\n\t            value = unformatTime(inputString);\n\t        } else {\n\t            value = unformatValue(inputString, delimiters, currencySymbol, ordinal, zeroFormat, abbreviations);\n\t        }\n\t    } else if (typeof inputString === \"number\") {\n\t        value = inputString;\n\t    } else {\n\t        return undefined;\n\t    }\n\n\t    if (value === undefined) {\n\t        return undefined;\n\t    }\n\n\t    return value;\n\t}\n\n\tunformatting = {\n\t    unformat\n\t};\n\treturn unformatting;\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\nvar validating$1;\nvar hasRequiredValidating;\n\nfunction requireValidating () {\n\tif (hasRequiredValidating) return validating$1;\n\thasRequiredValidating = 1;\n\tlet unformatter = requireUnformatting();\n\n\t// Simplified regexp supporting only `language`, `script`, and `region`\n\tconst bcp47RegExp = /^[a-z]{2,3}(-[a-zA-Z]{4})?(-([A-Z]{2}|[0-9]{3}))?$/;\n\n\tconst validOutputValues = [\n\t    \"currency\",\n\t    \"percent\",\n\t    \"byte\",\n\t    \"time\",\n\t    \"ordinal\",\n\t    \"number\"\n\t];\n\n\tconst validForceAverageValues = [\n\t    \"trillion\",\n\t    \"billion\",\n\t    \"million\",\n\t    \"thousand\"\n\t];\n\n\tconst validCurrencyPosition = [\n\t    \"prefix\",\n\t    \"infix\",\n\t    \"postfix\"\n\t];\n\n\tconst validNegativeValues = [\n\t    \"sign\",\n\t    \"parenthesis\"\n\t];\n\n\tconst validMandatoryAbbreviations = {\n\t    type: \"object\",\n\t    children: {\n\t        thousand: {\n\t            type: \"string\",\n\t            mandatory: true\n\t        },\n\t        million: {\n\t            type: \"string\",\n\t            mandatory: true\n\t        },\n\t        billion: {\n\t            type: \"string\",\n\t            mandatory: true\n\t        },\n\t        trillion: {\n\t            type: \"string\",\n\t            mandatory: true\n\t        }\n\t    },\n\t    mandatory: true\n\t};\n\n\tconst validAbbreviations = {\n\t    type: \"object\",\n\t    children: {\n\t        thousand: \"string\",\n\t        million: \"string\",\n\t        billion: \"string\",\n\t        trillion: \"string\"\n\t    }\n\t};\n\n\tconst validBaseValues = [\n\t    \"decimal\",\n\t    \"binary\",\n\t    \"general\"\n\t];\n\n\tconst validFormat = {\n\t    output: {\n\t        type: \"string\",\n\t        validValues: validOutputValues\n\t    },\n\t    base: {\n\t        type: \"string\",\n\t        validValues: validBaseValues,\n\t        restriction: (number, format) => format.output === \"byte\",\n\t        message: \"`base` must be provided only when the output is `byte`\",\n\t        mandatory: (format) => format.output === \"byte\"\n\t    },\n\t    characteristic: {\n\t        type: \"number\",\n\t        restriction: (number) => number >= 0,\n\t        message: \"value must be positive\"\n\t    },\n\t    prefix: \"string\",\n\t    postfix: \"string\",\n\t    forceAverage: {\n\t        type: \"string\",\n\t        validValues: validForceAverageValues\n\t    },\n\t    average: \"boolean\",\n\t    lowPrecision: {\n\t        type: \"boolean\",\n\t        restriction: (number, format) => format.average === true,\n\t        message: \"`lowPrecision` must be provided only when the option `average` is set\"\n\t    },\n\t    currencyPosition: {\n\t        type: \"string\",\n\t        validValues: validCurrencyPosition\n\t    },\n\t    currencySymbol: \"string\",\n\t    totalLength: {\n\t        type: \"number\",\n\t        restrictions: [\n\t            {\n\t                restriction: (number) => number >= 0,\n\t                message: \"value must be positive\"\n\t            },\n\t            {\n\t                restriction: (number, format) => !format.exponential,\n\t                message: \"`totalLength` is incompatible with `exponential`\"\n\t            }\n\t        ]\n\t    },\n\t    mantissa: {\n\t        type: \"number\",\n\t        restriction: (number) => number >= 0,\n\t        message: \"value must be positive\"\n\t    },\n\t    optionalMantissa: \"boolean\",\n\t    trimMantissa: \"boolean\",\n\t    roundingFunction: \"function\",\n\t    optionalCharacteristic: \"boolean\",\n\t    thousandSeparated: \"boolean\",\n\t    spaceSeparated: \"boolean\",\n\t    spaceSeparatedCurrency: \"boolean\",\n\t    spaceSeparatedAbbreviation: \"boolean\",\n\t    abbreviations: validAbbreviations,\n\t    negative: {\n\t        type: \"string\",\n\t        validValues: validNegativeValues\n\t    },\n\t    forceSign: \"boolean\",\n\t    exponential: {\n\t        type: \"boolean\"\n\t    },\n\t    prefixSymbol: {\n\t        type: \"boolean\",\n\t        restriction: (number, format) => format.output === \"percent\",\n\t        message: \"`prefixSymbol` can be provided only when the output is `percent`\"\n\t    }\n\t};\n\n\tconst validLanguage = {\n\t    languageTag: {\n\t        type: \"string\",\n\t        mandatory: true,\n\t        restriction: (tag) => {\n\t            return tag.match(bcp47RegExp);\n\t        },\n\t        message: \"the language tag must follow the BCP 47 specification (see https://tools.ieft.org/html/bcp47)\"\n\t    },\n\t    delimiters: {\n\t        type: \"object\",\n\t        children: {\n\t            thousands: \"string\",\n\t            decimal: \"string\",\n\t            thousandsSize: \"number\"\n\t        },\n\t        mandatory: true\n\t    },\n\t    abbreviations: validMandatoryAbbreviations,\n\t    spaceSeparated: \"boolean\",\n\t    spaceSeparatedCurrency: \"boolean\",\n\t    ordinal: {\n\t        type: \"function\",\n\t        mandatory: true\n\t    },\n\t    bytes: {\n\t        type: \"object\",\n\t        children: {\n\t            binarySuffixes: \"object\",\n\t            decimalSuffixes: \"object\"\n\t        }\n\t    },\n\t    currency: {\n\t        type: \"object\",\n\t        children: {\n\t            symbol: \"string\",\n\t            position: \"string\",\n\t            code: \"string\"\n\t        },\n\t        mandatory: true\n\t    },\n\t    defaults: \"format\",\n\t    ordinalFormat: \"format\",\n\t    byteFormat: \"format\",\n\t    percentageFormat: \"format\",\n\t    currencyFormat: \"format\",\n\t    timeDefaults: \"format\",\n\t    formats: {\n\t        type: \"object\",\n\t        children: {\n\t            fourDigits: {\n\t                type: \"format\",\n\t                mandatory: true\n\t            },\n\t            fullWithTwoDecimals: {\n\t                type: \"format\",\n\t                mandatory: true\n\t            },\n\t            fullWithTwoDecimalsNoCurrency: {\n\t                type: \"format\",\n\t                mandatory: true\n\t            },\n\t            fullWithNoDecimals: {\n\t                type: \"format\",\n\t                mandatory: true\n\t            }\n\t        }\n\t    }\n\t};\n\n\t/**\n\t * Check the validity of the provided input and format.\n\t * The check is NOT lazy.\n\t *\n\t * @param {string|number|Numbro} input - input to check\n\t * @param {NumbroFormat} format - format to check\n\t * @return {boolean} True when everything is correct\n\t */\n\tfunction validate(input, format) {\n\t    let validInput = validateInput(input);\n\t    let isFormatValid = validateFormat(format);\n\n\t    return validInput && isFormatValid;\n\t}\n\n\t/**\n\t * Check the validity of the numbro input.\n\t *\n\t * @param {string|number|Numbro} input - input to check\n\t * @return {boolean} True when everything is correct\n\t */\n\tfunction validateInput(input) {\n\t    let value = unformatter.unformat(input);\n\n\t    return value !== undefined;\n\t}\n\n\t/**\n\t * Check the validity of the provided format TOVALIDATE against SPEC.\n\t *\n\t * @param {NumbroFormat} toValidate - format to check\n\t * @param {*} spec - specification against which to check\n\t * @param {string} prefix - prefix use for error messages\n\t * @param {boolean} skipMandatoryCheck - `true` when the check for mandatory key must be skipped\n\t * @return {boolean} True when everything is correct\n\t */\n\tfunction validateSpec(toValidate, spec, prefix, skipMandatoryCheck = false) {\n\t    let results = Object.keys(toValidate).map((key) => {\n\t        if (!spec[key]) {\n\t            console.error(`${prefix} Invalid key: ${key}`); // eslint-disable-line no-console\n\t            return false;\n\t        }\n\n\t        let value = toValidate[key];\n\t        let data = spec[key];\n\n\t        if (typeof data === \"string\") {\n\t            data = {type: data};\n\t        }\n\n\t        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\t            let valid = validateSpec(value, validFormat, `[Validate ${key}]`, true);\n\n\t            if (!valid) {\n\t                return false;\n\t            }\n\t        } else if (typeof value !== data.type) {\n\t            console.error(`${prefix} ${key} type mismatched: \"${data.type}\" expected, \"${typeof value}\" provided`); // eslint-disable-line no-console\n\t            return false;\n\t        }\n\n\t        if (data.restrictions && data.restrictions.length) {\n\t            let length = data.restrictions.length;\n\t            for (let i = 0; i < length; i++) {\n\t                let {restriction, message} = data.restrictions[i];\n\t                if (!restriction(value, toValidate)) {\n\t                    console.error(`${prefix} ${key} invalid value: ${message}`); // eslint-disable-line no-console\n\t                    return false;\n\t                }\n\t            }\n\t        }\n\n\t        if (data.restriction && !data.restriction(value, toValidate)) {\n\t            console.error(`${prefix} ${key} invalid value: ${data.message}`); // eslint-disable-line no-console\n\t            return false;\n\t        }\n\n\t        if (data.validValues && data.validValues.indexOf(value) === -1) {\n\t            console.error(`${prefix} ${key} invalid value: must be among ${JSON.stringify(data.validValues)}, \"${value}\" provided`); // eslint-disable-line no-console\n\t            return false;\n\t        }\n\n\t        if (data.children) {\n\t            let valid = validateSpec(value, data.children, `[Validate ${key}]`);\n\n\t            if (!valid) {\n\t                return false;\n\t            }\n\t        }\n\n\t        return true;\n\t    });\n\n\t    if (!skipMandatoryCheck) {\n\t        results.push(...Object.keys(spec).map((key) => {\n\t            let data = spec[key];\n\t            if (typeof data === \"string\") {\n\t                data = {type: data};\n\t            }\n\n\t            if (data.mandatory) {\n\t                let mandatory = data.mandatory;\n\t                if (typeof mandatory === \"function\") {\n\t                    mandatory = mandatory(toValidate);\n\t                }\n\n\t                if (mandatory && toValidate[key] === undefined) {\n\t                    console.error(`${prefix} Missing mandatory key \"${key}\"`); // eslint-disable-line no-console\n\t                    return false;\n\t                }\n\t            }\n\n\t            return true;\n\t        }));\n\t    }\n\n\t    return results.reduce((acc, current) => {\n\t        return acc && current;\n\t    }, true);\n\t}\n\n\t/**\n\t * Check the provided FORMAT.\n\t *\n\t * @param {NumbroFormat} format - format to check\n\t * @return {boolean}\n\t */\n\tfunction validateFormat(format) {\n\t    return validateSpec(format, validFormat, \"[Validate format]\");\n\t}\n\n\t/**\n\t * Check the provided LANGUAGE.\n\t *\n\t * @param {NumbroLanguage} language - language to check\n\t * @return {boolean}\n\t */\n\tfunction validateLanguage(language) {\n\t    return validateSpec(language, validLanguage, \"[Validate language]\");\n\t}\n\n\tvalidating$1 = {\n\t    validate,\n\t    validateFormat,\n\t    validateInput,\n\t    validateLanguage\n\t};\n\treturn validating$1;\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\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        result.spaceSeparatedCurrency = true;\n\n        if (result.average || result.forceAverage) {\n            result.spaceSeparatedAbbreviation = true;\n        }\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 a trimmed mantissa. Append it to RESULT when found.\n *\n * @param {string} string - format\n * @param {NumbroFormat} result - Result accumulator\n */\nfunction parseTrimMantissa(string, result) {\n    const mantissa = string.split(\".\")[1];\n    if (mantissa) {\n        result.trimMantissa = mantissa.indexOf(\"[\") !== -1;\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    parseTrimMantissa(string, result);\n    parseThousandSeparated(string, result);\n    parseSpaceSeparated(string, result);\n    parseNegative(string, result);\n    parseForceSign(string, result);\n\n    return result;\n}\n\nvar parsing$2 = {\n    parseFormat\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\nvar globalState$2;\nvar hasRequiredGlobalState;\n\nfunction requireGlobalState () {\n\tif (hasRequiredGlobalState) return globalState$2;\n\thasRequiredGlobalState = 1;\n\tconst enUS = requireEnUS();\n\tconst validating = requireValidating();\n\tconst parsing = parsing$2;\n\n\tlet state = {};\n\n\tlet currentLanguageTag = undefined;\n\tlet languages = {};\n\n\tlet zeroFormat = null;\n\n\tlet globalDefaults = {};\n\n\tfunction chooseLanguage(tag) { currentLanguageTag = tag; }\n\n\tfunction currentLanguageData() { return languages[currentLanguageTag]; }\n\n\t/**\n\t * Return all the register languages\n\t *\n\t * @return {{}}\n\t */\n\tstate.languages = () => Object.assign({}, languages);\n\n\t//\n\t// Current language accessors\n\t//\n\n\t/**\n\t * Return the current language tag\n\t *\n\t * @return {string}\n\t */\n\tstate.currentLanguage = () => currentLanguageTag;\n\n\t/**\n\t * Return the current language bytes data\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentBytes = () => currentLanguageData().bytes || {};\n\n\t/**\n\t * Return the current language currency data\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentCurrency = () => currentLanguageData().currency;\n\n\t/**\n\t * Return the current language abbreviations data\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentAbbreviations = () => currentLanguageData().abbreviations;\n\n\t/**\n\t * Return the current language delimiters data\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentDelimiters = () => currentLanguageData().delimiters;\n\n\t/**\n\t * Return the current language ordinal function\n\t *\n\t * @return {function}\n\t */\n\tstate.currentOrdinal = () => currentLanguageData().ordinal;\n\n\t//\n\t// Defaults\n\t//\n\n\t/**\n\t * Return the current formatting defaults.\n\t * First use the current language default, then fallback to the globally defined defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentDefaults = () => Object.assign({}, currentLanguageData().defaults, globalDefaults);\n\n\t/**\n\t * Return the ordinal default-format.\n\t * First use the current language ordinal default, then fallback to the regular defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentOrdinalDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().ordinalFormat);\n\n\t/**\n\t * Return the byte default-format.\n\t * First use the current language byte default, then fallback to the regular defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentByteDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().byteFormat);\n\n\t/**\n\t * Return the percentage default-format.\n\t * First use the current language percentage default, then fallback to the regular defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentPercentageDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().percentageFormat);\n\n\t/**\n\t * Return the currency default-format.\n\t * First use the current language currency default, then fallback to the regular defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentCurrencyDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().currencyFormat);\n\n\t/**\n\t * Return the time default-format.\n\t * First use the current language currency default, then fallback to the regular defaults.\n\t *\n\t * @return {{}}\n\t */\n\tstate.currentTimeDefaultFormat = () => Object.assign({}, state.currentDefaults(), currentLanguageData().timeFormat);\n\n\t/**\n\t * Set the global formatting defaults.\n\t *\n\t * @param {{}|string} format - formatting options to use as defaults\n\t */\n\tstate.setDefaults = (format) => {\n\t    format = parsing.parseFormat(format);\n\t    if (validating.validateFormat(format)) {\n\t        globalDefaults = format;\n\t    }\n\t};\n\n\t//\n\t// Zero format\n\t//\n\n\t/**\n\t * Return the format string for 0.\n\t *\n\t * @return {string}\n\t */\n\tstate.getZeroFormat = () => zeroFormat;\n\n\t/**\n\t * Set a STRING to output when the value is 0.\n\t *\n\t * @param {{}|string} string - string to set\n\t */\n\tstate.setZeroFormat = (string) => zeroFormat = typeof(string) === \"string\" ? string : null;\n\n\t/**\n\t * Return true if a format for 0 has been set already.\n\t *\n\t * @return {boolean}\n\t */\n\tstate.hasZeroFormat = () => zeroFormat !== null;\n\n\t//\n\t// Getters/Setters\n\t//\n\n\t/**\n\t * Return the language data for the provided TAG.\n\t * Return the current language data if no tag is provided.\n\t *\n\t * Throw an error if the tag doesn't match any registered language.\n\t *\n\t * @param {string} [tag] - language tag of a registered language\n\t * @return {{}}\n\t */\n\tstate.languageData = (tag) => {\n\t    if (tag) {\n\t        if (languages[tag]) {\n\t            return languages[tag];\n\t        }\n\t        throw new Error(`Unknown tag \"${tag}\"`);\n\t    }\n\n\t    return currentLanguageData();\n\t};\n\n\t/**\n\t * Register the provided DATA as a language if and only if the data is valid.\n\t * If the data is not valid, an error is thrown.\n\t *\n\t * When USELANGUAGE is true, the registered language is then used.\n\t *\n\t * @param {{}} data - language data to register\n\t * @param {boolean} [useLanguage] - `true` if the provided data should become the current language\n\t */\n\tstate.registerLanguage = (data, useLanguage = false) => {\n\t    if (!validating.validateLanguage(data)) {\n\t        throw new Error(\"Invalid language data\");\n\t    }\n\n\t    languages[data.languageTag] = data;\n\n\t    if (useLanguage) {\n\t        chooseLanguage(data.languageTag);\n\t    }\n\t};\n\n\t/**\n\t * Set the current language according to TAG.\n\t * If TAG doesn't match a registered language, another language matching\n\t * the \"language\" part of the tag (according to BCP47: https://tools.ietf.org/rfc/bcp/bcp47.txt).\n\t * If none, the FALLBACKTAG is used. If the FALLBACKTAG doesn't match a register language,\n\t * `en-US` is finally used.\n\t *\n\t * @param tag\n\t * @param fallbackTag\n\t */\n\tstate.setLanguage = (tag, fallbackTag = enUS.languageTag) => {\n\t    if (!languages[tag]) {\n\t        let suffix = tag.split(\"-\")[0];\n\n\t        let matchingLanguageTag = Object.keys(languages).find(each => {\n\t            return each.split(\"-\")[0] === suffix;\n\t        });\n\n\t        if (!languages[matchingLanguageTag]) {\n\t            chooseLanguage(fallbackTag);\n\t            return;\n\t        }\n\n\t        chooseLanguage(matchingLanguageTag);\n\t        return;\n\t    }\n\n\t    chooseLanguage(tag);\n\t};\n\n\tstate.registerLanguage(enUS);\n\tcurrentLanguageTag = enUS.languageTag;\n\n\tglobalState$2 = state;\n\treturn globalState$2;\n}\n\nfunction commonjsRequire(path) {\n\tthrow new Error('Could not dynamically require \"' + path + '\". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');\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\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 = commonjsRequire(`../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\nvar loading = (numbro) => ({\n    loadLanguagesInNode: (tags) => loadLanguagesInNode(tags, numbro)\n});\n\nvar bignumber = {exports: {}};\n\n(function (module) {\n(function (globalObject) {\r\n\r\n\t/*\r\n\t *      bignumber.js v9.1.2\r\n\t *      A JavaScript library for arbitrary-precision arithmetic.\r\n\t *      https://github.com/MikeMcl/bignumber.js\r\n\t *      Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n\t *      MIT Licensed.\r\n\t *\r\n\t *      BigNumber.prototype methods     |  BigNumber methods\r\n\t *                                      |\r\n\t *      absoluteValue            abs    |  clone\r\n\t *      comparedTo                      |  config               set\r\n\t *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n\t *      dividedBy                div    |      ROUNDING_MODE\r\n\t *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n\t *      exponentiatedBy          pow    |      RANGE\r\n\t *      integerValue                    |      CRYPTO\r\n\t *      isEqualTo                eq     |      MODULO_MODE\r\n\t *      isFinite                        |      POW_PRECISION\r\n\t *      isGreaterThan            gt     |      FORMAT\r\n\t *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n\t *      isInteger                       |  isBigNumber\r\n\t *      isLessThan               lt     |  maximum              max\r\n\t *      isLessThanOrEqualTo      lte    |  minimum              min\r\n\t *      isNaN                           |  random\r\n\t *      isNegative                      |  sum\r\n\t *      isPositive                      |\r\n\t *      isZero                          |\r\n\t *      minus                           |\r\n\t *      modulo                   mod    |\r\n\t *      multipliedBy             times  |\r\n\t *      negated                         |\r\n\t *      plus                            |\r\n\t *      precision                sd     |\r\n\t *      shiftedBy                       |\r\n\t *      squareRoot               sqrt   |\r\n\t *      toExponential                   |\r\n\t *      toFixed                         |\r\n\t *      toFormat                        |\r\n\t *      toFraction                      |\r\n\t *      toJSON                          |\r\n\t *      toNumber                        |\r\n\t *      toPrecision                     |\r\n\t *      toString                        |\r\n\t *      valueOf                         |\r\n\t *\r\n\t */\r\n\r\n\r\n\t  var BigNumber,\r\n\t    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n\t    mathceil = Math.ceil,\r\n\t    mathfloor = Math.floor,\r\n\r\n\t    bignumberError = '[BigNumber Error] ',\r\n\t    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n\t    BASE = 1e14,\r\n\t    LOG_BASE = 14,\r\n\t    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n\t    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n\t    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n\t    SQRT_BASE = 1e7,\r\n\r\n\t    // EDITABLE\r\n\t    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n\t    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n\t    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n\t  /*\r\n\t   * Create and return a BigNumber constructor.\r\n\t   */\r\n\t  function clone(configObject) {\r\n\t    var div, convertBase, parseNumeric,\r\n\t      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n\t      ONE = new BigNumber(1),\r\n\r\n\r\n\t      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n\t      // The default values below must be integers within the inclusive ranges stated.\r\n\t      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n\t      // The maximum number of decimal places for operations involving division.\r\n\t      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n\t      // The rounding mode used when rounding to the above decimal places, and when using\r\n\t      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n\t      // UP         0 Away from zero.\r\n\t      // DOWN       1 Towards zero.\r\n\t      // CEIL       2 Towards +Infinity.\r\n\t      // FLOOR      3 Towards -Infinity.\r\n\t      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n\t      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n\t      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n\t      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n\t      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n\t      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n\t      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n\t      // The exponent value at and beneath which toString returns exponential notation.\r\n\t      // Number type: -7\r\n\t      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n\t      // The exponent value at and above which toString returns exponential notation.\r\n\t      // Number type: 21\r\n\t      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n\t      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n\t      // The minimum exponent value, beneath which underflow to zero occurs.\r\n\t      // Number type: -324  (5e-324)\r\n\t      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n\t      // The maximum exponent value, above which overflow to Infinity occurs.\r\n\t      // Number type:  308  (1.7976931348623157e+308)\r\n\t      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n\t      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n\t      // Whether to use cryptographically-secure random number generation, if available.\r\n\t      CRYPTO = false,                          // true or false\r\n\r\n\t      // The modulo mode used when calculating the modulus: a mod n.\r\n\t      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n\t      // The remainder (r) is calculated as: r = a - n * q.\r\n\t      //\r\n\t      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n\t      // DOWN      1 The remainder has the same sign as the dividend.\r\n\t      //             This modulo mode is commonly known as 'truncated division' and is\r\n\t      //             equivalent to (a % n) in JavaScript.\r\n\t      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n\t      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n\t      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n\t      //             The remainder is always positive.\r\n\t      //\r\n\t      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n\t      // modes are commonly used for the modulus operation.\r\n\t      // Although the other rounding modes can also be used, they may not give useful results.\r\n\t      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n\t      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n\t      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n\t      POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n\t      // The format specification used by the BigNumber.prototype.toFormat method.\r\n\t      FORMAT = {\r\n\t        prefix: '',\r\n\t        groupSize: 3,\r\n\t        secondaryGroupSize: 0,\r\n\t        groupSeparator: ',',\r\n\t        decimalSeparator: '.',\r\n\t        fractionGroupSize: 0,\r\n\t        fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n\t        suffix: ''\r\n\t      },\r\n\r\n\t      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n\t      // '-', '.', whitespace, or repeated character.\r\n\t      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n\t      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n\t      alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n\t    //------------------------------------------------------------------------------------------\r\n\r\n\r\n\t    // CONSTRUCTOR\r\n\r\n\r\n\t    /*\r\n\t     * The BigNumber constructor and exported function.\r\n\t     * Create and return a new instance of a BigNumber object.\r\n\t     *\r\n\t     * v {number|string|BigNumber} A numeric value.\r\n\t     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n\t     */\r\n\t    function BigNumber(v, b) {\r\n\t      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n\t        x = this;\r\n\r\n\t      // Enable constructor call without `new`.\r\n\t      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n\t      if (b == null) {\r\n\r\n\t        if (v && v._isBigNumber === true) {\r\n\t          x.s = v.s;\r\n\r\n\t          if (!v.c || v.e > MAX_EXP) {\r\n\t            x.c = x.e = null;\r\n\t          } else if (v.e < MIN_EXP) {\r\n\t            x.c = [x.e = 0];\r\n\t          } else {\r\n\t            x.e = v.e;\r\n\t            x.c = v.c.slice();\r\n\t          }\r\n\r\n\t          return;\r\n\t        }\r\n\r\n\t        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n\t          // Use `1 / n` to handle minus zero also.\r\n\t          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n\t          // Fast path for integers, where n < 2147483648 (2**31).\r\n\t          if (v === ~~v) {\r\n\t            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n\t            if (e > MAX_EXP) {\r\n\t              x.c = x.e = null;\r\n\t            } else {\r\n\t              x.e = e;\r\n\t              x.c = [v];\r\n\t            }\r\n\r\n\t            return;\r\n\t          }\r\n\r\n\t          str = String(v);\r\n\t        } else {\r\n\r\n\t          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n\t          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n\t        }\r\n\r\n\t        // Decimal point?\r\n\t        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n\t        // Exponential form?\r\n\t        if ((i = str.search(/e/i)) > 0) {\r\n\r\n\t          // Determine exponent.\r\n\t          if (e < 0) e = i;\r\n\t          e += +str.slice(i + 1);\r\n\t          str = str.substring(0, i);\r\n\t        } else if (e < 0) {\r\n\r\n\t          // Integer.\r\n\t          e = str.length;\r\n\t        }\r\n\r\n\t      } else {\r\n\r\n\t        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n\t        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n\t        // Allow exponential notation to be used with base 10 argument, while\r\n\t        // also rounding to DECIMAL_PLACES as with other bases.\r\n\t        if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n\t          x = new BigNumber(v);\r\n\t          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n\t        }\r\n\r\n\t        str = String(v);\r\n\r\n\t        if (isNum = typeof v == 'number') {\r\n\r\n\t          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n\t          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n\t          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n\t          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n\t          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n\t            throw Error\r\n\t             (tooManyDigits + v);\r\n\t          }\r\n\t        } else {\r\n\t          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n\t        }\r\n\r\n\t        alphabet = ALPHABET.slice(0, b);\r\n\t        e = i = 0;\r\n\r\n\t        // Check that str is a valid base b number.\r\n\t        // Don't use RegExp, so alphabet can contain special characters.\r\n\t        for (len = str.length; i < len; i++) {\r\n\t          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n\t            if (c == '.') {\r\n\r\n\t              // If '.' is not the first character and it has not be found before.\r\n\t              if (i > e) {\r\n\t                e = len;\r\n\t                continue;\r\n\t              }\r\n\t            } else if (!caseChanged) {\r\n\r\n\t              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n\t              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n\t                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n\t                caseChanged = true;\r\n\t                i = -1;\r\n\t                e = 0;\r\n\t                continue;\r\n\t              }\r\n\t            }\r\n\r\n\t            return parseNumeric(x, String(v), isNum, b);\r\n\t          }\r\n\t        }\r\n\r\n\t        // Prevent later check for length on converted number.\r\n\t        isNum = false;\r\n\t        str = convertBase(str, b, 10, x.s);\r\n\r\n\t        // Decimal point?\r\n\t        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\t        else e = str.length;\r\n\t      }\r\n\r\n\t      // Determine leading zeros.\r\n\t      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n\t      // Determine trailing zeros.\r\n\t      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n\t      if (str = str.slice(i, ++len)) {\r\n\t        len -= i;\r\n\r\n\t        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n\t        if (isNum && BigNumber.DEBUG &&\r\n\t          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n\t            throw Error\r\n\t             (tooManyDigits + (x.s * v));\r\n\t        }\r\n\r\n\t         // Overflow?\r\n\t        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n\t          // Infinity.\r\n\t          x.c = x.e = null;\r\n\r\n\t        // Underflow?\r\n\t        } else if (e < MIN_EXP) {\r\n\r\n\t          // Zero.\r\n\t          x.c = [x.e = 0];\r\n\t        } else {\r\n\t          x.e = e;\r\n\t          x.c = [];\r\n\r\n\t          // Transform base\r\n\r\n\t          // e is the base 10 exponent.\r\n\t          // i is where to slice str to get the first element of the coefficient array.\r\n\t          i = (e + 1) % LOG_BASE;\r\n\t          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n\t          if (i < len) {\r\n\t            if (i) x.c.push(+str.slice(0, i));\r\n\r\n\t            for (len -= LOG_BASE; i < len;) {\r\n\t              x.c.push(+str.slice(i, i += LOG_BASE));\r\n\t            }\r\n\r\n\t            i = LOG_BASE - (str = str.slice(i)).length;\r\n\t          } else {\r\n\t            i -= len;\r\n\t          }\r\n\r\n\t          for (; i--; str += '0');\r\n\t          x.c.push(+str);\r\n\t        }\r\n\t      } else {\r\n\r\n\t        // Zero.\r\n\t        x.c = [x.e = 0];\r\n\t      }\r\n\t    }\r\n\r\n\r\n\t    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n\t    BigNumber.clone = clone;\r\n\r\n\t    BigNumber.ROUND_UP = 0;\r\n\t    BigNumber.ROUND_DOWN = 1;\r\n\t    BigNumber.ROUND_CEIL = 2;\r\n\t    BigNumber.ROUND_FLOOR = 3;\r\n\t    BigNumber.ROUND_HALF_UP = 4;\r\n\t    BigNumber.ROUND_HALF_DOWN = 5;\r\n\t    BigNumber.ROUND_HALF_EVEN = 6;\r\n\t    BigNumber.ROUND_HALF_CEIL = 7;\r\n\t    BigNumber.ROUND_HALF_FLOOR = 8;\r\n\t    BigNumber.EUCLID = 9;\r\n\r\n\r\n\t    /*\r\n\t     * Configure infrequently-changing library-wide settings.\r\n\t     *\r\n\t     * Accept an object with the following optional properties (if the value of a property is\r\n\t     * a number, it must be an integer within the inclusive range stated):\r\n\t     *\r\n\t     *   DECIMAL_PLACES   {number}           0 to MAX\r\n\t     *   ROUNDING_MODE    {number}           0 to 8\r\n\t     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n\t     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n\t     *   CRYPTO           {boolean}          true or false\r\n\t     *   MODULO_MODE      {number}           0 to 9\r\n\t     *   POW_PRECISION       {number}           0 to MAX\r\n\t     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n\t     *                                       not contain '.'.\r\n\t     *   FORMAT           {object}           An object with some of the following properties:\r\n\t     *     prefix                 {string}\r\n\t     *     groupSize              {number}\r\n\t     *     secondaryGroupSize     {number}\r\n\t     *     groupSeparator         {string}\r\n\t     *     decimalSeparator       {string}\r\n\t     *     fractionGroupSize      {number}\r\n\t     *     fractionGroupSeparator {string}\r\n\t     *     suffix                 {string}\r\n\t     *\r\n\t     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n\t     *\r\n\t     * E.g.\r\n\t     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n\t     *\r\n\t     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n\t     *\r\n\t     * Return an object with the properties current values.\r\n\t     */\r\n\t    BigNumber.config = BigNumber.set = function (obj) {\r\n\t      var p, v;\r\n\r\n\t      if (obj != null) {\r\n\r\n\t        if (typeof obj == 'object') {\r\n\r\n\t          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n\t          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n\t            v = obj[p];\r\n\t            intCheck(v, 0, MAX, p);\r\n\t            DECIMAL_PLACES = v;\r\n\t          }\r\n\r\n\t          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n\t          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n\t            v = obj[p];\r\n\t            intCheck(v, 0, 8, p);\r\n\t            ROUNDING_MODE = v;\r\n\t          }\r\n\r\n\t          // EXPONENTIAL_AT {number|number[]}\r\n\t          // Integer, -MAX to MAX inclusive or\r\n\t          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n\t          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n\t            v = obj[p];\r\n\t            if (v && v.pop) {\r\n\t              intCheck(v[0], -MAX, 0, p);\r\n\t              intCheck(v[1], 0, MAX, p);\r\n\t              TO_EXP_NEG = v[0];\r\n\t              TO_EXP_POS = v[1];\r\n\t            } else {\r\n\t              intCheck(v, -MAX, MAX, p);\r\n\t              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n\t            }\r\n\t          }\r\n\r\n\t          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n\t          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n\t          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n\t            v = obj[p];\r\n\t            if (v && v.pop) {\r\n\t              intCheck(v[0], -MAX, -1, p);\r\n\t              intCheck(v[1], 1, MAX, p);\r\n\t              MIN_EXP = v[0];\r\n\t              MAX_EXP = v[1];\r\n\t            } else {\r\n\t              intCheck(v, -MAX, MAX, p);\r\n\t              if (v) {\r\n\t                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n\t              } else {\r\n\t                throw Error\r\n\t                 (bignumberError + p + ' cannot be zero: ' + v);\r\n\t              }\r\n\t            }\r\n\t          }\r\n\r\n\t          // CRYPTO {boolean} true or false.\r\n\t          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n\t          // '[BigNumber Error] crypto unavailable'\r\n\t          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n\t            v = obj[p];\r\n\t            if (v === !!v) {\r\n\t              if (v) {\r\n\t                if (typeof crypto != 'undefined' && crypto &&\r\n\t                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n\t                  CRYPTO = v;\r\n\t                } else {\r\n\t                  CRYPTO = !v;\r\n\t                  throw Error\r\n\t                   (bignumberError + 'crypto unavailable');\r\n\t                }\r\n\t              } else {\r\n\t                CRYPTO = v;\r\n\t              }\r\n\t            } else {\r\n\t              throw Error\r\n\t               (bignumberError + p + ' not true or false: ' + v);\r\n\t            }\r\n\t          }\r\n\r\n\t          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n\t          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n\t            v = obj[p];\r\n\t            intCheck(v, 0, 9, p);\r\n\t            MODULO_MODE = v;\r\n\t          }\r\n\r\n\t          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n\t          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n\t            v = obj[p];\r\n\t            intCheck(v, 0, MAX, p);\r\n\t            POW_PRECISION = v;\r\n\t          }\r\n\r\n\t          // FORMAT {object}\r\n\t          // '[BigNumber Error] FORMAT not an object: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n\t            v = obj[p];\r\n\t            if (typeof v == 'object') FORMAT = v;\r\n\t            else throw Error\r\n\t             (bignumberError + p + ' not an object: ' + v);\r\n\t          }\r\n\r\n\t          // ALPHABET {string}\r\n\t          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n\t          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n\t            v = obj[p];\r\n\r\n\t            // Disallow if less than two characters,\r\n\t            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n\t            if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n\t              alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n\t              ALPHABET = v;\r\n\t            } else {\r\n\t              throw Error\r\n\t               (bignumberError + p + ' invalid: ' + v);\r\n\t            }\r\n\t          }\r\n\r\n\t        } else {\r\n\r\n\t          // '[BigNumber Error] Object expected: {v}'\r\n\t          throw Error\r\n\t           (bignumberError + 'Object expected: ' + obj);\r\n\t        }\r\n\t      }\r\n\r\n\t      return {\r\n\t        DECIMAL_PLACES: DECIMAL_PLACES,\r\n\t        ROUNDING_MODE: ROUNDING_MODE,\r\n\t        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n\t        RANGE: [MIN_EXP, MAX_EXP],\r\n\t        CRYPTO: CRYPTO,\r\n\t        MODULO_MODE: MODULO_MODE,\r\n\t        POW_PRECISION: POW_PRECISION,\r\n\t        FORMAT: FORMAT,\r\n\t        ALPHABET: ALPHABET\r\n\t      };\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if v is a BigNumber instance, otherwise return false.\r\n\t     *\r\n\t     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n\t     *\r\n\t     * v {any}\r\n\t     *\r\n\t     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n\t     */\r\n\t    BigNumber.isBigNumber = function (v) {\r\n\t      if (!v || v._isBigNumber !== true) return false;\r\n\t      if (!BigNumber.DEBUG) return true;\r\n\r\n\t      var i, n,\r\n\t        c = v.c,\r\n\t        e = v.e,\r\n\t        s = v.s;\r\n\r\n\t      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n\t        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n\t          // If the first element is zero, the BigNumber value must be zero.\r\n\t          if (c[0] === 0) {\r\n\t            if (e === 0 && c.length === 1) return true;\r\n\t            break out;\r\n\t          }\r\n\r\n\t          // Calculate number of digits that c[0] should have, based on the exponent.\r\n\t          i = (e + 1) % LOG_BASE;\r\n\t          if (i < 1) i += LOG_BASE;\r\n\r\n\t          // Calculate number of digits of c[0].\r\n\t          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n\t          if (String(c[0]).length == i) {\r\n\r\n\t            for (i = 0; i < c.length; i++) {\r\n\t              n = c[i];\r\n\t              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n\t            }\r\n\r\n\t            // Last element cannot be zero, unless it is the only element.\r\n\t            if (n !== 0) return true;\r\n\t          }\r\n\t        }\r\n\r\n\t      // Infinity/NaN\r\n\t      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n\t        return true;\r\n\t      }\r\n\r\n\t      throw Error\r\n\t        (bignumberError + 'Invalid BigNumber: ' + v);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the maximum of the arguments.\r\n\t     *\r\n\t     * arguments {number|string|BigNumber}\r\n\t     */\r\n\t    BigNumber.maximum = BigNumber.max = function () {\r\n\t      return maxOrMin(arguments, -1);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the minimum of the arguments.\r\n\t     *\r\n\t     * arguments {number|string|BigNumber}\r\n\t     */\r\n\t    BigNumber.minimum = BigNumber.min = function () {\r\n\t      return maxOrMin(arguments, 1);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n\t     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n\t     * zeros are produced).\r\n\t     *\r\n\t     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n\t     * '[BigNumber Error] crypto unavailable'\r\n\t     */\r\n\t    BigNumber.random = (function () {\r\n\t      var pow2_53 = 0x20000000000000;\r\n\r\n\t      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n\t      // Check if Math.random() produces more than 32 bits of randomness.\r\n\t      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n\t      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n\t      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n\t       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n\t       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n\t         (Math.random() * 0x800000 | 0); };\r\n\r\n\t      return function (dp) {\r\n\t        var a, b, e, k, v,\r\n\t          i = 0,\r\n\t          c = [],\r\n\t          rand = new BigNumber(ONE);\r\n\r\n\t        if (dp == null) dp = DECIMAL_PLACES;\r\n\t        else intCheck(dp, 0, MAX);\r\n\r\n\t        k = mathceil(dp / LOG_BASE);\r\n\r\n\t        if (CRYPTO) {\r\n\r\n\t          // Browsers supporting crypto.getRandomValues.\r\n\t          if (crypto.getRandomValues) {\r\n\r\n\t            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n\t            for (; i < k;) {\r\n\r\n\t              // 53 bits:\r\n\t              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n\t              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n\t              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n\t              //                                     11111 11111111 11111111\r\n\t              // 0x20000 is 2^21.\r\n\t              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n\t              // Rejection sampling:\r\n\t              // 0 <= v < 9007199254740992\r\n\t              // Probability that v >= 9e15, is\r\n\t              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n\t              if (v >= 9e15) {\r\n\t                b = crypto.getRandomValues(new Uint32Array(2));\r\n\t                a[i] = b[0];\r\n\t                a[i + 1] = b[1];\r\n\t              } else {\r\n\r\n\t                // 0 <= v <= 8999999999999999\r\n\t                // 0 <= (v % 1e14) <= 99999999999999\r\n\t                c.push(v % 1e14);\r\n\t                i += 2;\r\n\t              }\r\n\t            }\r\n\t            i = k / 2;\r\n\r\n\t          // Node.js supporting crypto.randomBytes.\r\n\t          } else if (crypto.randomBytes) {\r\n\r\n\t            // buffer\r\n\t            a = crypto.randomBytes(k *= 7);\r\n\r\n\t            for (; i < k;) {\r\n\r\n\t              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n\t              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n\t              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n\t              // 0 <= v < 9007199254740992\r\n\t              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n\t                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n\t                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n\t              if (v >= 9e15) {\r\n\t                crypto.randomBytes(7).copy(a, i);\r\n\t              } else {\r\n\r\n\t                // 0 <= (v % 1e14) <= 99999999999999\r\n\t                c.push(v % 1e14);\r\n\t                i += 7;\r\n\t              }\r\n\t            }\r\n\t            i = k / 7;\r\n\t          } else {\r\n\t            CRYPTO = false;\r\n\t            throw Error\r\n\t             (bignumberError + 'crypto unavailable');\r\n\t          }\r\n\t        }\r\n\r\n\t        // Use Math.random.\r\n\t        if (!CRYPTO) {\r\n\r\n\t          for (; i < k;) {\r\n\t            v = random53bitInt();\r\n\t            if (v < 9e15) c[i++] = v % 1e14;\r\n\t          }\r\n\t        }\r\n\r\n\t        k = c[--i];\r\n\t        dp %= LOG_BASE;\r\n\r\n\t        // Convert trailing digits to zeros according to dp.\r\n\t        if (k && dp) {\r\n\t          v = POWS_TEN[LOG_BASE - dp];\r\n\t          c[i] = mathfloor(k / v) * v;\r\n\t        }\r\n\r\n\t        // Remove trailing elements which are zero.\r\n\t        for (; c[i] === 0; c.pop(), i--);\r\n\r\n\t        // Zero?\r\n\t        if (i < 0) {\r\n\t          c = [e = 0];\r\n\t        } else {\r\n\r\n\t          // Remove leading elements which are zero and adjust exponent accordingly.\r\n\t          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n\t          // Count the digits of the first element of c to determine leading zeros, and...\r\n\t          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n\t          // adjust the exponent accordingly.\r\n\t          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n\t        }\r\n\r\n\t        rand.e = e;\r\n\t        rand.c = c;\r\n\t        return rand;\r\n\t      };\r\n\t    })();\r\n\r\n\r\n\t    /*\r\n\t     * Return a BigNumber whose value is the sum of the arguments.\r\n\t     *\r\n\t     * arguments {number|string|BigNumber}\r\n\t     */\r\n\t    BigNumber.sum = function () {\r\n\t      var i = 1,\r\n\t        args = arguments,\r\n\t        sum = new BigNumber(args[0]);\r\n\t      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n\t      return sum;\r\n\t    };\r\n\r\n\r\n\t    // PRIVATE FUNCTIONS\r\n\r\n\r\n\t    // Called by BigNumber and BigNumber.prototype.toString.\r\n\t    convertBase = (function () {\r\n\t      var decimal = '0123456789';\r\n\r\n\t      /*\r\n\t       * Convert string of baseIn to an array of numbers of baseOut.\r\n\t       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n\t       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n\t       */\r\n\t      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n\t        var j,\r\n\t          arr = [0],\r\n\t          arrL,\r\n\t          i = 0,\r\n\t          len = str.length;\r\n\r\n\t        for (; i < len;) {\r\n\t          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n\t          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n\t          for (j = 0; j < arr.length; j++) {\r\n\r\n\t            if (arr[j] > baseOut - 1) {\r\n\t              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n\t              arr[j + 1] += arr[j] / baseOut | 0;\r\n\t              arr[j] %= baseOut;\r\n\t            }\r\n\t          }\r\n\t        }\r\n\r\n\t        return arr.reverse();\r\n\t      }\r\n\r\n\t      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n\t      // If the caller is toString, we are converting from base 10 to baseOut.\r\n\t      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n\t      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n\t        var alphabet, d, e, k, r, x, xc, y,\r\n\t          i = str.indexOf('.'),\r\n\t          dp = DECIMAL_PLACES,\r\n\t          rm = ROUNDING_MODE;\r\n\r\n\t        // Non-integer.\r\n\t        if (i >= 0) {\r\n\t          k = POW_PRECISION;\r\n\r\n\t          // Unlimited precision.\r\n\t          POW_PRECISION = 0;\r\n\t          str = str.replace('.', '');\r\n\t          y = new BigNumber(baseIn);\r\n\t          x = y.pow(str.length - i);\r\n\t          POW_PRECISION = k;\r\n\r\n\t          // Convert str as if an integer, then restore the fraction part by dividing the\r\n\t          // result by its base raised to a power.\r\n\r\n\t          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n\t           10, baseOut, decimal);\r\n\t          y.e = y.c.length;\r\n\t        }\r\n\r\n\t        // Convert the number as integer.\r\n\r\n\t        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n\t         ? (alphabet = ALPHABET, decimal)\r\n\t         : (alphabet = decimal, ALPHABET));\r\n\r\n\t        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n\t        e = k = xc.length;\r\n\r\n\t        // Remove trailing zeros.\r\n\t        for (; xc[--k] == 0; xc.pop());\r\n\r\n\t        // Zero?\r\n\t        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n\t        // Does str represent an integer? If so, no need for the division.\r\n\t        if (i < 0) {\r\n\t          --e;\r\n\t        } else {\r\n\t          x.c = xc;\r\n\t          x.e = e;\r\n\r\n\t          // The sign is needed for correct rounding.\r\n\t          x.s = sign;\r\n\t          x = div(x, y, dp, rm, baseOut);\r\n\t          xc = x.c;\r\n\t          r = x.r;\r\n\t          e = x.e;\r\n\t        }\r\n\r\n\t        // xc now represents str converted to baseOut.\r\n\r\n\t        // THe index of the rounding digit.\r\n\t        d = e + dp + 1;\r\n\r\n\t        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n\t        i = xc[d];\r\n\r\n\t        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n\t        k = baseOut / 2;\r\n\t        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n\t        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n\t              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n\t               rm == (x.s < 0 ? 8 : 7));\r\n\r\n\t        // If the index of the rounding digit is not greater than zero, or xc represents\r\n\t        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n\t        // such as 0.00001.\r\n\t        if (d < 1 || !xc[0]) {\r\n\r\n\t          // 1^-dp or 0\r\n\t          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n\t        } else {\r\n\r\n\t          // Truncate xc to the required number of decimal places.\r\n\t          xc.length = d;\r\n\r\n\t          // Round up?\r\n\t          if (r) {\r\n\r\n\t            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n\t            for (--baseOut; ++xc[--d] > baseOut;) {\r\n\t              xc[d] = 0;\r\n\r\n\t              if (!d) {\r\n\t                ++e;\r\n\t                xc = [1].concat(xc);\r\n\t              }\r\n\t            }\r\n\t          }\r\n\r\n\t          // Determine trailing zeros.\r\n\t          for (k = xc.length; !xc[--k];);\r\n\r\n\t          // E.g. [4, 11, 15] becomes 4bf.\r\n\t          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n\t          // Add leading zeros, decimal point and trailing zeros as required.\r\n\t          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n\t        }\r\n\r\n\t        // The caller will add the sign.\r\n\t        return str;\r\n\t      };\r\n\t    })();\r\n\r\n\r\n\t    // Perform division in the specified base. Called by div and convertBase.\r\n\t    div = (function () {\r\n\r\n\t      // Assume non-zero x and k.\r\n\t      function multiply(x, k, base) {\r\n\t        var m, temp, xlo, xhi,\r\n\t          carry = 0,\r\n\t          i = x.length,\r\n\t          klo = k % SQRT_BASE,\r\n\t          khi = k / SQRT_BASE | 0;\r\n\r\n\t        for (x = x.slice(); i--;) {\r\n\t          xlo = x[i] % SQRT_BASE;\r\n\t          xhi = x[i] / SQRT_BASE | 0;\r\n\t          m = khi * xlo + xhi * klo;\r\n\t          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n\t          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n\t          x[i] = temp % base;\r\n\t        }\r\n\r\n\t        if (carry) x = [carry].concat(x);\r\n\r\n\t        return x;\r\n\t      }\r\n\r\n\t      function compare(a, b, aL, bL) {\r\n\t        var i, cmp;\r\n\r\n\t        if (aL != bL) {\r\n\t          cmp = aL > bL ? 1 : -1;\r\n\t        } else {\r\n\r\n\t          for (i = cmp = 0; i < aL; i++) {\r\n\r\n\t            if (a[i] != b[i]) {\r\n\t              cmp = a[i] > b[i] ? 1 : -1;\r\n\t              break;\r\n\t            }\r\n\t          }\r\n\t        }\r\n\r\n\t        return cmp;\r\n\t      }\r\n\r\n\t      function subtract(a, b, aL, base) {\r\n\t        var i = 0;\r\n\r\n\t        // Subtract b from a.\r\n\t        for (; aL--;) {\r\n\t          a[aL] -= i;\r\n\t          i = a[aL] < b[aL] ? 1 : 0;\r\n\t          a[aL] = i * base + a[aL] - b[aL];\r\n\t        }\r\n\r\n\t        // Remove leading zeros.\r\n\t        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n\t      }\r\n\r\n\t      // x: dividend, y: divisor.\r\n\t      return function (x, y, dp, rm, base) {\r\n\t        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n\t          yL, yz,\r\n\t          s = x.s == y.s ? 1 : -1,\r\n\t          xc = x.c,\r\n\t          yc = y.c;\r\n\r\n\t        // Either NaN, Infinity or 0?\r\n\t        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n\t          return new BigNumber(\r\n\r\n\t           // Return NaN if either NaN, or both Infinity or 0.\r\n\t           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n\t            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n\t            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n\t         );\r\n\t        }\r\n\r\n\t        q = new BigNumber(s);\r\n\t        qc = q.c = [];\r\n\t        e = x.e - y.e;\r\n\t        s = dp + e + 1;\r\n\r\n\t        if (!base) {\r\n\t          base = BASE;\r\n\t          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n\t          s = s / LOG_BASE | 0;\r\n\t        }\r\n\r\n\t        // Result exponent may be one less then the current value of e.\r\n\t        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n\t        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n\t        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n\t        if (s < 0) {\r\n\t          qc.push(1);\r\n\t          more = true;\r\n\t        } else {\r\n\t          xL = xc.length;\r\n\t          yL = yc.length;\r\n\t          i = 0;\r\n\t          s += 2;\r\n\r\n\t          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n\t          n = mathfloor(base / (yc[0] + 1));\r\n\r\n\t          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n\t          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n\t          if (n > 1) {\r\n\t            yc = multiply(yc, n, base);\r\n\t            xc = multiply(xc, n, base);\r\n\t            yL = yc.length;\r\n\t            xL = xc.length;\r\n\t          }\r\n\r\n\t          xi = yL;\r\n\t          rem = xc.slice(0, yL);\r\n\t          remL = rem.length;\r\n\r\n\t          // Add zeros to make remainder as long as divisor.\r\n\t          for (; remL < yL; rem[remL++] = 0);\r\n\t          yz = yc.slice();\r\n\t          yz = [0].concat(yz);\r\n\t          yc0 = yc[0];\r\n\t          if (yc[1] >= base / 2) yc0++;\r\n\t          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n\t          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n\t          do {\r\n\t            n = 0;\r\n\r\n\t            // Compare divisor and remainder.\r\n\t            cmp = compare(yc, rem, yL, remL);\r\n\r\n\t            // If divisor < remainder.\r\n\t            if (cmp < 0) {\r\n\r\n\t              // Calculate trial digit, n.\r\n\r\n\t              rem0 = rem[0];\r\n\t              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n\t              // n is how many times the divisor goes into the current remainder.\r\n\t              n = mathfloor(rem0 / yc0);\r\n\r\n\t              //  Algorithm:\r\n\t              //  product = divisor multiplied by trial digit (n).\r\n\t              //  Compare product and remainder.\r\n\t              //  If product is greater than remainder:\r\n\t              //    Subtract divisor from product, decrement trial digit.\r\n\t              //  Subtract product from remainder.\r\n\t              //  If product was less than remainder at the last compare:\r\n\t              //    Compare new remainder and divisor.\r\n\t              //    If remainder is greater than divisor:\r\n\t              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n\t              if (n > 1) {\r\n\r\n\t                // n may be > base only when base is 3.\r\n\t                if (n >= base) n = base - 1;\r\n\r\n\t                // product = divisor * trial digit.\r\n\t                prod = multiply(yc, n, base);\r\n\t                prodL = prod.length;\r\n\t                remL = rem.length;\r\n\r\n\t                // Compare product and remainder.\r\n\t                // If product > remainder then trial digit n too high.\r\n\t                // n is 1 too high about 5% of the time, and is not known to have\r\n\t                // ever been more than 1 too high.\r\n\t                while (compare(prod, rem, prodL, remL) == 1) {\r\n\t                  n--;\r\n\r\n\t                  // Subtract divisor from product.\r\n\t                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n\t                  prodL = prod.length;\r\n\t                  cmp = 1;\r\n\t                }\r\n\t              } else {\r\n\r\n\t                // n is 0 or 1, cmp is -1.\r\n\t                // If n is 0, there is no need to compare yc and rem again below,\r\n\t                // so change cmp to 1 to avoid it.\r\n\t                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n\t                if (n == 0) {\r\n\r\n\t                  // divisor < remainder, so n must be at least 1.\r\n\t                  cmp = n = 1;\r\n\t                }\r\n\r\n\t                // product = divisor\r\n\t                prod = yc.slice();\r\n\t                prodL = prod.length;\r\n\t              }\r\n\r\n\t              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n\t              // Subtract product from remainder.\r\n\t              subtract(rem, prod, remL, base);\r\n\t              remL = rem.length;\r\n\r\n\t               // If product was < remainder.\r\n\t              if (cmp == -1) {\r\n\r\n\t                // Compare divisor and new remainder.\r\n\t                // If divisor < new remainder, subtract divisor from remainder.\r\n\t                // Trial digit n too low.\r\n\t                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n\t                while (compare(yc, rem, yL, remL) < 1) {\r\n\t                  n++;\r\n\r\n\t                  // Subtract divisor from remainder.\r\n\t                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n\t                  remL = rem.length;\r\n\t                }\r\n\t              }\r\n\t            } else if (cmp === 0) {\r\n\t              n++;\r\n\t              rem = [0];\r\n\t            } // else cmp === 1 and n will be 0\r\n\r\n\t            // Add the next digit, n, to the result array.\r\n\t            qc[i++] = n;\r\n\r\n\t            // Update the remainder.\r\n\t            if (rem[0]) {\r\n\t              rem[remL++] = xc[xi] || 0;\r\n\t            } else {\r\n\t              rem = [xc[xi]];\r\n\t              remL = 1;\r\n\t            }\r\n\t          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n\t          more = rem[0] != null;\r\n\r\n\t          // Leading zero?\r\n\t          if (!qc[0]) qc.splice(0, 1);\r\n\t        }\r\n\r\n\t        if (base == BASE) {\r\n\r\n\t          // To calculate q.e, first get the number of digits of qc[0].\r\n\t          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n\t          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n\t        // Caller is convertBase.\r\n\t        } else {\r\n\t          q.e = e;\r\n\t          q.r = +more;\r\n\t        }\r\n\r\n\t        return q;\r\n\t      };\r\n\t    })();\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n\t     * notation rounded to the specified decimal places or significant digits.\r\n\t     *\r\n\t     * n: a BigNumber.\r\n\t     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n\t     * rm: the rounding mode.\r\n\t     * id: 1 (toExponential) or 2 (toPrecision).\r\n\t     */\r\n\t    function format(n, i, rm, id) {\r\n\t      var c0, e, ne, len, str;\r\n\r\n\t      if (rm == null) rm = ROUNDING_MODE;\r\n\t      else intCheck(rm, 0, 8);\r\n\r\n\t      if (!n.c) return n.toString();\r\n\r\n\t      c0 = n.c[0];\r\n\t      ne = n.e;\r\n\r\n\t      if (i == null) {\r\n\t        str = coeffToString(n.c);\r\n\t        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n\t         ? toExponential(str, ne)\r\n\t         : toFixedPoint(str, ne, '0');\r\n\t      } else {\r\n\t        n = round(new BigNumber(n), i, rm);\r\n\r\n\t        // n.e may have changed if the value was rounded up.\r\n\t        e = n.e;\r\n\r\n\t        str = coeffToString(n.c);\r\n\t        len = str.length;\r\n\r\n\t        // toPrecision returns exponential notation if the number of significant digits\r\n\t        // specified is less than the number of digits necessary to represent the integer\r\n\t        // part of the value in fixed-point notation.\r\n\r\n\t        // Exponential notation.\r\n\t        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n\t          // Append zeros?\r\n\t          for (; len < i; str += '0', len++);\r\n\t          str = toExponential(str, e);\r\n\r\n\t        // Fixed-point notation.\r\n\t        } else {\r\n\t          i -= ne;\r\n\t          str = toFixedPoint(str, e, '0');\r\n\r\n\t          // Append zeros?\r\n\t          if (e + 1 > len) {\r\n\t            if (--i > 0) for (str += '.'; i--; str += '0');\r\n\t          } else {\r\n\t            i += e - len;\r\n\t            if (i > 0) {\r\n\t              if (e + 1 == len) str += '.';\r\n\t              for (; i--; str += '0');\r\n\t            }\r\n\t          }\r\n\t        }\r\n\t      }\r\n\r\n\t      return n.s < 0 && c0 ? '-' + str : str;\r\n\t    }\r\n\r\n\r\n\t    // Handle BigNumber.max and BigNumber.min.\r\n\t    // If any number is NaN, return NaN.\r\n\t    function maxOrMin(args, n) {\r\n\t      var k, y,\r\n\t        i = 1,\r\n\t        x = new BigNumber(args[0]);\r\n\r\n\t      for (; i < args.length; i++) {\r\n\t        y = new BigNumber(args[i]);\r\n\t        if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\r\n\t          x = y;\r\n\t        }\r\n\t      }\r\n\r\n\t      return x;\r\n\t    }\r\n\r\n\r\n\t    /*\r\n\t     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n\t     * Called by minus, plus and times.\r\n\t     */\r\n\t    function normalise(n, c, e) {\r\n\t      var i = 1,\r\n\t        j = c.length;\r\n\r\n\t       // Remove trailing zeros.\r\n\t      for (; !c[--j]; c.pop());\r\n\r\n\t      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n\t      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n\t      // Overflow?\r\n\t      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n\t        // Infinity.\r\n\t        n.c = n.e = null;\r\n\r\n\t      // Underflow?\r\n\t      } else if (e < MIN_EXP) {\r\n\r\n\t        // Zero.\r\n\t        n.c = [n.e = 0];\r\n\t      } else {\r\n\t        n.e = e;\r\n\t        n.c = c;\r\n\t      }\r\n\r\n\t      return n;\r\n\t    }\r\n\r\n\r\n\t    // Handle values that fail the validity test in BigNumber.\r\n\t    parseNumeric = (function () {\r\n\t      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n\t        dotAfter = /^([^.]+)\\.$/,\r\n\t        dotBefore = /^\\.([^.]+)$/,\r\n\t        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n\t        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n\t      return function (x, str, isNum, b) {\r\n\t        var base,\r\n\t          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n\t        // No exception on ±Infinity or NaN.\r\n\t        if (isInfinityOrNaN.test(s)) {\r\n\t          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n\t        } else {\r\n\t          if (!isNum) {\r\n\r\n\t            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n\t            s = s.replace(basePrefix, function (m, p1, p2) {\r\n\t              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n\t              return !b || b == base ? p1 : m;\r\n\t            });\r\n\r\n\t            if (b) {\r\n\t              base = b;\r\n\r\n\t              // E.g. '1.' to '1', '.1' to '0.1'\r\n\t              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n\t            }\r\n\r\n\t            if (str != s) return new BigNumber(s, base);\r\n\t          }\r\n\r\n\t          // '[BigNumber Error] Not a number: {n}'\r\n\t          // '[BigNumber Error] Not a base {b} number: {n}'\r\n\t          if (BigNumber.DEBUG) {\r\n\t            throw Error\r\n\t              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n\t          }\r\n\r\n\t          // NaN\r\n\t          x.s = null;\r\n\t        }\r\n\r\n\t        x.c = x.e = null;\r\n\t      }\r\n\t    })();\r\n\r\n\r\n\t    /*\r\n\t     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n\t     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n\t     */\r\n\t    function round(x, sd, rm, r) {\r\n\t      var d, i, j, k, n, ni, rd,\r\n\t        xc = x.c,\r\n\t        pows10 = POWS_TEN;\r\n\r\n\t      // if x is not Infinity or NaN...\r\n\t      if (xc) {\r\n\r\n\t        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n\t        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n\t        // ni is the index of n within x.c.\r\n\t        // d is the number of digits of n.\r\n\t        // i is the index of rd within n including leading zeros.\r\n\t        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n\t        out: {\r\n\r\n\t          // Get the number of digits of the first element of xc.\r\n\t          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n\t          i = sd - d;\r\n\r\n\t          // If the rounding digit is in the first element of xc...\r\n\t          if (i < 0) {\r\n\t            i += LOG_BASE;\r\n\t            j = sd;\r\n\t            n = xc[ni = 0];\r\n\r\n\t            // Get the rounding digit at index j of n.\r\n\t            rd = mathfloor(n / pows10[d - j - 1] % 10);\r\n\t          } else {\r\n\t            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n\t            if (ni >= xc.length) {\r\n\r\n\t              if (r) {\r\n\r\n\t                // Needed by sqrt.\r\n\t                for (; xc.length <= ni; xc.push(0));\r\n\t                n = rd = 0;\r\n\t                d = 1;\r\n\t                i %= LOG_BASE;\r\n\t                j = i - LOG_BASE + 1;\r\n\t              } else {\r\n\t                break out;\r\n\t              }\r\n\t            } else {\r\n\t              n = k = xc[ni];\r\n\r\n\t              // Get the number of digits of n.\r\n\t              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n\t              // Get the index of rd within n.\r\n\t              i %= LOG_BASE;\r\n\r\n\t              // Get the index of rd within n, adjusted for leading zeros.\r\n\t              // The number of leading zeros of n is given by LOG_BASE - d.\r\n\t              j = i - LOG_BASE + d;\r\n\r\n\t              // Get the rounding digit at index j of n.\r\n\t              rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\r\n\t            }\r\n\t          }\r\n\r\n\t          r = r || sd < 0 ||\r\n\r\n\t          // Are there any non-zero digits after the rounding digit?\r\n\t          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n\t          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n\t           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n\t          r = rm < 4\r\n\t           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n\t           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n\t            // Check whether the digit to the left of the rounding digit is odd.\r\n\t            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n\t             rm == (x.s < 0 ? 8 : 7));\r\n\r\n\t          if (sd < 1 || !xc[0]) {\r\n\t            xc.length = 0;\r\n\r\n\t            if (r) {\r\n\r\n\t              // Convert sd to decimal places.\r\n\t              sd -= x.e + 1;\r\n\r\n\t              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n\t              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n\t              x.e = -sd || 0;\r\n\t            } else {\r\n\r\n\t              // Zero.\r\n\t              xc[0] = x.e = 0;\r\n\t            }\r\n\r\n\t            return x;\r\n\t          }\r\n\r\n\t          // Remove excess digits.\r\n\t          if (i == 0) {\r\n\t            xc.length = ni;\r\n\t            k = 1;\r\n\t            ni--;\r\n\t          } else {\r\n\t            xc.length = ni + 1;\r\n\t            k = pows10[LOG_BASE - i];\r\n\r\n\t            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n\t            // j > 0 means i > number of leading zeros of n.\r\n\t            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n\t          }\r\n\r\n\t          // Round up?\r\n\t          if (r) {\r\n\r\n\t            for (; ;) {\r\n\r\n\t              // If the digit to be rounded up is in the first element of xc...\r\n\t              if (ni == 0) {\r\n\r\n\t                // i will be the length of xc[0] before k is added.\r\n\t                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n\t                j = xc[0] += k;\r\n\t                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n\t                // if i != k the length has increased.\r\n\t                if (i != k) {\r\n\t                  x.e++;\r\n\t                  if (xc[0] == BASE) xc[0] = 1;\r\n\t                }\r\n\r\n\t                break;\r\n\t              } else {\r\n\t                xc[ni] += k;\r\n\t                if (xc[ni] != BASE) break;\r\n\t                xc[ni--] = 0;\r\n\t                k = 1;\r\n\t              }\r\n\t            }\r\n\t          }\r\n\r\n\t          // Remove trailing zeros.\r\n\t          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n\t        }\r\n\r\n\t        // Overflow? Infinity.\r\n\t        if (x.e > MAX_EXP) {\r\n\t          x.c = x.e = null;\r\n\r\n\t        // Underflow? Zero.\r\n\t        } else if (x.e < MIN_EXP) {\r\n\t          x.c = [x.e = 0];\r\n\t        }\r\n\t      }\r\n\r\n\t      return x;\r\n\t    }\r\n\r\n\r\n\t    function valueOf(n) {\r\n\t      var str,\r\n\t        e = n.e;\r\n\r\n\t      if (e === null) return n.toString();\r\n\r\n\t      str = coeffToString(n.c);\r\n\r\n\t      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n\t        ? toExponential(str, e)\r\n\t        : toFixedPoint(str, e, '0');\r\n\r\n\t      return n.s < 0 ? '-' + str : str;\r\n\t    }\r\n\r\n\r\n\t    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n\t     */\r\n\t    P.absoluteValue = P.abs = function () {\r\n\t      var x = new BigNumber(this);\r\n\t      if (x.s < 0) x.s = 1;\r\n\t      return x;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return\r\n\t     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n\t     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n\t     *   0 if they have the same value,\r\n\t     *   or null if the value of either is NaN.\r\n\t     */\r\n\t    P.comparedTo = function (y, b) {\r\n\t      return compare(this, new BigNumber(y, b));\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n\t     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n\t     *\r\n\t     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n\t     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n\t     * ROUNDING_MODE if rm is omitted.\r\n\t     *\r\n\t     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n\t     */\r\n\t    P.decimalPlaces = P.dp = function (dp, rm) {\r\n\t      var c, n, v,\r\n\t        x = this;\r\n\r\n\t      if (dp != null) {\r\n\t        intCheck(dp, 0, MAX);\r\n\t        if (rm == null) rm = ROUNDING_MODE;\r\n\t        else intCheck(rm, 0, 8);\r\n\r\n\t        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n\t      }\r\n\r\n\t      if (!(c = x.c)) return null;\r\n\t      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n\t      // Subtract the number of trailing zeros of the last number.\r\n\t      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n\t      if (n < 0) n = 0;\r\n\r\n\t      return n;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *  n / 0 = I\r\n\t     *  n / N = N\r\n\t     *  n / I = 0\r\n\t     *  0 / n = 0\r\n\t     *  0 / 0 = N\r\n\t     *  0 / N = N\r\n\t     *  0 / I = 0\r\n\t     *  N / n = N\r\n\t     *  N / 0 = N\r\n\t     *  N / N = N\r\n\t     *  N / I = N\r\n\t     *  I / n = I\r\n\t     *  I / 0 = I\r\n\t     *  I / N = N\r\n\t     *  I / I = N\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n\t     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n\t     */\r\n\t    P.dividedBy = P.div = function (y, b) {\r\n\t      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n\t     * BigNumber by the value of BigNumber(y, b).\r\n\t     */\r\n\t    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n\t      return div(this, new BigNumber(y, b), 0, 1);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n\t     *\r\n\t     * If m is present, return the result modulo m.\r\n\t     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n\t     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n\t     *\r\n\t     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n\t     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n\t     *\r\n\t     * n {number|string|BigNumber} The exponent. An integer.\r\n\t     * [m] {number|string|BigNumber} The modulus.\r\n\t     *\r\n\t     * '[BigNumber Error] Exponent not an integer: {n}'\r\n\t     */\r\n\t    P.exponentiatedBy = P.pow = function (n, m) {\r\n\t      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n\t        x = this;\r\n\r\n\t      n = new BigNumber(n);\r\n\r\n\t      // Allow NaN and ±Infinity, but not other non-integers.\r\n\t      if (n.c && !n.isInteger()) {\r\n\t        throw Error\r\n\t          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n\t      }\r\n\r\n\t      if (m != null) m = new BigNumber(m);\r\n\r\n\t      // Exponent of MAX_SAFE_INTEGER is 15.\r\n\t      nIsBig = n.e > 14;\r\n\r\n\t      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n\t      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\t        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n\t        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n\t        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n\t        return m ? y.mod(m) : y;\r\n\t      }\r\n\r\n\t      nIsNeg = n.s < 0;\r\n\r\n\t      if (m) {\r\n\r\n\t        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n\t        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n\t        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n\t        if (isModExp) x = x.mod(m);\r\n\r\n\t      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n\t      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n\t      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n\t        // [1, 240000000]\r\n\t        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n\t        // [80000000000000]  [99999750000000]\r\n\t        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n\t        // If x is negative and n is odd, k = -0, else k = 0.\r\n\t        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n\t        // If x >= 1, k = ±Infinity.\r\n\t        if (x.e > -1) k = 1 / k;\r\n\r\n\t        // If n is negative return ±0, else return ±Infinity.\r\n\t        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n\t      } else if (POW_PRECISION) {\r\n\r\n\t        // Truncating each coefficient array to a length of k after each multiplication\r\n\t        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n\t        // i.e. there will be a minimum of 28 guard digits retained.\r\n\t        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n\t      }\r\n\r\n\t      if (nIsBig) {\r\n\t        half = new BigNumber(0.5);\r\n\t        if (nIsNeg) n.s = 1;\r\n\t        nIsOdd = isOdd(n);\r\n\t      } else {\r\n\t        i = Math.abs(+valueOf(n));\r\n\t        nIsOdd = i % 2;\r\n\t      }\r\n\r\n\t      y = new BigNumber(ONE);\r\n\r\n\t      // Performs 54 loop iterations for n of 9007199254740991.\r\n\t      for (; ;) {\r\n\r\n\t        if (nIsOdd) {\r\n\t          y = y.times(x);\r\n\t          if (!y.c) break;\r\n\r\n\t          if (k) {\r\n\t            if (y.c.length > k) y.c.length = k;\r\n\t          } else if (isModExp) {\r\n\t            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n\t          }\r\n\t        }\r\n\r\n\t        if (i) {\r\n\t          i = mathfloor(i / 2);\r\n\t          if (i === 0) break;\r\n\t          nIsOdd = i % 2;\r\n\t        } else {\r\n\t          n = n.times(half);\r\n\t          round(n, n.e + 1, 1);\r\n\r\n\t          if (n.e > 14) {\r\n\t            nIsOdd = isOdd(n);\r\n\t          } else {\r\n\t            i = +valueOf(n);\r\n\t            if (i === 0) break;\r\n\t            nIsOdd = i % 2;\r\n\t          }\r\n\t        }\r\n\r\n\t        x = x.times(x);\r\n\r\n\t        if (k) {\r\n\t          if (x.c && x.c.length > k) x.c.length = k;\r\n\t        } else if (isModExp) {\r\n\t          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n\t        }\r\n\t      }\r\n\r\n\t      if (isModExp) return y;\r\n\t      if (nIsNeg) y = ONE.div(y);\r\n\r\n\t      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n\t     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n\t     *\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n\t     */\r\n\t    P.integerValue = function (rm) {\r\n\t      var n = new BigNumber(this);\r\n\t      if (rm == null) rm = ROUNDING_MODE;\r\n\t      else intCheck(rm, 0, 8);\r\n\t      return round(n, n.e + 1, rm);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n\t     * otherwise return false.\r\n\t     */\r\n\t    P.isEqualTo = P.eq = function (y, b) {\r\n\t      return compare(this, new BigNumber(y, b)) === 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n\t     */\r\n\t    P.isFinite = function () {\r\n\t      return !!this.c;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n\t     * otherwise return false.\r\n\t     */\r\n\t    P.isGreaterThan = P.gt = function (y, b) {\r\n\t      return compare(this, new BigNumber(y, b)) > 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n\t     * BigNumber(y, b), otherwise return false.\r\n\t     */\r\n\t    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n\t      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n\t     */\r\n\t    P.isInteger = function () {\r\n\t      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n\t     * otherwise return false.\r\n\t     */\r\n\t    P.isLessThan = P.lt = function (y, b) {\r\n\t      return compare(this, new BigNumber(y, b)) < 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is less than or equal to the value of\r\n\t     * BigNumber(y, b), otherwise return false.\r\n\t     */\r\n\t    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n\t      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n\t     */\r\n\t    P.isNaN = function () {\r\n\t      return !this.s;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n\t     */\r\n\t    P.isNegative = function () {\r\n\t      return this.s < 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n\t     */\r\n\t    P.isPositive = function () {\r\n\t      return this.s > 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n\t     */\r\n\t    P.isZero = function () {\r\n\t      return !!this.c && this.c[0] == 0;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *  n - 0 = n\r\n\t     *  n - N = N\r\n\t     *  n - I = -I\r\n\t     *  0 - n = -n\r\n\t     *  0 - 0 = 0\r\n\t     *  0 - N = N\r\n\t     *  0 - I = -I\r\n\t     *  N - n = N\r\n\t     *  N - 0 = N\r\n\t     *  N - N = N\r\n\t     *  N - I = N\r\n\t     *  I - n = I\r\n\t     *  I - 0 = I\r\n\t     *  I - N = N\r\n\t     *  I - I = N\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n\t     * BigNumber(y, b).\r\n\t     */\r\n\t    P.minus = function (y, b) {\r\n\t      var i, j, t, xLTy,\r\n\t        x = this,\r\n\t        a = x.s;\r\n\r\n\t      y = new BigNumber(y, b);\r\n\t      b = y.s;\r\n\r\n\t      // Either NaN?\r\n\t      if (!a || !b) return new BigNumber(NaN);\r\n\r\n\t      // Signs differ?\r\n\t      if (a != b) {\r\n\t        y.s = -b;\r\n\t        return x.plus(y);\r\n\t      }\r\n\r\n\t      var xe = x.e / LOG_BASE,\r\n\t        ye = y.e / LOG_BASE,\r\n\t        xc = x.c,\r\n\t        yc = y.c;\r\n\r\n\t      if (!xe || !ye) {\r\n\r\n\t        // Either Infinity?\r\n\t        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n\t        // Either zero?\r\n\t        if (!xc[0] || !yc[0]) {\r\n\r\n\t          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n\t          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n\t           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n\t           ROUNDING_MODE == 3 ? -0 : 0);\r\n\t        }\r\n\t      }\r\n\r\n\t      xe = bitFloor(xe);\r\n\t      ye = bitFloor(ye);\r\n\t      xc = xc.slice();\r\n\r\n\t      // Determine which is the bigger number.\r\n\t      if (a = xe - ye) {\r\n\r\n\t        if (xLTy = a < 0) {\r\n\t          a = -a;\r\n\t          t = xc;\r\n\t        } else {\r\n\t          ye = xe;\r\n\t          t = yc;\r\n\t        }\r\n\r\n\t        t.reverse();\r\n\r\n\t        // Prepend zeros to equalise exponents.\r\n\t        for (b = a; b--; t.push(0));\r\n\t        t.reverse();\r\n\t      } else {\r\n\r\n\t        // Exponents equal. Check digit by digit.\r\n\t        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n\t        for (a = b = 0; b < j; b++) {\r\n\r\n\t          if (xc[b] != yc[b]) {\r\n\t            xLTy = xc[b] < yc[b];\r\n\t            break;\r\n\t          }\r\n\t        }\r\n\t      }\r\n\r\n\t      // x < y? Point xc to the array of the bigger number.\r\n\t      if (xLTy) {\r\n\t        t = xc;\r\n\t        xc = yc;\r\n\t        yc = t;\r\n\t        y.s = -y.s;\r\n\t      }\r\n\r\n\t      b = (j = yc.length) - (i = xc.length);\r\n\r\n\t      // Append zeros to xc if shorter.\r\n\t      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n\t      if (b > 0) for (; b--; xc[i++] = 0);\r\n\t      b = BASE - 1;\r\n\r\n\t      // Subtract yc from xc.\r\n\t      for (; j > a;) {\r\n\r\n\t        if (xc[--j] < yc[j]) {\r\n\t          for (i = j; i && !xc[--i]; xc[i] = b);\r\n\t          --xc[i];\r\n\t          xc[j] += BASE;\r\n\t        }\r\n\r\n\t        xc[j] -= yc[j];\r\n\t      }\r\n\r\n\t      // Remove leading zeros and adjust exponent accordingly.\r\n\t      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n\t      // Zero?\r\n\t      if (!xc[0]) {\r\n\r\n\t        // Following IEEE 754 (2008) 6.3,\r\n\t        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n\t        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n\t        y.c = [y.e = 0];\r\n\t        return y;\r\n\t      }\r\n\r\n\t      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n\t      // for finite x and y.\r\n\t      return normalise(y, xc, ye);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *   n % 0 =  N\r\n\t     *   n % N =  N\r\n\t     *   n % I =  n\r\n\t     *   0 % n =  0\r\n\t     *  -0 % n = -0\r\n\t     *   0 % 0 =  N\r\n\t     *   0 % N =  N\r\n\t     *   0 % I =  0\r\n\t     *   N % n =  N\r\n\t     *   N % 0 =  N\r\n\t     *   N % N =  N\r\n\t     *   N % I =  N\r\n\t     *   I % n =  N\r\n\t     *   I % 0 =  N\r\n\t     *   I % N =  N\r\n\t     *   I % I =  N\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n\t     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n\t     */\r\n\t    P.modulo = P.mod = function (y, b) {\r\n\t      var q, s,\r\n\t        x = this;\r\n\r\n\t      y = new BigNumber(y, b);\r\n\r\n\t      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n\t      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n\t        return new BigNumber(NaN);\r\n\r\n\t      // Return x if y is Infinity or x is zero.\r\n\t      } else if (!y.c || x.c && !x.c[0]) {\r\n\t        return new BigNumber(x);\r\n\t      }\r\n\r\n\t      if (MODULO_MODE == 9) {\r\n\r\n\t        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n\t        // r = x - qy    where  0 <= r < abs(y)\r\n\t        s = y.s;\r\n\t        y.s = 1;\r\n\t        q = div(x, y, 0, 3);\r\n\t        y.s = s;\r\n\t        q.s *= s;\r\n\t      } else {\r\n\t        q = div(x, y, 0, MODULO_MODE);\r\n\t      }\r\n\r\n\t      y = x.minus(q.times(y));\r\n\r\n\t      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n\t      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n\t      return y;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *  n * 0 = 0\r\n\t     *  n * N = N\r\n\t     *  n * I = I\r\n\t     *  0 * n = 0\r\n\t     *  0 * 0 = 0\r\n\t     *  0 * N = N\r\n\t     *  0 * I = N\r\n\t     *  N * n = N\r\n\t     *  N * 0 = N\r\n\t     *  N * N = N\r\n\t     *  N * I = N\r\n\t     *  I * n = I\r\n\t     *  I * 0 = N\r\n\t     *  I * N = N\r\n\t     *  I * I = I\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n\t     * of BigNumber(y, b).\r\n\t     */\r\n\t    P.multipliedBy = P.times = function (y, b) {\r\n\t      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n\t        base, sqrtBase,\r\n\t        x = this,\r\n\t        xc = x.c,\r\n\t        yc = (y = new BigNumber(y, b)).c;\r\n\r\n\t      // Either NaN, ±Infinity or ±0?\r\n\t      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n\t        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n\t        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n\t          y.c = y.e = y.s = null;\r\n\t        } else {\r\n\t          y.s *= x.s;\r\n\r\n\t          // Return ±Infinity if either is ±Infinity.\r\n\t          if (!xc || !yc) {\r\n\t            y.c = y.e = null;\r\n\r\n\t          // Return ±0 if either is ±0.\r\n\t          } else {\r\n\t            y.c = [0];\r\n\t            y.e = 0;\r\n\t          }\r\n\t        }\r\n\r\n\t        return y;\r\n\t      }\r\n\r\n\t      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n\t      y.s *= x.s;\r\n\t      xcL = xc.length;\r\n\t      ycL = yc.length;\r\n\r\n\t      // Ensure xc points to longer array and xcL to its length.\r\n\t      if (xcL < ycL) {\r\n\t        zc = xc;\r\n\t        xc = yc;\r\n\t        yc = zc;\r\n\t        i = xcL;\r\n\t        xcL = ycL;\r\n\t        ycL = i;\r\n\t      }\r\n\r\n\t      // Initialise the result array with zeros.\r\n\t      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n\t      base = BASE;\r\n\t      sqrtBase = SQRT_BASE;\r\n\r\n\t      for (i = ycL; --i >= 0;) {\r\n\t        c = 0;\r\n\t        ylo = yc[i] % sqrtBase;\r\n\t        yhi = yc[i] / sqrtBase | 0;\r\n\r\n\t        for (k = xcL, j = i + k; j > i;) {\r\n\t          xlo = xc[--k] % sqrtBase;\r\n\t          xhi = xc[k] / sqrtBase | 0;\r\n\t          m = yhi * xlo + xhi * ylo;\r\n\t          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n\t          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n\t          zc[j--] = xlo % base;\r\n\t        }\r\n\r\n\t        zc[j] = c;\r\n\t      }\r\n\r\n\t      if (c) {\r\n\t        ++e;\r\n\t      } else {\r\n\t        zc.splice(0, 1);\r\n\t      }\r\n\r\n\t      return normalise(y, zc, e);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n\t     * i.e. multiplied by -1.\r\n\t     */\r\n\t    P.negated = function () {\r\n\t      var x = new BigNumber(this);\r\n\t      x.s = -x.s || null;\r\n\t      return x;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *  n + 0 = n\r\n\t     *  n + N = N\r\n\t     *  n + I = I\r\n\t     *  0 + n = n\r\n\t     *  0 + 0 = 0\r\n\t     *  0 + N = N\r\n\t     *  0 + I = I\r\n\t     *  N + n = N\r\n\t     *  N + 0 = N\r\n\t     *  N + N = N\r\n\t     *  N + I = N\r\n\t     *  I + n = I\r\n\t     *  I + 0 = I\r\n\t     *  I + N = N\r\n\t     *  I + I = I\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n\t     * BigNumber(y, b).\r\n\t     */\r\n\t    P.plus = function (y, b) {\r\n\t      var t,\r\n\t        x = this,\r\n\t        a = x.s;\r\n\r\n\t      y = new BigNumber(y, b);\r\n\t      b = y.s;\r\n\r\n\t      // Either NaN?\r\n\t      if (!a || !b) return new BigNumber(NaN);\r\n\r\n\t      // Signs differ?\r\n\t       if (a != b) {\r\n\t        y.s = -b;\r\n\t        return x.minus(y);\r\n\t      }\r\n\r\n\t      var xe = x.e / LOG_BASE,\r\n\t        ye = y.e / LOG_BASE,\r\n\t        xc = x.c,\r\n\t        yc = y.c;\r\n\r\n\t      if (!xe || !ye) {\r\n\r\n\t        // Return ±Infinity if either ±Infinity.\r\n\t        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n\t        // Either zero?\r\n\t        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n\t        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n\t      }\r\n\r\n\t      xe = bitFloor(xe);\r\n\t      ye = bitFloor(ye);\r\n\t      xc = xc.slice();\r\n\r\n\t      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n\t      if (a = xe - ye) {\r\n\t        if (a > 0) {\r\n\t          ye = xe;\r\n\t          t = yc;\r\n\t        } else {\r\n\t          a = -a;\r\n\t          t = xc;\r\n\t        }\r\n\r\n\t        t.reverse();\r\n\t        for (; a--; t.push(0));\r\n\t        t.reverse();\r\n\t      }\r\n\r\n\t      a = xc.length;\r\n\t      b = yc.length;\r\n\r\n\t      // Point xc to the longer array, and b to the shorter length.\r\n\t      if (a - b < 0) {\r\n\t        t = yc;\r\n\t        yc = xc;\r\n\t        xc = t;\r\n\t        b = a;\r\n\t      }\r\n\r\n\t      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n\t      for (a = 0; b;) {\r\n\t        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n\t        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n\t      }\r\n\r\n\t      if (a) {\r\n\t        xc = [a].concat(xc);\r\n\t        ++ye;\r\n\t      }\r\n\r\n\t      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n\t      // ye = MAX_EXP + 1 possible\r\n\t      return normalise(y, xc, ye);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * If sd is undefined or null or true or false, return the number of significant digits of\r\n\t     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n\t     * If sd is true include integer-part trailing zeros in the count.\r\n\t     *\r\n\t     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n\t     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n\t     * ROUNDING_MODE if rm is omitted.\r\n\t     *\r\n\t     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n\t     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n\t     */\r\n\t    P.precision = P.sd = function (sd, rm) {\r\n\t      var c, n, v,\r\n\t        x = this;\r\n\r\n\t      if (sd != null && sd !== !!sd) {\r\n\t        intCheck(sd, 1, MAX);\r\n\t        if (rm == null) rm = ROUNDING_MODE;\r\n\t        else intCheck(rm, 0, 8);\r\n\r\n\t        return round(new BigNumber(x), sd, rm);\r\n\t      }\r\n\r\n\t      if (!(c = x.c)) return null;\r\n\t      v = c.length - 1;\r\n\t      n = v * LOG_BASE + 1;\r\n\r\n\t      if (v = c[v]) {\r\n\r\n\t        // Subtract the number of trailing zeros of the last element.\r\n\t        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n\t        // Add the number of digits of the first element.\r\n\t        for (v = c[0]; v >= 10; v /= 10, n++);\r\n\t      }\r\n\r\n\t      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n\t      return n;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n\t     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n\t     *\r\n\t     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n\t     */\r\n\t    P.shiftedBy = function (k) {\r\n\t      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n\t      return this.times('1e' + k);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     *  sqrt(-n) =  N\r\n\t     *  sqrt(N) =  N\r\n\t     *  sqrt(-I) =  N\r\n\t     *  sqrt(I) =  I\r\n\t     *  sqrt(0) =  0\r\n\t     *  sqrt(-0) = -0\r\n\t     *\r\n\t     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n\t     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n\t     */\r\n\t    P.squareRoot = P.sqrt = function () {\r\n\t      var m, n, r, rep, t,\r\n\t        x = this,\r\n\t        c = x.c,\r\n\t        s = x.s,\r\n\t        e = x.e,\r\n\t        dp = DECIMAL_PLACES + 4,\r\n\t        half = new BigNumber('0.5');\r\n\r\n\t      // Negative/NaN/Infinity/zero?\r\n\t      if (s !== 1 || !c || !c[0]) {\r\n\t        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n\t      }\r\n\r\n\t      // Initial estimate.\r\n\t      s = Math.sqrt(+valueOf(x));\r\n\r\n\t      // Math.sqrt underflow/overflow?\r\n\t      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n\t      if (s == 0 || s == 1 / 0) {\r\n\t        n = coeffToString(c);\r\n\t        if ((n.length + e) % 2 == 0) n += '0';\r\n\t        s = Math.sqrt(+n);\r\n\t        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n\t        if (s == 1 / 0) {\r\n\t          n = '5e' + e;\r\n\t        } else {\r\n\t          n = s.toExponential();\r\n\t          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n\t        }\r\n\r\n\t        r = new BigNumber(n);\r\n\t      } else {\r\n\t        r = new BigNumber(s + '');\r\n\t      }\r\n\r\n\t      // Check for zero.\r\n\t      // r could be zero if MIN_EXP is changed after the this value was created.\r\n\t      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n\t      // coeffToString to throw.\r\n\t      if (r.c[0]) {\r\n\t        e = r.e;\r\n\t        s = e + dp;\r\n\t        if (s < 3) s = 0;\r\n\r\n\t        // Newton-Raphson iteration.\r\n\t        for (; ;) {\r\n\t          t = r;\r\n\t          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n\t          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n\t            // The exponent of r may here be one less than the final result exponent,\r\n\t            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n\t            // are indexed correctly.\r\n\t            if (r.e < e) --s;\r\n\t            n = n.slice(s - 3, s + 1);\r\n\r\n\t            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n\t            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n\t            // iteration.\r\n\t            if (n == '9999' || !rep && n == '4999') {\r\n\r\n\t              // On the first iteration only, check to see if rounding up gives the\r\n\t              // exact result as the nines may infinitely repeat.\r\n\t              if (!rep) {\r\n\t                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n\t                if (t.times(t).eq(x)) {\r\n\t                  r = t;\r\n\t                  break;\r\n\t                }\r\n\t              }\r\n\r\n\t              dp += 4;\r\n\t              s += 4;\r\n\t              rep = 1;\r\n\t            } else {\r\n\r\n\t              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n\t              // result. If not, then there are further digits and m will be truthy.\r\n\t              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n\t                // Truncate to the first rounding digit.\r\n\t                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n\t                m = !r.times(r).eq(x);\r\n\t              }\r\n\r\n\t              break;\r\n\t            }\r\n\t          }\r\n\t        }\r\n\t      }\r\n\r\n\t      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of this BigNumber in exponential notation and\r\n\t     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n\t     *\r\n\t     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n\t     */\r\n\t    P.toExponential = function (dp, rm) {\r\n\t      if (dp != null) {\r\n\t        intCheck(dp, 0, MAX);\r\n\t        dp++;\r\n\t      }\r\n\t      return format(this, dp, rm, 1);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n\t     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n\t     *\r\n\t     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n\t     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n\t     *\r\n\t     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n\t     */\r\n\t    P.toFixed = function (dp, rm) {\r\n\t      if (dp != null) {\r\n\t        intCheck(dp, 0, MAX);\r\n\t        dp = dp + this.e + 1;\r\n\t      }\r\n\t      return format(this, dp, rm);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n\t     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n\t     * of the format or FORMAT object (see BigNumber.set).\r\n\t     *\r\n\t     * The formatting object may contain some or all of the properties shown below.\r\n\t     *\r\n\t     * FORMAT = {\r\n\t     *   prefix: '',\r\n\t     *   groupSize: 3,\r\n\t     *   secondaryGroupSize: 0,\r\n\t     *   groupSeparator: ',',\r\n\t     *   decimalSeparator: '.',\r\n\t     *   fractionGroupSize: 0,\r\n\t     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n\t     *   suffix: ''\r\n\t     * };\r\n\t     *\r\n\t     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     * [format] {object} Formatting options. See FORMAT pbject above.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n\t     * '[BigNumber Error] Argument not an object: {format}'\r\n\t     */\r\n\t    P.toFormat = function (dp, rm, format) {\r\n\t      var str,\r\n\t        x = this;\r\n\r\n\t      if (format == null) {\r\n\t        if (dp != null && rm && typeof rm == 'object') {\r\n\t          format = rm;\r\n\t          rm = null;\r\n\t        } else if (dp && typeof dp == 'object') {\r\n\t          format = dp;\r\n\t          dp = rm = null;\r\n\t        } else {\r\n\t          format = FORMAT;\r\n\t        }\r\n\t      } else if (typeof format != 'object') {\r\n\t        throw Error\r\n\t          (bignumberError + 'Argument not an object: ' + format);\r\n\t      }\r\n\r\n\t      str = x.toFixed(dp, rm);\r\n\r\n\t      if (x.c) {\r\n\t        var i,\r\n\t          arr = str.split('.'),\r\n\t          g1 = +format.groupSize,\r\n\t          g2 = +format.secondaryGroupSize,\r\n\t          groupSeparator = format.groupSeparator || '',\r\n\t          intPart = arr[0],\r\n\t          fractionPart = arr[1],\r\n\t          isNeg = x.s < 0,\r\n\t          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n\t          len = intDigits.length;\r\n\r\n\t        if (g2) {\r\n\t          i = g1;\r\n\t          g1 = g2;\r\n\t          g2 = i;\r\n\t          len -= i;\r\n\t        }\r\n\r\n\t        if (g1 > 0 && len > 0) {\r\n\t          i = len % g1 || g1;\r\n\t          intPart = intDigits.substr(0, i);\r\n\t          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n\t          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n\t          if (isNeg) intPart = '-' + intPart;\r\n\t        }\r\n\r\n\t        str = fractionPart\r\n\t         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n\t          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n\t           '$&' + (format.fractionGroupSeparator || ''))\r\n\t          : fractionPart)\r\n\t         : intPart;\r\n\t      }\r\n\r\n\t      return (format.prefix || '') + str + (format.suffix || '');\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n\t     * fraction with an integer numerator and an integer denominator.\r\n\t     * The denominator will be a positive non-zero value less than or equal to the specified\r\n\t     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n\t     * the lowest value necessary to represent the number exactly.\r\n\t     *\r\n\t     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n\t     */\r\n\t    P.toFraction = function (md) {\r\n\t      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n\t        x = this,\r\n\t        xc = x.c;\r\n\r\n\t      if (md != null) {\r\n\t        n = new BigNumber(md);\r\n\r\n\t        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n\t        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n\t          throw Error\r\n\t            (bignumberError + 'Argument ' +\r\n\t              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n\t        }\r\n\t      }\r\n\r\n\t      if (!xc) return new BigNumber(x);\r\n\r\n\t      d = new BigNumber(ONE);\r\n\t      n1 = d0 = new BigNumber(ONE);\r\n\t      d1 = n0 = new BigNumber(ONE);\r\n\t      s = coeffToString(xc);\r\n\r\n\t      // Determine initial denominator.\r\n\t      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n\t      e = d.e = s.length - x.e - 1;\r\n\t      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n\t      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n\t      exp = MAX_EXP;\r\n\t      MAX_EXP = 1 / 0;\r\n\t      n = new BigNumber(s);\r\n\r\n\t      // n0 = d1 = 0\r\n\t      n0.c[0] = 0;\r\n\r\n\t      for (; ;)  {\r\n\t        q = div(n, d, 0, 1);\r\n\t        d2 = d0.plus(q.times(d1));\r\n\t        if (d2.comparedTo(md) == 1) break;\r\n\t        d0 = d1;\r\n\t        d1 = d2;\r\n\t        n1 = n0.plus(q.times(d2 = n1));\r\n\t        n0 = d2;\r\n\t        d = n.minus(q.times(d2 = d));\r\n\t        n = d2;\r\n\t      }\r\n\r\n\t      d2 = div(md.minus(d0), d1, 0, 1);\r\n\t      n0 = n0.plus(d2.times(n1));\r\n\t      d0 = d0.plus(d2.times(d1));\r\n\t      n0.s = n1.s = x.s;\r\n\t      e = e * 2;\r\n\r\n\t      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n\t      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n\t          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n\t      MAX_EXP = exp;\r\n\r\n\t      return r;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return the value of this BigNumber converted to a number primitive.\r\n\t     */\r\n\t    P.toNumber = function () {\r\n\t      return +valueOf(this);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n\t     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n\t     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n\t     * exponential notation.\r\n\t     *\r\n\t     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n\t     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n\t     */\r\n\t    P.toPrecision = function (sd, rm) {\r\n\t      if (sd != null) intCheck(sd, 1, MAX);\r\n\t      return format(this, sd, rm, 2);\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n\t     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n\t     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n\t     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n\t     * TO_EXP_NEG, return exponential notation.\r\n\t     *\r\n\t     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n\t     *\r\n\t     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n\t     */\r\n\t    P.toString = function (b) {\r\n\t      var str,\r\n\t        n = this,\r\n\t        s = n.s,\r\n\t        e = n.e;\r\n\r\n\t      // Infinity or NaN?\r\n\t      if (e === null) {\r\n\t        if (s) {\r\n\t          str = 'Infinity';\r\n\t          if (s < 0) str = '-' + str;\r\n\t        } else {\r\n\t          str = 'NaN';\r\n\t        }\r\n\t      } else {\r\n\t        if (b == null) {\r\n\t          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n\t           ? toExponential(coeffToString(n.c), e)\r\n\t           : toFixedPoint(coeffToString(n.c), e, '0');\r\n\t        } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n\t          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n\t          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n\t        } else {\r\n\t          intCheck(b, 2, ALPHABET.length, 'Base');\r\n\t          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n\t        }\r\n\r\n\t        if (s < 0 && n.c[0]) str = '-' + str;\r\n\t      }\r\n\r\n\t      return str;\r\n\t    };\r\n\r\n\r\n\t    /*\r\n\t     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n\t     * negative zero.\r\n\t     */\r\n\t    P.valueOf = P.toJSON = function () {\r\n\t      return valueOf(this);\r\n\t    };\r\n\r\n\r\n\t    P._isBigNumber = true;\r\n\r\n\t    if (configObject != null) BigNumber.set(configObject);\r\n\r\n\t    return BigNumber;\r\n\t  }\r\n\r\n\r\n\t  // PRIVATE HELPER FUNCTIONS\r\n\r\n\t  // These functions don't need access to variables,\r\n\t  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\n\t  function bitFloor(n) {\r\n\t    var i = n | 0;\r\n\t    return n > 0 || n === i ? i : i - 1;\r\n\t  }\r\n\r\n\r\n\t  // Return a coefficient array as a string of base 10 digits.\r\n\t  function coeffToString(a) {\r\n\t    var s, z,\r\n\t      i = 1,\r\n\t      j = a.length,\r\n\t      r = a[0] + '';\r\n\r\n\t    for (; i < j;) {\r\n\t      s = a[i++] + '';\r\n\t      z = LOG_BASE - s.length;\r\n\t      for (; z--; s = '0' + s);\r\n\t      r += s;\r\n\t    }\r\n\r\n\t    // Determine trailing zeros.\r\n\t    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n\t    return r.slice(0, j + 1 || 1);\r\n\t  }\r\n\r\n\r\n\t  // Compare the value of BigNumbers x and y.\r\n\t  function compare(x, y) {\r\n\t    var a, b,\r\n\t      xc = x.c,\r\n\t      yc = y.c,\r\n\t      i = x.s,\r\n\t      j = y.s,\r\n\t      k = x.e,\r\n\t      l = y.e;\r\n\r\n\t    // Either NaN?\r\n\t    if (!i || !j) return null;\r\n\r\n\t    a = xc && !xc[0];\r\n\t    b = yc && !yc[0];\r\n\r\n\t    // Either zero?\r\n\t    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n\t    // Signs differ?\r\n\t    if (i != j) return i;\r\n\r\n\t    a = i < 0;\r\n\t    b = k == l;\r\n\r\n\t    // Either Infinity?\r\n\t    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n\t    // Compare exponents.\r\n\t    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n\t    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n\t    // Compare digit by digit.\r\n\t    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n\t    // Compare lengths.\r\n\t    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n\t  }\r\n\r\n\r\n\t  /*\r\n\t   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n\t   */\r\n\t  function intCheck(n, min, max, name) {\r\n\t    if (n < min || n > max || n !== mathfloor(n)) {\r\n\t      throw Error\r\n\t       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n\t         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n\t         : ' not a primitive number: ') + String(n));\r\n\t    }\r\n\t  }\r\n\r\n\r\n\t  // Assumes finite n.\r\n\t  function isOdd(n) {\r\n\t    var k = n.c.length - 1;\r\n\t    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n\t  }\r\n\r\n\r\n\t  function toExponential(str, e) {\r\n\t    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n\t     (e < 0 ? 'e' : 'e+') + e;\r\n\t  }\r\n\r\n\r\n\t  function toFixedPoint(str, e, z) {\r\n\t    var len, zs;\r\n\r\n\t    // Negative exponent?\r\n\t    if (e < 0) {\r\n\r\n\t      // Prepend zeros.\r\n\t      for (zs = z + '.'; ++e; zs += z);\r\n\t      str = zs + str;\r\n\r\n\t    // Positive exponent\r\n\t    } else {\r\n\t      len = str.length;\r\n\r\n\t      // Append zeros.\r\n\t      if (++e > len) {\r\n\t        for (zs = z, e -= len; --e; zs += z);\r\n\t        str += zs;\r\n\t      } else if (e < len) {\r\n\t        str = str.slice(0, e) + '.' + str.slice(e);\r\n\t      }\r\n\t    }\r\n\r\n\t    return str;\r\n\t  }\r\n\r\n\r\n\t  // EXPORT\r\n\r\n\r\n\t  BigNumber = clone();\r\n\t  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n\t  // AMD.\r\n\t  if (module.exports) {\r\n\t    module.exports = BigNumber;\r\n\r\n\t  // Browser.\r\n\t  } else {\r\n\t    if (!globalObject) {\r\n\t      globalObject = typeof self != 'undefined' && self ? self : window;\r\n\t    }\r\n\r\n\t    globalObject.BigNumber = BigNumber;\r\n\t  }\r\n\t})(commonjsGlobal); \n} (bignumber));\n\nvar bignumberExports = bignumber.exports;\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$1 = requireGlobalState();\nconst validating = requireValidating();\nconst parsing$1 = parsing$2;\nconst BigNumber$1 = bignumberExports;\n\nconst powers = {\n    trillion: Math.pow(10, 12),\n    billion: Math.pow(10, 9),\n    million: Math.pow(10, 6),\n    thousand: Math.pow(10, 3)\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    roundingFunction: Math.round,\n    spaceSeparatedAbbreviation: false\n};\n\nconst { binarySuffixes, decimalSuffixes } = globalState$1.currentBytes();\n\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\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$1.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$1.currentCurrencyDefaultFormat());\n            return formatCurrency(instance, providedFormat, globalState$1);\n        }\n        case \"percent\": {\n            providedFormat = formatOrDefault(providedFormat, globalState$1.currentPercentageDefaultFormat());\n            return formatPercentage(instance, providedFormat, globalState$1, numbro);\n        }\n        case \"byte\":\n            providedFormat = formatOrDefault(providedFormat, globalState$1.currentByteDefaultFormat());\n            return formatByte(instance, providedFormat, globalState$1, numbro);\n        case \"time\":\n            providedFormat = formatOrDefault(providedFormat, globalState$1.currentTimeDefaultFormat());\n            return formatTime(instance);\n        case \"ordinal\":\n            providedFormat = formatOrDefault(providedFormat, globalState$1.currentOrdinalDefaultFormat());\n            return formatOrdinal(instance, providedFormat, globalState$1);\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 options = Object.assign({}, defaultOptions, providedFormat);\n\n    const { binarySuffixes: localBinarySuffixes, decimalSuffixes: localDecimalSuffixes } = state.currentBytes();\n\n    const localBytes = {\n        general: { scale: 1024, suffixes: localDecimalSuffixes || decimalSuffixes, marker: \"bd\" },\n        binary: { scale: 1024, suffixes: localBinarySuffixes || binarySuffixes, marker: \"b\" },\n        decimal: { scale: 1000, suffixes: localDecimalSuffixes || decimalSuffixes, marker: \"d\" }\n    };\n    let baseInfo = localBytes[base];\n\n    let { value, suffix } = getFormatByteUnits(instance._value, baseInfo.suffixes, baseInfo.scale);\n\n    let output = formatNumber({\n        instance: numbro(value),\n        providedFormat,\n        state,\n        defaults: state.currentByteDefaultFormat()\n    });\n\n    return `${output}${options.spaceSeparated ? \" \" : \"\"}${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 clonedFormat = Object.assign({}, providedFormat);\n    let options = Object.assign({}, defaultOptions, clonedFormat);\n    let decimalSeparator = undefined;\n    let space = \"\";\n    let average = !!options.totalLength || !!options.forceAverage || options.average;\n    let position = clonedFormat.currencyPosition || currentCurrency.position;\n    let symbol = clonedFormat.currencySymbol || currentCurrency.symbol;\n    const spaceSeparatedCurrency = options.spaceSeparatedCurrency !== void 0\n        ? options.spaceSeparatedCurrency : options.spaceSeparated;\n\n    if (clonedFormat.lowPrecision === undefined) {\n        clonedFormat.lowPrecision = false;\n    }\n\n    if (spaceSeparatedCurrency) {\n        space = \" \";\n    }\n\n    if (position === \"infix\") {\n        decimalSeparator = space + symbol + space;\n    }\n\n    let output = formatNumber({\n        instance,\n        providedFormat: clonedFormat,\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 if (instance._value > 0 && options.forceSign) {\n            output = `+${space}${symbol}${output.slice(1)}`;\n        } else {\n            output = symbol + space + output;\n        }\n    }\n\n    if (!position || position === \"postfix\") {\n        space = !options.spaceSeparatedAbbreviation && 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 {boolean} [lowPrecision=true] - reduce average precision\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 * @param {function} roundingFunction - function used to round numbers\n * @return {{value: number, abbreviation: string, mantissaPrecision: number}}\n */\nfunction computeAverage({ value, forceAverage, lowPrecision = true, abbreviations, spaceSeparated = false, totalLength = 0, roundingFunction = Math.round }) {\n    let abbreviation = \"\";\n    let abs = Math.abs(value);\n    let mantissaPrecision = -1;\n\n    if (forceAverage && abbreviations[forceAverage] && powers[forceAverage]) {\n        abbreviation = abbreviations[forceAverage];\n        value = value / powers[forceAverage];\n    } else {\n        if (abs >= powers.trillion || (lowPrecision && roundingFunction(abs / powers.trillion) === 1)) {\n            // trillion\n            abbreviation = abbreviations.trillion;\n            value = value / powers.trillion;\n        } else if (abs < powers.trillion && abs >= powers.billion || (lowPrecision && roundingFunction(abs / powers.billion) === 1)) {\n            // billion\n            abbreviation = abbreviations.billion;\n            value = value / powers.billion;\n        } else if (abs < powers.billion && abs >= powers.million || (lowPrecision && roundingFunction(abs / powers.million) === 1)) {\n            // million\n            abbreviation = abbreviations.million;\n            value = value / powers.million;\n        } else if (abs < powers.million && abs >= powers.thousand || (lowPrecision && roundingFunction(abs / powers.thousand) === 1)) {\n            // thousand\n            abbreviation = abbreviations.thousand;\n            value = value / powers.thousand;\n        }\n    }\n\n    let optionalSpace = spaceSeparated ? \" \" : \"\";\n\n    if (abbreviation) {\n        abbreviation = optionalSpace + abbreviation;\n    }\n\n    if (totalLength) {\n        let isNegative = value < 0;\n        let characteristic = value.toString().split(\".\")[0];\n\n        let characteristicLength = isNegative\n            ? characteristic.length - 1\n            : characteristic.length;\n\n        mantissaPrecision = Math.max(totalLength - characteristicLength, 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 }) {\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 * @param {function} roundingFunction - rounding function to be used\n * @return {string}\n */\nfunction toFixed(value, precision, roundingFunction = Math.round) {\n    if (value.toString().indexOf(\"e\") !== -1) {\n        return toFixedLarge(value, precision);\n    }\n\n    const n = new BigNumber$1(roundingFunction(+`${value}e+${precision}`) / (Math.pow(10, precision)));\n    return n.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, roundingFunction) {\n    if (precision === -1) {\n        return output;\n    }\n\n    let result = toFixed(value, precision, roundingFunction);\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    const hasNegativeSign = value < 0 && currentCharacteristic.indexOf(\"-\") === 0;\n    if (hasNegativeSign) {\n            // Remove the negative sign\n            currentCharacteristic = currentCharacteristic.slice(1);\n            result = result.slice(1);\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    if (hasNegativeSign) {\n        // Add back the minus sign\n        result = `-${result}`;\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    const hasNegativeSign = value < 0 && characteristic.indexOf(\"-\") === 0;\n\n    if (thousandSeparated) {\n        if (hasNegativeSign) {\n            // Remove the negative 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 (hasNegativeSign) {\n            // Add back the negative 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$1, 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 lowPrecision = options.lowPrecision;\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    let roundingFunction = options.roundingFunction;\n\n    let abbreviation = \"\";\n    if (average) {\n        let data = computeAverage({\n            value,\n            forceAverage,\n            lowPrecision,\n            abbreviations: state.currentAbbreviations(),\n            spaceSeparated,\n            roundingFunction,\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, roundingFunction);\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\nvar formatting = (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/*!\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 = bignumberExports;\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\nvar manipulating = 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    BigNumber: BigNumber\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 VERSION = \"2.5.0\";\n\nconst globalState = requireGlobalState();\nconst validator = requireValidating();\nconst loader = loading(numbro);\nconst unformatter = requireUnformatting();\nlet formatter = formatting(numbro);\nlet manipulate = manipulating(numbro);\nconst parsing = parsing$2;\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;\nnumbro.BigNumber = manipulate.BigNumber;\n\nvar numbro_1 = numbro;\n\nvar numbro$1 = /*@__PURE__*/getDefaultExportFromCjs(numbro_1);\n\nexport { numbro$1 as default };\n"]}