{"version":3,"sources":["webpack:///./node_modules/numeral/numeral.js","webpack:///./src/filters/number.js"],"names":["__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_RESULT__","numeral","_","formats","locales","defaults","currentLocale","zeroFormat","nullFormat","defaultFormat","scalePercentBy100","options","Numeral","input","number","this","_input","_value","value","kind","unformatFunction","regexp","isNumeral","isNaN","replace","length","regexps","unformat","match","stringToNumber","Number","version","obj","numberToFormat","format","roundingFunction","abbrForce","abs","int","precision","signed","thousands","output","leadingCount","locale","negP","optDec","abbr","trillion","billion","million","decimal","neg","Math","includes","indexOf","RegExp","abbreviations","thousand","toString","split","toFixed","delimiters","slice","String","i","string","abbreviation","stringOriginal","currency","symbol","pow","min","search","insert","subString","start","reduce","array","callback","TypeError","t","Object","len","k","arguments","multiplier","x","parts","correctionFactor","args","Array","prototype","call","accum","next","mn","maxDecimals","optionals","boundedPrecision","optionalsRegExp","power","splitValue","minDecimals","max","key","toLowerCase","localeData","Error","reset","property","register","type","name","validate","val","culture","_decimalSep","_thousandSep","_currSymbol","_valArray","_abbrObj","_thousandRegEx","temp","console","warn","trim","e","substr","fn","clone","inputString","formatFunction","round","set","add","corrFactor","curr","currI","O","subtract","multiply","divide","difference","ordinal","b","space","splice","join","base","suffixes","binary","unformatRegex","concat","filter","item","bytes","suffix","bytesMultiplier","symbols","before","after","toExponential","hours","floor","minutes","seconds","timeArray","exports","__webpack_require__","module","numeral__WEBPACK_IMPORTED_MODULE_0__","numeral__WEBPACK_IMPORTED_MODULE_0___default","n","__webpack_exports__"],"mappings":"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","file":"js/chunk-0a6095ae.6da40408.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","import numeral from 'numeral'\n\nexport default (val, format = '0,0') => numeral(val).format(format)\n"],"sourceRoot":""}