{"version":3,"sources":["webpack:///./node_modules/core-js/modules/es.string.replace-all.js","webpack:///./node_modules/lodash/isEqual.js","webpack:///./node_modules/numeral/numeral.js","webpack:///./src/utils/index.js"],"names":["$","requireObjectCoercible","isRegExp","getRegExpFlags","wellKnownSymbol","IS_PURE","REPLACE","RegExpPrototype","RegExp","prototype","target","proto","replaceAll","searchValue","replaceValue","IS_REG_EXP","flags","replacer","string","searchString","template","result","position","index","O","this","String","call","indexOf","TypeError","undefined","replace","split","join","length","baseIsEqual","isEqual","value","other","module","exports","global","factory","numeral","_","VERSION","formats","locales","defaults","currentLocale","zeroFormat","nullFormat","defaultFormat","scalePercentBy100","options","Numeral","input","number","_input","_value","kind","unformatFunction","regexp","isNumeral","isNaN","regexps","unformat","match","stringToNumber","Number","version","obj","numberToFormat","format","roundingFunction","abbrForce","abs","int","precision","signed","thousands","output","locale","negP","optDec","leadingCount","abbr","trillion","billion","million","thousand","decimal","neg","Math","includes","abbreviations","toString","toFixed","delimiters","slice","i","abbreviation","stringOriginal","currency","symbol","pow","min","search","insert","subString","start","reduce","array","callback","t","Object","len","k","arguments","multiplier","x","parts","correctionFactor","args","Array","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","cback","curr","currI","subtract","multiply","divide","difference","ordinal","b","space","splice","base","suffixes","binary","allSuffixes","concat","filter","item","unformatRegex","bytes","suffix","bytesMultiplier","symbols","before","after","exponential","toExponential","num","hours","floor","minutes","seconds","timeArray","removeDiacritical","str","normalize","checkStatus","res","_res$data","status","data","succeeded","Vue","$toast","success","message","error","compareObjects","obj1","obj2","_isEquals","formatDate","date","moment","formatDateTime","formatDateRequest","formatDateRequestTime","formatDateTimeRequest","formatDateCheckTime","formatNumberToCost"],"mappings":"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","file":"js/chunk-01d88f70.ee6c2837.js","sourcesContent":["'use strict';\nvar $ = require('../internals/export');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar isRegExp = require('../internals/is-regexp');\nvar getRegExpFlags = require('../internals/regexp-flags');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar REPLACE = wellKnownSymbol('replace');\nvar RegExpPrototype = RegExp.prototype;\n\n// `String.prototype.replaceAll` method\n// https://github.com/tc39/proposal-string-replace-all\n$({ target: 'String', proto: true }, {\n  replaceAll: function replaceAll(searchValue, replaceValue) {\n    var O = requireObjectCoercible(this);\n    var IS_REG_EXP, flags, replacer, string, searchString, template, result, position, index;\n    if (searchValue != null) {\n      IS_REG_EXP = isRegExp(searchValue);\n      if (IS_REG_EXP) {\n        flags = String(requireObjectCoercible('flags' in RegExpPrototype\n          ? searchValue.flags\n          : getRegExpFlags.call(searchValue)\n        ));\n        if (!~flags.indexOf('g')) throw TypeError('`.replaceAll` does not allow non-global regexes');\n      }\n      replacer = searchValue[REPLACE];\n      if (replacer !== undefined) {\n        return replacer.call(searchValue, O, replaceValue);\n      } else if (IS_PURE && IS_REG_EXP) {\n        return String(O).replace(searchValue, replaceValue);\n      }\n    }\n    string = String(O);\n    searchString = String(searchValue);\n    if (searchString === '') return replaceAll.call(string, /(?:)/g, replaceValue);\n    template = string.split(searchString);\n    if (typeof replaceValue !== 'function') {\n      return template.join(String(replaceValue));\n    }\n    result = template[0];\n    position = result.length;\n    for (index = 1; index < template.length; index++) {\n      result += String(replaceValue(searchString, position, string));\n      position += searchString.length + template[index].length;\n      result += template[index];\n    }\n    return result;\n  }\n});\n","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","/*! @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 Vue from 'vue'\r\nimport moment from 'moment'\r\nimport * as numeral from 'numeral'\r\nimport _isEquals from 'lodash/isEqual'\r\n\r\nexport const removeDiacritical = str => (str ? str.toLowerCase().trim().normalize('NFD')\r\n  .replace(/[\\u0300-\\u036f]/g, '')\r\n  .replace(/[đĐ]/g, 'd')\r\n  .replace(/^-+|-+$/g, '') : '')\r\n\r\nexport const checkStatus = res => {\r\n  if (res.status === 200) {\r\n    if (res.data?.succeeded) {\r\n      Vue.$toast.success(res.data.message)\r\n      return true\r\n    }\r\n    return false\r\n  }\r\n  Vue.$toast.error(res.data.message)\r\n  return null\r\n}\r\n\r\nexport const compareObjects = (obj1, obj2) => _isEquals(obj1, obj2)\r\n\r\nexport const formatDate = date => (date ? moment(date).format('DD/MM/YYYY') : '')\r\n\r\nexport const formatDateTime = date => (date ? moment(date).format('DD/MM/YYYY HH:mm') : '')\r\n\r\nexport const formatDateRequest = date => (date ? moment(date).format('YYYY-MM-DD') : '')\r\n\r\nexport const formatDateRequestTime = date => (date ? moment(date).format('YYYY/MM/DD') : '')\r\n\r\nexport const formatDateTimeRequest = date => (date ? moment(date).format('YYYY-MM-DD HH:mm') : '')\r\n\r\nexport const formatDateTimeCheck = date => (date ? moment(date).format('DD/MM/YYYY HH:mm') : '')\r\n\r\nexport const formatDateCheckTime = date => (date ? moment(date).format('DD/MM/YYYY HH:mm A') : '')\r\n\r\nexport const formatNumberToCost = value => String(numeral(value).format()).replaceAll(',', '.')\r\n\r\nexport default {\r\n  removeDiacritical,\r\n  checkStatus,\r\n  formatDate,\r\n  formatDateRequest,\r\n  formatDateTimeCheck,\r\n  formatDateTimeRequest,\r\n  formatDateRequestTime,\r\n  formatNumberToCost,\r\n  compareObjects,\r\n}\r\n"],"sourceRoot":""}