{"version":3,"file":"vendors-91c40cd8.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/numbro/dist/es/numbro.js","webpack://iadviser/./node_modules/oblivious-set/dist/es/index.js","webpack://iadviser/./node_modules/path-browserify/index.js","webpack://iadviser/./node_modules/process/browser.js"],"sourcesContent":["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","/**\n * this is a set which automatically forgets\n * a given entry when a new entry is set and the ttl\n * of the old one is over\n */\nvar ObliviousSet = /** @class */ (function () {\n    function ObliviousSet(ttl) {\n        this.ttl = ttl;\n        this.set = new Set();\n        this.timeMap = new Map();\n    }\n    ObliviousSet.prototype.has = function (value) {\n        return this.set.has(value);\n    };\n    ObliviousSet.prototype.add = function (value) {\n        var _this = this;\n        this.timeMap.set(value, now());\n        this.set.add(value);\n        /**\n         * When a new value is added,\n         * start the cleanup at the next tick\n         * to not block the cpu for more important stuff\n         * that might happen.\n         */\n        setTimeout(function () {\n            removeTooOldValues(_this);\n        }, 0);\n    };\n    ObliviousSet.prototype.clear = function () {\n        this.set.clear();\n        this.timeMap.clear();\n    };\n    return ObliviousSet;\n}());\nexport { ObliviousSet };\n/**\n * Removes all entries from the set\n * where the TTL has expired\n */\nexport function removeTooOldValues(obliviousSet) {\n    var olderThen = now() - obliviousSet.ttl;\n    var iterator = obliviousSet.set[Symbol.iterator]();\n    /**\n     * Because we can assume the new values are added at the bottom,\n     * we start from the top and stop as soon as we reach a non-too-old value.\n     */\n    while (true) {\n        var value = iterator.next().value;\n        if (!value) {\n            return; // no more elements\n        }\n        var time = obliviousSet.timeMap.get(value);\n        if (time < olderThen) {\n            obliviousSet.timeMap.delete(value);\n            obliviousSet.set.delete(value);\n        }\n        else {\n            // We reached a value that is not old enough\n            return;\n        }\n    }\n}\nexport function now() {\n    return new Date().getTime();\n}\n//# sourceMappingURL=index.js.map","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n"],"names":["enUS","hasRequiredEnUS","unformatting","hasRequiredUnformatting","validating$1","hasRequiredValidating","commonjsGlobal","globalThis","window","__webpack_require__","g","self","getDefaultExportFromCjs","x","__esModule","Object","prototype","hasOwnProperty","call","requireEnUS","languageTag","delimiters","thousands","decimal","abbreviations","thousand","million","billion","trillion","spaceSeparated","ordinal","number","b","bytes","binarySuffixes","decimalSuffixes","currency","symbol","position","code","currencyFormat","thousandSeparated","totalLength","spaceSeparatedCurrency","formats","fourDigits","fullWithTwoDecimals","output","mantissa","fullWithTwoDecimalsNoCurrency","fullWithNoDecimals","requireUnformatting","allSuffixes","key","factor","Math","pow","escapeRegExp","s","replace","computeUnformattedValue","inputString","currencySymbol","zeroFormat","format","isNaN","stripped","newInput","i","length","suffix","RegExp","possibleOrdinalValue","parseFloat","ordinalString","inversedAbbreviations","keys","forEach","abbreviationValues","sort","reverse","numberOfAbbreviations","value","unformatValue","removeFormattingSymbols","unformat","globalState","requireGlobalState","currentDelimiters","currentCurrency","currentOrdinal","getZeroFormat","currentAbbreviations","indexOf","segments","split","hours","minutes","seconds","matchesTime","unformatTime","undefined","requireValidating","unformatter","bcp47RegExp","validFormat","type","validValues","base","restriction","message","mandatory","characteristic","prefix","postfix","forceAverage","average","lowPrecision","currencyPosition","restrictions","exponential","optionalMantissa","trimMantissa","roundingFunction","optionalCharacteristic","spaceSeparatedAbbreviation","children","negative","forceSign","prefixSymbol","validLanguage","tag","match","thousandsSize","defaults","ordinalFormat","byteFormat","percentageFormat","timeDefaults","validateInput","input","validateSpec","toValidate","spec","skipMandatoryCheck","results","map","console","error","data","JSON","stringify","push","reduce","acc","current","validateFormat","validate","validInput","isFormatValid","validateLanguage","language","globalState$2","hasRequiredGlobalState","parsing$2","parseFormat","string","result","parseOutput","slice","parsePostfix","parsePrefix","parseTotalLength","parseCharacteristic","parseOptionalCharacteristic","parseAverage","parseForceAverage","parseMantissa","parseOptionalMantissa","parseTrimMantissa","parseThousandSeparated","parseSpaceSeparated","parseNegative","parseForceSign","validating","parsing","currentLanguageTag","state","languages","globalDefaults","chooseLanguage","currentLanguageData","assign","currentLanguage","currentBytes","currentDefaults","currentOrdinalDefaultFormat","currentByteDefaultFormat","currentPercentageDefaultFormat","currentCurrencyDefaultFormat","currentTimeDefaultFormat","timeFormat","setDefaults","setZeroFormat","hasZeroFormat","languageData","Error","registerLanguage","useLanguage","setLanguage","fallbackTag","matchingLanguageTag","find","each","module","bignumber","exports","globalObject","BigNumber","isNumeric","mathceil","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","coeffToString","a","z","j","r","charCodeAt","compare","y","xc","c","yc","k","e","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","constructor","toString","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","ALPHABET","alphabetHasNormalDecimalDigits","v","alphabet","caseChanged","isNum","this","_isBigNumber","test","search","substring","round","DEBUG","toUpperCase","toLowerCase","rm","id","c0","ne","maxOrMin","args","normalise","pop","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","obj","p","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","arguments","minimum","random","dp","rand","Uint32Array","copy","splice","sum","plus","toBaseOut","baseIn","baseOut","arrL","arr","sign","callerIsToString","concat","multiply","m","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","gt","isGreaterThanOrEqualTo","gte","isLessThan","lt","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","bignumberExports","globalState$1","parsing$1","BigNumber$1","powers","defaultOptions","general","scale","suffixes","marker","binary","getFormatByteUnits","power","zeroes","formatNumber","instance","providedFormat","_value","options","characteristicPrecision","mantissaPrecision","abbreviation","characteristicLength","computeAverage","numberString","computeExponential","trim","toFixedLarge","currentCharacteristic","currentMantissa","hasTrailingZeroes","index","setMantissaPrecision","hasNegativeSign","missingZeros","setCharacteristicPrecision","thousandSeparator","indexesToInsertThousandDelimiters","counter","unshift","indexesOfGroupSpaces","replaceDelimiters","insertAbbreviation","insertSign","formatOrDefault","defaultFormat","other","numbro","otherValue","isNumbro","validator","loader","loadLanguagesInNode","tags","path","commonjsRequire","loading","formatter","clonedFormat","space","formatCurrency","formatPercentage","localBinarySuffixes","localDecimalSuffixes","baseInfo","formatByte","formatTime","ordinalFn","formatOrdinal","formatNumbro","insertPrefix","insertPostfix","getByteUnit","getBinaryByteUnit","getDecimalByteUnit","formatting","manipulate","add","divide","difference","manipulating","Numbro","binaryByteUnits","decimalByteUnits","byteUnits","normalizeInput","version","object","defaultCurrencyFormat","numbro$1","ObliviousSet","ttl","Set","timeMap","Map","has","_this","now","setTimeout","obliviousSet","olderThen","iterator","Symbol","next","get","delete","removeTooOldValues","clear","Date","getTime","assertPath","TypeError","normalizeStringPosix","allowAboveRoot","res","lastSegmentLength","lastSlash","dots","lastSlashIndex","lastIndexOf","posix","resolve","cwd","resolvedPath","resolvedAbsolute","process","normalize","isAbsolute","trailingSeparator","join","joined","arg","relative","from","to","fromStart","fromEnd","fromLen","toStart","toLen","lastCommonSep","fromCode","_makeLong","dirname","hasRoot","end","matchedSlash","basename","ext","start","extIdx","firstNonSlashEnd","extname","startDot","startPart","preDotState","pathObject","sep","dir","root","_format","parse","ret","delimiter","win32","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","runClearTimeout","Item","array","noop","nextTick","Array","apply","title","browser","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","umask"],"sourceRoot":""}