{"version":3,"file":"numeral-B_JHaXSC.js","sources":["../../../node_modules/numeral/numeral.js"],"sourcesContent":["/*! @preserve\n * numeral.js\n * version : 2.0.6\n * author : Adam Draper\n * license : MIT\n * http://adamwdraper.github.com/Numeral-js/\n */\n\n(function (global, factory) {\n    if (typeof define === 'function' && define.amd) {\n        define(factory);\n    } else if (typeof module === 'object' && module.exports) {\n        module.exports = factory();\n    } else {\n        global.numeral = factory();\n    }\n}(this, function () {\n    /************************************\n        Variables\n    ************************************/\n\n    var numeral,\n        _,\n        VERSION = '2.0.6',\n        formats = {},\n        locales = {},\n        defaults = {\n            currentLocale: 'en',\n            zeroFormat: null,\n            nullFormat: null,\n            defaultFormat: '0,0',\n            scalePercentBy100: true\n        },\n        options = {\n            currentLocale: defaults.currentLocale,\n            zeroFormat: defaults.zeroFormat,\n            nullFormat: defaults.nullFormat,\n            defaultFormat: defaults.defaultFormat,\n            scalePercentBy100: defaults.scalePercentBy100\n        };\n\n\n    /************************************\n        Constructors\n    ************************************/\n\n    // Numeral prototype object\n    function Numeral(input, number) {\n        this._input = input;\n\n        this._value = number;\n    }\n\n    numeral = function(input) {\n        var value,\n            kind,\n            unformatFunction,\n            regexp;\n\n        if (numeral.isNumeral(input)) {\n            value = input.value();\n        } else if (input === 0 || typeof input === 'undefined') {\n            value = 0;\n        } else if (input === null || _.isNaN(input)) {\n            value = null;\n        } else if (typeof input === 'string') {\n            if (options.zeroFormat && input === options.zeroFormat) {\n                value = 0;\n            } else if (options.nullFormat && input === options.nullFormat || !input.replace(/[^0-9]+/g, '').length) {\n                value = null;\n            } else {\n                for (kind in formats) {\n                    regexp = typeof formats[kind].regexps.unformat === 'function' ? formats[kind].regexps.unformat() : formats[kind].regexps.unformat;\n\n                    if (regexp && input.match(regexp)) {\n                        unformatFunction = formats[kind].unformat;\n\n                        break;\n                    }\n                }\n\n                unformatFunction = unformatFunction || numeral._.stringToNumber;\n\n                value = unformatFunction(input);\n            }\n        } else {\n            value = Number(input)|| null;\n        }\n\n        return new Numeral(input, value);\n    };\n\n    // version number\n    numeral.version = VERSION;\n\n    // compare numeral object\n    numeral.isNumeral = function(obj) {\n        return obj instanceof Numeral;\n    };\n\n    // helper functions\n    numeral._ = _ = {\n        // formats numbers separators, decimals places, signs, abbreviations\n        numberToFormat: function(value, format, roundingFunction) {\n            var locale = locales[numeral.options.currentLocale],\n                negP = false,\n                optDec = false,\n                leadingCount = 0,\n                abbr = '',\n                trillion = 1000000000000,\n                billion = 1000000000,\n                million = 1000000,\n                thousand = 1000,\n                decimal = '',\n                neg = false,\n                abbrForce, // force abbreviation\n                abs,\n                min,\n                max,\n                power,\n                int,\n                precision,\n                signed,\n                thousands,\n                output;\n\n            // make sure we never format a null value\n            value = value || 0;\n\n            abs = Math.abs(value);\n\n            // see if we should use parentheses for negative number or if we should prefix with a sign\n            // if both are present we default to parentheses\n            if (numeral._.includes(format, '(')) {\n                negP = true;\n                format = format.replace(/[\\(|\\)]/g, '');\n            } else if (numeral._.includes(format, '+') || numeral._.includes(format, '-')) {\n                signed = numeral._.includes(format, '+') ? format.indexOf('+') : value < 0 ? format.indexOf('-') : -1;\n                format = format.replace(/[\\+|\\-]/g, '');\n            }\n\n            // see if abbreviation is wanted\n            if (numeral._.includes(format, 'a')) {\n                abbrForce = format.match(/a(k|m|b|t)?/);\n\n                abbrForce = abbrForce ? abbrForce[1] : false;\n\n                // check for space before abbreviation\n                if (numeral._.includes(format, ' a')) {\n                    abbr = ' ';\n                }\n\n                format = format.replace(new RegExp(abbr + 'a[kmbt]?'), '');\n\n                if (abs >= trillion && !abbrForce || abbrForce === 't') {\n                    // trillion\n                    abbr += locale.abbreviations.trillion;\n                    value = value / trillion;\n                } else if (abs < trillion && abs >= billion && !abbrForce || abbrForce === 'b') {\n                    // billion\n                    abbr += locale.abbreviations.billion;\n                    value = value / billion;\n                } else if (abs < billion && abs >= million && !abbrForce || abbrForce === 'm') {\n                    // million\n                    abbr += locale.abbreviations.million;\n                    value = value / million;\n                } else if (abs < million && abs >= thousand && !abbrForce || abbrForce === 'k') {\n                    // thousand\n                    abbr += locale.abbreviations.thousand;\n                    value = value / thousand;\n                }\n            }\n\n            // check for optional decimals\n            if (numeral._.includes(format, '[.]')) {\n                optDec = true;\n                format = format.replace('[.]', '.');\n            }\n\n            // break number and format\n            int = value.toString().split('.')[0];\n            precision = format.split('.')[1];\n            thousands = format.indexOf(',');\n            leadingCount = (format.split('.')[0].split(',')[0].match(/0/g) || []).length;\n\n            if (precision) {\n                if (numeral._.includes(precision, '[')) {\n                    precision = precision.replace(']', '');\n                    precision = precision.split('[');\n                    decimal = numeral._.toFixed(value, (precision[0].length + precision[1].length), roundingFunction, precision[1].length);\n                } else {\n                    decimal = numeral._.toFixed(value, precision.length, roundingFunction);\n                }\n\n                int = decimal.split('.')[0];\n\n                if (numeral._.includes(decimal, '.')) {\n                    decimal = locale.delimiters.decimal + decimal.split('.')[1];\n                } else {\n                    decimal = '';\n                }\n\n                if (optDec && Number(decimal.slice(1)) === 0) {\n                    decimal = '';\n                }\n            } else {\n                int = numeral._.toFixed(value, 0, roundingFunction);\n            }\n\n            // check abbreviation again after rounding\n            if (abbr && !abbrForce && Number(int) >= 1000 && abbr !== locale.abbreviations.trillion) {\n                int = String(Number(int) / 1000);\n\n                switch (abbr) {\n                    case locale.abbreviations.thousand:\n                        abbr = locale.abbreviations.million;\n                        break;\n                    case locale.abbreviations.million:\n                        abbr = locale.abbreviations.billion;\n                        break;\n                    case locale.abbreviations.billion:\n                        abbr = locale.abbreviations.trillion;\n                        break;\n                }\n            }\n\n\n            // format number\n            if (numeral._.includes(int, '-')) {\n                int = int.slice(1);\n                neg = true;\n            }\n\n            if (int.length < leadingCount) {\n                for (var i = leadingCount - int.length; i > 0; i--) {\n                    int = '0' + int;\n                }\n            }\n\n            if (thousands > -1) {\n                int = int.toString().replace(/(\\d)(?=(\\d{3})+(?!\\d))/g, '$1' + locale.delimiters.thousands);\n            }\n\n            if (format.indexOf('.') === 0) {\n                int = '';\n            }\n\n            output = int + decimal + (abbr ? abbr : '');\n\n            if (negP) {\n                output = (negP && neg ? '(' : '') + output + (negP && neg ? ')' : '');\n            } else {\n                if (signed >= 0) {\n                    output = signed === 0 ? (neg ? '-' : '+') + output : output + (neg ? '-' : '+');\n                } else if (neg) {\n                    output = '-' + output;\n                }\n            }\n\n            return output;\n        },\n        // unformats numbers separators, decimals places, signs, abbreviations\n        stringToNumber: function(string) {\n            var locale = locales[options.currentLocale],\n                stringOriginal = string,\n                abbreviations = {\n                    thousand: 3,\n                    million: 6,\n                    billion: 9,\n                    trillion: 12\n                },\n                abbreviation,\n                value,\n                i,\n                regexp;\n\n            if (options.zeroFormat && string === options.zeroFormat) {\n                value = 0;\n            } else if (options.nullFormat && string === options.nullFormat || !string.replace(/[^0-9]+/g, '').length) {\n                value = null;\n            } else {\n                value = 1;\n\n                if (locale.delimiters.decimal !== '.') {\n                    string = string.replace(/\\./g, '').replace(locale.delimiters.decimal, '.');\n                }\n\n                for (abbreviation in abbreviations) {\n                    regexp = new RegExp('[^a-zA-Z]' + locale.abbreviations[abbreviation] + '(?:\\\\)|(\\\\' + locale.currency.symbol + ')?(?:\\\\))?)?$');\n\n                    if (stringOriginal.match(regexp)) {\n                        value *= Math.pow(10, abbreviations[abbreviation]);\n                        break;\n                    }\n                }\n\n                // check for negative number\n                value *= (string.split('-').length + Math.min(string.split('(').length - 1, string.split(')').length - 1)) % 2 ? 1 : -1;\n\n                // remove non numbers\n                string = string.replace(/[^0-9\\.]+/g, '');\n\n                value *= Number(string);\n            }\n\n            return value;\n        },\n        isNaN: function(value) {\n            return typeof value === 'number' && isNaN(value);\n        },\n        includes: function(string, search) {\n            return string.indexOf(search) !== -1;\n        },\n        insert: function(string, subString, start) {\n            return string.slice(0, start) + subString + string.slice(start);\n        },\n        reduce: function(array, callback /*, initialValue*/) {\n            if (this === null) {\n                throw new TypeError('Array.prototype.reduce called on null or undefined');\n            }\n\n            if (typeof callback !== 'function') {\n                throw new TypeError(callback + ' is not a function');\n            }\n\n            var t = Object(array),\n                len = t.length >>> 0,\n                k = 0,\n                value;\n\n            if (arguments.length === 3) {\n                value = arguments[2];\n            } else {\n                while (k < len && !(k in t)) {\n                    k++;\n                }\n\n                if (k >= len) {\n                    throw new TypeError('Reduce of empty array with no initial value');\n                }\n\n                value = t[k++];\n            }\n            for (; k < len; k++) {\n                if (k in t) {\n                    value = callback(value, t[k], k, t);\n                }\n            }\n            return value;\n        },\n        /**\n         * Computes the multiplier necessary to make x >= 1,\n         * effectively eliminating miscalculations caused by\n         * finite precision.\n         */\n        multiplier: function (x) {\n            var parts = x.toString().split('.');\n\n            return parts.length < 2 ? 1 : Math.pow(10, parts[1].length);\n        },\n        /**\n         * Given a variable number of arguments, returns the maximum\n         * multiplier that must be used to normalize an operation involving\n         * all of them.\n         */\n        correctionFactor: function () {\n            var args = Array.prototype.slice.call(arguments);\n\n            return args.reduce(function(accum, next) {\n                var mn = _.multiplier(next);\n                return accum > mn ? accum : mn;\n            }, 1);\n        },\n        /**\n         * Implementation of toFixed() that treats floats more like decimals\n         *\n         * Fixes binary rounding issues (eg. (0.615).toFixed(2) === '0.61') that present\n         * problems for accounting- and finance-related software.\n         */\n        toFixed: function(value, maxDecimals, roundingFunction, optionals) {\n            var splitValue = value.toString().split('.'),\n                minDecimals = maxDecimals - (optionals || 0),\n                boundedPrecision,\n                optionalsRegExp,\n                power,\n                output;\n\n            // Use the smallest precision value possible to avoid errors from floating point representation\n            if (splitValue.length === 2) {\n              boundedPrecision = Math.min(Math.max(splitValue[1].length, minDecimals), maxDecimals);\n            } else {\n              boundedPrecision = minDecimals;\n            }\n\n            power = Math.pow(10, boundedPrecision);\n\n            // Multiply up by precision, round accurately, then divide and use native toFixed():\n            output = (roundingFunction(value + 'e+' + boundedPrecision) / power).toFixed(boundedPrecision);\n\n            if (optionals > maxDecimals - boundedPrecision) {\n                optionalsRegExp = new RegExp('\\\\.?0{1,' + (optionals - (maxDecimals - boundedPrecision)) + '}$');\n                output = output.replace(optionalsRegExp, '');\n            }\n\n            return output;\n        }\n    };\n\n    // avaliable options\n    numeral.options = options;\n\n    // avaliable formats\n    numeral.formats = formats;\n\n    // avaliable formats\n    numeral.locales = locales;\n\n    // This function sets the current locale.  If\n    // no arguments are passed in, it will simply return the current global\n    // locale key.\n    numeral.locale = function(key) {\n        if (key) {\n            options.currentLocale = key.toLowerCase();\n        }\n\n        return options.currentLocale;\n    };\n\n    // This function provides access to the loaded locale data.  If\n    // no arguments are passed in, it will simply return the current\n    // global locale object.\n    numeral.localeData = function(key) {\n        if (!key) {\n            return locales[options.currentLocale];\n        }\n\n        key = key.toLowerCase();\n\n        if (!locales[key]) {\n            throw new Error('Unknown locale : ' + key);\n        }\n\n        return locales[key];\n    };\n\n    numeral.reset = function() {\n        for (var property in defaults) {\n            options[property] = defaults[property];\n        }\n    };\n\n    numeral.zeroFormat = function(format) {\n        options.zeroFormat = typeof(format) === 'string' ? format : null;\n    };\n\n    numeral.nullFormat = function (format) {\n        options.nullFormat = typeof(format) === 'string' ? format : null;\n    };\n\n    numeral.defaultFormat = function(format) {\n        options.defaultFormat = typeof(format) === 'string' ? format : '0.0';\n    };\n\n    numeral.register = function(type, name, format) {\n        name = name.toLowerCase();\n\n        if (this[type + 's'][name]) {\n            throw new TypeError(name + ' ' + type + ' already registered.');\n        }\n\n        this[type + 's'][name] = format;\n\n        return format;\n    };\n\n\n    numeral.validate = function(val, culture) {\n        var _decimalSep,\n            _thousandSep,\n            _currSymbol,\n            _valArray,\n            _abbrObj,\n            _thousandRegEx,\n            localeData,\n            temp;\n\n        //coerce val to string\n        if (typeof val !== 'string') {\n            val += '';\n\n            if (console.warn) {\n                console.warn('Numeral.js: Value is not string. It has been co-erced to: ', val);\n            }\n        }\n\n        //trim whitespaces from either sides\n        val = val.trim();\n\n        //if val is just digits return true\n        if (!!val.match(/^\\d+$/)) {\n            return true;\n        }\n\n        //if val is empty return false\n        if (val === '') {\n            return false;\n        }\n\n        //get the decimal and thousands separator from numeral.localeData\n        try {\n            //check if the culture is understood by numeral. if not, default it to current locale\n            localeData = numeral.localeData(culture);\n        } catch (e) {\n            localeData = numeral.localeData(numeral.locale());\n        }\n\n        //setup the delimiters and currency symbol based on culture/locale\n        _currSymbol = localeData.currency.symbol;\n        _abbrObj = localeData.abbreviations;\n        _decimalSep = localeData.delimiters.decimal;\n        if (localeData.delimiters.thousands === '.') {\n            _thousandSep = '\\\\.';\n        } else {\n            _thousandSep = localeData.delimiters.thousands;\n        }\n\n        // validating currency symbol\n        temp = val.match(/^[^\\d]+/);\n        if (temp !== null) {\n            val = val.substr(1);\n            if (temp[0] !== _currSymbol) {\n                return false;\n            }\n        }\n\n        //validating abbreviation symbol\n        temp = val.match(/[^\\d]+$/);\n        if (temp !== null) {\n            val = val.slice(0, -1);\n            if (temp[0] !== _abbrObj.thousand && temp[0] !== _abbrObj.million && temp[0] !== _abbrObj.billion && temp[0] !== _abbrObj.trillion) {\n                return false;\n            }\n        }\n\n        _thousandRegEx = new RegExp(_thousandSep + '{2}');\n\n        if (!val.match(/[^\\d.,]/g)) {\n            _valArray = val.split(_decimalSep);\n            if (_valArray.length > 2) {\n                return false;\n            } else {\n                if (_valArray.length < 2) {\n                    return ( !! _valArray[0].match(/^\\d+.*\\d$/) && !_valArray[0].match(_thousandRegEx));\n                } else {\n                    if (_valArray[0].length === 1) {\n                        return ( !! _valArray[0].match(/^\\d+$/) && !_valArray[0].match(_thousandRegEx) && !! _valArray[1].match(/^\\d+$/));\n                    } else {\n                        return ( !! _valArray[0].match(/^\\d+.*\\d$/) && !_valArray[0].match(_thousandRegEx) && !! _valArray[1].match(/^\\d+$/));\n                    }\n                }\n            }\n        }\n\n        return false;\n    };\n\n\n    /************************************\n        Numeral Prototype\n    ************************************/\n\n    numeral.fn = Numeral.prototype = {\n        clone: function() {\n            return numeral(this);\n        },\n        format: function(inputString, roundingFunction) {\n            var value = this._value,\n                format = inputString || options.defaultFormat,\n                kind,\n                output,\n                formatFunction;\n\n            // make sure we have a roundingFunction\n            roundingFunction = roundingFunction || Math.round;\n\n            // format based on value\n            if (value === 0 && options.zeroFormat !== null) {\n                output = options.zeroFormat;\n            } else if (value === null && options.nullFormat !== null) {\n                output = options.nullFormat;\n            } else {\n                for (kind in formats) {\n                    if (format.match(formats[kind].regexps.format)) {\n                        formatFunction = formats[kind].format;\n\n                        break;\n                    }\n                }\n\n                formatFunction = formatFunction || numeral._.numberToFormat;\n\n                output = formatFunction(value, format, roundingFunction);\n            }\n\n            return output;\n        },\n        value: function() {\n            return this._value;\n        },\n        input: function() {\n            return this._input;\n        },\n        set: function(value) {\n            this._value = Number(value);\n\n            return this;\n        },\n        add: function(value) {\n            var corrFactor = _.correctionFactor.call(null, this._value, value);\n\n            function cback(accum, curr, currI, O) {\n                return accum + Math.round(corrFactor * curr);\n            }\n\n            this._value = _.reduce([this._value, value], cback, 0) / corrFactor;\n\n            return this;\n        },\n        subtract: function(value) {\n            var corrFactor = _.correctionFactor.call(null, this._value, value);\n\n            function cback(accum, curr, currI, O) {\n                return accum - Math.round(corrFactor * curr);\n            }\n\n            this._value = _.reduce([value], cback, Math.round(this._value * corrFactor)) / corrFactor;\n\n            return this;\n        },\n        multiply: function(value) {\n            function cback(accum, curr, currI, O) {\n                var corrFactor = _.correctionFactor(accum, curr);\n                return Math.round(accum * corrFactor) * Math.round(curr * corrFactor) / Math.round(corrFactor * corrFactor);\n            }\n\n            this._value = _.reduce([this._value, value], cback, 1);\n\n            return this;\n        },\n        divide: function(value) {\n            function cback(accum, curr, currI, O) {\n                var corrFactor = _.correctionFactor(accum, curr);\n                return Math.round(accum * corrFactor) / Math.round(curr * corrFactor);\n            }\n\n            this._value = _.reduce([this._value, value], cback);\n\n            return this;\n        },\n        difference: function(value) {\n            return Math.abs(numeral(this._value).subtract(value).value());\n        }\n    };\n\n    /************************************\n        Default Locale && Format\n    ************************************/\n\n    numeral.register('locale', 'en', {\n        delimiters: {\n            thousands: ',',\n            decimal: '.'\n        },\n        abbreviations: {\n            thousand: 'k',\n            million: 'm',\n            billion: 'b',\n            trillion: 't'\n        },\n        ordinal: function(number) {\n            var b = number % 10;\n            return (~~(number % 100 / 10) === 1) ? 'th' :\n                (b === 1) ? 'st' :\n                (b === 2) ? 'nd' :\n                (b === 3) ? 'rd' : 'th';\n        },\n        currency: {\n            symbol: '$'\n        }\n    });\n\n    \n\n(function() {\n        numeral.register('format', 'bps', {\n            regexps: {\n                format: /(BPS)/,\n                unformat: /(BPS)/\n            },\n            format: function(value, format, roundingFunction) {\n                var space = numeral._.includes(format, ' BPS') ? ' ' : '',\n                    output;\n\n                value = value * 10000;\n\n                // check for space before BPS\n                format = format.replace(/\\s?BPS/, '');\n\n                output = numeral._.numberToFormat(value, format, roundingFunction);\n\n                if (numeral._.includes(output, ')')) {\n                    output = output.split('');\n\n                    output.splice(-1, 0, space + 'BPS');\n\n                    output = output.join('');\n                } else {\n                    output = output + space + 'BPS';\n                }\n\n                return output;\n            },\n            unformat: function(string) {\n                return +(numeral._.stringToNumber(string) * 0.0001).toFixed(15);\n            }\n        });\n})();\n\n\n(function() {\n        var decimal = {\n            base: 1000,\n            suffixes: ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']\n        },\n        binary = {\n            base: 1024,\n            suffixes: ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']\n        };\n\n    var allSuffixes =  decimal.suffixes.concat(binary.suffixes.filter(function (item) {\n            return decimal.suffixes.indexOf(item) < 0;\n        }));\n        var unformatRegex = allSuffixes.join('|');\n        // Allow support for BPS (http://www.investopedia.com/terms/b/basispoint.asp)\n        unformatRegex = '(' + unformatRegex.replace('B', 'B(?!PS)') + ')';\n\n    numeral.register('format', 'bytes', {\n        regexps: {\n            format: /([0\\s]i?b)/,\n            unformat: new RegExp(unformatRegex)\n        },\n        format: function(value, format, roundingFunction) {\n            var output,\n                bytes = numeral._.includes(format, 'ib') ? binary : decimal,\n                suffix = numeral._.includes(format, ' b') || numeral._.includes(format, ' ib') ? ' ' : '',\n                power,\n                min,\n                max;\n\n            // check for space before\n            format = format.replace(/\\s?i?b/, '');\n\n            for (power = 0; power <= bytes.suffixes.length; power++) {\n                min = Math.pow(bytes.base, power);\n                max = Math.pow(bytes.base, power + 1);\n\n                if (value === null || value === 0 || value >= min && value < max) {\n                    suffix += bytes.suffixes[power];\n\n                    if (min > 0) {\n                        value = value / min;\n                    }\n\n                    break;\n                }\n            }\n\n            output = numeral._.numberToFormat(value, format, roundingFunction);\n\n            return output + suffix;\n        },\n        unformat: function(string) {\n            var value = numeral._.stringToNumber(string),\n                power,\n                bytesMultiplier;\n\n            if (value) {\n                for (power = decimal.suffixes.length - 1; power >= 0; power--) {\n                    if (numeral._.includes(string, decimal.suffixes[power])) {\n                        bytesMultiplier = Math.pow(decimal.base, power);\n\n                        break;\n                    }\n\n                    if (numeral._.includes(string, binary.suffixes[power])) {\n                        bytesMultiplier = Math.pow(binary.base, power);\n\n                        break;\n                    }\n                }\n\n                value *= (bytesMultiplier || 1);\n            }\n\n            return value;\n        }\n    });\n})();\n\n\n(function() {\n        numeral.register('format', 'currency', {\n        regexps: {\n            format: /(\\$)/\n        },\n        format: function(value, format, roundingFunction) {\n            var locale = numeral.locales[numeral.options.currentLocale],\n                symbols = {\n                    before: format.match(/^([\\+|\\-|\\(|\\s|\\$]*)/)[0],\n                    after: format.match(/([\\+|\\-|\\)|\\s|\\$]*)$/)[0]\n                },\n                output,\n                symbol,\n                i;\n\n            // strip format of spaces and $\n            format = format.replace(/\\s?\\$\\s?/, '');\n\n            // format the number\n            output = numeral._.numberToFormat(value, format, roundingFunction);\n\n            // update the before and after based on value\n            if (value >= 0) {\n                symbols.before = symbols.before.replace(/[\\-\\(]/, '');\n                symbols.after = symbols.after.replace(/[\\-\\)]/, '');\n            } else if (value < 0 && (!numeral._.includes(symbols.before, '-') && !numeral._.includes(symbols.before, '('))) {\n                symbols.before = '-' + symbols.before;\n            }\n\n            // loop through each before symbol\n            for (i = 0; i < symbols.before.length; i++) {\n                symbol = symbols.before[i];\n\n                switch (symbol) {\n                    case '$':\n                        output = numeral._.insert(output, locale.currency.symbol, i);\n                        break;\n                    case ' ':\n                        output = numeral._.insert(output, ' ', i + locale.currency.symbol.length - 1);\n                        break;\n                }\n            }\n\n            // loop through each after symbol\n            for (i = symbols.after.length - 1; i >= 0; i--) {\n                symbol = symbols.after[i];\n\n                switch (symbol) {\n                    case '$':\n                        output = i === symbols.after.length - 1 ? output + locale.currency.symbol : numeral._.insert(output, locale.currency.symbol, -(symbols.after.length - (1 + i)));\n                        break;\n                    case ' ':\n                        output = i === symbols.after.length - 1 ? output + ' ' : numeral._.insert(output, ' ', -(symbols.after.length - (1 + i) + locale.currency.symbol.length - 1));\n                        break;\n                }\n            }\n\n\n            return output;\n        }\n    });\n})();\n\n\n(function() {\n        numeral.register('format', 'exponential', {\n        regexps: {\n            format: /(e\\+|e-)/,\n            unformat: /(e\\+|e-)/\n        },\n        format: function(value, format, roundingFunction) {\n            var output,\n                exponential = typeof value === 'number' && !numeral._.isNaN(value) ? value.toExponential() : '0e+0',\n                parts = exponential.split('e');\n\n            format = format.replace(/e[\\+|\\-]{1}0/, '');\n\n            output = numeral._.numberToFormat(Number(parts[0]), format, roundingFunction);\n\n            return output + 'e' + parts[1];\n        },\n        unformat: function(string) {\n            var parts = numeral._.includes(string, 'e+') ? string.split('e+') : string.split('e-'),\n                value = Number(parts[0]),\n                power = Number(parts[1]);\n\n            power = numeral._.includes(string, 'e-') ? power *= -1 : power;\n\n            function cback(accum, curr, currI, O) {\n                var corrFactor = numeral._.correctionFactor(accum, curr),\n                    num = (accum * corrFactor) * (curr * corrFactor) / (corrFactor * corrFactor);\n                return num;\n            }\n\n            return numeral._.reduce([value, Math.pow(10, power)], cback, 1);\n        }\n    });\n})();\n\n\n(function() {\n        numeral.register('format', 'ordinal', {\n        regexps: {\n            format: /(o)/\n        },\n        format: function(value, format, roundingFunction) {\n            var locale = numeral.locales[numeral.options.currentLocale],\n                output,\n                ordinal = numeral._.includes(format, ' o') ? ' ' : '';\n\n            // check for space before\n            format = format.replace(/\\s?o/, '');\n\n            ordinal += locale.ordinal(value);\n\n            output = numeral._.numberToFormat(value, format, roundingFunction);\n\n            return output + ordinal;\n        }\n    });\n})();\n\n\n(function() {\n        numeral.register('format', 'percentage', {\n        regexps: {\n            format: /(%)/,\n            unformat: /(%)/\n        },\n        format: function(value, format, roundingFunction) {\n            var space = numeral._.includes(format, ' %') ? ' ' : '',\n                output;\n\n            if (numeral.options.scalePercentBy100) {\n                value = value * 100;\n            }\n\n            // check for space before %\n            format = format.replace(/\\s?\\%/, '');\n\n            output = numeral._.numberToFormat(value, format, roundingFunction);\n\n            if (numeral._.includes(output, ')')) {\n                output = output.split('');\n\n                output.splice(-1, 0, space + '%');\n\n                output = output.join('');\n            } else {\n                output = output + space + '%';\n            }\n\n            return output;\n        },\n        unformat: function(string) {\n            var number = numeral._.stringToNumber(string);\n            if (numeral.options.scalePercentBy100) {\n                return number * 0.01;\n            }\n            return number;\n        }\n    });\n})();\n\n\n(function() {\n        numeral.register('format', 'time', {\n        regexps: {\n            format: /(:)/,\n            unformat: /(:)/\n        },\n        format: function(value, format, roundingFunction) {\n            var hours = Math.floor(value / 60 / 60),\n                minutes = Math.floor((value - (hours * 60 * 60)) / 60),\n                seconds = Math.round(value - (hours * 60 * 60) - (minutes * 60));\n\n            return hours + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);\n        },\n        unformat: function(string) {\n            var timeArray = string.split(':'),\n                seconds = 0;\n\n            // turn hours and minutes into seconds and add them all up\n            if (timeArray.length === 3) {\n                // hours\n                seconds = seconds + (Number(timeArray[0]) * 60 * 60);\n                // minutes\n                seconds = seconds + (Number(timeArray[1]) * 60);\n                // seconds\n                seconds = seconds + Number(timeArray[2]);\n            } else if (timeArray.length === 2) {\n                // minutes\n                seconds = seconds + (Number(timeArray[0]) * 60);\n                // seconds\n                seconds = seconds + Number(timeArray[1]);\n            }\n            return Number(seconds);\n        }\n    });\n})();\n\nreturn numeral;\n}));\n"],"names":["global","factory","module","this","numeral","_","VERSION","formats","locales","defaults","options","Numeral","input","number","value","kind","unformatFunction","regexp","obj","format","roundingFunction","locale","negP","optDec","leadingCount","abbr","trillion","billion","million","thousand","decimal","neg","abbrForce","abs","int","precision","signed","thousands","output","i","string","stringOriginal","abbreviations","abbreviation","search","subString","start","array","callback","t","len","k","x","parts","args","accum","next","mn","maxDecimals","optionals","splitValue","minDecimals","boundedPrecision","optionalsRegExp","power","key","property","type","name","val","culture","_decimalSep","_thousandSep","_currSymbol","_valArray","_abbrObj","_thousandRegEx","localeData","temp","e","inputString","formatFunction","corrFactor","cback","curr","currI","O","b","space","binary","allSuffixes","item","unformatRegex","bytes","suffix","min","max","bytesMultiplier","symbols","symbol","exponential","num","ordinal","hours","minutes","seconds","timeArray"],"mappings":"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","x_google_ignoreList":[0]}