{"version":3,"names":["loader","define","requireModule","require","requirejs","global","dict","obj","Object","create","undefined","oldGlobals","id","pending","mod","findModule","i","length","exports","module","noConflict","aliases","oldName","newName","hasOwnProperty","makeDefaultExport","registry","uuid","defaultDeps","Module","deps","callback","alias","this","hasExportsAsDep","isAlias","reified","Array","state","noop","Alias","referrer","Error","missingModule","findDeps","push","resolve","child","charAt","parts","split","parentBase","slice","l","part","pop","join","has","prototype","isExtensible","wrapModules","reify","result","apply","unsee","_reify","dep","entry","makeRequire","r","moduleId","arguments","unsupportedModule","isArray","name","defaultExport","target","entries","_eak_seen","clear","root","factory","amd","e","momentDurationFormatSetup","moment","toLocaleStringWorks","toLocaleStringRoundingWorks","intlNumberFormatWorks","intlNumberFormatRoundingWorks","types","bubbles","type","targets","value","stringIncludes","str","search","indexOf","repeatZero","qty","cachedNumberFormat","locale","options","cacheKey","map","keys","sort","key","cache","Intl","NumberFormat","formatNumber","number","userLocale","integerString","fractionString","exponentString","useToLocaleString","useGrouping","grouping","maximumSignificantDigits","minimumIntegerDigits","fractionDigits","groupingSeparator","decimalSeparator","localeStringOptions","maximumFractionDigits","minimumFractionDigits","roundingOptions","extend","parseFloat","format","toLocaleString","temp","toPrecision","toFixed","integerLength","fractionLength","digitCount","digits","digitsArray","reverse","carry","parseInt","toString","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","array","call","isObject","find","match","index","max","item","each","ret","pluck","prop","compact","unique","_a","intersection","_b","rest","any","featureTestFormatterRounding","formatter","featureTestFormatter","passed","durationsFormat","durations","args","settings","arg","precision","template","returnMomentTypes","formattedDurations","dur","outputTypes","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","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","targetMomentType","outputType","values","pluralKey","labels","localeDataKey","labelType","toLowerCase","labelKey","durationGetLabels","autoLocalized","pluralizedLabels","_durationLabelTypes","out","defaultFormatTemplate","_data","firstType","lastType","findLast","init","context","fn","updateLocale","toLocaleStringFormatter","toLocaleStringSupportsLocales","intlNumberFormatFormatter","window"],"sources":["../rewritten-packages/@embroider/synthesized-vendor/vendor/loader/loader.js","../../moment-duration-format/lib/moment-duration-format.js"],"sourcesContent":["var loader, define, requireModule, require, requirejs;\n\n(function (global) {\n  'use strict';\n\n  function dict() {\n    var obj = Object.create(null);\n    obj['__'] = undefined;\n    delete obj['__'];\n    return obj;\n  }\n\n  // Save off the original values of these globals, so we can restore them if someone asks us to\n  var oldGlobals = {\n    loader: loader,\n    define: define,\n    requireModule: requireModule,\n    require: require,\n    requirejs: requirejs\n  };\n\n  requirejs = require = requireModule = function (id) {\n    var pending = [];\n    var mod = findModule(id, '(require)', pending);\n\n    for (var i = pending.length - 1; i >= 0; i--) {\n      pending[i].exports();\n    }\n\n    return mod.module.exports;\n  };\n\n  loader = {\n    noConflict: function (aliases) {\n      var oldName, newName;\n\n      for (oldName in aliases) {\n        if (aliases.hasOwnProperty(oldName)) {\n          if (oldGlobals.hasOwnProperty(oldName)) {\n            newName = aliases[oldName];\n\n            global[newName] = global[oldName];\n            global[oldName] = oldGlobals[oldName];\n          }\n        }\n      }\n    },\n    // Option to enable or disable the generation of default exports\n    makeDefaultExport: true\n  };\n\n  var registry = dict();\n  var seen = dict();\n\n  var uuid = 0;\n\n  function unsupportedModule(length) {\n    throw new Error('an unsupported module was defined, expected `define(id, deps, module)` instead got: `' + length + '` arguments to define`');\n  }\n\n  var defaultDeps = ['require', 'exports', 'module'];\n\n  function Module(id, deps, callback, alias) {\n    this.uuid = uuid++;\n    this.id = id;\n    this.deps = !deps.length && callback.length ? defaultDeps : deps;\n    this.module = { exports: {} };\n    this.callback = callback;\n    this.hasExportsAsDep = false;\n    this.isAlias = alias;\n    this.reified = new Array(deps.length);\n\n    /*\n       Each module normally passes through these states, in order:\n         new       : initial state\n         pending   : this module is scheduled to be executed\n         reifying  : this module's dependencies are being executed\n         reified   : this module's dependencies finished executing successfully\n         errored   : this module's dependencies failed to execute\n         finalized : this module executed successfully\n     */\n    this.state = 'new';\n  }\n\n  Module.prototype.makeDefaultExport = function () {\n    var exports = this.module.exports;\n    if (exports !== null && (typeof exports === 'object' || typeof exports === 'function') && exports['default'] === undefined && Object.isExtensible(exports)) {\n      exports['default'] = exports;\n    }\n  };\n\n  Module.prototype.exports = function () {\n    // if finalized, there is no work to do. If reifying, there is a\n    // circular dependency so we must return our (partial) exports.\n    if (this.state === 'finalized' || this.state === 'reifying') {\n      return this.module.exports;\n    }\n\n\n    if (loader.wrapModules) {\n      this.callback = loader.wrapModules(this.id, this.callback);\n    }\n\n    this.reify();\n\n    var result = this.callback.apply(this, this.reified);\n    this.reified.length = 0;\n    this.state = 'finalized';\n\n    if (!(this.hasExportsAsDep && result === undefined)) {\n      this.module.exports = result;\n    }\n    if (loader.makeDefaultExport) {\n      this.makeDefaultExport();\n    }\n    return this.module.exports;\n  };\n\n  Module.prototype.unsee = function () {\n    this.state = 'new';\n    this.module = { exports: {} };\n  };\n\n  Module.prototype.reify = function () {\n    if (this.state === 'reified') {\n      return;\n    }\n    this.state = 'reifying';\n    try {\n      this.reified = this._reify();\n      this.state = 'reified';\n    } finally {\n      if (this.state === 'reifying') {\n        this.state = 'errored';\n      }\n    }\n  };\n\n  Module.prototype._reify = function () {\n    var reified = this.reified.slice();\n    for (var i = 0; i < reified.length; i++) {\n      var mod = reified[i];\n      reified[i] = mod.exports ? mod.exports : mod.module.exports();\n    }\n    return reified;\n  };\n\n  Module.prototype.findDeps = function (pending) {\n    if (this.state !== 'new') {\n      return;\n    }\n\n    this.state = 'pending';\n\n    var deps = this.deps;\n\n    for (var i = 0; i < deps.length; i++) {\n      var dep = deps[i];\n      var entry = this.reified[i] = { exports: undefined, module: undefined };\n      if (dep === 'exports') {\n        this.hasExportsAsDep = true;\n        entry.exports = this.module.exports;\n      } else if (dep === 'require') {\n        entry.exports = this.makeRequire();\n      } else if (dep === 'module') {\n        entry.exports = this.module;\n      } else {\n        entry.module = findModule(resolve(dep, this.id), this.id, pending);\n      }\n    }\n  };\n\n  Module.prototype.makeRequire = function () {\n    var id = this.id;\n    var r = function (dep) {\n      return require(resolve(dep, id));\n    };\n    r['default'] = r;\n    r.moduleId = id;\n    r.has = function (dep) {\n      return has(resolve(dep, id));\n    };\n    return r;\n  };\n\n  define = function (id, deps, callback) {\n    var module = registry[id];\n\n    // If a module for this id has already been defined and is in any state\n    // other than `new` (meaning it has been or is currently being required),\n    // then we return early to avoid redefinition.\n    if (module && module.state !== 'new') {\n      return;\n    }\n\n    if (arguments.length < 2) {\n      unsupportedModule(arguments.length);\n    }\n\n    if (!Array.isArray(deps)) {\n      callback = deps;\n      deps = [];\n    }\n\n    if (callback instanceof Alias) {\n      registry[id] = new Module(callback.id, deps, callback, true);\n    } else {\n      registry[id] = new Module(id, deps, callback, false);\n    }\n  };\n\n  define.exports = function (name, defaultExport) {\n    var module = registry[name];\n\n    // If a module for this name has already been defined and is in any state\n    // other than `new` (meaning it has been or is currently being required),\n    // then we return early to avoid redefinition.\n    if (module && module.state !== 'new') {\n      return;\n    }\n\n    module = new Module(name, [], noop, null);\n    module.module.exports = defaultExport;\n    module.state = 'finalized';\n    registry[name] = module;\n\n    return module;\n  };\n\n  function noop() {}\n  // we don't support all of AMD\n  // define.amd = {};\n\n  function Alias(id) {\n    this.id = id;\n  }\n\n  define.alias = function (id, target) {\n    if (arguments.length === 2) {\n      return define(target, new Alias(id));\n    }\n\n    return new Alias(id);\n  };\n\n  function missingModule(id, referrer) {\n    throw new Error('Could not find module `' + id + '` imported from `' + referrer + '`');\n  }\n\n  function findModule(id, referrer, pending) {\n    var mod = registry[id] || registry[id + '/index'];\n\n    while (mod && mod.isAlias) {\n      mod = registry[mod.id] || registry[mod.id + '/index'];\n    }\n\n    if (!mod) {\n      missingModule(id, referrer);\n    }\n\n    if (pending && mod.state !== 'pending' && mod.state !== 'finalized') {\n      mod.findDeps(pending);\n      pending.push(mod);\n    }\n    return mod;\n  }\n\n  function resolve(child, id) {\n    if (child.charAt(0) !== '.') {\n      return child;\n    }\n\n\n    var parts = child.split('/');\n    var nameParts = id.split('/');\n    var parentBase = nameParts.slice(0, -1);\n\n    for (var i = 0, l = parts.length; i < l; i++) {\n      var part = parts[i];\n\n      if (part === '..') {\n        if (parentBase.length === 0) {\n          throw new Error('Cannot access parent module of root');\n        }\n        parentBase.pop();\n      } else if (part === '.') {\n        continue;\n      } else {\n        parentBase.push(part);\n      }\n    }\n\n    return parentBase.join('/');\n  }\n\n  function has(id) {\n    return !!(registry[id] || registry[id + '/index']);\n  }\n\n  requirejs.entries = requirejs._eak_seen = registry;\n  requirejs.has = has;\n  requirejs.unsee = function (id) {\n    findModule(id, '(unsee)', false).unsee();\n  };\n\n  requirejs.clear = function () {\n    requirejs.entries = requirejs._eak_seen = registry = dict();\n    seen = dict();\n  };\n\n  // This code primes the JS engine for good performance by warming the\n  // JIT compiler for these functions.\n  define('foo', function () {});\n  define('foo/bar', [], function () {});\n  define('foo/asdf', ['module', 'exports', 'require'], function (module, exports, require) {\n    if (require.has('foo/bar')) {\n      require('foo/bar');\n    }\n  });\n  define('foo/baz', [], define.alias('foo'));\n  define('foo/quz', define.alias('foo'));\n  define.alias('foo', 'foo/qux');\n  define('foo/bar', ['foo', './quz', './baz', './asdf', './bar', '../foo'], function () {});\n  define('foo/main', ['foo/bar'], function () {});\n  define.exports('foo/exports', {});\n\n  require('foo/exports');\n  require('foo/main');\n  require.unsee('foo/bar');\n\n  requirejs.clear();\n\n  if (typeof exports === 'object' && typeof module === 'object' && module.exports) {\n    module.exports = { require: require, define: define };\n  }\n})(this);","/*! 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"],"mappings":"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","ignoreList":[]}