{"version":3,"sources":["../../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/toConsumableArray.js","../../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","../../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/iterableToArray.js","../../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/nonIterableSpread.js","../../../node_modules/moment-duration-format/lib/moment-duration-format.js"],"names":["arrayWithoutHoles","__webpack_require__","iterableToArray","nonIterableSpread","module","exports","arr","Array","isArray","i","arr2","length","iter","Symbol","iterator","Object","prototype","toString","call","from","TypeError","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","root","factory","this","moment","toLocaleStringWorks","toLocaleStringRoundingWorks","intlNumberFormatWorks","intlNumberFormatRoundingWorks","types","split","bubbles","type","targets","value","stringIncludes","str","search","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","localeStringOptions","maximumFractionDigits","minimumFractionDigits","roundingOptions","extend","parseFloat","format","toLocaleString","temp","toPrecision","toFixed","integerLength","fractionLength","digitCount","digits","digitsArray","reverse","carry","parseInt","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","array","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","flatten","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","undefined","momentDurationFormatSetup"],"mappings":"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","file":"static/js/7.2fb85203.chunk.js","sourcesContent":["var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nmodule.exports = _nonIterableSpread;","/*! 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(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; // `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\n  var toLocaleStringRoundingWorks = false; // `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\n  var intlNumberFormatWorks = false; // `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\n  var intlNumberFormatRoundingWorks = false; // Token type names in order of descending magnitude.\n\n  var types = \"escape years months weeks days hours minutes seconds milliseconds general\".split(\" \");\n  var bubbles = [{\n    type: \"seconds\",\n    targets: [{\n      type: \"minutes\",\n      value: 60\n    }, {\n      type: \"hours\",\n      value: 3600\n    }, {\n      type: \"days\",\n      value: 86400\n    }, {\n      type: \"weeks\",\n      value: 604800\n    }, {\n      type: \"months\",\n      value: 2678400\n    }, {\n      type: \"years\",\n      value: 31536000\n    }]\n  }, {\n    type: \"minutes\",\n    targets: [{\n      type: \"hours\",\n      value: 60\n    }, {\n      type: \"days\",\n      value: 1440\n    }, {\n      type: \"weeks\",\n      value: 10080\n    }, {\n      type: \"months\",\n      value: 44640\n    }, {\n      type: \"years\",\n      value: 525600\n    }]\n  }, {\n    type: \"hours\",\n    targets: [{\n      type: \"days\",\n      value: 24\n    }, {\n      type: \"weeks\",\n      value: 168\n    }, {\n      type: \"months\",\n      value: 744\n    }, {\n      type: \"years\",\n      value: 8760\n    }]\n  }, {\n    type: \"days\",\n    targets: [{\n      type: \"weeks\",\n      value: 7\n    }, {\n      type: \"months\",\n      value: 31\n    }, {\n      type: \"years\",\n      value: 365\n    }]\n  }, {\n    type: \"months\",\n    targets: [{\n      type: \"years\",\n      value: 12\n    }]\n  }]; // stringIncludes\n\n  function stringIncludes(str, search) {\n    if (search.length > str.length) {\n      return false;\n    }\n\n    return str.indexOf(search) !== -1;\n  } // repeatZero(qty)\n  // Returns \"0\" repeated `qty` times.\n  // `qty` must be a integer >= 0.\n\n\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  } // 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\n\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(keys(options).sort(), function (key) {\n      return key + ':' + options[key];\n    }).join(','); // Set our cache key\n\n    var cacheKey = locale + '+' + optionsString; // If we don't have this configuration cached, configure and cache it\n\n    if (!cachedNumberFormat.cache[cacheKey]) {\n      cachedNumberFormat.cache[cacheKey] = Intl.NumberFormat(locale, options);\n    } // Return the cached version of this configuration\n\n\n    return cachedNumberFormat.cache[cacheKey];\n  }\n\n  cachedNumberFormat.cache = {}; // 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\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      } // toLocaleString output is \"0.0\" instead of \"0\" for HTC browsers\n      // when maximumSignificantDigits is set. See #96.\n\n\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; // Add 1 to digit output length for floating point errors workaround. See below.\n\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    var temp = numberString.split(\"e\");\n    exponentString = temp[1] || \"\";\n    temp = temp[0].split(\".\");\n    fractionString = temp[1] || \"\";\n    integerString = temp[0] || \"\"; // 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    // *************** Implement String Rounding here ***********************\n    // Check integerString + fractionString length of toPrecision before rounding.\n    // Check length of fractionString from toFixed output before rounding.\n\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      } // Discard final fractionDigit.\n\n\n      if (fractionLength) {\n        digits = digits.slice(0, -1);\n      } // Separate integer and fraction.\n\n\n      integerString = digits.slice(0, integerLength);\n      fractionString = digits.slice(integerLength);\n    } // Trim trailing zeroes from fractionString because toPrecision outputs\n    // precision, not significant digits.\n\n\n    if (maximumSignificantDigits) {\n      fractionString = fractionString.replace(/0*$/, \"\");\n    } // Handle exponent.\n\n\n    var exponent = parseInt(exponentString, 10);\n\n    if (exponent > 0) {\n      if (fractionString.length <= exponent) {\n        fractionString = fractionString + repeatZero(exponent - fractionString.length);\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      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      } // Pad integer when using minimumIntegerDigits\n      // and not using maximumSignificantDigits.\n\n\n      if (integerString.length < minimumIntegerDigits) {\n        integerString = repeatZero(minimumIntegerDigits - integerString.length) + integerString;\n      }\n    }\n\n    var formattedString = \"\"; // Handle grouping.\n\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        temp = temp.slice(0, -group);\n      }\n    } else {\n      formattedString = integerString;\n    } // Add decimalSeparator and fraction.\n\n\n    if (fractionString) {\n      formattedString = formattedString + decimalSeparator + fractionString;\n    }\n\n    return formattedString;\n  } // durationLabelCompare\n\n\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    } // a must be equal to b\n\n\n    return 0;\n  } // durationGetLabels\n\n\n  function durationGetLabels(token, localeData) {\n    var labels = [];\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      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    return labels;\n  } // durationPluralKey\n\n\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\",\n      string: \"__\"\n    }, {\n      type: \"short\",\n      string: \"_\"\n    }],\n    durationPluralKey: durationPluralKey\n  }; // isArray\n\n  function isArray(array) {\n    return Object.prototype.toString.call(array) === \"[object Array]\";\n  } // isObject\n\n\n  function isObject(obj) {\n    return Object.prototype.toString.call(obj) === \"[object Object]\";\n  } // findLast\n\n\n  function findLast(array, callback) {\n    var index = array.length;\n\n    while (index -= 1) {\n      if (callback(array[index])) {\n        return array[index];\n      }\n    }\n  } // find\n\n\n  function find(array, callback) {\n    var index = 0;\n    var max = array && array.length || 0;\n    var match;\n\n    if (typeof callback !== \"function\") {\n      match = callback;\n\n      callback = function callback(item) {\n        return item === match;\n      };\n    }\n\n    while (index < max) {\n      if (callback(array[index])) {\n        return array[index];\n      }\n\n      index += 1;\n    }\n  } // each\n\n\n  function each(array, callback) {\n    var index = 0,\n        max = array.length;\n\n    if (!array || !max) {\n      return;\n    }\n\n    while (index < max) {\n      if (callback(array[index], index) === false) {\n        return;\n      }\n\n      index += 1;\n    }\n  } // map\n\n\n  function map(array, callback) {\n    var index = 0,\n        max = array.length,\n        ret = [];\n\n    if (!array || !max) {\n      return ret;\n    }\n\n    while (index < max) {\n      ret[index] = callback(array[index], index);\n      index += 1;\n    }\n\n    return ret;\n  } // pluck\n\n\n  function pluck(array, prop) {\n    return map(array, function (item) {\n      return item[prop];\n    });\n  } // compact\n\n\n  function compact(array) {\n    var ret = [];\n    each(array, function (item) {\n      if (item) {\n        ret.push(item);\n      }\n    });\n    return ret;\n  } // unique\n\n\n  function unique(array) {\n    var ret = [];\n    each(array, function (_a) {\n      if (!find(ret, _a)) {\n        ret.push(_a);\n      }\n    });\n    return ret;\n  } // intersection\n\n\n  function intersection(a, b) {\n    var ret = [];\n    each(a, function (_a) {\n      each(b, function (_b) {\n        if (_a === _b) {\n          ret.push(_a);\n        }\n      });\n    });\n    return unique(ret);\n  } // rest\n\n\n  function rest(array, callback) {\n    var ret = [];\n    each(array, function (item, index) {\n      if (!callback(item)) {\n        ret = array.slice(index);\n        return false;\n      }\n    });\n    return ret;\n  } // initial\n\n\n  function initial(array, callback) {\n    var reversed = array.slice().reverse();\n    return rest(reversed, callback).reverse();\n  } // extend\n\n\n  function extend(a, b) {\n    for (var key in b) {\n      if (b.hasOwnProperty(key)) {\n        a[key] = b[key];\n      }\n    }\n\n    return a;\n  } // keys\n\n\n  function keys(a) {\n    var ret = [];\n\n    for (var key in a) {\n      if (a.hasOwnProperty(key)) {\n        ret.push(key);\n      }\n    }\n\n    return ret;\n  } // any\n\n\n  function any(array, callback) {\n    var index = 0,\n        max = array.length;\n\n    if (!array || !max) {\n      return false;\n    }\n\n    while (index < max) {\n      if (callback(array[index], index) === true) {\n        return true;\n      }\n\n      index += 1;\n    }\n\n    return false;\n  } // flatten\n\n\n  function flatten(array) {\n    var ret = [];\n    each(array, function (child) {\n      ret = ret.concat(child);\n    });\n    return ret;\n  }\n\n  function toLocaleStringSupportsLocales() {\n    var number = 0;\n\n    try {\n      number.toLocaleString('i');\n    } catch (e) {\n      return e.name === 'RangeError';\n    }\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; // Test minimumIntegerDigits.\n\n    passed = passed && formatter(1, \"en\", {\n      minimumIntegerDigits: 1\n    }) === \"1\";\n    passed = passed && formatter(1, \"en\", {\n      minimumIntegerDigits: 2\n    }) === \"01\";\n    passed = passed && formatter(1, \"en\", {\n      minimumIntegerDigits: 3\n    }) === \"001\";\n\n    if (!passed) {\n      return false;\n    } // Test maximumFractionDigits and minimumFractionDigits.\n\n\n    passed = passed && formatter(99.99, \"en\", {\n      maximumFractionDigits: 0,\n      minimumFractionDigits: 0\n    }) === \"100\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumFractionDigits: 1,\n      minimumFractionDigits: 1\n    }) === \"100.0\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumFractionDigits: 2,\n      minimumFractionDigits: 2\n    }) === \"99.99\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumFractionDigits: 3,\n      minimumFractionDigits: 3\n    }) === \"99.990\";\n\n    if (!passed) {\n      return false;\n    } // Test maximumSignificantDigits.\n\n\n    passed = passed && formatter(99.99, \"en\", {\n      maximumSignificantDigits: 1\n    }) === \"100\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumSignificantDigits: 2\n    }) === \"100\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumSignificantDigits: 3\n    }) === \"100\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumSignificantDigits: 4\n    }) === \"99.99\";\n    passed = passed && formatter(99.99, \"en\", {\n      maximumSignificantDigits: 5\n    }) === \"99.99\";\n\n    if (!passed) {\n      return false;\n    } // Test grouping.\n\n\n    passed = passed && formatter(1000, \"en\", {\n      useGrouping: true\n    }) === \"1,000\";\n    passed = passed && formatter(1000, \"en\", {\n      useGrouping: false\n    }) === \"1000\";\n\n    if (!passed) {\n      return false;\n    }\n\n    return true;\n  } // durationsFormat(durations [, template] [, precision] [, settings])\n\n\n  function durationsFormat() {\n    var args = [].slice.call(arguments);\n    var settings = {};\n    var durations; // Parse arguments.\n\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    var formattedDurations = map(durations, function (dur) {\n      return dur.format(settings);\n    }); // Merge token types from all durations.\n\n    var outputTypes = intersection(types, unique(pluck(flatten(formattedDurations), \"type\")));\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    return map(durations, function (dur) {\n      return dur.format(settings);\n    });\n  } // durationFormat([template] [, precision] [, settings])\n\n\n  function durationFormat() {\n    var args = [].slice.call(arguments);\n    var settings = extend({}, this.format.defaults); // 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\n    var asMilliseconds = this.asMilliseconds();\n    var asMonths = this.asMonths(); // Treat invalid durations as having a value of 0 milliseconds.\n\n    if (typeof this.isValid === \"function\" && this.isValid() === false) {\n      asMilliseconds = 0;\n      asMonths = 0;\n    }\n\n    var isNegative = asMilliseconds < 0; // 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\n    var remainder = moment.duration(Math.abs(asMilliseconds), \"milliseconds\");\n    var remainderMonths = moment.duration(Math.abs(asMonths), \"months\"); // Parse arguments.\n\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    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    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    }; // Types array is available in the template function.\n\n    settings.types = types;\n\n    var typeMap = function typeMap(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\"); // Current duration object is available in the template function.\n\n    settings.duration = this; // Eval template function and cache template string.\n\n    var template = typeof settings.template === \"function\" ? settings.template.apply(settings) : settings.template; // outputTypes and returnMomentTypes are settings to support durationsFormat().\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\n    var outputTypes = settings.outputTypes; // returnMomentTypes is a boolean that sets durationFormat to return\n    // the processed momentTypes instead of formatted output.\n\n    var returnMomentTypes = settings.returnMomentTypes;\n    var largest = settings.largest; // Setup stopTrim array of token types.\n\n    var stopTrim = [];\n\n    if (!outputTypes) {\n      if (isArray(settings.stopTrim)) {\n        settings.stopTrim = settings.stopTrim.join(\"\");\n      } // Parse stopTrim string to create token types array.\n\n\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    } // Cache moment's locale data.\n\n\n    var localeData = moment.localeData();\n\n    if (!localeData) {\n      localeData = {};\n    } // Fall back to this plugin's `eng` extension.\n\n\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    }); // Replace Duration Time Template strings.\n    // For locale `eng`: `_HMS_`, `_HM_`, and `_MS_`.\n\n    each(keys(localeData._durationTimeTemplates), function (item) {\n      template = template.replace(\"_\" + item + \"_\", localeData._durationTimeTemplates[item]);\n    }); // Determine user's locale.\n\n    var userLocale = settings.userLocale || moment.locale();\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; // Use significant digits only when precision is greater than 0.\n\n    var useSignificantDigits = settings.useSignificantDigits && precision > 0;\n    var significantDigits = useSignificantDigits ? settings.precision : 0;\n    var significantDigitsCache = significantDigits;\n    var minValue = settings.minValue;\n    var isMinValue = false;\n    var maxValue = settings.maxValue;\n    var isMaxValue = false; // formatNumber fallback options.\n\n    var useToLocaleString = settings.useToLocaleString;\n    var groupingSeparator = settings.groupingSeparator;\n    var decimalSeparator = settings.decimalSeparator;\n    var grouping = settings.grouping;\n    useToLocaleString = useToLocaleString && (toLocaleStringWorks || intlNumberFormatWorks); // Trim options.\n\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 trimIncludes(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    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); // Parse format string to create raw tokens array.\n\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        // Replace escaped tokens with the non-escaped token text.\n        token: type === \"escape\" ? token.replace(tokenDefs.escape, \"$1\") : token,\n        // Ignore type on non-moment tokens.\n        type: type === \"escape\" || type === \"general\" ? null : type\n      };\n    }); // Associate text tokens with moment tokens.\n\n    var currentToken = {\n      index: 0,\n      length: 0,\n      token: \"\",\n      text: \"\",\n      type: null\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        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    } // Find unique moment token types in the template in order of\n    // descending magnitude.\n\n\n    var momentTypes = intersection(types, unique(compact(pluck(tokens, \"type\")))); // Exit early if there are no moment token types.\n\n    if (!momentTypes.length) {\n      return pluck(tokens, \"text\").join(\"\");\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\n\n    momentTypes = map(momentTypes, function (momentType, index) {\n      // Is this the least-magnitude moment token found?\n      var isSmallest = index + 1 === momentTypes.length; // Is this the greatest-magnitude moment token found?\n\n      var isLargest = !index; // Get the raw value in the current units.\n\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      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      } // 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\n\n      if (isLargest && forceLength === null && token.length > 1) {\n        forceLength = true;\n      } // Update remainder.\n\n\n      remainder.subtract(wholeValue, momentType);\n      remainderMonths.subtract(wholeValue, momentType);\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    var truncMethod = trunc ? Math.floor : Math.round;\n\n    var truncate = function truncate(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 formatValue(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 {\n          // 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          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 === \"\"\n      /* trim: false */\n      || find(stopTrim, momentType.type) || find(outputTypes, momentType.type))) {\n        foundFirst = true;\n      }\n\n      momentType.formattedValue = formatNumber(momentType.value, formatOptions, userLocale);\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    }; // Calculate formatted values.\n\n\n    momentTypes = map(momentTypes, formatValue);\n    momentTypes = compact(momentTypes); // Bubble rounded values.\n\n    if (momentTypes.length > 1) {\n      var findType = function findType(type) {\n        return find(momentTypes, function (momentType) {\n          return momentType.type === type;\n        });\n      };\n\n      var bubbleTypes = function bubbleTypes(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    } // Recalculate formatted values.\n\n\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      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      } // Largest.\n\n\n      if (largest && momentTypes.length) {\n        momentTypes = momentTypes.slice(0, largest);\n      } // Trim Small.\n\n\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      } // Trim Mid.\n\n\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        momentTypes = compact(momentTypes);\n      } // Trim Final.\n\n\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    } // Localize and pluralize unit labels.\n\n\n    each(tokens, function (token) {\n      var key = momentTokens[token.type];\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      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      var labels = durationGetLabels(key, localeData);\n      var autoLocalized = false;\n      var pluralizedLabels = {}; // Auto-Localized unit labels.\n\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      }); // Auto-pluralized unit labels.\n\n      if (usePlural && !autoLocalized) {\n        labels.sort(durationLabelCompare);\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            } // Skip this label if it is correct, but not present in\n            // the token's text.\n\n\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    }); // Build ouptut.\n\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    }); // Trim leading and trailing comma, space, colon, and dot.\n\n    return tokens.join(\"\").replace(/(,| |:|\\.)*$/, \"\").replace(/^(,| |:|\\.)*/, \"\");\n  } // defaultFormatTemplate\n\n\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    var lastType = findLast(this.types, findType); // Default template strings for each duration dimension type.\n\n    switch (firstType) {\n      case \"milliseconds\":\n        return \"S __\";\n\n      case \"seconds\": // Fallthrough.\n\n      case \"minutes\":\n        return \"*_MS_\";\n\n      case \"hours\":\n        return \"_HMS_\";\n\n      case \"days\":\n        // Possible Fallthrough.\n        if (firstType === lastType) {\n          return \"d __\";\n        }\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\n      case \"months\":\n        // Possible Fallthrough.\n        if (firstType === lastType) {\n          return \"M __\";\n        }\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\n      default:\n        if (this.trim === null) {\n          this.trim = \"both\";\n        }\n\n        return \"y __, d __, h __, m __, s __\";\n    }\n  } // init\n\n\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    context.duration.fn.format.defaults = {\n      // Many options are defaulted to `null` to distinguish between\n      // 'not set' and 'set to `false`'\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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // 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      // groupingSeparator\n      // The integer digit grouping separator used when using the fallback\n      // formatNumber function.\n      groupingSeparator: \",\",\n      // decimalSeparator\n      // The decimal separator used when using the fallback formatNumber\n      // function.\n      decimalSeparator: \".\",\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    context.updateLocale('en', engLocale);\n  } // Run feature tests for `Number#toLocaleString`.\n\n\n  var toLocaleStringFormatter = function toLocaleStringFormatter(number, locale, options) {\n    return number.toLocaleString(locale, options);\n  };\n\n  toLocaleStringWorks = toLocaleStringSupportsLocales() && featureTestFormatter(toLocaleStringFormatter);\n  toLocaleStringRoundingWorks = toLocaleStringWorks && featureTestFormatterRounding(toLocaleStringFormatter); // Run feature tests for `Intl.NumberFormat#format`.\n\n  var intlNumberFormatFormatter = function intlNumberFormatFormatter(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); // Initialize duration format on the global moment instance.\n\n  init(moment); // Return the init function so that duration format can be\n  // initialized on other moment instances.\n\n  return init;\n});"],"sourceRoot":""}