{"version":3,"file":"js/3704-ac0713c192a27306ff2a.js","mappings":"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","sources":["webpack://AYTM/./node_modules/moment-duration-format/lib/moment-duration-format.js"],"sourcesContent":["/*! Moment Duration Format v2.2.2\n *  https://github.com/jsmreese/moment-duration-format\n *  Date: 2018-02-16\n *\n *  Duration format plugin function for the Moment.js library\n *  http://momentjs.com/\n *\n *  Copyright 2018 John Madhavan-Reese\n *  Released under the MIT license\n */\n\n(function (root, factory) {\n    if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define(['moment'], factory);\n    } else if (typeof exports === 'object') {\n        // Node. Does not work with strict CommonJS, but only CommonJS-like\n        // enviroments that support module.exports, like Node.\n        try {\n            module.exports = factory(require('moment'));\n        } catch (e) {\n            // If moment is not available, leave the setup up to the user.\n            // Like when using moment-timezone or similar moment-based package.\n            module.exports = factory;\n        }\n    }\n\n    if (root) {\n        // Globals.\n        root.momentDurationFormatSetup = root.moment ? factory(root.moment) : factory;\n    }\n})(this, function (moment) {\n    // `Number#tolocaleString` is tested on plugin initialization.\n    // If the feature test passes, `toLocaleStringWorks` will be set to `true` and the\n    // native function will be used to generate formatted output. If the feature\n    // test fails, the fallback format function internal to this plugin will be\n    // used.\n    var toLocaleStringWorks = false;\n\n    // `Number#toLocaleString` rounds incorrectly for select numbers in Microsoft\n    // environments (Edge, IE11, Windows Phone) and possibly other environments.\n    // If the rounding test fails and `toLocaleString` will be used for formatting,\n    // the plugin will \"pre-round\" number values using the fallback number format\n    // function before passing them to `toLocaleString` for final formatting.\n    var toLocaleStringRoundingWorks = false;\n\n    // `Intl.NumberFormat#format` is tested on plugin initialization.\n    // If the feature test passes, `intlNumberFormatRoundingWorks` will be set to\n    // `true` and the native function will be used to generate formatted output.\n    // If the feature test fails, either `Number#tolocaleString` (if\n    // `toLocaleStringWorks` is `true`), or the fallback format function internal\n    //  to this plugin will be used.\n    var intlNumberFormatWorks = false;\n\n    // `Intl.NumberFormat#format` rounds incorrectly for select numbers in Microsoft\n    // environments (Edge, IE11, Windows Phone) and possibly other environments.\n    // If the rounding test fails and `Intl.NumberFormat#format` will be used for\n    // formatting, the plugin will \"pre-round\" number values using the fallback number\n    // format function before passing them to `Intl.NumberFormat#format` for final\n    // formatting.\n    var intlNumberFormatRoundingWorks = false;\n\n    // Token type names in order of descending magnitude.\n    var types = \"escape years months weeks days hours minutes seconds milliseconds general\".split(\" \");\n\n    var bubbles = [\n        {\n            type: \"seconds\",\n            targets: [\n                { type: \"minutes\", value: 60 },\n                { type: \"hours\", value: 3600 },\n                { type: \"days\", value: 86400 },\n                { type: \"weeks\", value: 604800 },\n                { type: \"months\", value: 2678400 },\n                { type: \"years\", value: 31536000 }\n            ]\n        },\n        {\n            type: \"minutes\",\n            targets: [\n                { type: \"hours\", value: 60 },\n                { type: \"days\", value: 1440 },\n                { type: \"weeks\", value: 10080 },\n                { type: \"months\", value: 44640 },\n                { type: \"years\", value: 525600 }\n            ]\n        },\n        {\n            type: \"hours\",\n            targets: [\n                { type: \"days\", value: 24 },\n                { type: \"weeks\", value: 168 },\n                { type: \"months\", value: 744 },\n                { type: \"years\", value: 8760 }\n            ]\n        },\n        {\n            type: \"days\",\n            targets: [\n                { type: \"weeks\", value: 7 },\n                { type: \"months\", value: 31 },\n                { type: \"years\", value: 365 }\n            ]\n        },\n        {\n            type: \"months\",\n            targets: [\n                { type: \"years\", value: 12 }\n            ]\n        }\n    ];\n\n    // stringIncludes\n    function stringIncludes(str, search) {\n        if (search.length > str.length) {\n          return false;\n        }\n\n        return str.indexOf(search) !== -1;\n    }\n\n    // repeatZero(qty)\n    // Returns \"0\" repeated `qty` times.\n    // `qty` must be a integer >= 0.\n    function repeatZero(qty) {\n        var result = \"\";\n\n        while (qty) {\n            result += \"0\";\n            qty -= 1;\n        }\n\n        return result;\n    }\n\n    function stringRound(digits) {\n        var digitsArray = digits.split(\"\").reverse();\n        var i = 0;\n        var carry = true;\n\n        while (carry && i < digitsArray.length) {\n            if (i) {\n                if (digitsArray[i] === \"9\") {\n                    digitsArray[i] = \"0\";\n                } else {\n                    digitsArray[i] = (parseInt(digitsArray[i], 10) + 1).toString();\n                    carry = false;\n                }\n            } else {\n                if (parseInt(digitsArray[i], 10) < 5) {\n                    carry = false;\n                }\n\n                digitsArray[i] = \"0\";\n            }\n\n            i += 1;\n        }\n\n        if (carry) {\n            digitsArray.push(\"1\");\n        }\n\n        return digitsArray.reverse().join(\"\");\n    }\n\n    // cachedNumberFormat\n    // Returns an `Intl.NumberFormat` instance for the given locale and configuration.\n    // On first use of a particular configuration, the instance is cached for fast\n    // repeat access.\n    function cachedNumberFormat(locale, options) {\n        // Create a sorted, stringified version of `options`\n        // for use as part of the cache key\n        var optionsString = map(\n            keys(options).sort(),\n            function(key) {\n                return key + ':' + options[key];\n            }\n        ).join(',');\n\n        // Set our cache key\n        var cacheKey = locale + '+' + optionsString;\n\n        // If we don't have this configuration cached, configure and cache it\n        if (!cachedNumberFormat.cache[cacheKey]) {\n            cachedNumberFormat.cache[cacheKey] = Intl.NumberFormat(locale, options);\n        }\n\n        // Return the cached version of this configuration\n        return cachedNumberFormat.cache[cacheKey];\n    }\n    cachedNumberFormat.cache = {};\n\n    // formatNumber\n    // Formats any number greater than or equal to zero using these options:\n    // - userLocale\n    // - useToLocaleString\n    // - useGrouping\n    // - grouping\n    // - maximumSignificantDigits\n    // - minimumIntegerDigits\n    // - fractionDigits\n    // - groupingSeparator\n    // - decimalSeparator\n    //\n    // `useToLocaleString` will use `Intl.NumberFormat` or `toLocaleString` for formatting.\n    // `userLocale` option is passed through to the formatting function.\n    // `fractionDigits` is passed through to `maximumFractionDigits` and `minimumFractionDigits`\n    // Using `maximumSignificantDigits` will override `minimumIntegerDigits` and `fractionDigits`.\n    function formatNumber(number, options, userLocale) {\n        var useToLocaleString = options.useToLocaleString;\n        var useGrouping = options.useGrouping;\n        var grouping = useGrouping && options.grouping.slice();\n        var maximumSignificantDigits = options.maximumSignificantDigits;\n        var minimumIntegerDigits = options.minimumIntegerDigits || 1;\n        var fractionDigits = options.fractionDigits || 0;\n        var groupingSeparator = options.groupingSeparator;\n        var decimalSeparator = options.decimalSeparator;\n\n        if (useToLocaleString && userLocale) {\n            var localeStringOptions = {\n                minimumIntegerDigits: minimumIntegerDigits,\n                useGrouping: useGrouping\n            };\n\n            if (fractionDigits) {\n                localeStringOptions.maximumFractionDigits = fractionDigits;\n                localeStringOptions.minimumFractionDigits = fractionDigits;\n            }\n\n            // toLocaleString output is \"0.0\" instead of \"0\" for HTC browsers\n            // when maximumSignificantDigits is set. See #96.\n            if (maximumSignificantDigits && number > 0) {\n                localeStringOptions.maximumSignificantDigits = maximumSignificantDigits;\n            }\n\n            if (intlNumberFormatWorks) {\n                if (!intlNumberFormatRoundingWorks) {\n                    var roundingOptions = extend({}, options);\n                    roundingOptions.useGrouping = false;\n                    roundingOptions.decimalSeparator = \".\";\n                    number = parseFloat(formatNumber(number, roundingOptions), 10);\n                }\n\n                return cachedNumberFormat(userLocale, localeStringOptions).format(number);\n            } else {\n                if (!toLocaleStringRoundingWorks) {\n                    var roundingOptions = extend({}, options);\n                    roundingOptions.useGrouping = false;\n                    roundingOptions.decimalSeparator = \".\";\n                    number = parseFloat(formatNumber(number, roundingOptions), 10);\n                }\n\n                return number.toLocaleString(userLocale, localeStringOptions);\n            }\n        }\n\n        var numberString;\n\n        // Add 1 to digit output length for floating point errors workaround. See below.\n        if (maximumSignificantDigits) {\n            numberString = number.toPrecision(maximumSignificantDigits + 1);\n        } else {\n            numberString = number.toFixed(fractionDigits + 1);\n        }\n\n        var integerString;\n        var fractionString;\n        var exponentString;\n\n        var temp = numberString.split(\"e\");\n\n        exponentString = temp[1] || \"\";\n\n        temp = temp[0].split(\".\");\n\n        fractionString = temp[1] || \"\";\n        integerString = temp[0] || \"\";\n\n        // Workaround for floating point errors in `toFixed` and `toPrecision`.\n        // (3.55).toFixed(1); --> \"3.5\"\n        // (123.55 - 120).toPrecision(2); --> \"3.5\"\n        // (123.55 - 120); --> 3.549999999999997\n        // (123.55 - 120).toFixed(2); --> \"3.55\"\n        // Round by examing the string output of the next digit.\n\n        // *************** Implement String Rounding here ***********************\n        // Check integerString + fractionString length of toPrecision before rounding.\n        // Check length of fractionString from toFixed output before rounding.\n        var integerLength = integerString.length;\n        var fractionLength = fractionString.length;\n        var digitCount = integerLength + fractionLength;\n        var digits = integerString + fractionString;\n\n        if (maximumSignificantDigits && digitCount === (maximumSignificantDigits + 1) || !maximumSignificantDigits && fractionLength === (fractionDigits + 1)) {\n            // Round digits.\n            digits = stringRound(digits);\n\n            if (digits.length === digitCount + 1) {\n                integerLength = integerLength + 1;\n            }\n\n            // Discard final fractionDigit.\n            if (fractionLength) {\n                digits = digits.slice(0, -1);\n            }\n\n            // Separate integer and fraction.\n            integerString = digits.slice(0, integerLength);\n            fractionString = digits.slice(integerLength);\n        }\n\n        // Trim trailing zeroes from fractionString because toPrecision outputs\n        // precision, not significant digits.\n        if (maximumSignificantDigits) {\n            fractionString = fractionString.replace(/0*$/, \"\");\n        }\n\n        // Handle exponent.\n        var exponent = parseInt(exponentString, 10);\n\n        if (exponent > 0) {\n            if (fractionString.length <= exponent) {\n                fractionString = fractionString + repeatZero(exponent - fractionString.length);\n\n                integerString = integerString + fractionString;\n                fractionString = \"\";\n            } else {\n                integerString = integerString + fractionString.slice(0, exponent);\n                fractionString = fractionString.slice(exponent);\n            }\n        } else if (exponent < 0) {\n            fractionString = (repeatZero(Math.abs(exponent) - integerString.length) + integerString + fractionString);\n\n            integerString = \"0\";\n        }\n\n        if (!maximumSignificantDigits) {\n            // Trim or pad fraction when not using maximumSignificantDigits.\n            fractionString = fractionString.slice(0, fractionDigits);\n\n            if (fractionString.length < fractionDigits) {\n                fractionString = fractionString + repeatZero(fractionDigits - fractionString.length);\n            }\n\n            // Pad integer when using minimumIntegerDigits\n            // and not using maximumSignificantDigits.\n            if (integerString.length < minimumIntegerDigits) {\n                integerString = repeatZero(minimumIntegerDigits - integerString.length) + integerString;\n            }\n        }\n\n        var formattedString = \"\";\n\n        // Handle grouping.\n        if (useGrouping) {\n            temp = integerString;\n            var group;\n\n            while (temp.length) {\n                if (grouping.length) {\n                    group = grouping.shift();\n                }\n\n                if (formattedString) {\n                    formattedString = groupingSeparator + formattedString;\n                }\n\n                formattedString = temp.slice(-group) + formattedString;\n\n                temp = temp.slice(0, -group);\n            }\n        } else {\n            formattedString = integerString;\n        }\n\n        // Add decimalSeparator and fraction.\n        if (fractionString) {\n            formattedString = formattedString + decimalSeparator + fractionString;\n        }\n\n        return formattedString;\n    }\n\n    // durationLabelCompare\n    function durationLabelCompare(a, b) {\n        if (a.label.length > b.label.length) {\n            return -1;\n        }\n\n        if (a.label.length < b.label.length) {\n            return 1;\n        }\n\n        // a must be equal to b\n        return 0;\n    }\n\n    // durationGetLabels\n    function durationGetLabels(token, localeData) {\n        var labels = [];\n\n        each(keys(localeData), function (localeDataKey) {\n            if (localeDataKey.slice(0, 15) !== \"_durationLabels\") {\n                return;\n            }\n\n            var labelType = localeDataKey.slice(15).toLowerCase();\n\n            each(keys(localeData[localeDataKey]), function (labelKey) {\n                if (labelKey.slice(0, 1) === token) {\n                    labels.push({\n                        type: labelType,\n                        key: labelKey,\n                        label: localeData[localeDataKey][labelKey]\n                    });\n                }\n            });\n        });\n\n        return labels;\n    }\n\n    // durationPluralKey\n    function durationPluralKey(token, integerValue, decimalValue) {\n        // Singular for a value of `1`, but not for `1.0`.\n        if (integerValue === 1 && decimalValue === null) {\n            return token;\n        }\n\n        return token + token;\n    }\n\n    var engLocale = {\n        durationLabelsStandard: {\n            S: 'millisecond',\n            SS: 'milliseconds',\n            s: 'second',\n            ss: 'seconds',\n            m: 'minute',\n            mm: 'minutes',\n            h: 'hour',\n            hh: 'hours',\n            d: 'day',\n            dd: 'days',\n            w: 'week',\n            ww: 'weeks',\n            M: 'month',\n            MM: 'months',\n            y: 'year',\n            yy: 'years'\n        },\n        durationLabelsShort: {\n            S: 'msec',\n            SS: 'msecs',\n            s: 'sec',\n            ss: 'secs',\n            m: 'min',\n            mm: 'mins',\n            h: 'hr',\n            hh: 'hrs',\n            d: 'dy',\n            dd: 'dys',\n            w: 'wk',\n            ww: 'wks',\n            M: 'mo',\n            MM: 'mos',\n            y: 'yr',\n            yy: 'yrs'\n        },\n        durationTimeTemplates: {\n            HMS: 'h:mm:ss',\n            HM: 'h:mm',\n            MS: 'm:ss'\n        },\n        durationLabelTypes: [\n            { type: \"standard\", string: \"__\" },\n            { type: \"short\", string: \"_\" }\n        ],\n        durationPluralKey: durationPluralKey\n    };\n\n    // isArray\n    function isArray(array) {\n        return Object.prototype.toString.call(array) === \"[object Array]\";\n    }\n\n    // isObject\n    function isObject(obj) {\n        return Object.prototype.toString.call(obj) === \"[object Object]\";\n    }\n\n    // findLast\n    function findLast(array, callback) {\n        var index = array.length;\n\n        while (index -= 1) {\n            if (callback(array[index])) { return array[index]; }\n        }\n    }\n\n    // find\n    function find(array, callback) {\n        var index = 0;\n\n        var max = array && array.length || 0;\n\n        var match;\n\n        if (typeof callback !== \"function\") {\n            match = callback;\n            callback = function (item) {\n                return item === match;\n            };\n        }\n\n        while (index < max) {\n            if (callback(array[index])) { return array[index]; }\n            index += 1;\n        }\n    }\n\n    // each\n    function each(array, callback) {\n        var index = 0,\n            max = array.length;\n\n        if (!array || !max) { return; }\n\n        while (index < max) {\n            if (callback(array[index], index) === false) { return; }\n            index += 1;\n        }\n    }\n\n    // map\n    function map(array, callback) {\n        var index = 0,\n            max = array.length,\n            ret = [];\n\n        if (!array || !max) { return ret; }\n\n        while (index < max) {\n            ret[index] = callback(array[index], index);\n            index += 1;\n        }\n\n        return ret;\n    }\n\n    // pluck\n    function pluck(array, prop) {\n        return map(array, function (item) {\n            return item[prop];\n        });\n    }\n\n    // compact\n    function compact(array) {\n        var ret = [];\n\n        each(array, function (item) {\n            if (item) { ret.push(item); }\n        });\n\n        return ret;\n    }\n\n    // unique\n    function unique(array) {\n        var ret = [];\n\n        each(array, function (_a) {\n            if (!find(ret, _a)) { ret.push(_a); }\n        });\n\n        return ret;\n    }\n\n    // intersection\n    function intersection(a, b) {\n        var ret = [];\n\n        each(a, function (_a) {\n            each(b, function (_b) {\n                if (_a === _b) { ret.push(_a); }\n            });\n        });\n\n        return unique(ret);\n    }\n\n    // rest\n    function rest(array, callback) {\n        var ret = [];\n\n        each(array, function (item, index) {\n            if (!callback(item)) {\n                ret = array.slice(index);\n                return false;\n            }\n        });\n\n        return ret;\n    }\n\n    // initial\n    function initial(array, callback) {\n        var reversed = array.slice().reverse();\n\n        return rest(reversed, callback).reverse();\n    }\n\n    // extend\n    function extend(a, b) {\n        for (var key in b) {\n            if (b.hasOwnProperty(key)) { a[key] = b[key]; }\n        }\n\n        return a;\n    }\n\n    // keys\n    function keys(a) {\n        var ret = [];\n\n        for (var key in a) {\n            if (a.hasOwnProperty(key)) { ret.push(key); }\n        }\n\n        return ret;\n    }\n\n    // any\n    function any(array, callback) {\n        var index = 0,\n            max = array.length;\n\n        if (!array || !max) { return false; }\n\n        while (index < max) {\n            if (callback(array[index], index) === true) { return true; }\n            index += 1;\n        }\n\n        return false;\n    }\n\n    // flatten\n    function flatten(array) {\n        var ret = [];\n\n        each(array, function(child) {\n            ret = ret.concat(child);\n        });\n\n        return ret;\n    }\n\n    function toLocaleStringSupportsLocales() {\n        var number = 0;\n        try {\n            number.toLocaleString('i');\n        } catch (e) {\n            return e.name === 'RangeError';\n        }\n        return false;\n    }\n\n    function featureTestFormatterRounding(formatter) {\n        return formatter(3.55, \"en\", {\n            useGrouping: false,\n            minimumIntegerDigits: 1,\n            minimumFractionDigits: 1,\n            maximumFractionDigits: 1\n        }) === \"3.6\";\n    }\n\n    function featureTestFormatter(formatter) {\n        var passed = true;\n\n        // Test minimumIntegerDigits.\n        passed = passed && formatter(1, \"en\", { minimumIntegerDigits: 1 }) === \"1\";\n        passed = passed && formatter(1, \"en\", { minimumIntegerDigits: 2 }) === \"01\";\n        passed = passed && formatter(1, \"en\", { minimumIntegerDigits: 3 }) === \"001\";\n        if (!passed) { return false; }\n\n        // Test maximumFractionDigits and minimumFractionDigits.\n        passed = passed && formatter(99.99, \"en\", { maximumFractionDigits: 0, minimumFractionDigits: 0 }) === \"100\";\n        passed = passed && formatter(99.99, \"en\", { maximumFractionDigits: 1, minimumFractionDigits: 1 }) === \"100.0\";\n        passed = passed && formatter(99.99, \"en\", { maximumFractionDigits: 2, minimumFractionDigits: 2 }) === \"99.99\";\n        passed = passed && formatter(99.99, \"en\", { maximumFractionDigits: 3, minimumFractionDigits: 3 }) === \"99.990\";\n        if (!passed) { return false; }\n\n        // Test maximumSignificantDigits.\n        passed = passed && formatter(99.99, \"en\", { maximumSignificantDigits: 1 }) === \"100\";\n        passed = passed && formatter(99.99, \"en\", { maximumSignificantDigits: 2 }) === \"100\";\n        passed = passed && formatter(99.99, \"en\", { maximumSignificantDigits: 3 }) === \"100\";\n        passed = passed && formatter(99.99, \"en\", { maximumSignificantDigits: 4 }) === \"99.99\";\n        passed = passed && formatter(99.99, \"en\", { maximumSignificantDigits: 5 }) === \"99.99\";\n        if (!passed) { return false; }\n\n        // Test grouping.\n        passed = passed && formatter(1000, \"en\", { useGrouping: true }) === \"1,000\";\n        passed = passed && formatter(1000, \"en\", { useGrouping: false }) === \"1000\";\n        if (!passed) { return false; }\n\n        return true;\n    }\n\n    // durationsFormat(durations [, template] [, precision] [, settings])\n    function durationsFormat() {\n        var args = [].slice.call(arguments);\n        var settings = {};\n        var durations;\n\n        // Parse arguments.\n        each(args, function (arg, index) {\n            if (!index) {\n                if (!isArray(arg)) {\n                    throw \"Expected array as the first argument to durationsFormat.\";\n                }\n\n                durations = arg;\n            }\n\n            if (typeof arg === \"string\" || typeof arg === \"function\") {\n                settings.template = arg;\n                return;\n            }\n\n            if (typeof arg === \"number\") {\n                settings.precision = arg;\n                return;\n            }\n\n            if (isObject(arg)) {\n                extend(settings, arg);\n            }\n        });\n\n        if (!durations || !durations.length) {\n            return [];\n        }\n\n        settings.returnMomentTypes = true;\n\n        var formattedDurations = map(durations, function (dur) {\n            return dur.format(settings);\n        });\n\n        // Merge token types from all durations.\n        var outputTypes = intersection(types, unique(pluck(flatten(formattedDurations), \"type\")));\n\n        var largest = settings.largest;\n\n        if (largest) {\n            outputTypes = outputTypes.slice(0, largest);\n        }\n\n        settings.returnMomentTypes = false;\n        settings.outputTypes = outputTypes;\n\n        return map(durations, function (dur) {\n            return dur.format(settings);\n        });\n    }\n\n    // durationFormat([template] [, precision] [, settings])\n    function durationFormat() {\n\n        var args = [].slice.call(arguments);\n        var settings = extend({}, this.format.defaults);\n\n        // Keep a shadow copy of this moment for calculating remainders.\n        // Perform all calculations on positive duration value, handle negative\n        // sign at the very end.\n        var asMilliseconds = this.asMilliseconds();\n        var asMonths = this.asMonths();\n\n        // Treat invalid durations as having a value of 0 milliseconds.\n        if (typeof this.isValid === \"function\" && this.isValid() === false) {\n            asMilliseconds = 0;\n            asMonths = 0;\n        }\n\n        var isNegative = asMilliseconds < 0;\n\n        // Two shadow copies are needed because of the way moment.js handles\n        // duration arithmetic for years/months and for weeks/days/hours/minutes/seconds.\n        var remainder = moment.duration(Math.abs(asMilliseconds), \"milliseconds\");\n        var remainderMonths = moment.duration(Math.abs(asMonths), \"months\");\n\n        // Parse arguments.\n        each(args, function (arg) {\n            if (typeof arg === \"string\" || typeof arg === \"function\") {\n                settings.template = arg;\n                return;\n            }\n\n            if (typeof arg === \"number\") {\n                settings.precision = arg;\n                return;\n            }\n\n            if (isObject(arg)) {\n                extend(settings, arg);\n            }\n        });\n\n        var momentTokens = {\n            years: \"y\",\n            months: \"M\",\n            weeks: \"w\",\n            days: \"d\",\n            hours: \"h\",\n            minutes: \"m\",\n            seconds: \"s\",\n            milliseconds: \"S\"\n        };\n\n        var tokenDefs = {\n            escape: /\\[(.+?)\\]/,\n            years: /\\*?[Yy]+/,\n            months: /\\*?M+/,\n            weeks: /\\*?[Ww]+/,\n            days: /\\*?[Dd]+/,\n            hours: /\\*?[Hh]+/,\n            minutes: /\\*?m+/,\n            seconds: /\\*?s+/,\n            milliseconds: /\\*?S+/,\n            general: /.+?/\n        };\n\n        // Types array is available in the template function.\n        settings.types = types;\n\n        var typeMap = function (token) {\n            return find(types, function (type) {\n                return tokenDefs[type].test(token);\n            });\n        };\n\n        var tokenizer = new RegExp(map(types, function (type) {\n            return tokenDefs[type].source;\n        }).join(\"|\"), \"g\");\n\n        // Current duration object is available in the template function.\n        settings.duration = this;\n\n        // Eval template function and cache template string.\n        var template = typeof settings.template === \"function\" ? settings.template.apply(settings) : settings.template;\n\n        // outputTypes and returnMomentTypes are settings to support durationsFormat().\n\n        // outputTypes is an array of moment token types that determines\n        // the tokens returned in formatted output. This option overrides\n        // trim, largest, stopTrim, etc.\n        var outputTypes = settings.outputTypes;\n\n        // returnMomentTypes is a boolean that sets durationFormat to return\n        // the processed momentTypes instead of formatted output.\n        var returnMomentTypes = settings.returnMomentTypes;\n\n        var largest = settings.largest;\n\n        // Setup stopTrim array of token types.\n        var stopTrim = [];\n\n        if (!outputTypes) {\n            if (isArray(settings.stopTrim)) {\n                settings.stopTrim = settings.stopTrim.join(\"\");\n            }\n\n            // Parse stopTrim string to create token types array.\n            if (settings.stopTrim) {\n                each(settings.stopTrim.match(tokenizer), function (token) {\n                    var type = typeMap(token);\n\n                    if (type === \"escape\" || type === \"general\") {\n                        return;\n                    }\n\n                    stopTrim.push(type);\n                });\n            }\n        }\n\n        // Cache moment's locale data.\n        var localeData = moment.localeData();\n\n        if (!localeData) {\n            localeData = {};\n        }\n\n        // Fall back to this plugin's `eng` extension.\n        each(keys(engLocale), function (key) {\n            if (typeof engLocale[key] === \"function\") {\n                if (!localeData[key]) {\n                    localeData[key] = engLocale[key];\n                }\n\n                return;\n            }\n\n            if (!localeData[\"_\" + key]) {\n                localeData[\"_\" + key] = engLocale[key];\n            }\n        });\n\n        // Replace Duration Time Template strings.\n        // For locale `eng`: `_HMS_`, `_HM_`, and `_MS_`.\n        each(keys(localeData._durationTimeTemplates), function (item) {\n            template = template.replace(\"_\" + item + \"_\", localeData._durationTimeTemplates[item]);\n        });\n\n        // Determine user's locale.\n        var userLocale = settings.userLocale || moment.locale();\n\n        var useLeftUnits = settings.useLeftUnits;\n        var usePlural = settings.usePlural;\n        var precision = settings.precision;\n        var forceLength = settings.forceLength;\n        var useGrouping = settings.useGrouping;\n        var trunc = settings.trunc;\n\n        // Use significant digits only when precision is greater than 0.\n        var useSignificantDigits = settings.useSignificantDigits && precision > 0;\n        var significantDigits = useSignificantDigits ? settings.precision : 0;\n        var significantDigitsCache = significantDigits;\n\n        var minValue = settings.minValue;\n        var isMinValue = false;\n\n        var maxValue = settings.maxValue;\n        var isMaxValue = false;\n\n        // formatNumber fallback options.\n        var useToLocaleString = settings.useToLocaleString;\n        var groupingSeparator = settings.groupingSeparator;\n        var decimalSeparator = settings.decimalSeparator;\n        var grouping = settings.grouping;\n\n        useToLocaleString = useToLocaleString && (toLocaleStringWorks || intlNumberFormatWorks);\n\n        // Trim options.\n        var trim = settings.trim;\n\n        if (isArray(trim)) {\n            trim = trim.join(\" \");\n        }\n\n        if (trim === null && (largest || maxValue || useSignificantDigits)) {\n            trim = \"all\";\n        }\n\n        if (trim === null || trim === true || trim === \"left\" || trim === \"right\") {\n            trim = \"large\";\n        }\n\n        if (trim === false) {\n            trim = \"\";\n        }\n\n        var trimIncludes = function (item) {\n            return item.test(trim);\n        };\n\n        var rLarge = /large/;\n        var rSmall = /small/;\n        var rBoth = /both/;\n        var rMid = /mid/;\n        var rAll = /^all|[^sm]all/;\n        var rFinal = /final/;\n\n        var trimLarge = largest > 0 || any([rLarge, rBoth, rAll], trimIncludes);\n        var trimSmall = any([rSmall, rBoth, rAll], trimIncludes);\n        var trimMid = any([rMid, rAll], trimIncludes);\n        var trimFinal = any([rFinal, rAll], trimIncludes);\n\n        // Parse format string to create raw tokens array.\n        var rawTokens = map(template.match(tokenizer), function (token, index) {\n            var type = typeMap(token);\n\n            if (token.slice(0, 1) === \"*\") {\n                token = token.slice(1);\n\n                if (type !== \"escape\" && type !== \"general\") {\n                    stopTrim.push(type);\n                }\n            }\n\n            return {\n                index: index,\n                length: token.length,\n                text: \"\",\n\n                // Replace escaped tokens with the non-escaped token text.\n                token: (type === \"escape\" ? token.replace(tokenDefs.escape, \"$1\") : token),\n\n                // Ignore type on non-moment tokens.\n                type: ((type === \"escape\" || type === \"general\") ? null : type)\n            };\n        });\n\n        // Associate text tokens with moment tokens.\n        var currentToken = {\n            index: 0,\n            length: 0,\n            token: \"\",\n            text: \"\",\n            type: null\n        };\n\n        var tokens = [];\n\n        if (useLeftUnits) {\n            rawTokens.reverse();\n        }\n\n        each(rawTokens, function (token) {\n            if (token.type) {\n                if (currentToken.type || currentToken.text) {\n                    tokens.push(currentToken);\n                }\n\n                currentToken = token;\n\n                return;\n            }\n\n            if (useLeftUnits) {\n                currentToken.text = token.token + currentToken.text;\n            } else {\n                currentToken.text += token.token;\n            }\n        });\n\n        if (currentToken.type || currentToken.text) {\n            tokens.push(currentToken);\n        }\n\n        if (useLeftUnits) {\n            tokens.reverse();\n        }\n\n        // Find unique moment token types in the template in order of\n        // descending magnitude.\n        var momentTypes = intersection(types, unique(compact(pluck(tokens, \"type\"))));\n\n        // Exit early if there are no moment token types.\n        if (!momentTypes.length) {\n            return pluck(tokens, \"text\").join(\"\");\n        }\n\n        // Calculate values for each moment type in the template.\n        // For processing the settings, values are associated with moment types.\n        // Values will be assigned to tokens at the last step in order to\n        // assume nothing about frequency or order of tokens in the template.\n        momentTypes = map(momentTypes, function (momentType, index) {\n            // Is this the least-magnitude moment token found?\n            var isSmallest = ((index + 1) === momentTypes.length);\n\n            // Is this the greatest-magnitude moment token found?\n            var isLargest = (!index);\n\n            // Get the raw value in the current units.\n            var rawValue;\n\n            if (momentType === \"years\" || momentType === \"months\") {\n                rawValue = remainderMonths.as(momentType);\n            } else {\n                rawValue = remainder.as(momentType);\n            }\n\n            var wholeValue = Math.floor(rawValue);\n            var decimalValue = rawValue - wholeValue;\n\n            var token = find(tokens, function (token) {\n                return momentType === token.type;\n            });\n\n            if (isLargest && maxValue && rawValue > maxValue) {\n                isMaxValue = true;\n            }\n\n            if (isSmallest && minValue && Math.abs(settings.duration.as(momentType)) < minValue) {\n                isMinValue = true;\n            }\n\n            // Note the length of the largest-magnitude moment token:\n            // if it is greater than one and forceLength is not set,\n            // then default forceLength to `true`.\n            //\n            // Rationale is this: If the template is \"h:mm:ss\" and the\n            // moment value is 5 minutes, the user-friendly output is\n            // \"5:00\", not \"05:00\". We shouldn't pad the `minutes` token\n            // even though it has length of two if the template is \"h:mm:ss\";\n            //\n            // If the minutes output should always include the leading zero\n            // even when the hour is trimmed then set `{ forceLength: true }`\n            // to output \"05:00\". If the template is \"hh:mm:ss\", the user\n            // clearly wanted everything padded so we should output \"05:00\";\n            //\n            // If the user wants the full padded output, they can use\n            // template \"hh:mm:ss\" and set `{ trim: false }` to output\n            // \"00:05:00\".\n            if (isLargest && forceLength === null && token.length > 1) {\n                forceLength = true;\n            }\n\n            // Update remainder.\n            remainder.subtract(wholeValue, momentType);\n            remainderMonths.subtract(wholeValue, momentType);\n\n            return {\n                rawValue: rawValue,\n                wholeValue: wholeValue,\n                // Decimal value is only retained for the least-magnitude\n                // moment type in the format template.\n                decimalValue: isSmallest ? decimalValue : 0,\n                isSmallest: isSmallest,\n                isLargest: isLargest,\n                type: momentType,\n                // Tokens can appear multiple times in a template string,\n                // but all instances must share the same length.\n                tokenLength: token.length\n            };\n        });\n\n        var truncMethod = trunc ? Math.floor : Math.round;\n        var truncate = function (value, places) {\n            var factor = Math.pow(10, places);\n            return truncMethod(value * factor) / factor;\n        };\n\n        var foundFirst = false;\n        var bubbled = false;\n\n        var formatValue = function (momentType, index) {\n            var formatOptions = {\n                useGrouping: useGrouping,\n                groupingSeparator: groupingSeparator,\n                decimalSeparator: decimalSeparator,\n                grouping: grouping,\n                useToLocaleString: useToLocaleString\n            };\n\n            if (useSignificantDigits) {\n                if (significantDigits <= 0) {\n                    momentType.rawValue = 0;\n                    momentType.wholeValue = 0;\n                    momentType.decimalValue = 0;\n                } else {\n                    formatOptions.maximumSignificantDigits = significantDigits;\n                    momentType.significantDigits = significantDigits;\n                }\n            }\n\n            if (isMaxValue && !bubbled) {\n                if (momentType.isLargest) {\n                    momentType.wholeValue = maxValue;\n                    momentType.decimalValue = 0;\n                } else {\n                    momentType.wholeValue = 0;\n                    momentType.decimalValue = 0;\n                }\n            }\n\n            if (isMinValue && !bubbled) {\n                if (momentType.isSmallest) {\n                    momentType.wholeValue = minValue;\n                    momentType.decimalValue = 0;\n                } else {\n                    momentType.wholeValue = 0;\n                    momentType.decimalValue = 0;\n                }\n            }\n\n            if (momentType.isSmallest || momentType.significantDigits && momentType.significantDigits - momentType.wholeValue.toString().length <= 0) {\n                // Apply precision to least significant token value.\n                if (precision < 0) {\n                    momentType.value = truncate(momentType.wholeValue, precision);\n                } else if (precision === 0) {\n                    momentType.value = truncMethod(momentType.wholeValue + momentType.decimalValue);\n                } else { // precision > 0\n                    if (useSignificantDigits) {\n                        if (trunc) {\n                            momentType.value = truncate(momentType.rawValue, significantDigits - momentType.wholeValue.toString().length);\n                        } else {\n                            momentType.value = momentType.rawValue;\n                        }\n\n                        if (momentType.wholeValue) {\n                            significantDigits -= momentType.wholeValue.toString().length;\n                        }\n                    } else {\n                        formatOptions.fractionDigits = precision;\n\n                        if (trunc) {\n                            momentType.value = momentType.wholeValue + truncate(momentType.decimalValue, precision);\n                        } else {\n                            momentType.value = momentType.wholeValue + momentType.decimalValue;\n                        }\n                    }\n                }\n            } else {\n                if (useSignificantDigits && momentType.wholeValue) {\n                    // Outer Math.round required here to handle floating point errors.\n                    momentType.value = Math.round(truncate(momentType.wholeValue, momentType.significantDigits - momentType.wholeValue.toString().length));\n\n                    significantDigits -= momentType.wholeValue.toString().length;\n                } else {\n                    momentType.value = momentType.wholeValue;\n                }\n            }\n\n            if (momentType.tokenLength > 1 && (forceLength || foundFirst)) {\n                formatOptions.minimumIntegerDigits = momentType.tokenLength;\n\n                if (bubbled && formatOptions.maximumSignificantDigits < momentType.tokenLength) {\n                    delete formatOptions.maximumSignificantDigits;\n                }\n            }\n\n            if (!foundFirst && (momentType.value > 0 || trim === \"\" /* trim: false */ || find(stopTrim, momentType.type) || find(outputTypes, momentType.type))) {\n                foundFirst = true;\n            }\n\n            momentType.formattedValue = formatNumber(momentType.value, formatOptions, userLocale);\n\n            formatOptions.useGrouping = false;\n            formatOptions.decimalSeparator = \".\";\n            momentType.formattedValueEn = formatNumber(momentType.value, formatOptions, \"en\");\n\n            if (momentType.tokenLength === 2 && momentType.type === \"milliseconds\") {\n                momentType.formattedValueMS = formatNumber(momentType.value, {\n                    minimumIntegerDigits: 3,\n                    useGrouping: false\n                }, \"en\").slice(0, 2);\n            }\n\n            return momentType;\n        };\n\n        // Calculate formatted values.\n        momentTypes = map(momentTypes, formatValue);\n        momentTypes = compact(momentTypes);\n\n        // Bubble rounded values.\n        if (momentTypes.length > 1) {\n            var findType = function (type) {\n                return find(momentTypes, function (momentType) {\n                    return momentType.type === type;\n                });\n            };\n\n            var bubbleTypes = function (bubble) {\n                var bubbleMomentType = findType(bubble.type);\n\n                if (!bubbleMomentType) {\n                    return;\n                }\n\n                each(bubble.targets, function (target) {\n                    var targetMomentType = findType(target.type);\n\n                    if (!targetMomentType) {\n                        return;\n                    }\n\n                    if (parseInt(bubbleMomentType.formattedValueEn, 10) === target.value) {\n                        bubbleMomentType.rawValue = 0;\n                        bubbleMomentType.wholeValue = 0;\n                        bubbleMomentType.decimalValue = 0;\n                        targetMomentType.rawValue += 1;\n                        targetMomentType.wholeValue += 1;\n                        targetMomentType.decimalValue = 0;\n                        targetMomentType.formattedValueEn = targetMomentType.wholeValue.toString();\n                        bubbled = true;\n                    }\n                });\n            };\n\n            each(bubbles, bubbleTypes);\n        }\n\n        // Recalculate formatted values.\n        if (bubbled) {\n            foundFirst = false;\n            significantDigits = significantDigitsCache;\n            momentTypes = map(momentTypes, formatValue);\n            momentTypes = compact(momentTypes);\n        }\n\n        if (outputTypes && !(isMaxValue && !settings.trim)) {\n            momentTypes = map(momentTypes, function (momentType) {\n                if (find(outputTypes, function (outputType) {\n                    return momentType.type === outputType;\n                })) {\n                    return momentType;\n                }\n\n                return null;\n            });\n\n            momentTypes = compact(momentTypes);\n        } else {\n            // Trim Large.\n            if (trimLarge) {\n                momentTypes = rest(momentTypes, function (momentType) {\n                    // Stop trimming on:\n                    // - the smallest moment type\n                    // - a type marked for stopTrim\n                    // - a type that has a whole value\n                    return !momentType.isSmallest && !momentType.wholeValue && !find(stopTrim, momentType.type);\n                });\n            }\n\n            // Largest.\n            if (largest && momentTypes.length) {\n                momentTypes = momentTypes.slice(0, largest);\n            }\n\n            // Trim Small.\n            if (trimSmall && momentTypes.length > 1) {\n                momentTypes = initial(momentTypes, function (momentType) {\n                    // Stop trimming on:\n                    // - a type marked for stopTrim\n                    // - a type that has a whole value\n                    // - the largest momentType\n                    return !momentType.wholeValue && !find(stopTrim, momentType.type) && !momentType.isLargest;\n                });\n            }\n\n            // Trim Mid.\n            if (trimMid) {\n                momentTypes = map(momentTypes, function (momentType, index) {\n                    if (index > 0 && index < momentTypes.length - 1 && !momentType.wholeValue) {\n                        return null;\n                    }\n\n                    return momentType;\n                });\n\n                momentTypes = compact(momentTypes);\n            }\n\n            // Trim Final.\n            if (trimFinal && momentTypes.length === 1 && !momentTypes[0].wholeValue && !(!trunc && momentTypes[0].isSmallest && momentTypes[0].rawValue < minValue)) {\n                momentTypes = [];\n            }\n        }\n\n        if (returnMomentTypes) {\n            return momentTypes;\n        }\n\n        // Localize and pluralize unit labels.\n        each(tokens, function (token) {\n            var key = momentTokens[token.type];\n\n            var momentType = find(momentTypes, function (momentType) {\n                return momentType.type === token.type;\n            });\n\n            if (!key || !momentType) {\n                return;\n            }\n\n            var values = momentType.formattedValueEn.split(\".\");\n\n            values[0] = parseInt(values[0], 10);\n\n            if (values[1]) {\n                values[1] = parseFloat(\"0.\" + values[1], 10);\n            } else {\n                values[1] = null;\n            }\n\n            var pluralKey = localeData.durationPluralKey(key, values[0], values[1]);\n\n            var labels = durationGetLabels(key, localeData);\n\n            var autoLocalized = false;\n\n            var pluralizedLabels = {};\n\n            // Auto-Localized unit labels.\n            each(localeData._durationLabelTypes, function (labelType) {\n                var label = find(labels, function (label) {\n                    return label.type === labelType.type && label.key === pluralKey;\n                });\n\n                if (label) {\n                    pluralizedLabels[label.type] = label.label;\n\n                    if (stringIncludes(token.text, labelType.string)) {\n                        token.text = token.text.replace(labelType.string, label.label);\n                        autoLocalized = true;\n                    }\n                }\n            });\n\n            // Auto-pluralized unit labels.\n            if (usePlural && !autoLocalized) {\n                labels.sort(durationLabelCompare);\n\n                each(labels, function (label) {\n                    if (pluralizedLabels[label.type] === label.label) {\n                        if (stringIncludes(token.text, label.label)) {\n                            // Stop checking this token if its label is already\n                            // correctly pluralized.\n                            return false;\n                        }\n\n                        // Skip this label if it is correct, but not present in\n                        // the token's text.\n                        return;\n                    }\n\n                    if (stringIncludes(token.text, label.label)) {\n                        // Replece this token's label and stop checking.\n                        token.text = token.text.replace(label.label, pluralizedLabels[label.type]);\n                        return false;\n                    }\n                });\n            }\n        });\n\n        // Build ouptut.\n        tokens = map(tokens, function (token) {\n            if (!token.type) {\n                return token.text;\n            }\n\n            var momentType = find(momentTypes, function (momentType) {\n                return momentType.type === token.type;\n            });\n\n            if (!momentType) {\n                return \"\";\n            }\n\n            var out = \"\";\n\n            if (useLeftUnits) {\n                out += token.text;\n            }\n\n            if (isNegative && isMaxValue || !isNegative && isMinValue) {\n                out += \"< \";\n                isMaxValue = false;\n                isMinValue = false;\n            }\n\n            if (isNegative && isMinValue || !isNegative && isMaxValue) {\n                out += \"> \";\n                isMaxValue = false;\n                isMinValue = false;\n            }\n\n            if (isNegative && (momentType.value > 0 || trim === \"\" || find(stopTrim, momentType.type) || find(outputTypes, momentType.type))) {\n                out += \"-\";\n                isNegative = false;\n            }\n\n            if (token.type === \"milliseconds\" && momentType.formattedValueMS) {\n                out += momentType.formattedValueMS;\n            } else {\n                out += momentType.formattedValue;\n            }\n\n            if (!useLeftUnits) {\n                out += token.text;\n            }\n\n            return out;\n        });\n\n        // Trim leading and trailing comma, space, colon, and dot.\n        return tokens.join(\"\").replace(/(,| |:|\\.)*$/, \"\").replace(/^(,| |:|\\.)*/, \"\");\n    }\n\n    // defaultFormatTemplate\n    function defaultFormatTemplate() {\n        var dur = this.duration;\n\n        var findType = function findType(type) {\n            return dur._data[type];\n        };\n\n        var firstType = find(this.types, findType);\n\n        var lastType = findLast(this.types, findType);\n\n        // Default template strings for each duration dimension type.\n        switch (firstType) {\n            case \"milliseconds\":\n                return \"S __\";\n            case \"seconds\": // Fallthrough.\n            case \"minutes\":\n                return \"*_MS_\";\n            case \"hours\":\n                return \"_HMS_\";\n            case \"days\": // Possible Fallthrough.\n                if (firstType === lastType) {\n                    return \"d __\";\n                }\n            case \"weeks\":\n                if (firstType === lastType) {\n                    return \"w __\";\n                }\n\n                if (this.trim === null) {\n                    this.trim = \"both\";\n                }\n\n                return \"w __, d __, h __\";\n            case \"months\": // Possible Fallthrough.\n                if (firstType === lastType) {\n                    return \"M __\";\n                }\n            case \"years\":\n                if (firstType === lastType) {\n                    return \"y __\";\n                }\n\n                if (this.trim === null) {\n                    this.trim = \"both\";\n                }\n\n                return \"y __, M __, d __\";\n            default:\n                if (this.trim === null) {\n                    this.trim = \"both\";\n                }\n\n                return \"y __, d __, h __, m __, s __\";\n        }\n    }\n\n    // init\n    function init(context) {\n        if (!context) {\n            throw \"Moment Duration Format init cannot find moment instance.\";\n        }\n\n        context.duration.format = durationsFormat;\n        context.duration.fn.format = durationFormat;\n\n        context.duration.fn.format.defaults = {\n            // Many options are defaulted to `null` to distinguish between\n            // 'not set' and 'set to `false`'\n\n            // trim\n            // Can be a string, a delimited list of strings, an array of strings,\n            // or a boolean.\n            // \"large\" - will trim largest-magnitude zero-value tokens until\n            // finding a token with a value, a token identified as 'stopTrim', or\n            // the final token of the format string.\n            // \"small\" - will trim smallest-magnitude zero-value tokens until\n            // finding a token with a value, a token identified as 'stopTrim', or\n            // the final token of the format string.\n            // \"both\" - will execute \"large\" trim then \"small\" trim.\n            // \"mid\" - will trim any zero-value tokens that are not the first or\n            // last tokens. Usually used in conjunction with \"large\" or \"both\".\n            // e.g. \"large mid\" or \"both mid\".\n            // \"final\" - will trim the final token if it is zero-value. Use this\n            // option with \"large\" or \"both\" to output an empty string when\n            // formatting a zero-value duration. e.g. \"large final\" or \"both final\".\n            // \"all\" - Will trim all zero-value tokens. Shorthand for \"both mid final\".\n            // \"left\" - maps to \"large\" to support plugin's version 1 API.\n            // \"right\" - maps to \"large\" to support plugin's version 1 API.\n            // `false` - template tokens are not trimmed.\n            // `true` - treated as \"large\".\n            // `null` - treated as \"large\".\n            trim: null,\n\n            // stopTrim\n            // A moment token string, a delimited set of moment token strings,\n            // or an array of moment token strings. Trimming will stop when a token\n            // listed in this option is reached. A \"*\" character in the format\n            // template string will also mark a moment token as stopTrim.\n            // e.g. \"d [days] *h:mm:ss\" will always stop trimming at the 'hours' token.\n            stopTrim: null,\n\n            // largest\n            // Set to a positive integer to output only the \"n\" largest-magnitude\n            // moment tokens that have a value. All lesser-magnitude moment tokens\n            // will be ignored. This option takes effect even if `trim` is set\n            // to `false`.\n            largest: null,\n\n            // maxValue\n            // Use `maxValue` to render generalized output for large duration values,\n            // e.g. `\"> 60 days\"`. `maxValue` must be a positive integer and is\n            /// applied to the greatest-magnitude moment token in the format template.\n            maxValue: null,\n\n            // minValue\n            // Use `minValue` to render generalized output for small duration values,\n            // e.g. `\"< 5 minutes\"`. `minValue` must be a positive integer and is\n            // applied to the least-magnitude moment token in the format template.\n            minValue: null,\n\n            // precision\n            // If a positive integer, number of decimal fraction digits to render.\n            // If a negative integer, number of integer place digits to truncate to 0.\n            // If `useSignificantDigits` is set to `true` and `precision` is a positive\n            // integer, sets the maximum number of significant digits used in the\n            // formatted output.\n            precision: 0,\n\n            // trunc\n            // Default behavior rounds final token value. Set to `true` to\n            // truncate final token value, which was the default behavior in\n            // version 1 of this plugin.\n            trunc: false,\n\n            // forceLength\n            // Force first moment token with a value to render at full length\n            // even when template is trimmed and first moment token has length of 1.\n            forceLength: null,\n\n            // userLocale\n            // Formatted numerical output is rendered using `toLocaleString`\n            // and the locale of the user's environment. Set this option to render\n            // numerical output using a different locale. Unit names are rendered\n            // and detected using the locale set in moment.js, which can be different\n            // from the locale of user's environment.\n            userLocale: null,\n\n            // usePlural\n            // Will automatically singularize or pluralize unit names when they\n            // appear in the text associated with each moment token. Standard and\n            // short unit labels are singularized and pluralized, based on locale.\n            // e.g. in english, \"1 second\" or \"1 sec\" would be rendered instead\n            // of \"1 seconds\" or \"1 secs\". The default pluralization function\n            // renders a plural label for a value with decimal precision.\n            // e.g. \"1.0 seconds\" is never rendered as \"1.0 second\".\n            // Label types and pluralization function are configurable in the\n            // localeData extensions.\n            usePlural: true,\n\n            // useLeftUnits\n            // The text to the right of each moment token in a format string\n            // is treated as that token's units for the purposes of trimming,\n            // singularizing, and auto-localizing.\n            // e.g. \"h [hours], m [minutes], s [seconds]\".\n            // To properly singularize or localize a format string such as\n            // \"[hours] h, [minutes] m, [seconds] s\", where the units appear\n            // to the left of each moment token, set useLeftUnits to `true`.\n            // This plugin is not tested in the context of rtl text.\n            useLeftUnits: false,\n\n            // useGrouping\n            // Enables locale-based digit grouping in the formatted output. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\n            useGrouping: true,\n\n            // useSignificantDigits\n            // Treat the `precision` option as the maximum significant digits\n            // to be rendered. Precision must be a positive integer. Significant\n            // digits extend across unit types,\n            // e.g. \"6 hours 37.5 minutes\" represents 4 significant digits.\n            // Enabling this option causes token length to be ignored. See  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\n            useSignificantDigits: false,\n\n            // template\n            // The template string used to format the duration. May be a function\n            // or a string. Template functions are executed with the `this` binding\n            // of the settings object so that template strings may be dynamically\n            // generated based on the duration object (accessible via `this.duration`)\n            // or any of the other settings. Leading and trailing space, comma,\n            // period, and colon characters are trimmed from the resulting string.\n            template: defaultFormatTemplate,\n\n            // useToLocaleString\n            // Set this option to `false` to ignore the `toLocaleString` feature\n            // test and force the use of the `formatNumber` fallback function\n            // included in this plugin.\n            useToLocaleString: true,\n\n            // formatNumber fallback options.\n            // When `toLocaleString` is detected and passes the feature test, the\n            // following options will have no effect: `toLocaleString` will be used\n            // for formatting and the grouping separator, decimal separator, and\n            // integer digit grouping will be determined by the user locale.\n\n            // groupingSeparator\n            // The integer digit grouping separator used when using the fallback\n            // formatNumber function.\n            groupingSeparator: \",\",\n\n            // decimalSeparator\n            // The decimal separator used when using the fallback formatNumber\n            // function.\n            decimalSeparator: \".\",\n\n            // grouping\n            // The integer digit grouping used when using the fallback formatNumber\n            // function. Must be an array. The default value of `[3]` gives the\n            // standard 3-digit thousand/million/billion digit groupings for the\n            // \"en\" locale. Setting this option to `[3, 2]` would generate the\n            // thousand/lakh/crore digit groupings used in the \"en-IN\" locale.\n            grouping: [3]\n        };\n\n        context.updateLocale('en', engLocale);\n    }\n\n    // Run feature tests for `Number#toLocaleString`.\n    var toLocaleStringFormatter = function(number, locale, options) {\n        return number.toLocaleString(locale, options);\n    };\n\n    toLocaleStringWorks = toLocaleStringSupportsLocales() && featureTestFormatter(toLocaleStringFormatter);\n    toLocaleStringRoundingWorks = toLocaleStringWorks && featureTestFormatterRounding(toLocaleStringFormatter);\n\n    // Run feature tests for `Intl.NumberFormat#format`.\n    var intlNumberFormatFormatter = function(number, locale, options) {\n        if (typeof window !== 'undefined' && window && window.Intl && window.Intl.NumberFormat) {\n            return window.Intl.NumberFormat(locale, options).format(number);\n        }\n    };\n\n    intlNumberFormatWorks = featureTestFormatter(intlNumberFormatFormatter);\n    intlNumberFormatRoundingWorks = intlNumberFormatWorks && featureTestFormatterRounding(intlNumberFormatFormatter);\n\n    // Initialize duration format on the global moment instance.\n    init(moment);\n\n    // Return the init function so that duration format can be\n    // initialized on other moment instances.\n    return init;\n});\n"],"names":["root","factory","this","moment","toLocaleStringWorks","toLocaleStringRoundingWorks","intlNumberFormatWorks","intlNumberFormatRoundingWorks","types","split","bubbles","type","targets","value","stringIncludes","str","search","length","indexOf","repeatZero","qty","result","cachedNumberFormat","locale","options","cacheKey","map","keys","sort","key","join","cache","Intl","NumberFormat","formatNumber","number","userLocale","integerString","fractionString","exponentString","useToLocaleString","useGrouping","grouping","slice","maximumSignificantDigits","minimumIntegerDigits","fractionDigits","groupingSeparator","decimalSeparator","roundingOptions","localeStringOptions","maximumFractionDigits","minimumFractionDigits","extend","parseFloat","format","toLocaleString","temp","toPrecision","toFixed","integerLength","fractionLength","digitCount","digits","digitsArray","reverse","i","carry","parseInt","toString","push","stringRound","replace","exponent","Math","abs","group","formattedString","shift","durationLabelCompare","a","b","label","engLocale","durationLabelsStandard","S","SS","s","ss","m","mm","h","hh","d","dd","w","ww","M","MM","y","yy","durationLabelsShort","durationTimeTemplates","HMS","HM","MS","durationLabelTypes","string","durationPluralKey","token","integerValue","decimalValue","isArray","array","Object","prototype","call","isObject","obj","find","callback","match","index","max","item","each","ret","pluck","prop","compact","unique","_a","intersection","_b","rest","hasOwnProperty","any","featureTestFormatterRounding","formatter","featureTestFormatter","passed","durationsFormat","durations","args","arguments","settings","arg","precision","template","returnMomentTypes","formattedDurations","dur","outputTypes","child","concat","largest","durationFormat","defaults","asMilliseconds","asMonths","isValid","isNegative","remainder","duration","remainderMonths","momentTokens","years","months","weeks","days","hours","minutes","seconds","milliseconds","tokenDefs","escape","general","typeMap","test","tokenizer","RegExp","source","apply","stopTrim","localeData","_durationTimeTemplates","useLeftUnits","usePlural","forceLength","trunc","useSignificantDigits","significantDigits","significantDigitsCache","minValue","isMinValue","maxValue","isMaxValue","trim","trimIncludes","rBoth","rAll","trimLarge","trimSmall","trimMid","trimFinal","rawTokens","text","currentToken","tokens","momentTypes","momentType","rawValue","isSmallest","isLargest","as","wholeValue","floor","subtract","tokenLength","truncMethod","round","truncate","places","factor","pow","foundFirst","bubbled","formatValue","formatOptions","formattedValue","formattedValueEn","formattedValueMS","findType","bubble","bubbleMomentType","target","targetMomentType","outputType","values","pluralKey","labels","localeDataKey","labelType","toLowerCase","labelKey","durationGetLabels","autoLocalized","pluralizedLabels","_durationLabelTypes","out","defaultFormatTemplate","_data","firstType","lastType","findLast","init","context","fn","updateLocale","toLocaleStringFormatter","e","name","toLocaleStringSupportsLocales","intlNumberFormatFormatter","window","momentDurationFormatSetup"],"sourceRoot":""}