{"version":3,"sources":["webpack:///./node_modules/core-js-pure/stable/instance/trim.js","webpack:///./node_modules/core-js-pure/stable/object/create.js","webpack:///./node_modules/core-js-pure/es/instance/trim.js","webpack:///./node_modules/moment/locale/se.js","webpack:///./node_modules/core-js-pure/modules/es.string.trim.js","webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./node_modules/underscore/underscore.js","webpack:///./node_modules/core-js/modules/es.symbol.description.js","webpack:///./node_modules/core-js-pure/internals/string-trim-forced.js","webpack:///./node_modules/riot/riot.js","webpack:///./node_modules/moment/moment.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/core-js-pure/es/string/virtual/trim.js","webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/object/create.js"],"names":["parent","module","exports","trim","StringPrototype","String","prototype","it","own","moment","defineLocale","months","split","monthsShort","weekdays","weekdaysShort","weekdaysMin","longDateFormat","LT","LTS","L","LL","LLL","LLLL","calendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","relativeTime","future","past","s","ss","m","mm","h","hh","d","dd","M","MM","y","yy","dayOfMonthOrdinalParse","ordinal","week","dow","doy","factory","$","$trim","target","proto","forced","forcedStringTrimMethod","this","__webpack_amd_options__","root","self","global","previousUnderscore","_","ArrayProto","Array","ObjProto","Object","SymbolProto","Symbol","push","slice","toString","hasOwnProperty","nativeIsArray","isArray","nativeKeys","keys","nativeCreate","create","Ctor","obj","_wrapped","nodeType","VERSION","builtinIteratee","optimizeCb","func","context","argCount","value","call","index","collection","accumulator","apply","arguments","cb","iteratee","identity","isFunction","isObject","matcher","property","Infinity","restArguments","startIndex","length","Math","max","rest","args","baseCreate","result","shallowProperty","key","has","path","deepGet","i","MAX_ARRAY_INDEX","pow","getLength","isArrayLike","each","forEach","map","collect","results","currentKey","createReduce","dir","reducer","memo","initial","reduce","foldl","inject","reduceRight","foldr","find","detect","predicate","findIndex","findKey","filter","select","list","reject","negate","every","all","some","any","contains","includes","include","item","fromIndex","guard","values","indexOf","invoke","contextPath","method","pluck","where","attrs","findWhere","computed","lastComputed","v","min","shuffle","sample","n","random","clone","last","rand","temp","sortBy","criteria","sort","left","right","a","b","group","behavior","partition","groupBy","indexBy","countBy","reStrSymbol","toArray","isString","match","size","pass","first","head","take","array","tail","drop","compact","Boolean","flatten","input","shallow","strict","output","idx","isArguments","j","len","without","otherArrays","difference","uniq","unique","isSorted","isBoolean","seen","union","arrays","intersection","argsLength","unzip","zip","object","createPredicateIndexFinder","findLastIndex","sortedIndex","low","high","mid","floor","createIndexFinder","predicateFind","isNaN","lastIndexOf","range","start","stop","step","ceil","chunk","count","executeBound","sourceFunc","boundFunc","callingContext","bind","TypeError","bound","callArgs","concat","partial","boundArgs","placeholder","position","bindAll","Error","memoize","hasher","cache","address","delay","wait","setTimeout","defer","throttle","options","timeout","previous","later","leading","now","throttled","remaining","clearTimeout","trailing","cancel","debounce","immediate","debounced","callNow","wrap","wrapper","compose","after","times","before","once","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","collectNonEnumProps","nonEnumIdx","constructor","prop","allKeys","mapObject","pairs","invert","functions","methods","names","createAssigner","keysFunc","defaults","source","l","extend","extendOwn","assign","eq","deepEq","keyInObj","pick","omit","props","tap","interceptor","isMatch","aStack","bStack","type","className","valueOf","areArrays","aCtor","bCtor","pop","isEqual","isEmpty","isElement","name","nodelist","document","childNodes","Int8Array","isFinite","isSymbol","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","unescapeMap","createEscaper","escaper","join","testRegexp","RegExp","replaceRegexp","string","test","replace","escape","unescape","fallback","idCounter","uniqueId","prefix","id","templateSettings","evaluate","interpolate","noMatch","escapes","escapeRegExp","escapeChar","template","text","settings","oldSettings","render","offset","variable","Function","e","data","argument","chain","instance","_chain","chainResult","mixin","toJSON","DESCRIPTORS","defineProperty","f","copyConstructorProperties","NativeSymbol","undefined","description","EmptyStringDescriptionStore","SymbolWrapper","symbolPrototype","symbolToString","native","regexp","configurable","get","symbol","desc","fails","whitespaces","METHOD_NAME","window","riot","version","__uid","__virtualDom","__tagImpl","T_UNDEF","XLINK_REGEX","SPECIAL_TAGS_REGEX","RESERVED_WORDS_BLACKLIST","SVG_TAGS_LIST","IE_VERSION","documentMode","FIREFOX","InstallTrigger","observable","el","callbacks","onEachEvent","fn","es","defineProperties","on","events","pos","typed","enumerable","writable","off","arr","splice","one","trigger","fns","arglen","busy","debouncedEmit","base","current","parser","secondParser","RE_ORIGIN","win","doc","hist","history","loc","location","prot","Router","clickEvent","ontouchstart","started","central","routeFound","emitStack","emitStackLevel","DEFAULT_PARSER","DEFAULT_SECOND_PARSER","re","autoExec","t","emit","click","normalize","str","getPathFromRoot","href","getPathFromBase","force","isRoot","shift","which","metaKey","ctrlKey","shiftKey","defaultPrevented","nodeName","parentNode","go","title","preventDefault","shouldReplace","replaceState","pushState","second","third","r","action","mainRouter","route","newSubRouter","router","arg","exec","fn2","query","q","k","readyState","brackets","UNDEF","_regex","_settings","R_STRINGS","S_QBLOCKS","UNSUPPORTED","NEED_ESCAPE","FINDBRACES","_pairs","cachedBrackets","_cache","_loopback","_rewrite","bp","_create","pair","_brackets","reOrIdx","_reset","tmpl","_bp","isexpr","parts","lastIndex","skipBraces","unescapeStr","ch","ix","recch","hasExpr","loopKeys","expr","val","set","o","R_MLCOMMS","_tmpl","qstr","RE_DQUOTE","_parseExpr","RE_QBMARK","_getTmpl","_logErr","err","ctx","errorHandler","riotData","tagName","_riot_id","haveRaw","hasRaw","clearCache","CH_IDEXPR","fromCharCode","RE_CSNAME","RE_QBLOCK","RE_BREND","asText","div","cnt","jsb","rightContext","_wrapExpr","lv","ir","JS_CONTEXT","JS_VARNAME","JS_NOPROPS","tb","p","mvar","mkdom","reHasYield","reYieldAll","reYieldSrc","reYieldDest","rootEls","tr","th","td","col","tblTags","_mkdom","templ","html","checkSvg","toLowerCase","mkEl","src","ref","def","replaceYield","innerHTML","firstChild","selectedIndex","tname","childElementCount","specialTags","container","DOMParser","parseFromString","appendChild","ownerDocument","importNode","documentElement","setInnerHTML","stub","mkitem","moveNestedTags","child","tags","tag","moveChildTag","addVirtual","sib","_root","_virts","nextSibling","insertBefore","moveVirtual","insertTag","isVirtual","prevTag","newTag","virtualFn","dom","isInStub","styleManager","_riot","add","styleNode","newNode","setAttr","userNode","replaceChild","getElementsByTagName","cssTextProp","styleSheet","stylesToInject","css","cssText","parseNamedElements","childTags","forceParsingNamed","walk","isLoop","getAttr","getTag","opts","Tag","getTagName","ptag","getImmediateCustomParentTag","_parent","addChildTag","initChildTag","isArr","getNamedKey","setNamed","parseExpressions","expressions","addExpr","extra","attr","nodeValue","remAttr","hasKeys","mustReorder","impl","getOuterHTML","useRoot","createTextNode","isOption","oldItems","removeChild","items","frag","createDocumentFragment","itemsLength","_mustReorder","oldPos","hasImpl","cloneNode","mount","update","_item","unmount","unmountRedundant","multiple","__riot1374","_each","attributes","bool","conf","inherit","cleanUpData","propsInSyncWithParent","updateOpts","toCamel","inheritFrom","mustSync","onChildUpdate","toggle","isMount","evt","_tag","isMounted","isInherited","isWritable","normalizeData","attrName","handler","event","currentTarget","srcElement","charCode","keyCode","returnValue","preventUpdate","setEventHandler","remove","insertTo","inStub","style","display","RIOT_PREFIX","rAF","mix","getPrototypeOf","getOwnPropertyNames","descriptor","getOwnPropertyDescriptor","hasGetterSetter","init","globalMixin","walkAttributes","keepRootTag","tagIndex","node","els","outerHTML","removeAttribute","c","toUpperCase","getAttribute","xlink","setAttributeNS","setAttribute","cachedTag","newPos","namedTag","isSvg","createElementNS","createElement","$$","selector","querySelectorAll","querySelector","mixins","globals","_id","w","raf","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","navigator","userAgent","lastTime","nowtime","util","g","store","tag2","allTags","addRiotTags","selectAllTags","nodeList","_el","pushTags","riotTag","_innerHTML","mountTo","vdom","hookCallback","hooks","isDate","res","hasOwnProp","createUTC","format","locale","createLocalOrUTC","utc","getParsingFlags","_pf","empty","unusedTokens","unusedInput","overflow","charsLeftOver","nullInput","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","meridiem","rfc2822","weekdayMismatch","isValid","_isValid","flags","parsedParts","isNowValid","_d","invalidWeekday","_strict","bigHour","isFrozen","createInvalid","NaN","fun","momentProperties","copyConfig","to","from","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","updateInProgress","Moment","config","updateOffset","isMoment","absFloor","number","toInt","argumentForCoercion","coercedNumber","compareArrays","array1","array2","dontConvert","lengthDiff","abs","diffs","warn","msg","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","stack","deprecations","deprecateSimple","mergeConfigs","parentConfig","childConfig","Locale","aliases","addUnitAlias","unit","shorthand","lowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","priorities","addUnitPriority","priority","zeroFill","targetLength","forceSign","absNumber","zerosToFill","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","token","padded","callback","localeData","formatMoment","expandFormat","mom","makeFormatFunction","invalidDate","replaceLongDateFormatTokens","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchWord","regexes","addRegexToken","regex","strictRegex","isStrict","getParseRegexForToken","regexEscape","matched","p1","p2","p3","p4","tokens","addParseToken","addWeekParseToken","_w","addTimeToArrayFromToken","_a","daysInYear","year","isLeapYear","parseTwoDigitYear","parseInt","getSetYear","makeGetSet","keepTime","set$1","month","date","daysInMonth","x","modMonth","monthsShortRegex","monthsRegex","monthsParse","MONTHS_IN_FORMAT","defaultLocaleMonths","defaultLocaleMonthsShort","handleStrictParse","monthName","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","setMonth","dayOfMonth","getSetMonth","defaultMonthsShortRegex","defaultMonthsRegex","computeMonthsParse","cmpLenRev","shortPieces","longPieces","mixedPieces","_monthsRegex","_monthsShortRegex","_monthsStrictRegex","_monthsShortStrictRegex","createDate","ms","getFullYear","setFullYear","createUTCDate","UTC","getUTCFullYear","setUTCFullYear","firstWeekOffset","fwd","getUTCDay","dayOfYearFromWeeks","weekday","resYear","resDayOfYear","dayOfYear","weekOfYear","resWeek","weekOffset","weeksInYear","weekOffsetNext","shiftWeekdays","ws","weekdaysMinRegex","weekdaysShortRegex","weekdaysRegex","weekdaysParse","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","handleStrictParse$1","weekdayName","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","day","defaultWeekdaysRegex","defaultWeekdaysShortRegex","defaultWeekdaysMinRegex","computeWeekdaysParse","minp","shortp","longp","minPieces","_weekdaysRegex","_weekdaysShortRegex","_weekdaysMinRegex","_weekdaysStrictRegex","_weekdaysShortStrictRegex","_weekdaysMinStrictRegex","hFormat","hours","lowercase","minutes","matchMeridiem","_meridiemParse","seconds","kInput","_isPm","isPM","_meridiem","pos1","pos2","globalLocale","getSetHour","baseConfig","meridiemParse","locales","localeFamilies","normalizeLocale","loadLocale","oldLocale","_abbr","getSetGlobalLocale","getLocale","abbr","_config","parentLocale","next","chooseLocale","checkOverflow","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","configFromArray","currentDate","expectedWeekday","yearToUse","nowValue","_useUTC","getUTCMonth","getUTCDate","getMonth","getDate","currentDateArray","weekYear","weekdayOverflow","GG","W","E","createLocal","_week","curWeek","gg","_dayOfYear","dayOfYearFromWeekInfo","_nextDay","getDay","setUTCMinutes","getUTCMinutes","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","configFromISO","allowTime","dateFormat","timeFormat","tzFormat","configFromStringAndFormat","untruncateYear","yearStr","obsOffsets","UT","GMT","EDT","EST","CDT","CST","MDT","MST","PDT","PST","configFromRFC2822","monthStr","dayStr","hourStr","minuteStr","secondStr","parsedArray","weekdayStr","parsedInput","checkWeekday","obsOffset","militaryOffset","numOffset","hm","calculateOffset","ISO_8601","RFC_2822","skipped","stringLength","totalParsedInputLength","hour","isPm","meridiemHour","meridiemFixWrap","prepareConfig","preparse","tempConfig","bestMoment","scoreToBeat","currentScore","score","configFromStringAndArray","createFromInputFallback","configFromString","minute","millisecond","configFromObject","configFromInput","isUTC","isObjectEmpty","prototypeMin","other","prototypeMax","pickBy","moments","ordering","Duration","duration","years","quarters","quarter","weeks","isoWeek","days","milliseconds","unitHasDecimal","isDurationValid","_milliseconds","_days","_months","_data","_bubble","isDuration","absRound","round","separator","utcOffset","sign","offsetFromString","chunkOffset","cloneWithOffset","model","diff","setTime","local","getDateOffset","getTimezoneOffset","isUtc","aspNetRegex","isoRegex","createDuration","ret","diffRes","parseIso","isBefore","positiveMomentsDifference","inp","isAfter","createAdder","direction","period","tmp","addSubtract","isAdding","invalid","subtract","monthDiff","wholeMonthDiff","anchor","newLocaleData","defaultFormat","defaultFormatUtc","lang","mod$1","dividend","divisor","localStartOfDate","utcStartOfDate","addWeekYearFormatToken","getter","getSetWeekYearHelper","weeksTarget","setWeekAll","dayOfYearData","isoWeekYear","_dayOfMonthOrdinalParse","_ordinalParse","_dayOfMonthOrdinalParseLenient","getSetDayOfMonth","getSetMinute","getSetSecond","parseMs","getSetMillisecond","preParsePostFormat","time","formats","sod","startOf","calendarFormat","asFloat","that","zoneDelta","endOf","startOfDate","isoWeekday","inputString","postformat","withoutSuffix","humanize","fromNow","toNow","invalidAt","localInput","isBetween","inclusivity","localFrom","localTo","isSame","inputMs","isSameOrAfter","isSameOrBefore","parsingFlags","prioritized","unitsObj","u","getPrioritizedUnits","toObject","toDate","toISOString","keepOffset","inspect","zone","isLocal","suffix","unix","creationData","isoWeeks","weekInfo","isoWeeksInYear","parseWeekday","parseIsoWeekday","keepLocalTime","keepMinutes","localAdjust","_changeInProgress","parseZone","tZone","hasAlignedHourOffset","isDST","isUtcOffset","zoneAbbr","zoneName","dates","isDSTShifted","_isDSTShifted","proto$1","get$1","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","_calendar","_longDateFormat","formatUpper","_invalidDate","_ordinal","isFuture","_relativeTime","pastFuture","isFormat","_monthsShort","_monthsParseExact","firstDayOfYear","firstDayOfWeek","_weekdays","_weekdaysMin","_weekdaysShort","_weekdaysParseExact","_fullWeekdaysParse","charAt","isLower","langData","mathAbs","addSubtract$1","absCeil","daysToMonths","monthsToDays","makeAs","alias","as","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asQuarters","asYears","makeGetter","thresholds","substituteTimeAgo","abs$1","toISOString$1","Y","D","toFixed","total","totalSign","ymSign","daysSign","hmsSign","proto$2","monthsFromDays","withSuffix","posNegDuration","relativeTime$1","toIsoString","updateLocale","tmpLocale","relativeTimeRounding","roundingFunction","relativeTimeThreshold","threshold","limit","myMoment","HTML5_FMT","DATETIME_LOCAL","DATETIME_LOCAL_SECONDS","DATETIME_LOCAL_MS","DATE","TIME","TIME_SECONDS","TIME_MS","WEEK","MONTH","webpackPolyfill","paths","children","entryVirtual"],"mappings":"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","file":"script/chunks/chunk.3.32a58efa95.js","sourcesContent":["var parent = require('../../es/instance/trim');\n\nmodule.exports = parent;\n","var parent = require('../../es/object/create');\n\nmodule.exports = parent;\n","var trim = require('../string/virtual/trim');\n\nvar StringPrototype = String.prototype;\n\nmodule.exports = function (it) {\n  var own = it.trim;\n  return typeof it === 'string' || it === StringPrototype\n    || (it instanceof String && own === StringPrototype.trim) ? trim : own;\n};\n","//! moment.js locale configuration\n\n;(function (global, factory) {\n   typeof exports === 'object' && typeof module !== 'undefined'\n       && typeof require === 'function' ? factory(require('../moment')) :\n   typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n   factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n\n    var se = moment.defineLocale('se', {\n        months : 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split('_'),\n        monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),\n        weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),\n        weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),\n        weekdaysMin : 's_v_m_g_d_b_L'.split('_'),\n        longDateFormat : {\n            LT : 'HH:mm',\n            LTS : 'HH:mm:ss',\n            L : 'DD.MM.YYYY',\n            LL : 'MMMM D. [b.] YYYY',\n            LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',\n            LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'\n        },\n        calendar : {\n            sameDay: '[otne ti] LT',\n            nextDay: '[ihttin ti] LT',\n            nextWeek: 'dddd [ti] LT',\n            lastDay: '[ikte ti] LT',\n            lastWeek: '[ovddit] dddd [ti] LT',\n            sameElse: 'L'\n        },\n        relativeTime : {\n            future : '%s geažes',\n            past : 'maŋit %s',\n            s : 'moadde sekunddat',\n            ss: '%d sekunddat',\n            m : 'okta minuhta',\n            mm : '%d minuhtat',\n            h : 'okta diimmu',\n            hh : '%d diimmut',\n            d : 'okta beaivi',\n            dd : '%d beaivvit',\n            M : 'okta mánnu',\n            MM : '%d mánut',\n            y : 'okta jahki',\n            yy : '%d jagit'\n        },\n        dayOfMonthOrdinalParse: /\\d{1,2}\\./,\n        ordinal : '%d.',\n        week : {\n            dow : 1, // Monday is the first day of the week.\n            doy : 4  // The week that contains Jan 4th is the first week of the year.\n        }\n    });\n\n    return se;\n\n})));\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n  trim: function trim() {\n    return $trim(this);\n  }\n});\n","module.exports = require(\"core-js-pure/stable/instance/trim\");","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","//     Underscore.js 1.9.2\n//     https://underscorejs.org\n//     (c) 2009-2018 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n            typeof global == 'object' && global.global === global && global ||\n            this ||\n            {};\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push = ArrayProto.push,\n      slice = ArrayProto.slice,\n      toString = ObjProto.toString,\n      hasOwnProperty = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var nativeIsArray = Array.isArray,\n      nativeKeys = Object.keys,\n      nativeCreate = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for their old module API. If we're in\n  // the browser, add `_` as a global object.\n  // (`nodeType` is checked to ensure that `module`\n  // and `exports` are not HTML elements.)\n  if (typeof exports != 'undefined' && !exports.nodeType) {\n    if (typeof module != 'undefined' && !module.nodeType && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.9.2';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      // The 2-argument case is omitted because we’re not using it.\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  var builtinIteratee;\n\n  // An internal function to generate callbacks that can be applied to each\n  // element in a collection, returning the desired result — either `identity`,\n  // an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (_.iteratee !== builtinIteratee) return _.iteratee(value, context);\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value) && !_.isArray(value)) return _.matcher(value);\n    return _.property(value);\n  };\n\n  // External wrapper for our callback generator. Users may customize\n  // `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n  // This abstraction hides the internal-only argCount argument.\n  _.iteratee = builtinIteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // Some functions take a variable number of arguments, or a few expected\n  // arguments at the beginning and then a variable number of values to operate\n  // on. This helper accumulates all remaining arguments past the function’s\n  // argument length (or an explicit `startIndex`), into an array that becomes\n  // the last argument. Similar to ES6’s \"rest parameter\".\n  var restArguments = function(func, startIndex) {\n    startIndex = startIndex == null ? func.length - 1 : +startIndex;\n    return function() {\n      var length = Math.max(arguments.length - startIndex, 0),\n          rest = Array(length),\n          index = 0;\n      for (; index < length; index++) {\n        rest[index] = arguments[index + startIndex];\n      }\n      switch (startIndex) {\n        case 0: return func.call(this, rest);\n        case 1: return func.call(this, arguments[0], rest);\n        case 2: return func.call(this, arguments[0], arguments[1], rest);\n      }\n      var args = Array(startIndex + 1);\n      for (index = 0; index < startIndex; index++) {\n        args[index] = arguments[index];\n      }\n      args[startIndex] = rest;\n      return func.apply(this, args);\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var shallowProperty = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  var has = function(obj, path) {\n    return obj != null && hasOwnProperty.call(obj, path);\n  }\n\n  var deepGet = function(obj, path) {\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      if (obj == null) return void 0;\n      obj = obj[path[i]];\n    }\n    return length ? obj : void 0;\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object.\n  // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = shallowProperty('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  var createReduce = function(dir) {\n    // Wrap code that reassigns argument variables in a separate function than\n    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n    var reducer = function(obj, iteratee, memo, initial) {\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      if (!initial) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    };\n\n    return function(obj, iteratee, memo, context) {\n      var initial = arguments.length >= 3;\n      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n    };\n  };\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var keyFinder = isArrayLike(obj) ? _.findIndex : _.findKey;\n    var key = keyFinder(obj, predicate, context);\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = restArguments(function(obj, path, args) {\n    var contextPath, func;\n    if (_.isFunction(path)) {\n      func = path;\n    } else if (_.isArray(path)) {\n      contextPath = path.slice(0, -1);\n      path = path[path.length - 1];\n    }\n    return _.map(obj, function(context) {\n      var method = func;\n      if (!method) {\n        if (contextPath && contextPath.length) {\n          context = deepGet(context, contextPath);\n        }\n        if (context == null) return void 0;\n        method = context[path];\n      }\n      return method == null ? method : method.apply(context, args);\n    });\n  });\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection.\n  _.shuffle = function(obj) {\n    return _.sample(obj, Infinity);\n  };\n\n  // Sample **n** random values from a collection using the modern version of the\n  // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    var sample = isArrayLike(obj) ? _.clone(obj) : _.values(obj);\n    var length = getLength(sample);\n    n = Math.max(Math.min(n, length), 0);\n    var last = length - 1;\n    for (var index = 0; index < n; index++) {\n      var rand = _.random(index, last);\n      var temp = sample[index];\n      sample[index] = sample[rand];\n      sample[rand] = temp;\n    }\n    return sample.slice(0, n);\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    var index = 0;\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, key, list) {\n      return {\n        value: value,\n        index: index++,\n        criteria: iteratee(value, key, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior, partition) {\n    return function(obj, iteratee, context) {\n      var result = partition ? [[], []] : {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  var reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (_.isString(obj)) {\n      // Keep surrogate pair characters together\n      return obj.match(reStrSymbol);\n    }\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = group(function(result, value, pass) {\n    result[pass ? 0 : 1].push(value);\n  }, true);\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null || array.length < 1) return n == null ? void 0 : [];\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null || array.length < 1) return n == null ? void 0 : [];\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, Boolean);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, output) {\n    output = output || [];\n    var idx = output.length;\n    for (var i = 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        // Flatten current level of array or arguments object.\n        if (shallow) {\n          var j = 0, len = value.length;\n          while (j < len) output[idx++] = value[j++];\n        } else {\n          flatten(value, shallow, strict, output);\n          idx = output.length;\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = restArguments(function(array, otherArrays) {\n    return _.difference(array, otherArrays);\n  });\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // The faster algorithm will not work with an iteratee if the iteratee\n  // is not a one-to-one function, so providing an iteratee will disable\n  // the faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted && !iteratee) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = restArguments(function(arrays) {\n    return _.uniq(flatten(arrays, true, true));\n  });\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      var j;\n      for (j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = restArguments(function(array, rest) {\n    rest = flatten(rest, true, true);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  });\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices.\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = restArguments(_.unzip);\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values. Passing by pairs is the reverse of _.pairs.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions.\n  var createPredicateIndexFinder = function(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  };\n\n  // Returns the first index on an array-like that passes a predicate test.\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions.\n  var createIndexFinder = function(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n          i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  };\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](https://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    if (!step) {\n      step = stop < start ? -1 : 1;\n    }\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Chunk a single array into multiple arrays, each containing `count` or fewer\n  // items.\n  _.chunk = function(array, count) {\n    if (count == null || count < 1) return [];\n    var result = [];\n    var i = 0, length = array.length;\n    while (i < length) {\n      result.push(slice.call(array, i, i += count));\n    }\n    return result;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments.\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = restArguments(function(func, context, args) {\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var bound = restArguments(function(callArgs) {\n      return executeBound(func, bound, context, this, args.concat(callArgs));\n    });\n    return bound;\n  });\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder by default, allowing any combination of arguments to be\n  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\n  _.partial = restArguments(function(func, boundArgs) {\n    var placeholder = _.partial.placeholder;\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  });\n\n  _.partial.placeholder = _;\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = restArguments(function(obj, keys) {\n    keys = flatten(keys, false, false);\n    var index = keys.length;\n    if (index < 1) throw new Error('bindAll must be passed function names');\n    while (index--) {\n      var key = keys[index];\n      obj[key] = _.bind(obj[key], obj);\n    }\n  });\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = restArguments(function(func, wait, args) {\n    return setTimeout(function() {\n      return func.apply(null, args);\n    }, wait);\n  });\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var timeout, context, args, result;\n    var previous = 0;\n    if (!options) options = {};\n\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n\n    var throttled = function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n\n    throttled.cancel = function() {\n      clearTimeout(timeout);\n      previous = 0;\n      timeout = context = args = null;\n    };\n\n    return throttled;\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, result;\n\n    var later = function(context, args) {\n      timeout = null;\n      if (args) result = func.apply(context, args);\n    };\n\n    var debounced = restArguments(function(args) {\n      if (timeout) clearTimeout(timeout);\n      if (immediate) {\n        var callNow = !timeout;\n        timeout = setTimeout(later, wait);\n        if (callNow) result = func.apply(this, args);\n      } else {\n        timeout = _.delay(later, wait, this, args);\n      }\n\n      return result;\n    });\n\n    debounced.cancel = function() {\n      clearTimeout(timeout);\n      timeout = null;\n    };\n\n    return debounced;\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  _.restArguments = restArguments;\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var collectNonEnumProps = function(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  };\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`.\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object.\n  // In contrast to _.map it returns an object.\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = _.keys(obj),\n        length = keys.length,\n        results = {};\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys[index];\n      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  // The opposite of _.object.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`.\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, defaults) {\n    return function(obj) {\n      var length = arguments.length;\n      if (defaults) obj = Object(obj);\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!defaults || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s).\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test.\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Internal pick helper function to determine if `obj` has key `key`.\n  var keyInObj = function(value, key, obj) {\n    return key in obj;\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = restArguments(function(obj, keys) {\n    var result = {}, iteratee = keys[0];\n    if (obj == null) return result;\n    if (_.isFunction(iteratee)) {\n      if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n      keys = _.allKeys(obj);\n    } else {\n      iteratee = keyInObj;\n      keys = flatten(keys, false, false);\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  });\n\n  // Return a copy of the object without the blacklisted properties.\n  _.omit = restArguments(function(obj, keys) {\n    var iteratee = keys[0], context;\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n      if (keys.length > 1) context = keys[1];\n    } else {\n      keys = _.map(flatten(keys, false, false), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  });\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq, deepEq;\n  eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // `null` or `undefined` only equal to itself (strict comparison).\n    if (a == null || b == null) return false;\n    // `NaN`s are equivalent, but non-reflexive.\n    if (a !== a) return b !== b;\n    // Exhaust primitive checks\n    var type = typeof a;\n    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n    return deepEq(a, b, aStack, bStack);\n  };\n\n  // Internal recursive comparison function for `isEqual`.\n  deepEq = function(a, b, aStack, bStack) {\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN.\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n      case '[object Symbol]':\n        return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError, isMap, isWeakMap, isSet, isWeakSet.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\n  var nodelist = root.document && root.document.childNodes;\n  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return !_.isSymbol(obj) && isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`?\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && isNaN(obj);\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, path) {\n    if (!_.isArray(path)) {\n      return has(obj, path);\n    }\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      var key = path[i];\n      if (obj == null || !hasOwnProperty.call(obj, key)) {\n        return false;\n      }\n      obj = obj[key];\n    }\n    return !!length;\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  // Creates a function that, when passed an object, will traverse that object’s\n  // properties down the given `path`, specified as an array of keys or indexes.\n  _.property = function(path) {\n    if (!_.isArray(path)) {\n      return shallowProperty(path);\n    }\n    return function(obj) {\n      return deepGet(obj, path);\n    };\n  };\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    if (obj == null) {\n      return function(){};\n    }\n    return function(path) {\n      return !_.isArray(path) ? obj[path] : deepGet(obj, path);\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n  // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped.\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // Traverses the children of `obj` along `path`. If a child is a function, it\n  // is invoked with its parent as context. Returns the value of the final\n  // child, or `fallback` if any child is undefined.\n  _.result = function(obj, path, fallback) {\n    if (!_.isArray(path)) path = [path];\n    var length = path.length;\n    if (!length) {\n      return _.isFunction(fallback) ? fallback.call(obj) : fallback;\n    }\n    for (var i = 0; i < length; i++) {\n      var prop = obj == null ? void 0 : obj[path[i]];\n      if (prop === void 0) {\n        prop = fallback;\n        i = length; // Ensure we don't continue iterating.\n      }\n      obj = _.isFunction(prop) ? prop.call(obj) : prop;\n    }\n    return obj;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate: /<%([\\s\\S]+?)%>/g,\n    interpolate: /<%=([\\s\\S]+?)%>/g,\n    escape: /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\": \"'\",\n    '\\\\': '\\\\',\n    '\\r': 'r',\n    '\\n': 'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offset.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    var render;\n    try {\n      render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var chainResult = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return chainResult(this, func.apply(_, args));\n      };\n    });\n    return _;\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return chainResult(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return chainResult(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return String(this._wrapped);\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define == 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}());\n","// `Symbol.prototype.description` getter\n// https://tc39.github.io/ecma262/#sec-symbol.prototype.description\n'use strict';\nvar $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar has = require('../internals/has');\nvar isObject = require('../internals/is-object');\nvar defineProperty = require('../internals/object-define-property').f;\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\n\nvar NativeSymbol = global.Symbol;\n\nif (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||\n  // Safari 12 bug\n  NativeSymbol().description !== undefined\n)) {\n  var EmptyStringDescriptionStore = {};\n  // wrap Symbol constructor for correct work with undefined description\n  var SymbolWrapper = function Symbol() {\n    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);\n    var result = this instanceof SymbolWrapper\n      ? new NativeSymbol(description)\n      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'\n      : description === undefined ? NativeSymbol() : NativeSymbol(description);\n    if (description === '') EmptyStringDescriptionStore[result] = true;\n    return result;\n  };\n  copyConstructorProperties(SymbolWrapper, NativeSymbol);\n  var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;\n  symbolPrototype.constructor = SymbolWrapper;\n\n  var symbolToString = symbolPrototype.toString;\n  var native = String(NativeSymbol('test')) == 'Symbol(test)';\n  var regexp = /^Symbol\\((.*)\\)[^)]+$/;\n  defineProperty(symbolPrototype, 'description', {\n    configurable: true,\n    get: function description() {\n      var symbol = isObject(this) ? this.valueOf() : this;\n      var string = symbolToString.call(symbol);\n      if (has(EmptyStringDescriptionStore, symbol)) return '';\n      var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');\n      return desc === '' ? undefined : desc;\n    }\n  });\n\n  $({ global: true, forced: true }, {\n    Symbol: SymbolWrapper\n  });\n}\n","var fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n  return fails(function () {\n    return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;\n  });\n};\n","/* Riot v2.6.8, @license MIT */\n\n;(function(window, undefined) {\n  'use strict';\nvar riot = { version: 'v2.6.8', settings: {} },\n  // be aware, internal usage\n  // ATTENTION: prefix the global dynamic variables with `__`\n\n  // counter to give a unique id to all the Tag instances\n  __uid = 0,\n  // tags instances cache\n  __virtualDom = [],\n  // tags implementation cache\n  __tagImpl = {},\n\n  /**\n   * Const\n   */\n  GLOBAL_MIXIN = '__global_mixin',\n\n  // riot specific prefixes\n  RIOT_PREFIX = 'riot-',\n  RIOT_TAG = RIOT_PREFIX + 'tag',\n  RIOT_TAG_IS = 'data-is',\n\n  // for typeof == '' comparisons\n  T_STRING = 'string',\n  T_OBJECT = 'object',\n  T_UNDEF  = 'undefined',\n  T_FUNCTION = 'function',\n  XLINK_NS = 'http://www.w3.org/1999/xlink',\n  XLINK_REGEX = /^xlink:(\\w+)/,\n  // special native tags that cannot be treated like the others\n  SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,\n  RESERVED_WORDS_BLACKLIST = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|parent|opts|trigger|o(?:n|ff|ne))$/,\n  // SVG tags list https://www.w3.org/TR/SVG/attindex.html#PresentationAttributes\n  SVG_TAGS_LIST = ['altGlyph', 'animate', 'animateColor', 'circle', 'clipPath', 'defs', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'filter', 'font', 'foreignObject', 'g', 'glyph', 'glyphRef', 'image', 'line', 'linearGradient', 'marker', 'mask', 'missing-glyph', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'switch', 'symbol', 'text', 'textPath', 'tref', 'tspan', 'use'],\n\n  // version# for IE 8-11, 0 for others\n  IE_VERSION = (window && window.document || {}).documentMode | 0,\n\n  // detect firefox to fix #1374\n  FIREFOX = window && !!window.InstallTrigger\n/* istanbul ignore next */\nriot.observable = function(el) {\n\n  /**\n   * Extend the original object or create a new empty one\n   * @type { Object }\n   */\n\n  el = el || {}\n\n  /**\n   * Private variables\n   */\n  var callbacks = {},\n    slice = Array.prototype.slice\n\n  /**\n   * Private Methods\n   */\n\n  /**\n   * Helper function needed to get and loop all the events in a string\n   * @param   { String }   e - event string\n   * @param   {Function}   fn - callback\n   */\n  function onEachEvent(e, fn) {\n    var es = e.split(' '), l = es.length, i = 0\n    for (; i < l; i++) {\n      var name = es[i]\n      if (name) fn(name, i)\n    }\n  }\n\n  /**\n   * Public Api\n   */\n\n  // extend the el object adding the observable methods\n  Object.defineProperties(el, {\n    /**\n     * Listen to the given space separated list of `events` and\n     * execute the `callback` each time an event is triggered.\n     * @param  { String } events - events ids\n     * @param  { Function } fn - callback function\n     * @returns { Object } el\n     */\n    on: {\n      value: function(events, fn) {\n        if (typeof fn != 'function')  return el\n\n        onEachEvent(events, function(name, pos) {\n          (callbacks[name] = callbacks[name] || []).push(fn)\n          fn.typed = pos > 0\n        })\n\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Removes the given space separated list of `events` listeners\n     * @param   { String } events - events ids\n     * @param   { Function } fn - callback function\n     * @returns { Object } el\n     */\n    off: {\n      value: function(events, fn) {\n        if (events == '*' && !fn) callbacks = {}\n        else {\n          onEachEvent(events, function(name, pos) {\n            if (fn) {\n              var arr = callbacks[name]\n              for (var i = 0, cb; cb = arr && arr[i]; ++i) {\n                if (cb == fn) arr.splice(i--, 1)\n              }\n            } else delete callbacks[name]\n          })\n        }\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Listen to the given space separated list of `events` and\n     * execute the `callback` at most once\n     * @param   { String } events - events ids\n     * @param   { Function } fn - callback function\n     * @returns { Object } el\n     */\n    one: {\n      value: function(events, fn) {\n        function on() {\n          el.off(events, on)\n          fn.apply(el, arguments)\n        }\n        return el.on(events, on)\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Execute all callback functions that listen to\n     * the given space separated list of `events`\n     * @param   { String } events - events ids\n     * @returns { Object } el\n     */\n    trigger: {\n      value: function(events) {\n\n        // getting the arguments\n        var arglen = arguments.length - 1,\n          args = new Array(arglen),\n          fns\n\n        for (var i = 0; i < arglen; i++) {\n          args[i] = arguments[i + 1] // skip first argument\n        }\n\n        onEachEvent(events, function(name, pos) {\n\n          fns = slice.call(callbacks[name] || [], 0)\n\n          for (var i = 0, fn; fn = fns[i]; ++i) {\n            if (fn.busy) continue\n            fn.busy = 1\n            fn.apply(el, fn.typed ? [name].concat(args) : args)\n            if (fns[i] !== fn) { i-- }\n            fn.busy = 0\n          }\n\n          if (callbacks['*'] && name != '*')\n            el.trigger.apply(el, ['*', name].concat(args))\n\n        })\n\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    }\n  })\n\n  return el\n\n}\n/* istanbul ignore next */\n;(function(riot) {\n\n/**\n * Simple client-side router\n * @module riot-route\n */\n\n\nvar RE_ORIGIN = /^.+?\\/\\/+[^\\/]+/,\n  EVENT_LISTENER = 'EventListener',\n  REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER,\n  ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER,\n  HAS_ATTRIBUTE = 'hasAttribute',\n  REPLACE = 'replace',\n  POPSTATE = 'popstate',\n  HASHCHANGE = 'hashchange',\n  TRIGGER = 'trigger',\n  MAX_EMIT_STACK_LEVEL = 3,\n  win = typeof window != 'undefined' && window,\n  doc = typeof document != 'undefined' && document,\n  hist = win && history,\n  loc = win && (hist.location || win.location), // see html5-history-api\n  prot = Router.prototype, // to minify more\n  clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click',\n  started = false,\n  central = riot.observable(),\n  routeFound = false,\n  debouncedEmit,\n  base, current, parser, secondParser, emitStack = [], emitStackLevel = 0\n\n/**\n * Default parser. You can replace it via router.parser method.\n * @param {string} path - current path (normalized)\n * @returns {array} array\n */\nfunction DEFAULT_PARSER(path) {\n  return path.split(/[/?#]/)\n}\n\n/**\n * Default parser (second). You can replace it via router.parser method.\n * @param {string} path - current path (normalized)\n * @param {string} filter - filter string (normalized)\n * @returns {array} array\n */\nfunction DEFAULT_SECOND_PARSER(path, filter) {\n  var re = new RegExp('^' + filter[REPLACE](/\\*/g, '([^/?#]+?)')[REPLACE](/\\.\\./, '.*') + '$'),\n    args = path.match(re)\n\n  if (args) return args.slice(1)\n}\n\n/**\n * Simple/cheap debounce implementation\n * @param   {function} fn - callback\n * @param   {number} delay - delay in seconds\n * @returns {function} debounced function\n */\nfunction debounce(fn, delay) {\n  var t\n  return function () {\n    clearTimeout(t)\n    t = setTimeout(fn, delay)\n  }\n}\n\n/**\n * Set the window listeners to trigger the routes\n * @param {boolean} autoExec - see route.start\n */\nfunction start(autoExec) {\n  debouncedEmit = debounce(emit, 1)\n  win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit)\n  win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit)\n  doc[ADD_EVENT_LISTENER](clickEvent, click)\n  if (autoExec) emit(true)\n}\n\n/**\n * Router class\n */\nfunction Router() {\n  this.$ = []\n  riot.observable(this) // make it observable\n  central.on('stop', this.s.bind(this))\n  central.on('emit', this.e.bind(this))\n}\n\nfunction normalize(path) {\n  return path[REPLACE](/^\\/|\\/$/, '')\n}\n\nfunction isString(str) {\n  return typeof str == 'string'\n}\n\n/**\n * Get the part after domain name\n * @param {string} href - fullpath\n * @returns {string} path from root\n */\nfunction getPathFromRoot(href) {\n  return (href || loc.href)[REPLACE](RE_ORIGIN, '')\n}\n\n/**\n * Get the part after base\n * @param {string} href - fullpath\n * @returns {string} path from base\n */\nfunction getPathFromBase(href) {\n  return base[0] == '#'\n    ? (href || loc.href || '').split(base)[1] || ''\n    : (loc ? getPathFromRoot(href) : href || '')[REPLACE](base, '')\n}\n\nfunction emit(force) {\n  // the stack is needed for redirections\n  var isRoot = emitStackLevel == 0, first\n  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return\n\n  emitStackLevel++\n  emitStack.push(function() {\n    var path = getPathFromBase()\n    if (force || path != current) {\n      central[TRIGGER]('emit', path)\n      current = path\n    }\n  })\n  if (isRoot) {\n    while (first = emitStack.shift()) first() // stack increses within this call\n    emitStackLevel = 0\n  }\n}\n\nfunction click(e) {\n  if (\n    e.which != 1 // not left click\n    || e.metaKey || e.ctrlKey || e.shiftKey // or meta keys\n    || e.defaultPrevented // or default prevented\n  ) return\n\n  var el = e.target\n  while (el && el.nodeName != 'A') el = el.parentNode\n\n  if (\n    !el || el.nodeName != 'A' // not A tag\n    || el[HAS_ATTRIBUTE]('download') // has download attr\n    || !el[HAS_ATTRIBUTE]('href') // has no href attr\n    || el.target && el.target != '_self' // another window or frame\n    || el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) == -1 // cross origin\n  ) return\n\n  if (el.href != loc.href\n    && (\n      el.href.split('#')[0] == loc.href.split('#')[0] // internal jump\n      || base[0] != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base\n      || base[0] == '#' && el.href.split(base)[0] != loc.href.split(base)[0] // outside of #base\n      || !go(getPathFromBase(el.href), el.title || doc.title) // route not found\n    )) return\n\n  e.preventDefault()\n}\n\n/**\n * Go to the path\n * @param {string} path - destination path\n * @param {string} title - page title\n * @param {boolean} shouldReplace - use replaceState or pushState\n * @returns {boolean} - route not found flag\n */\nfunction go(path, title, shouldReplace) {\n  // Server-side usage: directly execute handlers for the path\n  if (!hist) return central[TRIGGER]('emit', getPathFromBase(path))\n\n  path = base + normalize(path)\n  title = title || doc.title\n  // browsers ignores the second parameter `title`\n  shouldReplace\n    ? hist.replaceState(null, title, path)\n    : hist.pushState(null, title, path)\n  // so we need to set it manually\n  doc.title = title\n  routeFound = false\n  emit()\n  return routeFound\n}\n\n/**\n * Go to path or set action\n * a single string:                go there\n * two strings:                    go there with setting a title\n * two strings and boolean:        replace history with setting a title\n * a single function:              set an action on the default route\n * a string/RegExp and a function: set an action on the route\n * @param {(string|function)} first - path / action / filter\n * @param {(string|RegExp|function)} second - title / action\n * @param {boolean} third - replace flag\n */\nprot.m = function(first, second, third) {\n  if (isString(first) && (!second || isString(second))) go(first, second, third || false)\n  else if (second) this.r(first, second)\n  else this.r('@', first)\n}\n\n/**\n * Stop routing\n */\nprot.s = function() {\n  this.off('*')\n  this.$ = []\n}\n\n/**\n * Emit\n * @param {string} path - path\n */\nprot.e = function(path) {\n  this.$.concat('@').some(function(filter) {\n    var args = (filter == '@' ? parser : secondParser)(normalize(path), normalize(filter))\n    if (typeof args != 'undefined') {\n      this[TRIGGER].apply(null, [filter].concat(args))\n      return routeFound = true // exit from loop\n    }\n  }, this)\n}\n\n/**\n * Register route\n * @param {string} filter - filter for matching to url\n * @param {function} action - action to register\n */\nprot.r = function(filter, action) {\n  if (filter != '@') {\n    filter = '/' + normalize(filter)\n    this.$.push(filter)\n  }\n  this.on(filter, action)\n}\n\nvar mainRouter = new Router()\nvar route = mainRouter.m.bind(mainRouter)\n\n/**\n * Create a sub router\n * @returns {function} the method of a new Router object\n */\nroute.create = function() {\n  var newSubRouter = new Router()\n  // assign sub-router's main method\n  var router = newSubRouter.m.bind(newSubRouter)\n  // stop only this sub-router\n  router.stop = newSubRouter.s.bind(newSubRouter)\n  return router\n}\n\n/**\n * Set the base of url\n * @param {(str|RegExp)} arg - a new base or '#' or '#!'\n */\nroute.base = function(arg) {\n  base = arg || '#'\n  current = getPathFromBase() // recalculate current path\n}\n\n/** Exec routing right now **/\nroute.exec = function() {\n  emit(true)\n}\n\n/**\n * Replace the default router to yours\n * @param {function} fn - your parser function\n * @param {function} fn2 - your secondParser function\n */\nroute.parser = function(fn, fn2) {\n  if (!fn && !fn2) {\n    // reset parser for testing...\n    parser = DEFAULT_PARSER\n    secondParser = DEFAULT_SECOND_PARSER\n  }\n  if (fn) parser = fn\n  if (fn2) secondParser = fn2\n}\n\n/**\n * Helper function to get url query as an object\n * @returns {object} parsed query\n */\nroute.query = function() {\n  var q = {}\n  var href = loc.href || current\n  href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })\n  return q\n}\n\n/** Stop routing **/\nroute.stop = function () {\n  if (started) {\n    if (win) {\n      win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit)\n      win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit)\n      doc[REMOVE_EVENT_LISTENER](clickEvent, click)\n    }\n    central[TRIGGER]('stop')\n    started = false\n  }\n}\n\n/**\n * Start routing\n * @param {boolean} autoExec - automatically exec after starting if true\n */\nroute.start = function (autoExec) {\n  if (!started) {\n    if (win) {\n      if (document.readyState == 'complete') start(autoExec)\n      // the timeout is needed to solve\n      // a weird safari bug https://github.com/riot/route/issues/33\n      else win[ADD_EVENT_LISTENER]('load', function() {\n        setTimeout(function() { start(autoExec) }, 1)\n      })\n    }\n    started = true\n  }\n}\n\n/** Prepare the router **/\nroute.base()\nroute.parser()\n\nriot.route = route\n})(riot)\n/* istanbul ignore next */\n\n/**\n * The riot template engine\n * @version v2.4.2\n */\n/**\n * riot.util.brackets\n *\n * - `brackets    ` - Returns a string or regex based on its parameter\n * - `brackets.set` - Change the current riot brackets\n *\n * @module\n */\n\nvar brackets = (function (UNDEF) {\n\n  var\n    REGLOB = 'g',\n\n    R_MLCOMMS = /\\/\\*[^*]*\\*+(?:[^*\\/][^*]*\\*+)*\\//g,\n\n    R_STRINGS = /\"[^\"\\\\]*(?:\\\\[\\S\\s][^\"\\\\]*)*\"|'[^'\\\\]*(?:\\\\[\\S\\s][^'\\\\]*)*'/g,\n\n    S_QBLOCKS = R_STRINGS.source + '|' +\n      /(?:\\breturn\\s+|(?:[$\\w\\)\\]]|\\+\\+|--)\\s*(\\/)(?![*\\/]))/.source + '|' +\n      /\\/(?=[^*\\/])[^[\\/\\\\]*(?:(?:\\[(?:\\\\.|[^\\]\\\\]*)*\\]|\\\\.)[^[\\/\\\\]*)*?(\\/)[gim]*/.source,\n\n    UNSUPPORTED = RegExp('[\\\\' + 'x00-\\\\x1F<>a-zA-Z0-9\\'\",;\\\\\\\\]'),\n\n    NEED_ESCAPE = /(?=[[\\]()*+?.^$|])/g,\n\n    FINDBRACES = {\n      '(': RegExp('([()])|'   + S_QBLOCKS, REGLOB),\n      '[': RegExp('([[\\\\]])|' + S_QBLOCKS, REGLOB),\n      '{': RegExp('([{}])|'   + S_QBLOCKS, REGLOB)\n    },\n\n    DEFAULT = '{ }'\n\n  var _pairs = [\n    '{', '}',\n    '{', '}',\n    /{[^}]*}/,\n    /\\\\([{}])/g,\n    /\\\\({)|{/g,\n    RegExp('\\\\\\\\(})|([[({])|(})|' + S_QBLOCKS, REGLOB),\n    DEFAULT,\n    /^\\s*{\\^?\\s*([$\\w]+)(?:\\s*,\\s*(\\S+))?\\s+in\\s+(\\S.*)\\s*}/,\n    /(^|[^\\\\]){=[\\S\\s]*?}/\n  ]\n\n  var\n    cachedBrackets = UNDEF,\n    _regex,\n    _cache = [],\n    _settings\n\n  function _loopback (re) { return re }\n\n  function _rewrite (re, bp) {\n    if (!bp) bp = _cache\n    return new RegExp(\n      re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''\n    )\n  }\n\n  function _create (pair) {\n    if (pair === DEFAULT) return _pairs\n\n    var arr = pair.split(' ')\n\n    if (arr.length !== 2 || UNSUPPORTED.test(pair)) {\n      throw new Error('Unsupported brackets \"' + pair + '\"')\n    }\n    arr = arr.concat(pair.replace(NEED_ESCAPE, '\\\\').split(' '))\n\n    arr[4] = _rewrite(arr[1].length > 1 ? /{[\\S\\s]*?}/ : _pairs[4], arr)\n    arr[5] = _rewrite(pair.length > 3 ? /\\\\({|})/g : _pairs[5], arr)\n    arr[6] = _rewrite(_pairs[6], arr)\n    arr[7] = RegExp('\\\\\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB)\n    arr[8] = pair\n    return arr\n  }\n\n  function _brackets (reOrIdx) {\n    return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]\n  }\n\n  _brackets.split = function split (str, tmpl, _bp) {\n    // istanbul ignore next: _bp is for the compiler\n    if (!_bp) _bp = _cache\n\n    var\n      parts = [],\n      match,\n      isexpr,\n      start,\n      pos,\n      re = _bp[6]\n\n    isexpr = start = re.lastIndex = 0\n\n    while ((match = re.exec(str))) {\n\n      pos = match.index\n\n      if (isexpr) {\n\n        if (match[2]) {\n          re.lastIndex = skipBraces(str, match[2], re.lastIndex)\n          continue\n        }\n        if (!match[3]) {\n          continue\n        }\n      }\n\n      if (!match[1]) {\n        unescapeStr(str.slice(start, pos))\n        start = re.lastIndex\n        re = _bp[6 + (isexpr ^= 1)]\n        re.lastIndex = start\n      }\n    }\n\n    if (str && start < str.length) {\n      unescapeStr(str.slice(start))\n    }\n\n    return parts\n\n    function unescapeStr (s) {\n      if (tmpl || isexpr) {\n        parts.push(s && s.replace(_bp[5], '$1'))\n      } else {\n        parts.push(s)\n      }\n    }\n\n    function skipBraces (s, ch, ix) {\n      var\n        match,\n        recch = FINDBRACES[ch]\n\n      recch.lastIndex = ix\n      ix = 1\n      while ((match = recch.exec(s))) {\n        if (match[1] &&\n          !(match[1] === ch ? ++ix : --ix)) break\n      }\n      return ix ? s.length : recch.lastIndex\n    }\n  }\n\n  _brackets.hasExpr = function hasExpr (str) {\n    return _cache[4].test(str)\n  }\n\n  _brackets.loopKeys = function loopKeys (expr) {\n    var m = expr.match(_cache[9])\n\n    return m\n      ? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }\n      : { val: expr.trim() }\n  }\n\n  _brackets.array = function array (pair) {\n    return pair ? _create(pair) : _cache\n  }\n\n  function _reset (pair) {\n    if ((pair || (pair = DEFAULT)) !== _cache[8]) {\n      _cache = _create(pair)\n      _regex = pair === DEFAULT ? _loopback : _rewrite\n      _cache[9] = _regex(_pairs[9])\n    }\n    cachedBrackets = pair\n  }\n\n  function _setSettings (o) {\n    var b\n\n    o = o || {}\n    b = o.brackets\n    Object.defineProperty(o, 'brackets', {\n      set: _reset,\n      get: function () { return cachedBrackets },\n      enumerable: true\n    })\n    _settings = o\n    _reset(b)\n  }\n\n  Object.defineProperty(_brackets, 'settings', {\n    set: _setSettings,\n    get: function () { return _settings }\n  })\n\n  /* istanbul ignore next: in the browser riot is always in the scope */\n  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {}\n  _brackets.set = _reset\n\n  _brackets.R_STRINGS = R_STRINGS\n  _brackets.R_MLCOMMS = R_MLCOMMS\n  _brackets.S_QBLOCKS = S_QBLOCKS\n\n  return _brackets\n\n})()\n\n/**\n * @module tmpl\n *\n * tmpl          - Root function, returns the template value, render with data\n * tmpl.hasExpr  - Test the existence of a expression inside a string\n * tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)\n */\n\nvar tmpl = (function () {\n\n  var _cache = {}\n\n  function _tmpl (str, data) {\n    if (!str) return str\n\n    return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)\n  }\n\n  _tmpl.haveRaw = brackets.hasRaw\n\n  _tmpl.hasExpr = brackets.hasExpr\n\n  _tmpl.loopKeys = brackets.loopKeys\n\n  // istanbul ignore next\n  _tmpl.clearCache = function () { _cache = {} }\n\n  _tmpl.errorHandler = null\n\n  function _logErr (err, ctx) {\n\n    if (_tmpl.errorHandler) {\n\n      err.riotData = {\n        tagName: ctx && ctx.root && ctx.root.tagName,\n        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase\n      }\n      _tmpl.errorHandler(err)\n    }\n  }\n\n  function _create (str) {\n    var expr = _getTmpl(str)\n\n    if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr\n\n    return new Function('E', expr + ';')    // eslint-disable-line no-new-func\n  }\n\n  var\n    CH_IDEXPR = String.fromCharCode(0x2057),\n    RE_CSNAME = /^(?:(-?[_A-Za-z\\xA0-\\xFF][-\\w\\xA0-\\xFF]*)|\\u2057(\\d+)~):/,\n    RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),\n    RE_DQUOTE = /\\u2057/g,\n    RE_QBMARK = /\\u2057(\\d+)~/g\n\n  function _getTmpl (str) {\n    var\n      qstr = [],\n      expr,\n      parts = brackets.split(str.replace(RE_DQUOTE, '\"'), 1)\n\n    if (parts.length > 2 || parts[0]) {\n      var i, j, list = []\n\n      for (i = j = 0; i < parts.length; ++i) {\n\n        expr = parts[i]\n\n        if (expr && (expr = i & 1\n\n            ? _parseExpr(expr, 1, qstr)\n\n            : '\"' + expr\n                .replace(/\\\\/g, '\\\\\\\\')\n                .replace(/\\r\\n?|\\n/g, '\\\\n')\n                .replace(/\"/g, '\\\\\"') +\n              '\"'\n\n          )) list[j++] = expr\n\n      }\n\n      expr = j < 2 ? list[0]\n           : '[' + list.join(',') + '].join(\"\")'\n\n    } else {\n\n      expr = _parseExpr(parts[1], 0, qstr)\n    }\n\n    if (qstr[0]) {\n      expr = expr.replace(RE_QBMARK, function (_, pos) {\n        return qstr[pos]\n          .replace(/\\r/g, '\\\\r')\n          .replace(/\\n/g, '\\\\n')\n      })\n    }\n    return expr\n  }\n\n  var\n    RE_BREND = {\n      '(': /[()]/g,\n      '[': /[[\\]]/g,\n      '{': /[{}]/g\n    }\n\n  function _parseExpr (expr, asText, qstr) {\n\n    expr = expr\n          .replace(RE_QBLOCK, function (s, div) {\n            return s.length > 2 && !div ? CH_IDEXPR + (qstr.push(s) - 1) + '~' : s\n          })\n          .replace(/\\s+/g, ' ').trim()\n          .replace(/\\ ?([[\\({},?\\.:])\\ ?/g, '$1')\n\n    if (expr) {\n      var\n        list = [],\n        cnt = 0,\n        match\n\n      while (expr &&\n            (match = expr.match(RE_CSNAME)) &&\n            !match.index\n        ) {\n        var\n          key,\n          jsb,\n          re = /,|([[{(])|$/g\n\n        expr = RegExp.rightContext\n        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\\s+/g, ' ') : match[1]\n\n        while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)\n\n        jsb  = expr.slice(0, match.index)\n        expr = RegExp.rightContext\n\n        list[cnt++] = _wrapExpr(jsb, 1, key)\n      }\n\n      expr = !cnt ? _wrapExpr(expr, asText)\n           : cnt > 1 ? '[' + list.join(',') + '].join(\" \").trim()' : list[0]\n    }\n    return expr\n\n    function skipBraces (ch, re) {\n      var\n        mm,\n        lv = 1,\n        ir = RE_BREND[ch]\n\n      ir.lastIndex = re.lastIndex\n      while (mm = ir.exec(expr)) {\n        if (mm[0] === ch) ++lv\n        else if (!--lv) break\n      }\n      re.lastIndex = lv ? expr.length : ir.lastIndex\n    }\n  }\n\n  // istanbul ignore next: not both\n  var // eslint-disable-next-line max-len\n    JS_CONTEXT = '\"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',\n    JS_VARNAME = /[,{][\\$\\w]+(?=:)|(^ *|[^$\\w\\.{])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\\w]))([$_A-Za-z][$\\w]*)/g,\n    JS_NOPROPS = /^(?=(\\.[$\\w]+))\\1(?:[^.[(]|$)/\n\n  function _wrapExpr (expr, asText, key) {\n    var tb\n\n    expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {\n      if (mvar) {\n        pos = tb ? 0 : pos + match.length\n\n        if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {\n          match = p + '(\"' + mvar + JS_CONTEXT + mvar\n          if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['\n        } else if (pos) {\n          tb = !JS_NOPROPS.test(s.slice(pos))\n        }\n      }\n      return match\n    })\n\n    if (tb) {\n      expr = 'try{return ' + expr + '}catch(e){E(e,this)}'\n    }\n\n    if (key) {\n\n      expr = (tb\n          ? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'\n        ) + '?\"' + key + '\":\"\"'\n\n    } else if (asText) {\n\n      expr = 'function(v){' + (tb\n          ? expr.replace('return ', 'v=') : 'v=(' + expr + ')'\n        ) + ';return v||v===0?v:\"\"}.call(this)'\n    }\n\n    return expr\n  }\n\n  _tmpl.version = brackets.version = 'v2.4.2'\n\n  return _tmpl\n\n})()\n\n/*\n  lib/browser/tag/mkdom.js\n\n  Includes hacks needed for the Internet Explorer version 9 and below\n  See: http://kangax.github.io/compat-table/es5/#ie8\n       http://codeplanet.io/dropping-ie8/\n*/\nvar mkdom = (function _mkdom() {\n  var\n    reHasYield  = /<yield\\b/i,\n    reYieldAll  = /<yield\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>|>)/ig,\n    reYieldSrc  = /<yield\\s+to=['\"]([^'\">]*)['\"]\\s*>([\\S\\s]*?)<\\/yield\\s*>/ig,\n    reYieldDest = /<yield\\s+from=['\"]?([-\\w]+)['\"]?\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>)/ig\n  var\n    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },\n    tblTags = IE_VERSION && IE_VERSION < 10\n      ? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/\n\n  /**\n   * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be\n   * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.\n   *\n   * @param   { String } templ  - The template coming from the custom tag definition\n   * @param   { String } [html] - HTML content that comes from the DOM element where you\n   *           will mount the tag, mostly the original tag in the page\n   * @param   { Boolean } checkSvg - flag needed to know if we need to force the svg rendering in case of loop nodes\n   * @returns {HTMLElement} DOM element with _templ_ merged through `YIELD` with the _html_.\n   */\n  function _mkdom(templ, html, checkSvg) {\n    var\n      match   = templ && templ.match(/^\\s*<([-\\w]+)/),\n      tagName = match && match[1].toLowerCase(),\n      el = mkEl('div', checkSvg && isSVGTag(tagName))\n\n    // replace all the yield tags with the tag inner html\n    templ = replaceYield(templ, html)\n\n    /* istanbul ignore next */\n    if (tblTags.test(tagName))\n      el = specialTags(el, templ, tagName)\n    else\n      setInnerHTML(el, templ)\n\n    el.stub = true\n\n    return el\n  }\n\n  /*\n    Creates the root element for table or select child elements:\n    tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup\n  */\n  function specialTags(el, templ, tagName) {\n    var\n      select = tagName[0] === 'o',\n      parent = select ? 'select>' : 'table>'\n\n    // trim() is important here, this ensures we don't have artifacts,\n    // so we can check if we have only one element inside the parent\n    el.innerHTML = '<' + parent + templ.trim() + '</' + parent\n    parent = el.firstChild\n\n    // returns the immediate parent if tr/th/td/col is the only element, if not\n    // returns the whole tree, as this can include additional elements\n    if (select) {\n      parent.selectedIndex = -1  // for IE9, compatible w/current riot behavior\n    } else {\n      // avoids insertion of cointainer inside container (ex: tbody inside tbody)\n      var tname = rootEls[tagName]\n      if (tname && parent.childElementCount === 1) parent = $(tname, parent)\n    }\n    return parent\n  }\n\n  /*\n    Replace the yield tag from any tag template with the innerHTML of the\n    original tag in the page\n  */\n  function replaceYield(templ, html) {\n    // do nothing if no yield\n    if (!reHasYield.test(templ)) return templ\n\n    // be careful with #1343 - string on the source having `$1`\n    var src = {}\n\n    html = html && html.replace(reYieldSrc, function (_, ref, text) {\n      src[ref] = src[ref] || text   // preserve first definition\n      return ''\n    }).trim()\n\n    return templ\n      .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs\n        return src[ref] || def || ''\n      })\n      .replace(reYieldAll, function (_, def) {        // yield without any \"from\"\n        return html || def || ''\n      })\n  }\n\n  return _mkdom\n\n})()\n\n/**\n * Convert the item looped into an object used to extend the child tag properties\n * @param   { Object } expr - object containing the keys used to extend the children tags\n * @param   { * } key - value to assign to the new object returned\n * @param   { * } val - value containing the position of the item in the array\n * @returns { Object } - new object containing the values of the original item\n *\n * The variables 'key' and 'val' are arbitrary.\n * They depend on the collection type looped (Array, Object)\n * and on the expression used on the each tag\n *\n */\nfunction mkitem(expr, key, val) {\n  var item = {}\n  item[expr.key] = key\n  if (expr.pos) item[expr.pos] = val\n  return item\n}\n\n/**\n * Unmount the redundant tags\n * @param   { Array } items - array containing the current items to loop\n * @param   { Array } tags - array containing all the children tags\n */\nfunction unmountRedundant(items, tags) {\n\n  var i = tags.length,\n    j = items.length,\n    t\n\n  while (i > j) {\n    t = tags[--i]\n    tags.splice(i, 1)\n    t.unmount()\n  }\n}\n\n/**\n * Move the nested custom tags in non custom loop tags\n * @param   { Object } child - non custom loop tag\n * @param   { Number } i - current position of the loop tag\n */\nfunction moveNestedTags(child, i) {\n  Object.keys(child.tags).forEach(function(tagName) {\n    var tag = child.tags[tagName]\n    if (isArray(tag))\n      each(tag, function (t) {\n        moveChildTag(t, tagName, i)\n      })\n    else\n      moveChildTag(tag, tagName, i)\n  })\n}\n\n/**\n * Adds the elements for a virtual tag\n * @param { Tag } tag - the tag whose root's children will be inserted or appended\n * @param { Node } src - the node that will do the inserting or appending\n * @param { Tag } target - only if inserting, insert before this tag's first child\n */\nfunction addVirtual(tag, src, target) {\n  var el = tag._root, sib\n  tag._virts = []\n  while (el) {\n    sib = el.nextSibling\n    if (target)\n      src.insertBefore(el, target._root)\n    else\n      src.appendChild(el)\n\n    tag._virts.push(el) // hold for unmounting\n    el = sib\n  }\n}\n\n/**\n * Move virtual tag and all child nodes\n * @param { Tag } tag - first child reference used to start move\n * @param { Node } src  - the node that will do the inserting\n * @param { Tag } target - insert before this tag's first child\n * @param { Number } len - how many child nodes to move\n */\nfunction moveVirtual(tag, src, target, len) {\n  var el = tag._root, sib, i = 0\n  for (; i < len; i++) {\n    sib = el.nextSibling\n    src.insertBefore(el, target._root)\n    el = sib\n  }\n}\n\n/**\n * Insert a new tag avoiding the insert for the conditional tags\n * @param   {Boolean} isVirtual [description]\n * @param   { Tag }  prevTag - tag instance used as reference to prepend our new tag\n * @param   { Tag }  newTag - new tag to be inserted\n * @param   { HTMLElement }  root - loop parent node\n * @param   { Array }  tags - array containing the current tags list\n * @param   { Function }  virtualFn - callback needed to move or insert virtual DOM\n * @param   { Object } dom - DOM node we need to loop\n */\nfunction insertTag(isVirtual, prevTag, newTag, root, tags, virtualFn, dom) {\n  if (isInStub(prevTag.root)) return\n  if (isVirtual) virtualFn(prevTag, root, newTag, dom.childNodes.length)\n  else root.insertBefore(prevTag.root, newTag.root) // #1374 some browsers reset selected here\n}\n\n\n/**\n * Manage tags having the 'each'\n * @param   { Object } dom - DOM node we need to loop\n * @param   { Tag } parent - parent tag instance where the dom node is contained\n * @param   { String } expr - string contained in the 'each' attribute\n */\nfunction _each(dom, parent, expr) {\n\n  // remove the each property from the original tag\n  remAttr(dom, 'each')\n\n  var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),\n    tagName = getTagName(dom),\n    impl = __tagImpl[tagName] || { tmpl: getOuterHTML(dom) },\n    useRoot = SPECIAL_TAGS_REGEX.test(tagName),\n    root = dom.parentNode,\n    ref = document.createTextNode(''),\n    child = getTag(dom),\n    isOption = tagName.toLowerCase() === 'option', // the option tags must be treated differently\n    tags = [],\n    oldItems = [],\n    hasKeys,\n    isVirtual = dom.tagName == 'VIRTUAL'\n\n  // parse the each expression\n  expr = tmpl.loopKeys(expr)\n\n  // insert a marked where the loop tags will be injected\n  root.insertBefore(ref, dom)\n\n  // clean template code\n  parent.one('before-mount', function () {\n\n    // remove the original DOM node\n    dom.parentNode.removeChild(dom)\n    if (root.stub) root = parent.root\n\n  }).on('update', function () {\n    // get the new items collection\n    var items = tmpl(expr.val, parent),\n      // create a fragment to hold the new DOM nodes to inject in the parent tag\n      frag = document.createDocumentFragment()\n\n    // object loop. any changes cause full redraw\n    if (!isArray(items)) {\n      hasKeys = items || false\n      items = hasKeys ?\n        Object.keys(items).map(function (key) {\n          return mkitem(expr, key, items[key])\n        }) : []\n    }\n\n    // loop all the new items\n    var i = 0,\n      itemsLength = items.length\n\n    for (; i < itemsLength; i++) {\n      // reorder only if the items are objects\n      var\n        item = items[i],\n        _mustReorder = mustReorder && typeof item == T_OBJECT && !hasKeys,\n        oldPos = oldItems.indexOf(item),\n        pos = ~oldPos && _mustReorder ? oldPos : i,\n        // does a tag exist in this position?\n        tag = tags[pos]\n\n      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item\n\n      // new tag\n      if (\n        !_mustReorder && !tag // with no-reorder we just update the old tags\n        ||\n        _mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements\n      ) {\n\n        tag = new Tag(impl, {\n          parent: parent,\n          isLoop: true,\n          hasImpl: !!__tagImpl[tagName],\n          root: useRoot ? root : dom.cloneNode(),\n          item: item\n        }, dom.innerHTML)\n\n        tag.mount()\n\n        if (isVirtual) tag._root = tag.root.firstChild // save reference for further moves or inserts\n        // this tag must be appended\n        if (i == tags.length || !tags[i]) { // fix 1581\n          if (isVirtual)\n            addVirtual(tag, frag)\n          else frag.appendChild(tag.root)\n        }\n        // this tag must be insert\n        else {\n          insertTag(isVirtual, tag, tags[i], root, tags, addVirtual, dom)\n          oldItems.splice(i, 0, item)\n        }\n\n        tags.splice(i, 0, tag)\n        pos = i // handled here so no move\n      } else tag.update(item, true)\n\n      // reorder the tag if it's not located in its previous position\n      if (\n        pos !== i && _mustReorder &&\n        tags[i] // fix 1581 unable to reproduce it in a test!\n      ) {\n        // #closes 2040 PLEASE DON'T REMOVE IT!\n        // there are no tests for this feature\n        if (contains(items, oldItems[i]))\n          insertTag(isVirtual, tag, tags[i], root, tags, moveVirtual, dom)\n\n        // update the position attribute if it exists\n        if (expr.pos)\n          tag[expr.pos] = i\n        // move the old tag instance\n        tags.splice(i, 0, tags.splice(pos, 1)[0])\n        // move the old item\n        oldItems.splice(i, 0, oldItems.splice(pos, 1)[0])\n        // if the loop tags are not custom\n        // we need to move all their custom tags into the right position\n        if (!child && tag.tags) moveNestedTags(tag, i)\n      }\n\n      // cache the original item to use it in the events bound to this node\n      // and its children\n      tag._item = item\n      // cache the real parent tag internally\n      defineProperty(tag, '_parent', parent)\n    }\n\n    // remove the redundant tags\n    unmountRedundant(items, tags)\n\n    // insert the new nodes\n    root.insertBefore(frag, ref)\n    if (isOption) {\n\n      // #1374 FireFox bug in <option selected={expression}>\n      if (FIREFOX && !root.multiple) {\n        for (var n = 0; n < root.length; n++) {\n          if (root[n].__riot1374) {\n            root.selectedIndex = n  // clear other options\n            delete root[n].__riot1374\n            break\n          }\n        }\n      }\n    }\n\n    // set the 'tags' property of the parent tag\n    // if child is 'undefined' it means that we don't need to set this property\n    // for example:\n    // we don't need store the `myTag.tags['div']` property if we are looping a div tag\n    // but we need to track the `myTag.tags['child']` property looping a custom child node named `child`\n    if (child) parent.tags[tagName] = tags\n\n    // clone the items array\n    oldItems = items.slice()\n\n  })\n\n}\n/**\n * Object that will be used to inject and manage the css of every tag instance\n */\nvar styleManager = (function(_riot) {\n\n  if (!window) return { // skip injection on the server\n    add: function () {},\n    inject: function () {}\n  }\n\n  var styleNode = (function () {\n    // create a new style element with the correct type\n    var newNode = mkEl('style')\n    setAttr(newNode, 'type', 'text/css')\n\n    // replace any user node or insert the new one into the head\n    var userNode = $('style[type=riot]')\n    if (userNode) {\n      if (userNode.id) newNode.id = userNode.id\n      userNode.parentNode.replaceChild(newNode, userNode)\n    }\n    else document.getElementsByTagName('head')[0].appendChild(newNode)\n\n    return newNode\n  })()\n\n  // Create cache and shortcut to the correct property\n  var cssTextProp = styleNode.styleSheet,\n    stylesToInject = ''\n\n  // Expose the style node in a non-modificable property\n  Object.defineProperty(_riot, 'styleNode', {\n    value: styleNode,\n    writable: true\n  })\n\n  /**\n   * Public api\n   */\n  return {\n    /**\n     * Save a tag style to be later injected into DOM\n     * @param   { String } css [description]\n     */\n    add: function(css) {\n      stylesToInject += css\n    },\n    /**\n     * Inject all previously saved tag styles into DOM\n     * innerHTML seems slow: http://jsperf.com/riot-insert-style\n     */\n    inject: function() {\n      if (stylesToInject) {\n        if (cssTextProp) cssTextProp.cssText += stylesToInject\n        else styleNode.innerHTML += stylesToInject\n        stylesToInject = ''\n      }\n    }\n  }\n\n})(riot)\n\n\nfunction parseNamedElements(root, tag, childTags, forceParsingNamed) {\n\n  walk(root, function(dom) {\n    if (dom.nodeType == 1) {\n      dom.isLoop = dom.isLoop ||\n                  (dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))\n                    ? 1 : 0\n\n      // custom child tag\n      if (childTags) {\n        var child = getTag(dom)\n\n        if (child && !dom.isLoop)\n          childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))\n      }\n\n      if (!dom.isLoop || forceParsingNamed)\n        setNamed(dom, tag, [])\n    }\n\n  })\n\n}\n\nfunction parseExpressions(root, tag, expressions) {\n\n  function addExpr(dom, val, extra) {\n    if (tmpl.hasExpr(val)) {\n      expressions.push(extend({ dom: dom, expr: val }, extra))\n    }\n  }\n\n  walk(root, function(dom) {\n    var type = dom.nodeType,\n      attr\n\n    // text node\n    if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)\n    if (type != 1) return\n\n    /* element */\n\n    // loop\n    attr = getAttr(dom, 'each')\n\n    if (attr) { _each(dom, tag, attr); return false }\n\n    // attribute expressions\n    each(dom.attributes, function(attr) {\n      var name = attr.name,\n        bool = name.split('__')[1]\n\n      addExpr(dom, attr.value, { attr: bool || name, bool: bool })\n      if (bool) { remAttr(dom, name); return false }\n\n    })\n\n    // skip custom tags\n    if (getTag(dom)) return false\n\n  })\n\n}\nfunction Tag(impl, conf, innerHTML) {\n\n  var self = riot.observable(this),\n    opts = inherit(conf.opts) || {},\n    parent = conf.parent,\n    isLoop = conf.isLoop,\n    hasImpl = conf.hasImpl,\n    item = cleanUpData(conf.item),\n    expressions = [],\n    childTags = [],\n    root = conf.root,\n    tagName = root.tagName.toLowerCase(),\n    attr = {},\n    propsInSyncWithParent = [],\n    dom\n\n  // only call unmount if we have a valid __tagImpl (has name property)\n  if (impl.name && root._tag) root._tag.unmount(true)\n\n  // not yet mounted\n  this.isMounted = false\n  root.isLoop = isLoop\n\n  // keep a reference to the tag just created\n  // so we will be able to mount this tag multiple times\n  root._tag = this\n\n  // create a unique id to this tag\n  // it could be handy to use it also to improve the virtual dom rendering speed\n  defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id\n\n  extend(this, { parent: parent, root: root, opts: opts}, item)\n  // protect the \"tags\" property from being overridden\n  defineProperty(this, 'tags', {})\n\n  // grab attributes\n  each(root.attributes, function(el) {\n    var val = el.value\n    // remember attributes with expressions only\n    if (tmpl.hasExpr(val)) attr[el.name] = val\n  })\n\n  dom = mkdom(impl.tmpl, innerHTML, isLoop)\n\n  // options\n  function updateOpts() {\n    var ctx = hasImpl && isLoop ? self : parent || self\n\n    // update opts from current DOM attributes\n    each(root.attributes, function(el) {\n      if (el.name in attr) return\n      var val = el.value\n      opts[toCamel(el.name)] = tmpl.hasExpr(val) ? tmpl(val, ctx) : val\n    })\n    // recover those with expressions\n    each(Object.keys(attr), function(name) {\n      opts[toCamel(name)] = tmpl(attr[name], ctx)\n    })\n  }\n\n  function normalizeData(data) {\n    for (var key in item) {\n      if (typeof self[key] !== T_UNDEF && isWritable(self, key))\n        self[key] = data[key]\n    }\n  }\n\n  function inheritFrom(target) {\n    each(Object.keys(target), function(k) {\n      // some properties must be always in sync with the parent tag\n      var mustSync = !RESERVED_WORDS_BLACKLIST.test(k) && contains(propsInSyncWithParent, k)\n\n      if (typeof self[k] === T_UNDEF || mustSync) {\n        // track the property to keep in sync\n        // so we can keep it updated\n        if (!mustSync) propsInSyncWithParent.push(k)\n        self[k] = target[k]\n      }\n    })\n  }\n\n  /**\n   * Update the tag expressions and options\n   * @param   { * }  data - data we want to use to extend the tag properties\n   * @param   { Boolean } isInherited - is this update coming from a parent tag?\n   * @returns { self }\n   */\n  defineProperty(this, 'update', function(data, isInherited) {\n\n    // make sure the data passed will not override\n    // the component core methods\n    data = cleanUpData(data)\n    // inherit properties from the parent in loop\n    if (isLoop) {\n      inheritFrom(self.parent)\n    }\n    // normalize the tag properties in case an item object was initially passed\n    if (data && isObject(item)) {\n      normalizeData(data)\n      item = data\n    }\n    extend(self, data)\n    updateOpts()\n    self.trigger('update', data)\n    update(expressions, self)\n\n    // the updated event will be triggered\n    // once the DOM will be ready and all the re-flows are completed\n    // this is useful if you want to get the \"real\" root properties\n    // 4 ex: root.offsetWidth ...\n    if (isInherited && self.parent)\n      // closes #1599\n      self.parent.one('updated', function() { self.trigger('updated') })\n    else rAF(function() { self.trigger('updated') })\n\n    return this\n  })\n\n  defineProperty(this, 'mixin', function() {\n    each(arguments, function(mix) {\n      var instance,\n        props = [],\n        obj\n\n      mix = typeof mix === T_STRING ? riot.mixin(mix) : mix\n\n      // check if the mixin is a function\n      if (isFunction(mix)) {\n        // create the new mixin instance\n        instance = new mix()\n      } else instance = mix\n\n      var proto = Object.getPrototypeOf(instance)\n\n      // build multilevel prototype inheritance chain property list\n      do props = props.concat(Object.getOwnPropertyNames(obj || instance))\n      while (obj = Object.getPrototypeOf(obj || instance))\n\n      // loop the keys in the function prototype or the all object keys\n      each(props, function(key) {\n        // bind methods to self\n        // allow mixins to override other properties/parent mixins\n        if (key != 'init') {\n          // check for getters/setters\n          var descriptor = Object.getOwnPropertyDescriptor(instance, key) || Object.getOwnPropertyDescriptor(proto, key)\n          var hasGetterSetter = descriptor && (descriptor.get || descriptor.set)\n\n          // apply method only if it does not already exist on the instance\n          if (!self.hasOwnProperty(key) && hasGetterSetter) {\n            Object.defineProperty(self, key, descriptor)\n          } else {\n            self[key] = isFunction(instance[key]) ?\n              instance[key].bind(self) :\n              instance[key]\n          }\n        }\n      })\n\n      // init method will be called automatically\n      if (instance.init) instance.init.bind(self)()\n    })\n    return this\n  })\n\n  defineProperty(this, 'mount', function() {\n\n    updateOpts()\n\n    // add global mixins\n    var globalMixin = riot.mixin(GLOBAL_MIXIN)\n\n    if (globalMixin)\n      for (var i in globalMixin)\n        if (globalMixin.hasOwnProperty(i))\n          self.mixin(globalMixin[i])\n\n    // children in loop should inherit from true parent\n    if (self._parent && self._parent.root.isLoop) {\n      inheritFrom(self._parent)\n    }\n\n    // initialiation\n    if (impl.fn) impl.fn.call(self, opts)\n\n    // parse layout after init. fn may calculate args for nested custom tags\n    parseExpressions(dom, self, expressions)\n\n    // mount the child tags\n    toggle(true)\n\n    // update the root adding custom attributes coming from the compiler\n    // it fixes also #1087\n    if (impl.attrs)\n      walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })\n    if (impl.attrs || hasImpl)\n      parseExpressions(self.root, self, expressions)\n\n    if (!self.parent || isLoop) self.update(item)\n\n    // internal use only, fixes #403\n    self.trigger('before-mount')\n\n    if (isLoop && !hasImpl) {\n      // update the root attribute for the looped elements\n      root = dom.firstChild\n    } else {\n      while (dom.firstChild) root.appendChild(dom.firstChild)\n      if (root.stub) root = parent.root\n    }\n\n    defineProperty(self, 'root', root)\n\n    // parse the named dom nodes in the looped child\n    // adding them to the parent as well\n    if (isLoop)\n      parseNamedElements(self.root, self.parent, null, true)\n\n    // if it's not a child tag we can trigger its mount event\n    if (!self.parent || self.parent.isMounted) {\n      self.isMounted = true\n      self.trigger('mount')\n    }\n    // otherwise we need to wait that the parent event gets triggered\n    else self.parent.one('mount', function() {\n      // avoid to trigger the `mount` event for the tags\n      // not visible included in an if statement\n      if (!isInStub(self.root)) {\n        self.parent.isMounted = self.isMounted = true\n        self.trigger('mount')\n      }\n    })\n  })\n\n\n  defineProperty(this, 'unmount', function(keepRootTag) {\n    var el = root,\n      p = el.parentNode,\n      ptag,\n      tagIndex = __virtualDom.indexOf(self)\n\n    self.trigger('before-unmount')\n\n    // remove this tag instance from the global virtualDom variable\n    if (~tagIndex)\n      __virtualDom.splice(tagIndex, 1)\n\n    if (p) {\n\n      if (parent) {\n        ptag = getImmediateCustomParentTag(parent)\n        // remove this tag from the parent tags object\n        // if there are multiple nested tags with same name..\n        // remove this element form the array\n        if (isArray(ptag.tags[tagName]))\n          each(ptag.tags[tagName], function(tag, i) {\n            if (tag._riot_id == self._riot_id)\n              ptag.tags[tagName].splice(i, 1)\n          })\n        else\n          // otherwise just delete the tag instance\n          ptag.tags[tagName] = undefined\n      }\n\n      else\n        while (el.firstChild) el.removeChild(el.firstChild)\n\n      if (!keepRootTag)\n        p.removeChild(el)\n      else {\n        // the riot-tag and the data-is attributes aren't needed anymore, remove them\n        remAttr(p, RIOT_TAG_IS)\n        remAttr(p, RIOT_TAG) // this will be removed in riot 3.0.0\n      }\n\n    }\n\n    if (this._virts) {\n      each(this._virts, function(v) {\n        if (v.parentNode) v.parentNode.removeChild(v)\n      })\n    }\n\n    self.trigger('unmount')\n    toggle()\n    self.off('*')\n    self.isMounted = false\n    delete root._tag\n\n  })\n\n  // proxy function to bind updates\n  // dispatched from a parent tag\n  function onChildUpdate(data) { self.update(data, true) }\n\n  function toggle(isMount) {\n\n    // mount/unmount children\n    each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })\n\n    // listen/unlisten parent (events flow one way from parent to children)\n    if (!parent) return\n    var evt = isMount ? 'on' : 'off'\n\n    // the loop tags will be always in sync with the parent automatically\n    if (isLoop)\n      parent[evt]('unmount', self.unmount)\n    else {\n      parent[evt]('update', onChildUpdate)[evt]('unmount', self.unmount)\n    }\n  }\n\n\n  // named elements available for fn\n  parseNamedElements(dom, this, childTags)\n\n}\n/**\n * Attach an event to a DOM node\n * @param { String } name - event name\n * @param { Function } handler - event callback\n * @param { Object } dom - dom node\n * @param { Tag } tag - tag instance\n */\nfunction setEventHandler(name, handler, dom, tag) {\n\n  dom[name] = function(e) {\n\n    var ptag = tag._parent,\n      item = tag._item,\n      el\n\n    if (!item)\n      while (ptag && !item) {\n        item = ptag._item\n        ptag = ptag._parent\n      }\n\n    // cross browser event fix\n    e = e || window.event\n\n    // override the event properties\n    if (isWritable(e, 'currentTarget')) e.currentTarget = dom\n    if (isWritable(e, 'target')) e.target = e.srcElement\n    if (isWritable(e, 'which')) e.which = e.charCode || e.keyCode\n\n    e.item = item\n\n    // prevent default behaviour (by default)\n    if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {\n      if (e.preventDefault) e.preventDefault()\n      e.returnValue = false\n    }\n\n    if (!e.preventUpdate) {\n      el = item ? getImmediateCustomParentTag(ptag) : tag\n      el.update()\n    }\n\n  }\n\n}\n\n\n/**\n * Insert a DOM node replacing another one (used by if- attribute)\n * @param   { Object } root - parent node\n * @param   { Object } node - node replaced\n * @param   { Object } before - node added\n */\nfunction insertTo(root, node, before) {\n  if (!root) return\n  root.insertBefore(before, node)\n  root.removeChild(node)\n}\n\n/**\n * Update the expressions in a Tag instance\n * @param   { Array } expressions - expression that must be re evaluated\n * @param   { Tag } tag - tag instance\n */\nfunction update(expressions, tag) {\n\n  each(expressions, function(expr, i) {\n\n    var dom = expr.dom,\n      attrName = expr.attr,\n      value = tmpl(expr.expr, tag),\n      parent = expr.parent || expr.dom.parentNode\n\n    if (expr.bool) {\n      value = !!value\n    } else if (value == null) {\n      value = ''\n    }\n\n    // #1638: regression of #1612, update the dom only if the value of the\n    // expression was changed\n    if (expr.value === value) {\n      return\n    }\n    expr.value = value\n\n    // textarea and text nodes has no attribute name\n    if (!attrName) {\n      // about #815 w/o replace: the browser converts the value to a string,\n      // the comparison by \"==\" does too, but not in the server\n      value += ''\n      // test for parent avoids error with invalid assignment to nodeValue\n      if (parent) {\n        // cache the parent node because somehow it will become null on IE\n        // on the next iteration\n        expr.parent = parent\n        if (parent.tagName === 'TEXTAREA') {\n          parent.value = value                    // #1113\n          if (!IE_VERSION) dom.nodeValue = value  // #1625 IE throws here, nodeValue\n        }                                         // will be available on 'updated'\n        else dom.nodeValue = value\n      }\n      return\n    }\n\n    // ~~#1612: look for changes in dom.value when updating the value~~\n    if (attrName === 'value') {\n      if (dom.value !== value) {\n        dom.value = value\n        setAttr(dom, attrName, value)\n      }\n      return\n    } else {\n      // remove original attribute\n      remAttr(dom, attrName)\n    }\n\n    // event handler\n    if (isFunction(value)) {\n      setEventHandler(attrName, value, dom, tag)\n\n    // if- conditional\n    } else if (attrName == 'if') {\n      var stub = expr.stub,\n        add = function() { insertTo(stub.parentNode, stub, dom) },\n        remove = function() { insertTo(dom.parentNode, dom, stub) }\n\n      // add to DOM\n      if (value) {\n        if (stub) {\n          add()\n          dom.inStub = false\n          // avoid to trigger the mount event if the tags is not visible yet\n          // maybe we can optimize this avoiding to mount the tag at all\n          if (!isInStub(dom)) {\n            walk(dom, function(el) {\n              if (el._tag && !el._tag.isMounted)\n                el._tag.isMounted = !!el._tag.trigger('mount')\n            })\n          }\n        }\n      // remove from DOM\n      } else {\n        stub = expr.stub = stub || document.createTextNode('')\n        // if the parentNode is defined we can easily replace the tag\n        if (dom.parentNode)\n          remove()\n        // otherwise we need to wait the updated event\n        else (tag.parent || tag).one('updated', remove)\n\n        dom.inStub = true\n      }\n    // show / hide\n    } else if (attrName === 'show') {\n      dom.style.display = value ? '' : 'none'\n\n    } else if (attrName === 'hide') {\n      dom.style.display = value ? 'none' : ''\n\n    } else if (expr.bool) {\n      dom[attrName] = value\n      if (value) setAttr(dom, attrName, attrName)\n      if (FIREFOX && attrName === 'selected' && dom.tagName === 'OPTION') {\n        dom.__riot1374 = value   // #1374\n      }\n\n    } else if (value === 0 || value && typeof value !== T_OBJECT) {\n      // <img src=\"{ expr }\">\n      if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {\n        attrName = attrName.slice(RIOT_PREFIX.length)\n      }\n      setAttr(dom, attrName, value)\n    }\n\n  })\n\n}\n/**\n * Specialized function for looping an array-like collection with `each={}`\n * @param   { Array } els - collection of items\n * @param   {Function} fn - callback function\n * @returns { Array } the array looped\n */\nfunction each(els, fn) {\n  var len = els ? els.length : 0\n\n  for (var i = 0, el; i < len; i++) {\n    el = els[i]\n    // return false -> current item was removed by fn during the loop\n    if (el != null && fn(el, i) === false) i--\n  }\n  return els\n}\n\n/**\n * Detect if the argument passed is a function\n * @param   { * } v - whatever you want to pass to this function\n * @returns { Boolean } -\n */\nfunction isFunction(v) {\n  return typeof v === T_FUNCTION || false   // avoid IE problems\n}\n\n/**\n * Get the outer html of any DOM node SVGs included\n * @param   { Object } el - DOM node to parse\n * @returns { String } el.outerHTML\n */\nfunction getOuterHTML(el) {\n  if (el.outerHTML) return el.outerHTML\n  // some browsers do not support outerHTML on the SVGs tags\n  else {\n    var container = mkEl('div')\n    container.appendChild(el.cloneNode(true))\n    return container.innerHTML\n  }\n}\n\n/**\n * Set the inner html of any DOM node SVGs included\n * @param { Object } container - DOM node where we will inject the new html\n * @param { String } html - html to inject\n */\nfunction setInnerHTML(container, html) {\n  if (typeof container.innerHTML != T_UNDEF) container.innerHTML = html\n  // some browsers do not support innerHTML on the SVGs tags\n  else {\n    var doc = new DOMParser().parseFromString(html, 'application/xml')\n    container.appendChild(\n      container.ownerDocument.importNode(doc.documentElement, true)\n    )\n  }\n}\n\n/**\n * Checks wether a DOM node must be considered part of an svg document\n * @param   { String }  name - tag name\n * @returns { Boolean } -\n */\nfunction isSVGTag(name) {\n  return ~SVG_TAGS_LIST.indexOf(name)\n}\n\n/**\n * Detect if the argument passed is an object, exclude null.\n * NOTE: Use isObject(x) && !isArray(x) to excludes arrays.\n * @param   { * } v - whatever you want to pass to this function\n * @returns { Boolean } -\n */\nfunction isObject(v) {\n  return v && typeof v === T_OBJECT         // typeof null is 'object'\n}\n\n/**\n * Remove any DOM attribute from a node\n * @param   { Object } dom - DOM node we want to update\n * @param   { String } name - name of the property we want to remove\n */\nfunction remAttr(dom, name) {\n  dom.removeAttribute(name)\n}\n\n/**\n * Convert a string containing dashes to camel case\n * @param   { String } string - input string\n * @returns { String } my-string -> myString\n */\nfunction toCamel(string) {\n  return string.replace(/-(\\w)/g, function(_, c) {\n    return c.toUpperCase()\n  })\n}\n\n/**\n * Get the value of any DOM attribute on a node\n * @param   { Object } dom - DOM node we want to parse\n * @param   { String } name - name of the attribute we want to get\n * @returns { String | undefined } name of the node attribute whether it exists\n */\nfunction getAttr(dom, name) {\n  return dom.getAttribute(name)\n}\n\n/**\n * Set any DOM/SVG attribute\n * @param { Object } dom - DOM node we want to update\n * @param { String } name - name of the property we want to set\n * @param { String } val - value of the property we want to set\n */\nfunction setAttr(dom, name, val) {\n  var xlink = XLINK_REGEX.exec(name)\n  if (xlink && xlink[1])\n    dom.setAttributeNS(XLINK_NS, xlink[1], val)\n  else\n    dom.setAttribute(name, val)\n}\n\n/**\n * Detect the tag implementation by a DOM node\n * @param   { Object } dom - DOM node we need to parse to get its tag implementation\n * @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)\n */\nfunction getTag(dom) {\n  return dom.tagName && __tagImpl[getAttr(dom, RIOT_TAG_IS) ||\n    getAttr(dom, RIOT_TAG) || dom.tagName.toLowerCase()]\n}\n/**\n * Add a child tag to its parent into the `tags` object\n * @param   { Object } tag - child tag instance\n * @param   { String } tagName - key where the new tag will be stored\n * @param   { Object } parent - tag instance where the new child tag will be included\n */\nfunction addChildTag(tag, tagName, parent) {\n  var cachedTag = parent.tags[tagName]\n\n  // if there are multiple children tags having the same name\n  if (cachedTag) {\n    // if the parent tags property is not yet an array\n    // create it adding the first cached tag\n    if (!isArray(cachedTag))\n      // don't add the same tag twice\n      if (cachedTag !== tag)\n        parent.tags[tagName] = [cachedTag]\n    // add the new nested tag to the array\n    if (!contains(parent.tags[tagName], tag))\n      parent.tags[tagName].push(tag)\n  } else {\n    parent.tags[tagName] = tag\n  }\n}\n\n/**\n * Move the position of a custom tag in its parent tag\n * @param   { Object } tag - child tag instance\n * @param   { String } tagName - key where the tag was stored\n * @param   { Number } newPos - index where the new tag will be stored\n */\nfunction moveChildTag(tag, tagName, newPos) {\n  var parent = tag.parent,\n    tags\n  // no parent no move\n  if (!parent) return\n\n  tags = parent.tags[tagName]\n\n  if (isArray(tags))\n    tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])\n  else addChildTag(tag, tagName, parent)\n}\n\n/**\n * Create a new child tag including it correctly into its parent\n * @param   { Object } child - child tag implementation\n * @param   { Object } opts - tag options containing the DOM node where the tag will be mounted\n * @param   { String } innerHTML - inner html of the child node\n * @param   { Object } parent - instance of the parent tag including the child custom tag\n * @returns { Object } instance of the new child tag just created\n */\nfunction initChildTag(child, opts, innerHTML, parent) {\n  var tag = new Tag(child, opts, innerHTML),\n    tagName = getTagName(opts.root),\n    ptag = getImmediateCustomParentTag(parent)\n  // fix for the parent attribute in the looped elements\n  tag.parent = ptag\n  // store the real parent tag\n  // in some cases this could be different from the custom parent tag\n  // for example in nested loops\n  tag._parent = parent\n\n  // add this tag to the custom parent tag\n  addChildTag(tag, tagName, ptag)\n  // and also to the real parent tag\n  if (ptag !== parent)\n    addChildTag(tag, tagName, parent)\n  // empty the child node once we got its template\n  // to avoid that its children get compiled multiple times\n  opts.root.innerHTML = ''\n\n  return tag\n}\n\n/**\n * Loop backward all the parents tree to detect the first custom parent tag\n * @param   { Object } tag - a Tag instance\n * @returns { Object } the instance of the first custom parent tag found\n */\nfunction getImmediateCustomParentTag(tag) {\n  var ptag = tag\n  while (!getTag(ptag.root)) {\n    if (!ptag.parent) break\n    ptag = ptag.parent\n  }\n  return ptag\n}\n\n/**\n * Helper function to set an immutable property\n * @param   { Object } el - object where the new property will be set\n * @param   { String } key - object key where the new property will be stored\n * @param   { * } value - value of the new property\n* @param   { Object } options - set the propery overriding the default options\n * @returns { Object } - the initial object\n */\nfunction defineProperty(el, key, value, options) {\n  Object.defineProperty(el, key, extend({\n    value: value,\n    enumerable: false,\n    writable: false,\n    configurable: true\n  }, options))\n  return el\n}\n\n/**\n * Get the tag name of any DOM node\n * @param   { Object } dom - DOM node we want to parse\n * @returns { String } name to identify this dom node in riot\n */\nfunction getTagName(dom) {\n  var child = getTag(dom),\n    namedTag = getAttr(dom, 'name'),\n    tagName = namedTag && !tmpl.hasExpr(namedTag) ?\n                namedTag :\n              child ? child.name : dom.tagName.toLowerCase()\n\n  return tagName\n}\n\n/**\n * Extend any object with other properties\n * @param   { Object } src - source object\n * @returns { Object } the resulting extended object\n *\n * var obj = { foo: 'baz' }\n * extend(obj, {bar: 'bar', foo: 'bar'})\n * console.log(obj) => {bar: 'bar', foo: 'bar'}\n *\n */\nfunction extend(src) {\n  var obj, args = arguments\n  for (var i = 1; i < args.length; ++i) {\n    if (obj = args[i]) {\n      for (var key in obj) {\n        // check if this property of the source object could be overridden\n        if (isWritable(src, key))\n          src[key] = obj[key]\n      }\n    }\n  }\n  return src\n}\n\n/**\n * Check whether an array contains an item\n * @param   { Array } arr - target array\n * @param   { * } item - item to test\n * @returns { Boolean } Does 'arr' contain 'item'?\n */\nfunction contains(arr, item) {\n  return ~arr.indexOf(item)\n}\n\n/**\n * Check whether an object is a kind of array\n * @param   { * } a - anything\n * @returns {Boolean} is 'a' an array?\n */\nfunction isArray(a) { return Array.isArray(a) || a instanceof Array }\n\n/**\n * Detect whether a property of an object could be overridden\n * @param   { Object }  obj - source object\n * @param   { String }  key - object property\n * @returns { Boolean } is this property writable?\n */\nfunction isWritable(obj, key) {\n  var props = Object.getOwnPropertyDescriptor(obj, key)\n  return typeof obj[key] === T_UNDEF || props && props.writable\n}\n\n\n/**\n * With this function we avoid that the internal Tag methods get overridden\n * @param   { Object } data - options we want to use to extend the tag instance\n * @returns { Object } clean object without containing the riot internal reserved words\n */\nfunction cleanUpData(data) {\n  if (!(data instanceof Tag) && !(data && typeof data.trigger == T_FUNCTION))\n    return data\n\n  var o = {}\n  for (var key in data) {\n    if (!RESERVED_WORDS_BLACKLIST.test(key)) o[key] = data[key]\n  }\n  return o\n}\n\n/**\n * Walk down recursively all the children tags starting dom node\n * @param   { Object }   dom - starting node where we will start the recursion\n * @param   { Function } fn - callback to transform the child node just found\n */\nfunction walk(dom, fn) {\n  if (dom) {\n    // stop the recursion\n    if (fn(dom) === false) return\n    else {\n      dom = dom.firstChild\n\n      while (dom) {\n        walk(dom, fn)\n        dom = dom.nextSibling\n      }\n    }\n  }\n}\n\n/**\n * Minimize risk: only zero or one _space_ between attr & value\n * @param   { String }   html - html string we want to parse\n * @param   { Function } fn - callback function to apply on any attribute found\n */\nfunction walkAttributes(html, fn) {\n  var m,\n    re = /([-\\w]+) ?= ?(?:\"([^\"]*)|'([^']*)|({[^}]*}))/g\n\n  while (m = re.exec(html)) {\n    fn(m[1].toLowerCase(), m[2] || m[3] || m[4])\n  }\n}\n\n/**\n * Check whether a DOM node is in stub mode, useful for the riot 'if' directive\n * @param   { Object }  dom - DOM node we want to parse\n * @returns { Boolean } -\n */\nfunction isInStub(dom) {\n  while (dom) {\n    if (dom.inStub) return true\n    dom = dom.parentNode\n  }\n  return false\n}\n\n/**\n * Create a generic DOM node\n * @param   { String } name - name of the DOM node we want to create\n * @param   { Boolean } isSvg - should we use a SVG as parent node?\n * @returns { Object } DOM node just created\n */\nfunction mkEl(name, isSvg) {\n  return isSvg ?\n    document.createElementNS('http://www.w3.org/2000/svg', 'svg') :\n    document.createElement(name)\n}\n\n/**\n * Shorter and fast way to select multiple nodes in the DOM\n * @param   { String } selector - DOM selector\n * @param   { Object } ctx - DOM node where the targets of our search will is located\n * @returns { Object } dom nodes found\n */\nfunction $$(selector, ctx) {\n  return (ctx || document).querySelectorAll(selector)\n}\n\n/**\n * Shorter and fast way to select a single node in the DOM\n * @param   { String } selector - unique dom selector\n * @param   { Object } ctx - DOM node where the target of our search will is located\n * @returns { Object } dom node found\n */\nfunction $(selector, ctx) {\n  return (ctx || document).querySelector(selector)\n}\n\n/**\n * Simple object prototypal inheritance\n * @param   { Object } parent - parent object\n * @returns { Object } child instance\n */\nfunction inherit(parent) {\n  return Object.create(parent || null)\n}\n\n/**\n * Get the name property needed to identify a DOM node in riot\n * @param   { Object } dom - DOM node we need to parse\n * @returns { String | undefined } give us back a string to identify this dom node\n */\nfunction getNamedKey(dom) {\n  return getAttr(dom, 'id') || getAttr(dom, 'name')\n}\n\n/**\n * Set the named properties of a tag element\n * @param { Object } dom - DOM node we need to parse\n * @param { Object } parent - tag instance where the named dom element will be eventually added\n * @param { Array } keys - list of all the tag instance properties\n */\nfunction setNamed(dom, parent, keys) {\n  // get the key value we want to add to the tag instance\n  var key = getNamedKey(dom),\n    isArr,\n    // add the node detected to a tag instance using the named property\n    add = function(value) {\n      // avoid to override the tag properties already set\n      if (contains(keys, key)) return\n      // check whether this value is an array\n      isArr = isArray(value)\n      // if the key was never set\n      if (!value)\n        // set it once on the tag instance\n        parent[key] = dom\n      // if it was an array and not yet set\n      else if (!isArr || isArr && !contains(value, dom)) {\n        // add the dom node into the array\n        if (isArr)\n          value.push(dom)\n        else\n          parent[key] = [value, dom]\n      }\n    }\n\n  // skip the elements with no named properties\n  if (!key) return\n\n  // check whether this key has been already evaluated\n  if (tmpl.hasExpr(key))\n    // wait the first updated event only once\n    parent.one('mount', function() {\n      key = getNamedKey(dom)\n      add(parent[key])\n    })\n  else\n    add(parent[key])\n\n}\n\n/**\n * Faster String startsWith alternative\n * @param   { String } src - source string\n * @param   { String } str - test string\n * @returns { Boolean } -\n */\nfunction startsWith(src, str) {\n  return src.slice(0, str.length) === str\n}\n\n/**\n * requestAnimationFrame function\n * Adapted from https://gist.github.com/paulirish/1579671, license MIT\n */\nvar rAF = (function (w) {\n  var raf = w.requestAnimationFrame    ||\n            w.mozRequestAnimationFrame || w.webkitRequestAnimationFrame\n\n  if (!raf || /iP(ad|hone|od).*OS 6/.test(w.navigator.userAgent)) {  // buggy iOS6\n    var lastTime = 0\n\n    raf = function (cb) {\n      var nowtime = Date.now(), timeout = Math.max(16 - (nowtime - lastTime), 0)\n      setTimeout(function () { cb(lastTime = nowtime + timeout) }, timeout)\n    }\n  }\n  return raf\n\n})(window || {})\n\n/**\n * Mount a tag creating new Tag instance\n * @param   { Object } root - dom node where the tag will be mounted\n * @param   { String } tagName - name of the riot tag we want to mount\n * @param   { Object } opts - options to pass to the Tag instance\n * @returns { Tag } a new Tag instance\n */\nfunction mountTo(root, tagName, opts) {\n  var tag = __tagImpl[tagName],\n    // cache the inner HTML to fix #855\n    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML\n\n  // clear the inner html\n  root.innerHTML = ''\n\n  if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)\n\n  if (tag && tag.mount) {\n    tag.mount()\n    // add this tag to the virtualDom variable\n    if (!contains(__virtualDom, tag)) __virtualDom.push(tag)\n  }\n\n  return tag\n}\n/**\n * Riot public api\n */\n\n// share methods for other riot parts, e.g. compiler\nriot.util = { brackets: brackets, tmpl: tmpl }\n\n/**\n * Create a mixin that could be globally shared across all the tags\n */\nriot.mixin = (function() {\n  var mixins = {},\n    globals = mixins[GLOBAL_MIXIN] = {},\n    _id = 0\n\n  /**\n   * Create/Return a mixin by its name\n   * @param   { String }  name - mixin name (global mixin if object)\n   * @param   { Object }  mixin - mixin logic\n   * @param   { Boolean } g - is global?\n   * @returns { Object }  the mixin logic\n   */\n  return function(name, mixin, g) {\n    // Unnamed global\n    if (isObject(name)) {\n      riot.mixin('__unnamed_'+_id++, name, true)\n      return\n    }\n\n    var store = g ? globals : mixins\n\n    // Getter\n    if (!mixin) {\n      if (typeof store[name] === T_UNDEF) {\n        throw new Error('Unregistered mixin: ' + name)\n      }\n      return store[name]\n    }\n    // Setter\n    if (isFunction(mixin)) {\n      extend(mixin.prototype, store[name] || {})\n      store[name] = mixin\n    }\n    else {\n      store[name] = extend(store[name] || {}, mixin)\n    }\n  }\n\n})()\n\n/**\n * Create a new riot tag implementation\n * @param   { String }   name - name/id of the new riot tag\n * @param   { String }   html - tag template\n * @param   { String }   css - custom tag css\n * @param   { String }   attrs - root tag attributes\n * @param   { Function } fn - user function\n * @returns { String } name/id of the tag just created\n */\nriot.tag = function(name, html, css, attrs, fn) {\n  if (isFunction(attrs)) {\n    fn = attrs\n    if (/^[\\w\\-]+\\s?=/.test(css)) {\n      attrs = css\n      css = ''\n    } else attrs = ''\n  }\n  if (css) {\n    if (isFunction(css)) fn = css\n    else styleManager.add(css)\n  }\n  name = name.toLowerCase()\n  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }\n  return name\n}\n\n/**\n * Create a new riot tag implementation (for use by the compiler)\n * @param   { String }   name - name/id of the new riot tag\n * @param   { String }   html - tag template\n * @param   { String }   css - custom tag css\n * @param   { String }   attrs - root tag attributes\n * @param   { Function } fn - user function\n * @returns { String } name/id of the tag just created\n */\nriot.tag2 = function(name, html, css, attrs, fn) {\n  if (css) styleManager.add(css)\n  //if (bpair) riot.settings.brackets = bpair\n  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }\n  return name\n}\n\n/**\n * Mount a tag using a specific tag implementation\n * @param   { String } selector - tag DOM selector\n * @param   { String } tagName - tag implementation name\n * @param   { Object } opts - tag logic\n * @returns { Array } new tags instances\n */\nriot.mount = function(selector, tagName, opts) {\n\n  var els,\n    allTags,\n    tags = []\n\n  // helper functions\n\n  function addRiotTags(arr) {\n    var list = ''\n    each(arr, function (e) {\n      if (!/[^-\\w]/.test(e)) {\n        e = e.trim().toLowerCase()\n        list += ',[' + RIOT_TAG_IS + '=\"' + e + '\"],[' + RIOT_TAG + '=\"' + e + '\"]'\n      }\n    })\n    return list\n  }\n\n  function selectAllTags() {\n    var keys = Object.keys(__tagImpl)\n    return keys + addRiotTags(keys)\n  }\n\n  function pushTags(root) {\n    if (root.tagName) {\n      var riotTag = getAttr(root, RIOT_TAG_IS) || getAttr(root, RIOT_TAG)\n\n      // have tagName? force riot-tag to be the same\n      if (tagName && riotTag !== tagName) {\n        riotTag = tagName\n        setAttr(root, RIOT_TAG_IS, tagName)\n        setAttr(root, RIOT_TAG, tagName) // this will be removed in riot 3.0.0\n      }\n      var tag = mountTo(root, riotTag || root.tagName.toLowerCase(), opts)\n\n      if (tag) tags.push(tag)\n    } else if (root.length) {\n      each(root, pushTags)   // assume nodeList\n    }\n  }\n\n  // ----- mount code -----\n\n  // inject styles into DOM\n  styleManager.inject()\n\n  if (isObject(tagName)) {\n    opts = tagName\n    tagName = 0\n  }\n\n  // crawl the DOM to find the tag\n  if (typeof selector === T_STRING) {\n    if (selector === '*')\n      // select all the tags registered\n      // and also the tags found with the riot-tag attribute set\n      selector = allTags = selectAllTags()\n    else\n      // or just the ones named like the selector\n      selector += addRiotTags(selector.split(/, */))\n\n    // make sure to pass always a selector\n    // to the querySelectorAll function\n    els = selector ? $$(selector) : []\n  }\n  else\n    // probably you have passed already a tag or a NodeList\n    els = selector\n\n  // select all the registered and mount them inside their root elements\n  if (tagName === '*') {\n    // get all custom tags\n    tagName = allTags || selectAllTags()\n    // if the root els it's just a single tag\n    if (els.tagName)\n      els = $$(tagName, els)\n    else {\n      // select all the children for all the different root elements\n      var nodeList = []\n      each(els, function (_el) {\n        nodeList.push($$(tagName, _el))\n      })\n      els = nodeList\n    }\n    // get rid of the tagName\n    tagName = 0\n  }\n\n  pushTags(els)\n\n  return tags\n}\n\n/**\n * Update all the tags instances created\n * @returns { Array } all the tags instances\n */\nriot.update = function() {\n  return each(__virtualDom, function(tag) {\n    tag.update()\n  })\n}\n\n/**\n * Export the Virtual DOM\n */\nriot.vdom = __virtualDom\n\n/**\n * Export the Tag constructor\n */\nriot.Tag = Tag\n  // support CommonJS, AMD & browser\n  /* istanbul ignore next */\n  if (typeof exports === T_OBJECT)\n    module.exports = riot\n  else if (typeof define === T_FUNCTION && typeof define.amd !== T_UNDEF)\n    define(function() { return riot })\n  else\n    window.riot = riot\n\n})(typeof window != 'undefined' ? window : void 0);\n","//! moment.js\n\n;(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\n    var hookCallback;\n\n    function hooks () {\n        return hookCallback.apply(null, arguments);\n    }\n\n    // This is done to register the method called with moment()\n    // without creating circular dependencies.\n    function setHookCallback (callback) {\n        hookCallback = callback;\n    }\n\n    function isArray(input) {\n        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n    }\n\n    function isObject(input) {\n        // IE8 will treat undefined and null as object if it wasn't for\n        // input != null\n        return input != null && Object.prototype.toString.call(input) === '[object Object]';\n    }\n\n    function isObjectEmpty(obj) {\n        if (Object.getOwnPropertyNames) {\n            return (Object.getOwnPropertyNames(obj).length === 0);\n        } else {\n            var k;\n            for (k in obj) {\n                if (obj.hasOwnProperty(k)) {\n                    return false;\n                }\n            }\n            return true;\n        }\n    }\n\n    function isUndefined(input) {\n        return input === void 0;\n    }\n\n    function isNumber(input) {\n        return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n    }\n\n    function isDate(input) {\n        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n    }\n\n    function map(arr, fn) {\n        var res = [], i;\n        for (i = 0; i < arr.length; ++i) {\n            res.push(fn(arr[i], i));\n        }\n        return res;\n    }\n\n    function hasOwnProp(a, b) {\n        return Object.prototype.hasOwnProperty.call(a, b);\n    }\n\n    function extend(a, b) {\n        for (var i in b) {\n            if (hasOwnProp(b, i)) {\n                a[i] = b[i];\n            }\n        }\n\n        if (hasOwnProp(b, 'toString')) {\n            a.toString = b.toString;\n        }\n\n        if (hasOwnProp(b, 'valueOf')) {\n            a.valueOf = b.valueOf;\n        }\n\n        return a;\n    }\n\n    function createUTC (input, format, locale, strict) {\n        return createLocalOrUTC(input, format, locale, strict, true).utc();\n    }\n\n    function defaultParsingFlags() {\n        // We need to deep clone this object.\n        return {\n            empty           : false,\n            unusedTokens    : [],\n            unusedInput     : [],\n            overflow        : -2,\n            charsLeftOver   : 0,\n            nullInput       : false,\n            invalidMonth    : null,\n            invalidFormat   : false,\n            userInvalidated : false,\n            iso             : false,\n            parsedDateParts : [],\n            meridiem        : null,\n            rfc2822         : false,\n            weekdayMismatch : false\n        };\n    }\n\n    function getParsingFlags(m) {\n        if (m._pf == null) {\n            m._pf = defaultParsingFlags();\n        }\n        return m._pf;\n    }\n\n    var some;\n    if (Array.prototype.some) {\n        some = Array.prototype.some;\n    } else {\n        some = function (fun) {\n            var t = Object(this);\n            var len = t.length >>> 0;\n\n            for (var i = 0; i < len; i++) {\n                if (i in t && fun.call(this, t[i], i, t)) {\n                    return true;\n                }\n            }\n\n            return false;\n        };\n    }\n\n    function isValid(m) {\n        if (m._isValid == null) {\n            var flags = getParsingFlags(m);\n            var parsedParts = some.call(flags.parsedDateParts, function (i) {\n                return i != null;\n            });\n            var isNowValid = !isNaN(m._d.getTime()) &&\n                flags.overflow < 0 &&\n                !flags.empty &&\n                !flags.invalidMonth &&\n                !flags.invalidWeekday &&\n                !flags.weekdayMismatch &&\n                !flags.nullInput &&\n                !flags.invalidFormat &&\n                !flags.userInvalidated &&\n                (!flags.meridiem || (flags.meridiem && parsedParts));\n\n            if (m._strict) {\n                isNowValid = isNowValid &&\n                    flags.charsLeftOver === 0 &&\n                    flags.unusedTokens.length === 0 &&\n                    flags.bigHour === undefined;\n            }\n\n            if (Object.isFrozen == null || !Object.isFrozen(m)) {\n                m._isValid = isNowValid;\n            }\n            else {\n                return isNowValid;\n            }\n        }\n        return m._isValid;\n    }\n\n    function createInvalid (flags) {\n        var m = createUTC(NaN);\n        if (flags != null) {\n            extend(getParsingFlags(m), flags);\n        }\n        else {\n            getParsingFlags(m).userInvalidated = true;\n        }\n\n        return m;\n    }\n\n    // Plugins that add properties should also add the key here (null value),\n    // so we can properly clone ourselves.\n    var momentProperties = hooks.momentProperties = [];\n\n    function copyConfig(to, from) {\n        var i, prop, val;\n\n        if (!isUndefined(from._isAMomentObject)) {\n            to._isAMomentObject = from._isAMomentObject;\n        }\n        if (!isUndefined(from._i)) {\n            to._i = from._i;\n        }\n        if (!isUndefined(from._f)) {\n            to._f = from._f;\n        }\n        if (!isUndefined(from._l)) {\n            to._l = from._l;\n        }\n        if (!isUndefined(from._strict)) {\n            to._strict = from._strict;\n        }\n        if (!isUndefined(from._tzm)) {\n            to._tzm = from._tzm;\n        }\n        if (!isUndefined(from._isUTC)) {\n            to._isUTC = from._isUTC;\n        }\n        if (!isUndefined(from._offset)) {\n            to._offset = from._offset;\n        }\n        if (!isUndefined(from._pf)) {\n            to._pf = getParsingFlags(from);\n        }\n        if (!isUndefined(from._locale)) {\n            to._locale = from._locale;\n        }\n\n        if (momentProperties.length > 0) {\n            for (i = 0; i < momentProperties.length; i++) {\n                prop = momentProperties[i];\n                val = from[prop];\n                if (!isUndefined(val)) {\n                    to[prop] = val;\n                }\n            }\n        }\n\n        return to;\n    }\n\n    var updateInProgress = false;\n\n    // Moment prototype object\n    function Moment(config) {\n        copyConfig(this, config);\n        this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n        if (!this.isValid()) {\n            this._d = new Date(NaN);\n        }\n        // Prevent infinite loop in case updateOffset creates new moment\n        // objects.\n        if (updateInProgress === false) {\n            updateInProgress = true;\n            hooks.updateOffset(this);\n            updateInProgress = false;\n        }\n    }\n\n    function isMoment (obj) {\n        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n    }\n\n    function absFloor (number) {\n        if (number < 0) {\n            // -0 -> 0\n            return Math.ceil(number) || 0;\n        } else {\n            return Math.floor(number);\n        }\n    }\n\n    function toInt(argumentForCoercion) {\n        var coercedNumber = +argumentForCoercion,\n            value = 0;\n\n        if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n            value = absFloor(coercedNumber);\n        }\n\n        return value;\n    }\n\n    // compare two arrays, return the number of differences\n    function compareArrays(array1, array2, dontConvert) {\n        var len = Math.min(array1.length, array2.length),\n            lengthDiff = Math.abs(array1.length - array2.length),\n            diffs = 0,\n            i;\n        for (i = 0; i < len; i++) {\n            if ((dontConvert && array1[i] !== array2[i]) ||\n                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {\n                diffs++;\n            }\n        }\n        return diffs + lengthDiff;\n    }\n\n    function warn(msg) {\n        if (hooks.suppressDeprecationWarnings === false &&\n                (typeof console !==  'undefined') && console.warn) {\n            console.warn('Deprecation warning: ' + msg);\n        }\n    }\n\n    function deprecate(msg, fn) {\n        var firstTime = true;\n\n        return extend(function () {\n            if (hooks.deprecationHandler != null) {\n                hooks.deprecationHandler(null, msg);\n            }\n            if (firstTime) {\n                var args = [];\n                var arg;\n                for (var i = 0; i < arguments.length; i++) {\n                    arg = '';\n                    if (typeof arguments[i] === 'object') {\n                        arg += '\\n[' + i + '] ';\n                        for (var key in arguments[0]) {\n                            arg += key + ': ' + arguments[0][key] + ', ';\n                        }\n                        arg = arg.slice(0, -2); // Remove trailing comma and space\n                    } else {\n                        arg = arguments[i];\n                    }\n                    args.push(arg);\n                }\n                warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + (new Error()).stack);\n                firstTime = false;\n            }\n            return fn.apply(this, arguments);\n        }, fn);\n    }\n\n    var deprecations = {};\n\n    function deprecateSimple(name, msg) {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(name, msg);\n        }\n        if (!deprecations[name]) {\n            warn(msg);\n            deprecations[name] = true;\n        }\n    }\n\n    hooks.suppressDeprecationWarnings = false;\n    hooks.deprecationHandler = null;\n\n    function isFunction(input) {\n        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n    }\n\n    function set (config) {\n        var prop, i;\n        for (i in config) {\n            prop = config[i];\n            if (isFunction(prop)) {\n                this[i] = prop;\n            } else {\n                this['_' + i] = prop;\n            }\n        }\n        this._config = config;\n        // Lenient ordinal parsing accepts just a number in addition to\n        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n        // TODO: Remove \"ordinalParse\" fallback in next major release.\n        this._dayOfMonthOrdinalParseLenient = new RegExp(\n            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n                '|' + (/\\d{1,2}/).source);\n    }\n\n    function mergeConfigs(parentConfig, childConfig) {\n        var res = extend({}, parentConfig), prop;\n        for (prop in childConfig) {\n            if (hasOwnProp(childConfig, prop)) {\n                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                    res[prop] = {};\n                    extend(res[prop], parentConfig[prop]);\n                    extend(res[prop], childConfig[prop]);\n                } else if (childConfig[prop] != null) {\n                    res[prop] = childConfig[prop];\n                } else {\n                    delete res[prop];\n                }\n            }\n        }\n        for (prop in parentConfig) {\n            if (hasOwnProp(parentConfig, prop) &&\n                    !hasOwnProp(childConfig, prop) &&\n                    isObject(parentConfig[prop])) {\n                // make sure changes to properties don't modify parent config\n                res[prop] = extend({}, res[prop]);\n            }\n        }\n        return res;\n    }\n\n    function Locale(config) {\n        if (config != null) {\n            this.set(config);\n        }\n    }\n\n    var keys;\n\n    if (Object.keys) {\n        keys = Object.keys;\n    } else {\n        keys = function (obj) {\n            var i, res = [];\n            for (i in obj) {\n                if (hasOwnProp(obj, i)) {\n                    res.push(i);\n                }\n            }\n            return res;\n        };\n    }\n\n    var defaultCalendar = {\n        sameDay : '[Today at] LT',\n        nextDay : '[Tomorrow at] LT',\n        nextWeek : 'dddd [at] LT',\n        lastDay : '[Yesterday at] LT',\n        lastWeek : '[Last] dddd [at] LT',\n        sameElse : 'L'\n    };\n\n    function calendar (key, mom, now) {\n        var output = this._calendar[key] || this._calendar['sameElse'];\n        return isFunction(output) ? output.call(mom, now) : output;\n    }\n\n    var defaultLongDateFormat = {\n        LTS  : 'h:mm:ss A',\n        LT   : 'h:mm A',\n        L    : 'MM/DD/YYYY',\n        LL   : 'MMMM D, YYYY',\n        LLL  : 'MMMM D, YYYY h:mm A',\n        LLLL : 'dddd, MMMM D, YYYY h:mm A'\n    };\n\n    function longDateFormat (key) {\n        var format = this._longDateFormat[key],\n            formatUpper = this._longDateFormat[key.toUpperCase()];\n\n        if (format || !formatUpper) {\n            return format;\n        }\n\n        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {\n            return val.slice(1);\n        });\n\n        return this._longDateFormat[key];\n    }\n\n    var defaultInvalidDate = 'Invalid date';\n\n    function invalidDate () {\n        return this._invalidDate;\n    }\n\n    var defaultOrdinal = '%d';\n    var defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\n    function ordinal (number) {\n        return this._ordinal.replace('%d', number);\n    }\n\n    var defaultRelativeTime = {\n        future : 'in %s',\n        past   : '%s ago',\n        s  : 'a few seconds',\n        ss : '%d seconds',\n        m  : 'a minute',\n        mm : '%d minutes',\n        h  : 'an hour',\n        hh : '%d hours',\n        d  : 'a day',\n        dd : '%d days',\n        M  : 'a month',\n        MM : '%d months',\n        y  : 'a year',\n        yy : '%d years'\n    };\n\n    function relativeTime (number, withoutSuffix, string, isFuture) {\n        var output = this._relativeTime[string];\n        return (isFunction(output)) ?\n            output(number, withoutSuffix, string, isFuture) :\n            output.replace(/%d/i, number);\n    }\n\n    function pastFuture (diff, output) {\n        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n        return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n    }\n\n    var aliases = {};\n\n    function addUnitAlias (unit, shorthand) {\n        var lowerCase = unit.toLowerCase();\n        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n    }\n\n    function normalizeUnits(units) {\n        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n    }\n\n    function normalizeObjectUnits(inputObject) {\n        var normalizedInput = {},\n            normalizedProp,\n            prop;\n\n        for (prop in inputObject) {\n            if (hasOwnProp(inputObject, prop)) {\n                normalizedProp = normalizeUnits(prop);\n                if (normalizedProp) {\n                    normalizedInput[normalizedProp] = inputObject[prop];\n                }\n            }\n        }\n\n        return normalizedInput;\n    }\n\n    var priorities = {};\n\n    function addUnitPriority(unit, priority) {\n        priorities[unit] = priority;\n    }\n\n    function getPrioritizedUnits(unitsObj) {\n        var units = [];\n        for (var u in unitsObj) {\n            units.push({unit: u, priority: priorities[u]});\n        }\n        units.sort(function (a, b) {\n            return a.priority - b.priority;\n        });\n        return units;\n    }\n\n    function zeroFill(number, targetLength, forceSign) {\n        var absNumber = '' + Math.abs(number),\n            zerosToFill = targetLength - absNumber.length,\n            sign = number >= 0;\n        return (sign ? (forceSign ? '+' : '') : '-') +\n            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n    }\n\n    var formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;\n\n    var localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\n    var formatFunctions = {};\n\n    var formatTokenFunctions = {};\n\n    // token:    'M'\n    // padded:   ['MM', 2]\n    // ordinal:  'Mo'\n    // callback: function () { this.month() + 1 }\n    function addFormatToken (token, padded, ordinal, callback) {\n        var func = callback;\n        if (typeof callback === 'string') {\n            func = function () {\n                return this[callback]();\n            };\n        }\n        if (token) {\n            formatTokenFunctions[token] = func;\n        }\n        if (padded) {\n            formatTokenFunctions[padded[0]] = function () {\n                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n            };\n        }\n        if (ordinal) {\n            formatTokenFunctions[ordinal] = function () {\n                return this.localeData().ordinal(func.apply(this, arguments), token);\n            };\n        }\n    }\n\n    function removeFormattingTokens(input) {\n        if (input.match(/\\[[\\s\\S]/)) {\n            return input.replace(/^\\[|\\]$/g, '');\n        }\n        return input.replace(/\\\\/g, '');\n    }\n\n    function makeFormatFunction(format) {\n        var array = format.match(formattingTokens), i, length;\n\n        for (i = 0, length = array.length; i < length; i++) {\n            if (formatTokenFunctions[array[i]]) {\n                array[i] = formatTokenFunctions[array[i]];\n            } else {\n                array[i] = removeFormattingTokens(array[i]);\n            }\n        }\n\n        return function (mom) {\n            var output = '', i;\n            for (i = 0; i < length; i++) {\n                output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n            }\n            return output;\n        };\n    }\n\n    // format date using native date object\n    function formatMoment(m, format) {\n        if (!m.isValid()) {\n            return m.localeData().invalidDate();\n        }\n\n        format = expandFormat(format, m.localeData());\n        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n\n        return formatFunctions[format](m);\n    }\n\n    function expandFormat(format, locale) {\n        var i = 5;\n\n        function replaceLongDateFormatTokens(input) {\n            return locale.longDateFormat(input) || input;\n        }\n\n        localFormattingTokens.lastIndex = 0;\n        while (i >= 0 && localFormattingTokens.test(format)) {\n            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n            localFormattingTokens.lastIndex = 0;\n            i -= 1;\n        }\n\n        return format;\n    }\n\n    var match1         = /\\d/;            //       0 - 9\n    var match2         = /\\d\\d/;          //      00 - 99\n    var match3         = /\\d{3}/;         //     000 - 999\n    var match4         = /\\d{4}/;         //    0000 - 9999\n    var match6         = /[+-]?\\d{6}/;    // -999999 - 999999\n    var match1to2      = /\\d\\d?/;         //       0 - 99\n    var match3to4      = /\\d\\d\\d\\d?/;     //     999 - 9999\n    var match5to6      = /\\d\\d\\d\\d\\d\\d?/; //   99999 - 999999\n    var match1to3      = /\\d{1,3}/;       //       0 - 999\n    var match1to4      = /\\d{1,4}/;       //       0 - 9999\n    var match1to6      = /[+-]?\\d{1,6}/;  // -999999 - 999999\n\n    var matchUnsigned  = /\\d+/;           //       0 - inf\n    var matchSigned    = /[+-]?\\d+/;      //    -inf - inf\n\n    var matchOffset    = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\n    var matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\n    var matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/; // 123456789 123456789.123\n\n    // any word (or two) characters or numbers including two/three word month in arabic.\n    // includes scottish gaelic two word and hyphenated months\n    var matchWord = /[0-9]{0,256}['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFF07\\uFF10-\\uFFEF]{1,256}|[\\u0600-\\u06FF\\/]{1,256}(\\s*?[\\u0600-\\u06FF]{1,256}){1,2}/i;\n\n    var regexes = {};\n\n    function addRegexToken (token, regex, strictRegex) {\n        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n            return (isStrict && strictRegex) ? strictRegex : regex;\n        };\n    }\n\n    function getParseRegexForToken (token, config) {\n        if (!hasOwnProp(regexes, token)) {\n            return new RegExp(unescapeFormat(token));\n        }\n\n        return regexes[token](config._strict, config._locale);\n    }\n\n    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\n    function unescapeFormat(s) {\n        return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n            return p1 || p2 || p3 || p4;\n        }));\n    }\n\n    function regexEscape(s) {\n        return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n    }\n\n    var tokens = {};\n\n    function addParseToken (token, callback) {\n        var i, func = callback;\n        if (typeof token === 'string') {\n            token = [token];\n        }\n        if (isNumber(callback)) {\n            func = function (input, array) {\n                array[callback] = toInt(input);\n            };\n        }\n        for (i = 0; i < token.length; i++) {\n            tokens[token[i]] = func;\n        }\n    }\n\n    function addWeekParseToken (token, callback) {\n        addParseToken(token, function (input, array, config, token) {\n            config._w = config._w || {};\n            callback(input, config._w, config, token);\n        });\n    }\n\n    function addTimeToArrayFromToken(token, input, config) {\n        if (input != null && hasOwnProp(tokens, token)) {\n            tokens[token](input, config._a, config, token);\n        }\n    }\n\n    var YEAR = 0;\n    var MONTH = 1;\n    var DATE = 2;\n    var HOUR = 3;\n    var MINUTE = 4;\n    var SECOND = 5;\n    var MILLISECOND = 6;\n    var WEEK = 7;\n    var WEEKDAY = 8;\n\n    // FORMATTING\n\n    addFormatToken('Y', 0, 0, function () {\n        var y = this.year();\n        return y <= 9999 ? '' + y : '+' + y;\n    });\n\n    addFormatToken(0, ['YY', 2], 0, function () {\n        return this.year() % 100;\n    });\n\n    addFormatToken(0, ['YYYY',   4],       0, 'year');\n    addFormatToken(0, ['YYYYY',  5],       0, 'year');\n    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n    // ALIASES\n\n    addUnitAlias('year', 'y');\n\n    // PRIORITIES\n\n    addUnitPriority('year', 1);\n\n    // PARSING\n\n    addRegexToken('Y',      matchSigned);\n    addRegexToken('YY',     match1to2, match2);\n    addRegexToken('YYYY',   match1to4, match4);\n    addRegexToken('YYYYY',  match1to6, match6);\n    addRegexToken('YYYYYY', match1to6, match6);\n\n    addParseToken(['YYYYY', 'YYYYYY'], YEAR);\n    addParseToken('YYYY', function (input, array) {\n        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n    });\n    addParseToken('YY', function (input, array) {\n        array[YEAR] = hooks.parseTwoDigitYear(input);\n    });\n    addParseToken('Y', function (input, array) {\n        array[YEAR] = parseInt(input, 10);\n    });\n\n    // HELPERS\n\n    function daysInYear(year) {\n        return isLeapYear(year) ? 366 : 365;\n    }\n\n    function isLeapYear(year) {\n        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n    }\n\n    // HOOKS\n\n    hooks.parseTwoDigitYear = function (input) {\n        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n    };\n\n    // MOMENTS\n\n    var getSetYear = makeGetSet('FullYear', true);\n\n    function getIsLeapYear () {\n        return isLeapYear(this.year());\n    }\n\n    function makeGetSet (unit, keepTime) {\n        return function (value) {\n            if (value != null) {\n                set$1(this, unit, value);\n                hooks.updateOffset(this, keepTime);\n                return this;\n            } else {\n                return get(this, unit);\n            }\n        };\n    }\n\n    function get (mom, unit) {\n        return mom.isValid() ?\n            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n    }\n\n    function set$1 (mom, unit, value) {\n        if (mom.isValid() && !isNaN(value)) {\n            if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {\n                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));\n            }\n            else {\n                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function stringGet (units) {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units]();\n        }\n        return this;\n    }\n\n\n    function stringSet (units, value) {\n        if (typeof units === 'object') {\n            units = normalizeObjectUnits(units);\n            var prioritized = getPrioritizedUnits(units);\n            for (var i = 0; i < prioritized.length; i++) {\n                this[prioritized[i].unit](units[prioritized[i].unit]);\n            }\n        } else {\n            units = normalizeUnits(units);\n            if (isFunction(this[units])) {\n                return this[units](value);\n            }\n        }\n        return this;\n    }\n\n    function mod(n, x) {\n        return ((n % x) + x) % x;\n    }\n\n    var indexOf;\n\n    if (Array.prototype.indexOf) {\n        indexOf = Array.prototype.indexOf;\n    } else {\n        indexOf = function (o) {\n            // I know\n            var i;\n            for (i = 0; i < this.length; ++i) {\n                if (this[i] === o) {\n                    return i;\n                }\n            }\n            return -1;\n        };\n    }\n\n    function daysInMonth(year, month) {\n        if (isNaN(year) || isNaN(month)) {\n            return NaN;\n        }\n        var modMonth = mod(month, 12);\n        year += (month - modMonth) / 12;\n        return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);\n    }\n\n    // FORMATTING\n\n    addFormatToken('M', ['MM', 2], 'Mo', function () {\n        return this.month() + 1;\n    });\n\n    addFormatToken('MMM', 0, 0, function (format) {\n        return this.localeData().monthsShort(this, format);\n    });\n\n    addFormatToken('MMMM', 0, 0, function (format) {\n        return this.localeData().months(this, format);\n    });\n\n    // ALIASES\n\n    addUnitAlias('month', 'M');\n\n    // PRIORITY\n\n    addUnitPriority('month', 8);\n\n    // PARSING\n\n    addRegexToken('M',    match1to2);\n    addRegexToken('MM',   match1to2, match2);\n    addRegexToken('MMM',  function (isStrict, locale) {\n        return locale.monthsShortRegex(isStrict);\n    });\n    addRegexToken('MMMM', function (isStrict, locale) {\n        return locale.monthsRegex(isStrict);\n    });\n\n    addParseToken(['M', 'MM'], function (input, array) {\n        array[MONTH] = toInt(input) - 1;\n    });\n\n    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n        var month = config._locale.monthsParse(input, token, config._strict);\n        // if we didn't find a month name, mark the date as invalid.\n        if (month != null) {\n            array[MONTH] = month;\n        } else {\n            getParsingFlags(config).invalidMonth = input;\n        }\n    });\n\n    // LOCALES\n\n    var MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\n    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\n    function localeMonths (m, format) {\n        if (!m) {\n            return isArray(this._months) ? this._months :\n                this._months['standalone'];\n        }\n        return isArray(this._months) ? this._months[m.month()] :\n            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n    }\n\n    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\n    function localeMonthsShort (m, format) {\n        if (!m) {\n            return isArray(this._monthsShort) ? this._monthsShort :\n                this._monthsShort['standalone'];\n        }\n        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :\n            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n    }\n\n    function handleStrictParse(monthName, format, strict) {\n        var i, ii, mom, llc = monthName.toLocaleLowerCase();\n        if (!this._monthsParse) {\n            // this is not used\n            this._monthsParse = [];\n            this._longMonthsParse = [];\n            this._shortMonthsParse = [];\n            for (i = 0; i < 12; ++i) {\n                mom = createUTC([2000, i]);\n                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n            }\n        }\n\n        if (strict) {\n            if (format === 'MMM') {\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._longMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        } else {\n            if (format === 'MMM') {\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._longMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._longMonthsParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        }\n    }\n\n    function localeMonthsParse (monthName, format, strict) {\n        var i, mom, regex;\n\n        if (this._monthsParseExact) {\n            return handleStrictParse.call(this, monthName, format, strict);\n        }\n\n        if (!this._monthsParse) {\n            this._monthsParse = [];\n            this._longMonthsParse = [];\n            this._shortMonthsParse = [];\n        }\n\n        // TODO: add sorting\n        // Sorting makes sure if one month (or abbr) is a prefix of another\n        // see sorting in computeMonthsParse\n        for (i = 0; i < 12; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, i]);\n            if (strict && !this._longMonthsParse[i]) {\n                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n            }\n            if (!strict && !this._monthsParse[i]) {\n                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n            }\n            // test the regex\n            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n                return i;\n            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n                return i;\n            } else if (!strict && this._monthsParse[i].test(monthName)) {\n                return i;\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function setMonth (mom, value) {\n        var dayOfMonth;\n\n        if (!mom.isValid()) {\n            // No op\n            return mom;\n        }\n\n        if (typeof value === 'string') {\n            if (/^\\d+$/.test(value)) {\n                value = toInt(value);\n            } else {\n                value = mom.localeData().monthsParse(value);\n                // TODO: Another silent failure?\n                if (!isNumber(value)) {\n                    return mom;\n                }\n            }\n        }\n\n        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n        return mom;\n    }\n\n    function getSetMonth (value) {\n        if (value != null) {\n            setMonth(this, value);\n            hooks.updateOffset(this, true);\n            return this;\n        } else {\n            return get(this, 'Month');\n        }\n    }\n\n    function getDaysInMonth () {\n        return daysInMonth(this.year(), this.month());\n    }\n\n    var defaultMonthsShortRegex = matchWord;\n    function monthsShortRegex (isStrict) {\n        if (this._monthsParseExact) {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                computeMonthsParse.call(this);\n            }\n            if (isStrict) {\n                return this._monthsShortStrictRegex;\n            } else {\n                return this._monthsShortRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_monthsShortRegex')) {\n                this._monthsShortRegex = defaultMonthsShortRegex;\n            }\n            return this._monthsShortStrictRegex && isStrict ?\n                this._monthsShortStrictRegex : this._monthsShortRegex;\n        }\n    }\n\n    var defaultMonthsRegex = matchWord;\n    function monthsRegex (isStrict) {\n        if (this._monthsParseExact) {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                computeMonthsParse.call(this);\n            }\n            if (isStrict) {\n                return this._monthsStrictRegex;\n            } else {\n                return this._monthsRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                this._monthsRegex = defaultMonthsRegex;\n            }\n            return this._monthsStrictRegex && isStrict ?\n                this._monthsStrictRegex : this._monthsRegex;\n        }\n    }\n\n    function computeMonthsParse () {\n        function cmpLenRev(a, b) {\n            return b.length - a.length;\n        }\n\n        var shortPieces = [], longPieces = [], mixedPieces = [],\n            i, mom;\n        for (i = 0; i < 12; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, i]);\n            shortPieces.push(this.monthsShort(mom, ''));\n            longPieces.push(this.months(mom, ''));\n            mixedPieces.push(this.months(mom, ''));\n            mixedPieces.push(this.monthsShort(mom, ''));\n        }\n        // Sorting makes sure if one month (or abbr) is a prefix of another it\n        // will match the longer piece.\n        shortPieces.sort(cmpLenRev);\n        longPieces.sort(cmpLenRev);\n        mixedPieces.sort(cmpLenRev);\n        for (i = 0; i < 12; i++) {\n            shortPieces[i] = regexEscape(shortPieces[i]);\n            longPieces[i] = regexEscape(longPieces[i]);\n        }\n        for (i = 0; i < 24; i++) {\n            mixedPieces[i] = regexEscape(mixedPieces[i]);\n        }\n\n        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n        this._monthsShortRegex = this._monthsRegex;\n        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    }\n\n    function createDate (y, m, d, h, M, s, ms) {\n        // can't just apply() to create a date:\n        // https://stackoverflow.com/q/181348\n        var date;\n        // the date constructor remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            date = new Date(y + 400, m, d, h, M, s, ms);\n            if (isFinite(date.getFullYear())) {\n                date.setFullYear(y);\n            }\n        } else {\n            date = new Date(y, m, d, h, M, s, ms);\n        }\n\n        return date;\n    }\n\n    function createUTCDate (y) {\n        var date;\n        // the Date.UTC function remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            var args = Array.prototype.slice.call(arguments);\n            // preserve leap years using a full 400 year cycle, then reset\n            args[0] = y + 400;\n            date = new Date(Date.UTC.apply(null, args));\n            if (isFinite(date.getUTCFullYear())) {\n                date.setUTCFullYear(y);\n            }\n        } else {\n            date = new Date(Date.UTC.apply(null, arguments));\n        }\n\n        return date;\n    }\n\n    // start-of-first-week - start-of-year\n    function firstWeekOffset(year, dow, doy) {\n        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n            fwd = 7 + dow - doy,\n            // first-week day local weekday -- which local weekday is fwd\n            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n        return -fwdlw + fwd - 1;\n    }\n\n    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\n    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n        var localWeekday = (7 + weekday - dow) % 7,\n            weekOffset = firstWeekOffset(year, dow, doy),\n            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n            resYear, resDayOfYear;\n\n        if (dayOfYear <= 0) {\n            resYear = year - 1;\n            resDayOfYear = daysInYear(resYear) + dayOfYear;\n        } else if (dayOfYear > daysInYear(year)) {\n            resYear = year + 1;\n            resDayOfYear = dayOfYear - daysInYear(year);\n        } else {\n            resYear = year;\n            resDayOfYear = dayOfYear;\n        }\n\n        return {\n            year: resYear,\n            dayOfYear: resDayOfYear\n        };\n    }\n\n    function weekOfYear(mom, dow, doy) {\n        var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n            resWeek, resYear;\n\n        if (week < 1) {\n            resYear = mom.year() - 1;\n            resWeek = week + weeksInYear(resYear, dow, doy);\n        } else if (week > weeksInYear(mom.year(), dow, doy)) {\n            resWeek = week - weeksInYear(mom.year(), dow, doy);\n            resYear = mom.year() + 1;\n        } else {\n            resYear = mom.year();\n            resWeek = week;\n        }\n\n        return {\n            week: resWeek,\n            year: resYear\n        };\n    }\n\n    function weeksInYear(year, dow, doy) {\n        var weekOffset = firstWeekOffset(year, dow, doy),\n            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n    }\n\n    // FORMATTING\n\n    addFormatToken('w', ['ww', 2], 'wo', 'week');\n    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n    // ALIASES\n\n    addUnitAlias('week', 'w');\n    addUnitAlias('isoWeek', 'W');\n\n    // PRIORITIES\n\n    addUnitPriority('week', 5);\n    addUnitPriority('isoWeek', 5);\n\n    // PARSING\n\n    addRegexToken('w',  match1to2);\n    addRegexToken('ww', match1to2, match2);\n    addRegexToken('W',  match1to2);\n    addRegexToken('WW', match1to2, match2);\n\n    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n        week[token.substr(0, 1)] = toInt(input);\n    });\n\n    // HELPERS\n\n    // LOCALES\n\n    function localeWeek (mom) {\n        return weekOfYear(mom, this._week.dow, this._week.doy).week;\n    }\n\n    var defaultLocaleWeek = {\n        dow : 0, // Sunday is the first day of the week.\n        doy : 6  // The week that contains Jan 6th is the first week of the year.\n    };\n\n    function localeFirstDayOfWeek () {\n        return this._week.dow;\n    }\n\n    function localeFirstDayOfYear () {\n        return this._week.doy;\n    }\n\n    // MOMENTS\n\n    function getSetWeek (input) {\n        var week = this.localeData().week(this);\n        return input == null ? week : this.add((input - week) * 7, 'd');\n    }\n\n    function getSetISOWeek (input) {\n        var week = weekOfYear(this, 1, 4).week;\n        return input == null ? week : this.add((input - week) * 7, 'd');\n    }\n\n    // FORMATTING\n\n    addFormatToken('d', 0, 'do', 'day');\n\n    addFormatToken('dd', 0, 0, function (format) {\n        return this.localeData().weekdaysMin(this, format);\n    });\n\n    addFormatToken('ddd', 0, 0, function (format) {\n        return this.localeData().weekdaysShort(this, format);\n    });\n\n    addFormatToken('dddd', 0, 0, function (format) {\n        return this.localeData().weekdays(this, format);\n    });\n\n    addFormatToken('e', 0, 0, 'weekday');\n    addFormatToken('E', 0, 0, 'isoWeekday');\n\n    // ALIASES\n\n    addUnitAlias('day', 'd');\n    addUnitAlias('weekday', 'e');\n    addUnitAlias('isoWeekday', 'E');\n\n    // PRIORITY\n    addUnitPriority('day', 11);\n    addUnitPriority('weekday', 11);\n    addUnitPriority('isoWeekday', 11);\n\n    // PARSING\n\n    addRegexToken('d',    match1to2);\n    addRegexToken('e',    match1to2);\n    addRegexToken('E',    match1to2);\n    addRegexToken('dd',   function (isStrict, locale) {\n        return locale.weekdaysMinRegex(isStrict);\n    });\n    addRegexToken('ddd',   function (isStrict, locale) {\n        return locale.weekdaysShortRegex(isStrict);\n    });\n    addRegexToken('dddd',   function (isStrict, locale) {\n        return locale.weekdaysRegex(isStrict);\n    });\n\n    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n        var weekday = config._locale.weekdaysParse(input, token, config._strict);\n        // if we didn't get a weekday name, mark the date as invalid\n        if (weekday != null) {\n            week.d = weekday;\n        } else {\n            getParsingFlags(config).invalidWeekday = input;\n        }\n    });\n\n    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n        week[token] = toInt(input);\n    });\n\n    // HELPERS\n\n    function parseWeekday(input, locale) {\n        if (typeof input !== 'string') {\n            return input;\n        }\n\n        if (!isNaN(input)) {\n            return parseInt(input, 10);\n        }\n\n        input = locale.weekdaysParse(input);\n        if (typeof input === 'number') {\n            return input;\n        }\n\n        return null;\n    }\n\n    function parseIsoWeekday(input, locale) {\n        if (typeof input === 'string') {\n            return locale.weekdaysParse(input) % 7 || 7;\n        }\n        return isNaN(input) ? null : input;\n    }\n\n    // LOCALES\n    function shiftWeekdays (ws, n) {\n        return ws.slice(n, 7).concat(ws.slice(0, n));\n    }\n\n    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\n    function localeWeekdays (m, format) {\n        var weekdays = isArray(this._weekdays) ? this._weekdays :\n            this._weekdays[(m && m !== true && this._weekdays.isFormat.test(format)) ? 'format' : 'standalone'];\n        return (m === true) ? shiftWeekdays(weekdays, this._week.dow)\n            : (m) ? weekdays[m.day()] : weekdays;\n    }\n\n    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\n    function localeWeekdaysShort (m) {\n        return (m === true) ? shiftWeekdays(this._weekdaysShort, this._week.dow)\n            : (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n    }\n\n    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\n    function localeWeekdaysMin (m) {\n        return (m === true) ? shiftWeekdays(this._weekdaysMin, this._week.dow)\n            : (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n    }\n\n    function handleStrictParse$1(weekdayName, format, strict) {\n        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();\n        if (!this._weekdaysParse) {\n            this._weekdaysParse = [];\n            this._shortWeekdaysParse = [];\n            this._minWeekdaysParse = [];\n\n            for (i = 0; i < 7; ++i) {\n                mom = createUTC([2000, 1]).day(i);\n                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n            }\n        }\n\n        if (strict) {\n            if (format === 'dddd') {\n                ii = indexOf.call(this._weekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else if (format === 'ddd') {\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        } else {\n            if (format === 'dddd') {\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else if (format === 'ddd') {\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        }\n    }\n\n    function localeWeekdaysParse (weekdayName, format, strict) {\n        var i, mom, regex;\n\n        if (this._weekdaysParseExact) {\n            return handleStrictParse$1.call(this, weekdayName, format, strict);\n        }\n\n        if (!this._weekdaysParse) {\n            this._weekdaysParse = [];\n            this._minWeekdaysParse = [];\n            this._shortWeekdaysParse = [];\n            this._fullWeekdaysParse = [];\n        }\n\n        for (i = 0; i < 7; i++) {\n            // make the regex if we don't have it already\n\n            mom = createUTC([2000, 1]).day(i);\n            if (strict && !this._fullWeekdaysParse[i]) {\n                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\\\.?') + '$', 'i');\n                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\\\.?') + '$', 'i');\n                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\\\.?') + '$', 'i');\n            }\n            if (!this._weekdaysParse[i]) {\n                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n            }\n            // test the regex\n            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n                return i;\n            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n                return i;\n            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n                return i;\n            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n                return i;\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function getSetDayOfWeek (input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n        if (input != null) {\n            input = parseWeekday(input, this.localeData());\n            return this.add(input - day, 'd');\n        } else {\n            return day;\n        }\n    }\n\n    function getSetLocaleDayOfWeek (input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n        return input == null ? weekday : this.add(input - weekday, 'd');\n    }\n\n    function getSetISODayOfWeek (input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n\n        // behaves the same as moment#day except\n        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n        // as a setter, sunday should belong to the previous week.\n\n        if (input != null) {\n            var weekday = parseIsoWeekday(input, this.localeData());\n            return this.day(this.day() % 7 ? weekday : weekday - 7);\n        } else {\n            return this.day() || 7;\n        }\n    }\n\n    var defaultWeekdaysRegex = matchWord;\n    function weekdaysRegex (isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysStrictRegex;\n            } else {\n                return this._weekdaysRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                this._weekdaysRegex = defaultWeekdaysRegex;\n            }\n            return this._weekdaysStrictRegex && isStrict ?\n                this._weekdaysStrictRegex : this._weekdaysRegex;\n        }\n    }\n\n    var defaultWeekdaysShortRegex = matchWord;\n    function weekdaysShortRegex (isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysShortStrictRegex;\n            } else {\n                return this._weekdaysShortRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n                this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n            }\n            return this._weekdaysShortStrictRegex && isStrict ?\n                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n        }\n    }\n\n    var defaultWeekdaysMinRegex = matchWord;\n    function weekdaysMinRegex (isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysMinStrictRegex;\n            } else {\n                return this._weekdaysMinRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n                this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n            }\n            return this._weekdaysMinStrictRegex && isStrict ?\n                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n        }\n    }\n\n\n    function computeWeekdaysParse () {\n        function cmpLenRev(a, b) {\n            return b.length - a.length;\n        }\n\n        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],\n            i, mom, minp, shortp, longp;\n        for (i = 0; i < 7; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, 1]).day(i);\n            minp = this.weekdaysMin(mom, '');\n            shortp = this.weekdaysShort(mom, '');\n            longp = this.weekdays(mom, '');\n            minPieces.push(minp);\n            shortPieces.push(shortp);\n            longPieces.push(longp);\n            mixedPieces.push(minp);\n            mixedPieces.push(shortp);\n            mixedPieces.push(longp);\n        }\n        // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n        // will match the longer piece.\n        minPieces.sort(cmpLenRev);\n        shortPieces.sort(cmpLenRev);\n        longPieces.sort(cmpLenRev);\n        mixedPieces.sort(cmpLenRev);\n        for (i = 0; i < 7; i++) {\n            shortPieces[i] = regexEscape(shortPieces[i]);\n            longPieces[i] = regexEscape(longPieces[i]);\n            mixedPieces[i] = regexEscape(mixedPieces[i]);\n        }\n\n        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n        this._weekdaysShortRegex = this._weekdaysRegex;\n        this._weekdaysMinRegex = this._weekdaysRegex;\n\n        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n    }\n\n    // FORMATTING\n\n    function hFormat() {\n        return this.hours() % 12 || 12;\n    }\n\n    function kFormat() {\n        return this.hours() || 24;\n    }\n\n    addFormatToken('H', ['HH', 2], 0, 'hour');\n    addFormatToken('h', ['hh', 2], 0, hFormat);\n    addFormatToken('k', ['kk', 2], 0, kFormat);\n\n    addFormatToken('hmm', 0, 0, function () {\n        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n    });\n\n    addFormatToken('hmmss', 0, 0, function () {\n        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n            zeroFill(this.seconds(), 2);\n    });\n\n    addFormatToken('Hmm', 0, 0, function () {\n        return '' + this.hours() + zeroFill(this.minutes(), 2);\n    });\n\n    addFormatToken('Hmmss', 0, 0, function () {\n        return '' + this.hours() + zeroFill(this.minutes(), 2) +\n            zeroFill(this.seconds(), 2);\n    });\n\n    function meridiem (token, lowercase) {\n        addFormatToken(token, 0, 0, function () {\n            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n        });\n    }\n\n    meridiem('a', true);\n    meridiem('A', false);\n\n    // ALIASES\n\n    addUnitAlias('hour', 'h');\n\n    // PRIORITY\n    addUnitPriority('hour', 13);\n\n    // PARSING\n\n    function matchMeridiem (isStrict, locale) {\n        return locale._meridiemParse;\n    }\n\n    addRegexToken('a',  matchMeridiem);\n    addRegexToken('A',  matchMeridiem);\n    addRegexToken('H',  match1to2);\n    addRegexToken('h',  match1to2);\n    addRegexToken('k',  match1to2);\n    addRegexToken('HH', match1to2, match2);\n    addRegexToken('hh', match1to2, match2);\n    addRegexToken('kk', match1to2, match2);\n\n    addRegexToken('hmm', match3to4);\n    addRegexToken('hmmss', match5to6);\n    addRegexToken('Hmm', match3to4);\n    addRegexToken('Hmmss', match5to6);\n\n    addParseToken(['H', 'HH'], HOUR);\n    addParseToken(['k', 'kk'], function (input, array, config) {\n        var kInput = toInt(input);\n        array[HOUR] = kInput === 24 ? 0 : kInput;\n    });\n    addParseToken(['a', 'A'], function (input, array, config) {\n        config._isPm = config._locale.isPM(input);\n        config._meridiem = input;\n    });\n    addParseToken(['h', 'hh'], function (input, array, config) {\n        array[HOUR] = toInt(input);\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('hmm', function (input, array, config) {\n        var pos = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos));\n        array[MINUTE] = toInt(input.substr(pos));\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('hmmss', function (input, array, config) {\n        var pos1 = input.length - 4;\n        var pos2 = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos1));\n        array[MINUTE] = toInt(input.substr(pos1, 2));\n        array[SECOND] = toInt(input.substr(pos2));\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('Hmm', function (input, array, config) {\n        var pos = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos));\n        array[MINUTE] = toInt(input.substr(pos));\n    });\n    addParseToken('Hmmss', function (input, array, config) {\n        var pos1 = input.length - 4;\n        var pos2 = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos1));\n        array[MINUTE] = toInt(input.substr(pos1, 2));\n        array[SECOND] = toInt(input.substr(pos2));\n    });\n\n    // LOCALES\n\n    function localeIsPM (input) {\n        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n        // Using charAt should be more compatible.\n        return ((input + '').toLowerCase().charAt(0) === 'p');\n    }\n\n    var defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\n    function localeMeridiem (hours, minutes, isLower) {\n        if (hours > 11) {\n            return isLower ? 'pm' : 'PM';\n        } else {\n            return isLower ? 'am' : 'AM';\n        }\n    }\n\n\n    // MOMENTS\n\n    // Setting the hour should keep the time, because the user explicitly\n    // specified which hour they want. So trying to maintain the same hour (in\n    // a new timezone) makes sense. Adding/subtracting hours does not follow\n    // this rule.\n    var getSetHour = makeGetSet('Hours', true);\n\n    var baseConfig = {\n        calendar: defaultCalendar,\n        longDateFormat: defaultLongDateFormat,\n        invalidDate: defaultInvalidDate,\n        ordinal: defaultOrdinal,\n        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n        relativeTime: defaultRelativeTime,\n\n        months: defaultLocaleMonths,\n        monthsShort: defaultLocaleMonthsShort,\n\n        week: defaultLocaleWeek,\n\n        weekdays: defaultLocaleWeekdays,\n        weekdaysMin: defaultLocaleWeekdaysMin,\n        weekdaysShort: defaultLocaleWeekdaysShort,\n\n        meridiemParse: defaultLocaleMeridiemParse\n    };\n\n    // internal storage for locale config files\n    var locales = {};\n    var localeFamilies = {};\n    var globalLocale;\n\n    function normalizeLocale(key) {\n        return key ? key.toLowerCase().replace('_', '-') : key;\n    }\n\n    // pick the locale from the array\n    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\n    function chooseLocale(names) {\n        var i = 0, j, next, locale, split;\n\n        while (i < names.length) {\n            split = normalizeLocale(names[i]).split('-');\n            j = split.length;\n            next = normalizeLocale(names[i + 1]);\n            next = next ? next.split('-') : null;\n            while (j > 0) {\n                locale = loadLocale(split.slice(0, j).join('-'));\n                if (locale) {\n                    return locale;\n                }\n                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n                    //the next array item is better than a shallower substring of this one\n                    break;\n                }\n                j--;\n            }\n            i++;\n        }\n        return globalLocale;\n    }\n\n    function loadLocale(name) {\n        var oldLocale = null;\n        // TODO: Find a better way to register and load all the locales in Node\n        if (!locales[name] && (typeof module !== 'undefined') &&\n                module && module.exports) {\n            try {\n                oldLocale = globalLocale._abbr;\n                var aliasedRequire = require;\n                aliasedRequire('./locale/' + name);\n                getSetGlobalLocale(oldLocale);\n            } catch (e) {}\n        }\n        return locales[name];\n    }\n\n    // This function will load locale and then set the global locale.  If\n    // no arguments are passed in, it will simply return the current global\n    // locale key.\n    function getSetGlobalLocale (key, values) {\n        var data;\n        if (key) {\n            if (isUndefined(values)) {\n                data = getLocale(key);\n            }\n            else {\n                data = defineLocale(key, values);\n            }\n\n            if (data) {\n                // moment.duration._locale = moment._locale = data;\n                globalLocale = data;\n            }\n            else {\n                if ((typeof console !==  'undefined') && console.warn) {\n                    //warn user if arguments are passed but the locale could not be set\n                    console.warn('Locale ' + key +  ' not found. Did you forget to load it?');\n                }\n            }\n        }\n\n        return globalLocale._abbr;\n    }\n\n    function defineLocale (name, config) {\n        if (config !== null) {\n            var locale, parentConfig = baseConfig;\n            config.abbr = name;\n            if (locales[name] != null) {\n                deprecateSimple('defineLocaleOverride',\n                        'use moment.updateLocale(localeName, config) to change ' +\n                        'an existing locale. moment.defineLocale(localeName, ' +\n                        'config) should only be used for creating a new locale ' +\n                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n                parentConfig = locales[name]._config;\n            } else if (config.parentLocale != null) {\n                if (locales[config.parentLocale] != null) {\n                    parentConfig = locales[config.parentLocale]._config;\n                } else {\n                    locale = loadLocale(config.parentLocale);\n                    if (locale != null) {\n                        parentConfig = locale._config;\n                    } else {\n                        if (!localeFamilies[config.parentLocale]) {\n                            localeFamilies[config.parentLocale] = [];\n                        }\n                        localeFamilies[config.parentLocale].push({\n                            name: name,\n                            config: config\n                        });\n                        return null;\n                    }\n                }\n            }\n            locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n            if (localeFamilies[name]) {\n                localeFamilies[name].forEach(function (x) {\n                    defineLocale(x.name, x.config);\n                });\n            }\n\n            // backwards compat for now: also set the locale\n            // make sure we set the locale AFTER all child locales have been\n            // created, so we won't end up with the child locale set.\n            getSetGlobalLocale(name);\n\n\n            return locales[name];\n        } else {\n            // useful for testing\n            delete locales[name];\n            return null;\n        }\n    }\n\n    function updateLocale(name, config) {\n        if (config != null) {\n            var locale, tmpLocale, parentConfig = baseConfig;\n            // MERGE\n            tmpLocale = loadLocale(name);\n            if (tmpLocale != null) {\n                parentConfig = tmpLocale._config;\n            }\n            config = mergeConfigs(parentConfig, config);\n            locale = new Locale(config);\n            locale.parentLocale = locales[name];\n            locales[name] = locale;\n\n            // backwards compat for now: also set the locale\n            getSetGlobalLocale(name);\n        } else {\n            // pass null for config to unupdate, useful for tests\n            if (locales[name] != null) {\n                if (locales[name].parentLocale != null) {\n                    locales[name] = locales[name].parentLocale;\n                } else if (locales[name] != null) {\n                    delete locales[name];\n                }\n            }\n        }\n        return locales[name];\n    }\n\n    // returns locale data\n    function getLocale (key) {\n        var locale;\n\n        if (key && key._locale && key._locale._abbr) {\n            key = key._locale._abbr;\n        }\n\n        if (!key) {\n            return globalLocale;\n        }\n\n        if (!isArray(key)) {\n            //short-circuit everything else\n            locale = loadLocale(key);\n            if (locale) {\n                return locale;\n            }\n            key = [key];\n        }\n\n        return chooseLocale(key);\n    }\n\n    function listLocales() {\n        return keys(locales);\n    }\n\n    function checkOverflow (m) {\n        var overflow;\n        var a = m._a;\n\n        if (a && getParsingFlags(m).overflow === -2) {\n            overflow =\n                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :\n                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :\n                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :\n                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :\n                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :\n                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :\n                -1;\n\n            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n                overflow = DATE;\n            }\n            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n                overflow = WEEK;\n            }\n            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n                overflow = WEEKDAY;\n            }\n\n            getParsingFlags(m).overflow = overflow;\n        }\n\n        return m;\n    }\n\n    // Pick the first defined of two or three arguments.\n    function defaults(a, b, c) {\n        if (a != null) {\n            return a;\n        }\n        if (b != null) {\n            return b;\n        }\n        return c;\n    }\n\n    function currentDateArray(config) {\n        // hooks is actually the exported moment object\n        var nowValue = new Date(hooks.now());\n        if (config._useUTC) {\n            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n        }\n        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n    }\n\n    // convert an array to a date.\n    // the array should mirror the parameters below\n    // note: all values past the year are optional and will default to the lowest possible value.\n    // [year, month, day , hour, minute, second, millisecond]\n    function configFromArray (config) {\n        var i, date, input = [], currentDate, expectedWeekday, yearToUse;\n\n        if (config._d) {\n            return;\n        }\n\n        currentDate = currentDateArray(config);\n\n        //compute day of the year from weeks and weekdays\n        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n            dayOfYearFromWeekInfo(config);\n        }\n\n        //if the day of the year is set, figure out what it is\n        if (config._dayOfYear != null) {\n            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n                getParsingFlags(config)._overflowDayOfYear = true;\n            }\n\n            date = createUTCDate(yearToUse, 0, config._dayOfYear);\n            config._a[MONTH] = date.getUTCMonth();\n            config._a[DATE] = date.getUTCDate();\n        }\n\n        // Default to current date.\n        // * if no year, month, day of month are given, default to today\n        // * if day of month is given, default month and year\n        // * if month is given, default only year\n        // * if year is given, don't default anything\n        for (i = 0; i < 3 && config._a[i] == null; ++i) {\n            config._a[i] = input[i] = currentDate[i];\n        }\n\n        // Zero out whatever was not defaulted, including time\n        for (; i < 7; i++) {\n            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n        }\n\n        // Check for 24:00:00.000\n        if (config._a[HOUR] === 24 &&\n                config._a[MINUTE] === 0 &&\n                config._a[SECOND] === 0 &&\n                config._a[MILLISECOND] === 0) {\n            config._nextDay = true;\n            config._a[HOUR] = 0;\n        }\n\n        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();\n\n        // Apply timezone offset from input. The actual utcOffset can be changed\n        // with parseZone.\n        if (config._tzm != null) {\n            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n        }\n\n        if (config._nextDay) {\n            config._a[HOUR] = 24;\n        }\n\n        // check for mismatching day of week\n        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {\n            getParsingFlags(config).weekdayMismatch = true;\n        }\n    }\n\n    function dayOfYearFromWeekInfo(config) {\n        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n        w = config._w;\n        if (w.GG != null || w.W != null || w.E != null) {\n            dow = 1;\n            doy = 4;\n\n            // TODO: We need to take the current isoWeekYear, but that depends on\n            // how we interpret now (local, utc, fixed offset). So create\n            // a now version of current config (take local/utc/offset flags, and\n            // create now).\n            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n            week = defaults(w.W, 1);\n            weekday = defaults(w.E, 1);\n            if (weekday < 1 || weekday > 7) {\n                weekdayOverflow = true;\n            }\n        } else {\n            dow = config._locale._week.dow;\n            doy = config._locale._week.doy;\n\n            var curWeek = weekOfYear(createLocal(), dow, doy);\n\n            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n            // Default to current week.\n            week = defaults(w.w, curWeek.week);\n\n            if (w.d != null) {\n                // weekday -- low day numbers are considered next week\n                weekday = w.d;\n                if (weekday < 0 || weekday > 6) {\n                    weekdayOverflow = true;\n                }\n            } else if (w.e != null) {\n                // local weekday -- counting starts from beginning of week\n                weekday = w.e + dow;\n                if (w.e < 0 || w.e > 6) {\n                    weekdayOverflow = true;\n                }\n            } else {\n                // default to beginning of week\n                weekday = dow;\n            }\n        }\n        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n            getParsingFlags(config)._overflowWeeks = true;\n        } else if (weekdayOverflow != null) {\n            getParsingFlags(config)._overflowWeekday = true;\n        } else {\n            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n            config._a[YEAR] = temp.year;\n            config._dayOfYear = temp.dayOfYear;\n        }\n    }\n\n    // iso 8601 regex\n    // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\n    var extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n    var basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\n    var tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\n    var isoDates = [\n        ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n        ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n        ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n        ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n        ['YYYY-DDD', /\\d{4}-\\d{3}/],\n        ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n        ['YYYYYYMMDD', /[+-]\\d{10}/],\n        ['YYYYMMDD', /\\d{8}/],\n        // YYYYMM is NOT allowed by the standard\n        ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n        ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n        ['YYYYDDD', /\\d{7}/]\n    ];\n\n    // iso time formats and regexes\n    var isoTimes = [\n        ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n        ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n        ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n        ['HH:mm', /\\d\\d:\\d\\d/],\n        ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n        ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n        ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n        ['HHmm', /\\d\\d\\d\\d/],\n        ['HH', /\\d\\d/]\n    ];\n\n    var aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n    // date from iso format\n    function configFromISO(config) {\n        var i, l,\n            string = config._i,\n            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n            allowTime, dateFormat, timeFormat, tzFormat;\n\n        if (match) {\n            getParsingFlags(config).iso = true;\n\n            for (i = 0, l = isoDates.length; i < l; i++) {\n                if (isoDates[i][1].exec(match[1])) {\n                    dateFormat = isoDates[i][0];\n                    allowTime = isoDates[i][2] !== false;\n                    break;\n                }\n            }\n            if (dateFormat == null) {\n                config._isValid = false;\n                return;\n            }\n            if (match[3]) {\n                for (i = 0, l = isoTimes.length; i < l; i++) {\n                    if (isoTimes[i][1].exec(match[3])) {\n                        // match[2] should be 'T' or space\n                        timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                        break;\n                    }\n                }\n                if (timeFormat == null) {\n                    config._isValid = false;\n                    return;\n                }\n            }\n            if (!allowTime && timeFormat != null) {\n                config._isValid = false;\n                return;\n            }\n            if (match[4]) {\n                if (tzRegex.exec(match[4])) {\n                    tzFormat = 'Z';\n                } else {\n                    config._isValid = false;\n                    return;\n                }\n            }\n            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n            configFromStringAndFormat(config);\n        } else {\n            config._isValid = false;\n        }\n    }\n\n    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\n    var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\\d{4}))$/;\n\n    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {\n        var result = [\n            untruncateYear(yearStr),\n            defaultLocaleMonthsShort.indexOf(monthStr),\n            parseInt(dayStr, 10),\n            parseInt(hourStr, 10),\n            parseInt(minuteStr, 10)\n        ];\n\n        if (secondStr) {\n            result.push(parseInt(secondStr, 10));\n        }\n\n        return result;\n    }\n\n    function untruncateYear(yearStr) {\n        var year = parseInt(yearStr, 10);\n        if (year <= 49) {\n            return 2000 + year;\n        } else if (year <= 999) {\n            return 1900 + year;\n        }\n        return year;\n    }\n\n    function preprocessRFC2822(s) {\n        // Remove comments and folding whitespace and replace multiple-spaces with a single space\n        return s.replace(/\\([^)]*\\)|[\\n\\t]/g, ' ').replace(/(\\s\\s+)/g, ' ').replace(/^\\s\\s*/, '').replace(/\\s\\s*$/, '');\n    }\n\n    function checkWeekday(weekdayStr, parsedInput, config) {\n        if (weekdayStr) {\n            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),\n                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();\n            if (weekdayProvided !== weekdayActual) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return false;\n            }\n        }\n        return true;\n    }\n\n    var obsOffsets = {\n        UT: 0,\n        GMT: 0,\n        EDT: -4 * 60,\n        EST: -5 * 60,\n        CDT: -5 * 60,\n        CST: -6 * 60,\n        MDT: -6 * 60,\n        MST: -7 * 60,\n        PDT: -7 * 60,\n        PST: -8 * 60\n    };\n\n    function calculateOffset(obsOffset, militaryOffset, numOffset) {\n        if (obsOffset) {\n            return obsOffsets[obsOffset];\n        } else if (militaryOffset) {\n            // the only allowed military tz is Z\n            return 0;\n        } else {\n            var hm = parseInt(numOffset, 10);\n            var m = hm % 100, h = (hm - m) / 100;\n            return h * 60 + m;\n        }\n    }\n\n    // date and time from ref 2822 format\n    function configFromRFC2822(config) {\n        var match = rfc2822.exec(preprocessRFC2822(config._i));\n        if (match) {\n            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);\n            if (!checkWeekday(match[1], parsedArray, config)) {\n                return;\n            }\n\n            config._a = parsedArray;\n            config._tzm = calculateOffset(match[8], match[9], match[10]);\n\n            config._d = createUTCDate.apply(null, config._a);\n            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n\n            getParsingFlags(config).rfc2822 = true;\n        } else {\n            config._isValid = false;\n        }\n    }\n\n    // date from iso format or fallback\n    function configFromString(config) {\n        var matched = aspNetJsonRegex.exec(config._i);\n\n        if (matched !== null) {\n            config._d = new Date(+matched[1]);\n            return;\n        }\n\n        configFromISO(config);\n        if (config._isValid === false) {\n            delete config._isValid;\n        } else {\n            return;\n        }\n\n        configFromRFC2822(config);\n        if (config._isValid === false) {\n            delete config._isValid;\n        } else {\n            return;\n        }\n\n        // Final attempt, use Input Fallback\n        hooks.createFromInputFallback(config);\n    }\n\n    hooks.createFromInputFallback = deprecate(\n        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n        'discouraged and will be removed in an upcoming major release. Please refer to ' +\n        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n        function (config) {\n            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n        }\n    );\n\n    // constant that refers to the ISO standard\n    hooks.ISO_8601 = function () {};\n\n    // constant that refers to the RFC 2822 form\n    hooks.RFC_2822 = function () {};\n\n    // date from string and format string\n    function configFromStringAndFormat(config) {\n        // TODO: Move this to another part of the creation flow to prevent circular deps\n        if (config._f === hooks.ISO_8601) {\n            configFromISO(config);\n            return;\n        }\n        if (config._f === hooks.RFC_2822) {\n            configFromRFC2822(config);\n            return;\n        }\n        config._a = [];\n        getParsingFlags(config).empty = true;\n\n        // This array is used to make a Date, either with `new Date` or `Date.UTC`\n        var string = '' + config._i,\n            i, parsedInput, tokens, token, skipped,\n            stringLength = string.length,\n            totalParsedInputLength = 0;\n\n        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n        for (i = 0; i < tokens.length; i++) {\n            token = tokens[i];\n            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n            // console.log('token', token, 'parsedInput', parsedInput,\n            //         'regex', getParseRegexForToken(token, config));\n            if (parsedInput) {\n                skipped = string.substr(0, string.indexOf(parsedInput));\n                if (skipped.length > 0) {\n                    getParsingFlags(config).unusedInput.push(skipped);\n                }\n                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n                totalParsedInputLength += parsedInput.length;\n            }\n            // don't parse if it's not a known token\n            if (formatTokenFunctions[token]) {\n                if (parsedInput) {\n                    getParsingFlags(config).empty = false;\n                }\n                else {\n                    getParsingFlags(config).unusedTokens.push(token);\n                }\n                addTimeToArrayFromToken(token, parsedInput, config);\n            }\n            else if (config._strict && !parsedInput) {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n        }\n\n        // add remaining unparsed input length to the string\n        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n        if (string.length > 0) {\n            getParsingFlags(config).unusedInput.push(string);\n        }\n\n        // clear _12h flag if hour is <= 12\n        if (config._a[HOUR] <= 12 &&\n            getParsingFlags(config).bigHour === true &&\n            config._a[HOUR] > 0) {\n            getParsingFlags(config).bigHour = undefined;\n        }\n\n        getParsingFlags(config).parsedDateParts = config._a.slice(0);\n        getParsingFlags(config).meridiem = config._meridiem;\n        // handle meridiem\n        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n        configFromArray(config);\n        checkOverflow(config);\n    }\n\n\n    function meridiemFixWrap (locale, hour, meridiem) {\n        var isPm;\n\n        if (meridiem == null) {\n            // nothing to do\n            return hour;\n        }\n        if (locale.meridiemHour != null) {\n            return locale.meridiemHour(hour, meridiem);\n        } else if (locale.isPM != null) {\n            // Fallback\n            isPm = locale.isPM(meridiem);\n            if (isPm && hour < 12) {\n                hour += 12;\n            }\n            if (!isPm && hour === 12) {\n                hour = 0;\n            }\n            return hour;\n        } else {\n            // this is not supposed to happen\n            return hour;\n        }\n    }\n\n    // date from string and array of format strings\n    function configFromStringAndArray(config) {\n        var tempConfig,\n            bestMoment,\n\n            scoreToBeat,\n            i,\n            currentScore;\n\n        if (config._f.length === 0) {\n            getParsingFlags(config).invalidFormat = true;\n            config._d = new Date(NaN);\n            return;\n        }\n\n        for (i = 0; i < config._f.length; i++) {\n            currentScore = 0;\n            tempConfig = copyConfig({}, config);\n            if (config._useUTC != null) {\n                tempConfig._useUTC = config._useUTC;\n            }\n            tempConfig._f = config._f[i];\n            configFromStringAndFormat(tempConfig);\n\n            if (!isValid(tempConfig)) {\n                continue;\n            }\n\n            // if there is any input that was not parsed add a penalty for that format\n            currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n            //or tokens\n            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n            getParsingFlags(tempConfig).score = currentScore;\n\n            if (scoreToBeat == null || currentScore < scoreToBeat) {\n                scoreToBeat = currentScore;\n                bestMoment = tempConfig;\n            }\n        }\n\n        extend(config, bestMoment || tempConfig);\n    }\n\n    function configFromObject(config) {\n        if (config._d) {\n            return;\n        }\n\n        var i = normalizeObjectUnits(config._i);\n        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n            return obj && parseInt(obj, 10);\n        });\n\n        configFromArray(config);\n    }\n\n    function createFromConfig (config) {\n        var res = new Moment(checkOverflow(prepareConfig(config)));\n        if (res._nextDay) {\n            // Adding is smart enough around DST\n            res.add(1, 'd');\n            res._nextDay = undefined;\n        }\n\n        return res;\n    }\n\n    function prepareConfig (config) {\n        var input = config._i,\n            format = config._f;\n\n        config._locale = config._locale || getLocale(config._l);\n\n        if (input === null || (format === undefined && input === '')) {\n            return createInvalid({nullInput: true});\n        }\n\n        if (typeof input === 'string') {\n            config._i = input = config._locale.preparse(input);\n        }\n\n        if (isMoment(input)) {\n            return new Moment(checkOverflow(input));\n        } else if (isDate(input)) {\n            config._d = input;\n        } else if (isArray(format)) {\n            configFromStringAndArray(config);\n        } else if (format) {\n            configFromStringAndFormat(config);\n        }  else {\n            configFromInput(config);\n        }\n\n        if (!isValid(config)) {\n            config._d = null;\n        }\n\n        return config;\n    }\n\n    function configFromInput(config) {\n        var input = config._i;\n        if (isUndefined(input)) {\n            config._d = new Date(hooks.now());\n        } else if (isDate(input)) {\n            config._d = new Date(input.valueOf());\n        } else if (typeof input === 'string') {\n            configFromString(config);\n        } else if (isArray(input)) {\n            config._a = map(input.slice(0), function (obj) {\n                return parseInt(obj, 10);\n            });\n            configFromArray(config);\n        } else if (isObject(input)) {\n            configFromObject(config);\n        } else if (isNumber(input)) {\n            // from milliseconds\n            config._d = new Date(input);\n        } else {\n            hooks.createFromInputFallback(config);\n        }\n    }\n\n    function createLocalOrUTC (input, format, locale, strict, isUTC) {\n        var c = {};\n\n        if (locale === true || locale === false) {\n            strict = locale;\n            locale = undefined;\n        }\n\n        if ((isObject(input) && isObjectEmpty(input)) ||\n                (isArray(input) && input.length === 0)) {\n            input = undefined;\n        }\n        // object construction must be done this way.\n        // https://github.com/moment/moment/issues/1423\n        c._isAMomentObject = true;\n        c._useUTC = c._isUTC = isUTC;\n        c._l = locale;\n        c._i = input;\n        c._f = format;\n        c._strict = strict;\n\n        return createFromConfig(c);\n    }\n\n    function createLocal (input, format, locale, strict) {\n        return createLocalOrUTC(input, format, locale, strict, false);\n    }\n\n    var prototypeMin = deprecate(\n        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n        function () {\n            var other = createLocal.apply(null, arguments);\n            if (this.isValid() && other.isValid()) {\n                return other < this ? this : other;\n            } else {\n                return createInvalid();\n            }\n        }\n    );\n\n    var prototypeMax = deprecate(\n        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n        function () {\n            var other = createLocal.apply(null, arguments);\n            if (this.isValid() && other.isValid()) {\n                return other > this ? this : other;\n            } else {\n                return createInvalid();\n            }\n        }\n    );\n\n    // Pick a moment m from moments so that m[fn](other) is true for all\n    // other. This relies on the function fn to be transitive.\n    //\n    // moments should either be an array of moment objects or an array, whose\n    // first element is an array of moment objects.\n    function pickBy(fn, moments) {\n        var res, i;\n        if (moments.length === 1 && isArray(moments[0])) {\n            moments = moments[0];\n        }\n        if (!moments.length) {\n            return createLocal();\n        }\n        res = moments[0];\n        for (i = 1; i < moments.length; ++i) {\n            if (!moments[i].isValid() || moments[i][fn](res)) {\n                res = moments[i];\n            }\n        }\n        return res;\n    }\n\n    // TODO: Use [].sort instead?\n    function min () {\n        var args = [].slice.call(arguments, 0);\n\n        return pickBy('isBefore', args);\n    }\n\n    function max () {\n        var args = [].slice.call(arguments, 0);\n\n        return pickBy('isAfter', args);\n    }\n\n    var now = function () {\n        return Date.now ? Date.now() : +(new Date());\n    };\n\n    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\n    function isDurationValid(m) {\n        for (var key in m) {\n            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n                return false;\n            }\n        }\n\n        var unitHasDecimal = false;\n        for (var i = 0; i < ordering.length; ++i) {\n            if (m[ordering[i]]) {\n                if (unitHasDecimal) {\n                    return false; // only allow non-integers for smallest unit\n                }\n                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                    unitHasDecimal = true;\n                }\n            }\n        }\n\n        return true;\n    }\n\n    function isValid$1() {\n        return this._isValid;\n    }\n\n    function createInvalid$1() {\n        return createDuration(NaN);\n    }\n\n    function Duration (duration) {\n        var normalizedInput = normalizeObjectUnits(duration),\n            years = normalizedInput.year || 0,\n            quarters = normalizedInput.quarter || 0,\n            months = normalizedInput.month || 0,\n            weeks = normalizedInput.week || normalizedInput.isoWeek || 0,\n            days = normalizedInput.day || 0,\n            hours = normalizedInput.hour || 0,\n            minutes = normalizedInput.minute || 0,\n            seconds = normalizedInput.second || 0,\n            milliseconds = normalizedInput.millisecond || 0;\n\n        this._isValid = isDurationValid(normalizedInput);\n\n        // representation for dateAddRemove\n        this._milliseconds = +milliseconds +\n            seconds * 1e3 + // 1000\n            minutes * 6e4 + // 1000 * 60\n            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n        // Because of dateAddRemove treats 24 hours as different from a\n        // day when working around DST, we need to store them separately\n        this._days = +days +\n            weeks * 7;\n        // It is impossible to translate months into days without knowing\n        // which months you are are talking about, so we have to store\n        // it separately.\n        this._months = +months +\n            quarters * 3 +\n            years * 12;\n\n        this._data = {};\n\n        this._locale = getLocale();\n\n        this._bubble();\n    }\n\n    function isDuration (obj) {\n        return obj instanceof Duration;\n    }\n\n    function absRound (number) {\n        if (number < 0) {\n            return Math.round(-1 * number) * -1;\n        } else {\n            return Math.round(number);\n        }\n    }\n\n    // FORMATTING\n\n    function offset (token, separator) {\n        addFormatToken(token, 0, 0, function () {\n            var offset = this.utcOffset();\n            var sign = '+';\n            if (offset < 0) {\n                offset = -offset;\n                sign = '-';\n            }\n            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n        });\n    }\n\n    offset('Z', ':');\n    offset('ZZ', '');\n\n    // PARSING\n\n    addRegexToken('Z',  matchShortOffset);\n    addRegexToken('ZZ', matchShortOffset);\n    addParseToken(['Z', 'ZZ'], function (input, array, config) {\n        config._useUTC = true;\n        config._tzm = offsetFromString(matchShortOffset, input);\n    });\n\n    // HELPERS\n\n    // timezone chunker\n    // '+10:00' > ['10',  '00']\n    // '-1530'  > ['-15', '30']\n    var chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\n    function offsetFromString(matcher, string) {\n        var matches = (string || '').match(matcher);\n\n        if (matches === null) {\n            return null;\n        }\n\n        var chunk   = matches[matches.length - 1] || [];\n        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n        var minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n        return minutes === 0 ?\n          0 :\n          parts[0] === '+' ? minutes : -minutes;\n    }\n\n    // Return a moment from input, that is local/utc/zone equivalent to model.\n    function cloneWithOffset(input, model) {\n        var res, diff;\n        if (model._isUTC) {\n            res = model.clone();\n            diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n            // Use low-level api, because this fn is low-level api.\n            res._d.setTime(res._d.valueOf() + diff);\n            hooks.updateOffset(res, false);\n            return res;\n        } else {\n            return createLocal(input).local();\n        }\n    }\n\n    function getDateOffset (m) {\n        // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n        // https://github.com/moment/moment/pull/1871\n        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;\n    }\n\n    // HOOKS\n\n    // This function will be called whenever a moment is mutated.\n    // It is intended to keep the offset in sync with the timezone.\n    hooks.updateOffset = function () {};\n\n    // MOMENTS\n\n    // keepLocalTime = true means only change the timezone, without\n    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n    // +0200, so we adjust the time as needed, to be valid.\n    //\n    // Keeping the time actually adds/subtracts (one hour)\n    // from the actual represented time. That is why we call updateOffset\n    // a second time. In case it wants us to change the offset again\n    // _changeInProgress == true case, then we have to adjust, because\n    // there is no such time in the given timezone.\n    function getSetOffset (input, keepLocalTime, keepMinutes) {\n        var offset = this._offset || 0,\n            localAdjust;\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        if (input != null) {\n            if (typeof input === 'string') {\n                input = offsetFromString(matchShortOffset, input);\n                if (input === null) {\n                    return this;\n                }\n            } else if (Math.abs(input) < 16 && !keepMinutes) {\n                input = input * 60;\n            }\n            if (!this._isUTC && keepLocalTime) {\n                localAdjust = getDateOffset(this);\n            }\n            this._offset = input;\n            this._isUTC = true;\n            if (localAdjust != null) {\n                this.add(localAdjust, 'm');\n            }\n            if (offset !== input) {\n                if (!keepLocalTime || this._changeInProgress) {\n                    addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n                } else if (!this._changeInProgress) {\n                    this._changeInProgress = true;\n                    hooks.updateOffset(this, true);\n                    this._changeInProgress = null;\n                }\n            }\n            return this;\n        } else {\n            return this._isUTC ? offset : getDateOffset(this);\n        }\n    }\n\n    function getSetZone (input, keepLocalTime) {\n        if (input != null) {\n            if (typeof input !== 'string') {\n                input = -input;\n            }\n\n            this.utcOffset(input, keepLocalTime);\n\n            return this;\n        } else {\n            return -this.utcOffset();\n        }\n    }\n\n    function setOffsetToUTC (keepLocalTime) {\n        return this.utcOffset(0, keepLocalTime);\n    }\n\n    function setOffsetToLocal (keepLocalTime) {\n        if (this._isUTC) {\n            this.utcOffset(0, keepLocalTime);\n            this._isUTC = false;\n\n            if (keepLocalTime) {\n                this.subtract(getDateOffset(this), 'm');\n            }\n        }\n        return this;\n    }\n\n    function setOffsetToParsedOffset () {\n        if (this._tzm != null) {\n            this.utcOffset(this._tzm, false, true);\n        } else if (typeof this._i === 'string') {\n            var tZone = offsetFromString(matchOffset, this._i);\n            if (tZone != null) {\n                this.utcOffset(tZone);\n            }\n            else {\n                this.utcOffset(0, true);\n            }\n        }\n        return this;\n    }\n\n    function hasAlignedHourOffset (input) {\n        if (!this.isValid()) {\n            return false;\n        }\n        input = input ? createLocal(input).utcOffset() : 0;\n\n        return (this.utcOffset() - input) % 60 === 0;\n    }\n\n    function isDaylightSavingTime () {\n        return (\n            this.utcOffset() > this.clone().month(0).utcOffset() ||\n            this.utcOffset() > this.clone().month(5).utcOffset()\n        );\n    }\n\n    function isDaylightSavingTimeShifted () {\n        if (!isUndefined(this._isDSTShifted)) {\n            return this._isDSTShifted;\n        }\n\n        var c = {};\n\n        copyConfig(c, this);\n        c = prepareConfig(c);\n\n        if (c._a) {\n            var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n            this._isDSTShifted = this.isValid() &&\n                compareArrays(c._a, other.toArray()) > 0;\n        } else {\n            this._isDSTShifted = false;\n        }\n\n        return this._isDSTShifted;\n    }\n\n    function isLocal () {\n        return this.isValid() ? !this._isUTC : false;\n    }\n\n    function isUtcOffset () {\n        return this.isValid() ? this._isUTC : false;\n    }\n\n    function isUtc () {\n        return this.isValid() ? this._isUTC && this._offset === 0 : false;\n    }\n\n    // ASP.NET json date format regex\n    var aspNetRegex = /^(\\-|\\+)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n    // and further modified to allow for strings containing both week and day\n    var isoRegex = /^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;\n\n    function createDuration (input, key) {\n        var duration = input,\n            // matching against regexp is expensive, do it on demand\n            match = null,\n            sign,\n            ret,\n            diffRes;\n\n        if (isDuration(input)) {\n            duration = {\n                ms : input._milliseconds,\n                d  : input._days,\n                M  : input._months\n            };\n        } else if (isNumber(input)) {\n            duration = {};\n            if (key) {\n                duration[key] = input;\n            } else {\n                duration.milliseconds = input;\n            }\n        } else if (!!(match = aspNetRegex.exec(input))) {\n            sign = (match[1] === '-') ? -1 : 1;\n            duration = {\n                y  : 0,\n                d  : toInt(match[DATE])                         * sign,\n                h  : toInt(match[HOUR])                         * sign,\n                m  : toInt(match[MINUTE])                       * sign,\n                s  : toInt(match[SECOND])                       * sign,\n                ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n            };\n        } else if (!!(match = isoRegex.exec(input))) {\n            sign = (match[1] === '-') ? -1 : 1;\n            duration = {\n                y : parseIso(match[2], sign),\n                M : parseIso(match[3], sign),\n                w : parseIso(match[4], sign),\n                d : parseIso(match[5], sign),\n                h : parseIso(match[6], sign),\n                m : parseIso(match[7], sign),\n                s : parseIso(match[8], sign)\n            };\n        } else if (duration == null) {// checks for null or undefined\n            duration = {};\n        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n            diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n\n            duration = {};\n            duration.ms = diffRes.milliseconds;\n            duration.M = diffRes.months;\n        }\n\n        ret = new Duration(duration);\n\n        if (isDuration(input) && hasOwnProp(input, '_locale')) {\n            ret._locale = input._locale;\n        }\n\n        return ret;\n    }\n\n    createDuration.fn = Duration.prototype;\n    createDuration.invalid = createInvalid$1;\n\n    function parseIso (inp, sign) {\n        // We'd normally use ~~inp for this, but unfortunately it also\n        // converts floats to ints.\n        // inp may be undefined, so careful calling replace on it.\n        var res = inp && parseFloat(inp.replace(',', '.'));\n        // apply sign while we're at it\n        return (isNaN(res) ? 0 : res) * sign;\n    }\n\n    function positiveMomentsDifference(base, other) {\n        var res = {};\n\n        res.months = other.month() - base.month() +\n            (other.year() - base.year()) * 12;\n        if (base.clone().add(res.months, 'M').isAfter(other)) {\n            --res.months;\n        }\n\n        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));\n\n        return res;\n    }\n\n    function momentsDifference(base, other) {\n        var res;\n        if (!(base.isValid() && other.isValid())) {\n            return {milliseconds: 0, months: 0};\n        }\n\n        other = cloneWithOffset(other, base);\n        if (base.isBefore(other)) {\n            res = positiveMomentsDifference(base, other);\n        } else {\n            res = positiveMomentsDifference(other, base);\n            res.milliseconds = -res.milliseconds;\n            res.months = -res.months;\n        }\n\n        return res;\n    }\n\n    // TODO: remove 'name' arg after deprecation is removed\n    function createAdder(direction, name) {\n        return function (val, period) {\n            var dur, tmp;\n            //invert the arguments, but complain about it\n            if (period !== null && !isNaN(+period)) {\n                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +\n                'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n                tmp = val; val = period; period = tmp;\n            }\n\n            val = typeof val === 'string' ? +val : val;\n            dur = createDuration(val, period);\n            addSubtract(this, dur, direction);\n            return this;\n        };\n    }\n\n    function addSubtract (mom, duration, isAdding, updateOffset) {\n        var milliseconds = duration._milliseconds,\n            days = absRound(duration._days),\n            months = absRound(duration._months);\n\n        if (!mom.isValid()) {\n            // No op\n            return;\n        }\n\n        updateOffset = updateOffset == null ? true : updateOffset;\n\n        if (months) {\n            setMonth(mom, get(mom, 'Month') + months * isAdding);\n        }\n        if (days) {\n            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n        }\n        if (milliseconds) {\n            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n        }\n        if (updateOffset) {\n            hooks.updateOffset(mom, days || months);\n        }\n    }\n\n    var add      = createAdder(1, 'add');\n    var subtract = createAdder(-1, 'subtract');\n\n    function getCalendarFormat(myMoment, now) {\n        var diff = myMoment.diff(now, 'days', true);\n        return diff < -6 ? 'sameElse' :\n                diff < -1 ? 'lastWeek' :\n                diff < 0 ? 'lastDay' :\n                diff < 1 ? 'sameDay' :\n                diff < 2 ? 'nextDay' :\n                diff < 7 ? 'nextWeek' : 'sameElse';\n    }\n\n    function calendar$1 (time, formats) {\n        // We want to compare the start of today, vs this.\n        // Getting start-of-today depends on whether we're local/utc/offset or not.\n        var now = time || createLocal(),\n            sod = cloneWithOffset(now, this).startOf('day'),\n            format = hooks.calendarFormat(this, sod) || 'sameElse';\n\n        var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n\n        return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n    }\n\n    function clone () {\n        return new Moment(this);\n    }\n\n    function isAfter (input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input);\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() > localInput.valueOf();\n        } else {\n            return localInput.valueOf() < this.clone().startOf(units).valueOf();\n        }\n    }\n\n    function isBefore (input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input);\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() < localInput.valueOf();\n        } else {\n            return this.clone().endOf(units).valueOf() < localInput.valueOf();\n        }\n    }\n\n    function isBetween (from, to, units, inclusivity) {\n        var localFrom = isMoment(from) ? from : createLocal(from),\n            localTo = isMoment(to) ? to : createLocal(to);\n        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {\n            return false;\n        }\n        inclusivity = inclusivity || '()';\n        return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) &&\n            (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));\n    }\n\n    function isSame (input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input),\n            inputMs;\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() === localInput.valueOf();\n        } else {\n            inputMs = localInput.valueOf();\n            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n        }\n    }\n\n    function isSameOrAfter (input, units) {\n        return this.isSame(input, units) || this.isAfter(input, units);\n    }\n\n    function isSameOrBefore (input, units) {\n        return this.isSame(input, units) || this.isBefore(input, units);\n    }\n\n    function diff (input, units, asFloat) {\n        var that,\n            zoneDelta,\n            output;\n\n        if (!this.isValid()) {\n            return NaN;\n        }\n\n        that = cloneWithOffset(input, this);\n\n        if (!that.isValid()) {\n            return NaN;\n        }\n\n        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n        units = normalizeUnits(units);\n\n        switch (units) {\n            case 'year': output = monthDiff(this, that) / 12; break;\n            case 'month': output = monthDiff(this, that); break;\n            case 'quarter': output = monthDiff(this, that) / 3; break;\n            case 'second': output = (this - that) / 1e3; break; // 1000\n            case 'minute': output = (this - that) / 6e4; break; // 1000 * 60\n            case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60\n            case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst\n            case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst\n            default: output = this - that;\n        }\n\n        return asFloat ? output : absFloor(output);\n    }\n\n    function monthDiff (a, b) {\n        // difference in months\n        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),\n            // b is in (anchor - 1 month, anchor + 1 month)\n            anchor = a.clone().add(wholeMonthDiff, 'months'),\n            anchor2, adjust;\n\n        if (b - anchor < 0) {\n            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n            // linear across the month\n            adjust = (b - anchor) / (anchor - anchor2);\n        } else {\n            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n            // linear across the month\n            adjust = (b - anchor) / (anchor2 - anchor);\n        }\n\n        //check for negative zero, return zero if negative zero\n        return -(wholeMonthDiff + adjust) || 0;\n    }\n\n    hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\n    hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\n    function toString () {\n        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n    }\n\n    function toISOString(keepOffset) {\n        if (!this.isValid()) {\n            return null;\n        }\n        var utc = keepOffset !== true;\n        var m = utc ? this.clone().utc() : this;\n        if (m.year() < 0 || m.year() > 9999) {\n            return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');\n        }\n        if (isFunction(Date.prototype.toISOString)) {\n            // native implementation is ~50x faster, use it when we can\n            if (utc) {\n                return this.toDate().toISOString();\n            } else {\n                return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));\n            }\n        }\n        return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');\n    }\n\n    /**\n     * Return a human readable representation of a moment that can\n     * also be evaluated to get a new moment which is the same\n     *\n     * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n     */\n    function inspect () {\n        if (!this.isValid()) {\n            return 'moment.invalid(/* ' + this._i + ' */)';\n        }\n        var func = 'moment';\n        var zone = '';\n        if (!this.isLocal()) {\n            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n            zone = 'Z';\n        }\n        var prefix = '[' + func + '(\"]';\n        var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';\n        var datetime = '-MM-DD[T]HH:mm:ss.SSS';\n        var suffix = zone + '[\")]';\n\n        return this.format(prefix + year + datetime + suffix);\n    }\n\n    function format (inputString) {\n        if (!inputString) {\n            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n        }\n        var output = formatMoment(this, inputString);\n        return this.localeData().postformat(output);\n    }\n\n    function from (time, withoutSuffix) {\n        if (this.isValid() &&\n                ((isMoment(time) && time.isValid()) ||\n                 createLocal(time).isValid())) {\n            return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);\n        } else {\n            return this.localeData().invalidDate();\n        }\n    }\n\n    function fromNow (withoutSuffix) {\n        return this.from(createLocal(), withoutSuffix);\n    }\n\n    function to (time, withoutSuffix) {\n        if (this.isValid() &&\n                ((isMoment(time) && time.isValid()) ||\n                 createLocal(time).isValid())) {\n            return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);\n        } else {\n            return this.localeData().invalidDate();\n        }\n    }\n\n    function toNow (withoutSuffix) {\n        return this.to(createLocal(), withoutSuffix);\n    }\n\n    // If passed a locale key, it will set the locale for this\n    // instance.  Otherwise, it will return the locale configuration\n    // variables for this instance.\n    function locale (key) {\n        var newLocaleData;\n\n        if (key === undefined) {\n            return this._locale._abbr;\n        } else {\n            newLocaleData = getLocale(key);\n            if (newLocaleData != null) {\n                this._locale = newLocaleData;\n            }\n            return this;\n        }\n    }\n\n    var lang = deprecate(\n        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n        function (key) {\n            if (key === undefined) {\n                return this.localeData();\n            } else {\n                return this.locale(key);\n            }\n        }\n    );\n\n    function localeData () {\n        return this._locale;\n    }\n\n    var MS_PER_SECOND = 1000;\n    var MS_PER_MINUTE = 60 * MS_PER_SECOND;\n    var MS_PER_HOUR = 60 * MS_PER_MINUTE;\n    var MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;\n\n    // actual modulo - handles negative numbers (for dates before 1970):\n    function mod$1(dividend, divisor) {\n        return (dividend % divisor + divisor) % divisor;\n    }\n\n    function localStartOfDate(y, m, d) {\n        // the date constructor remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            return new Date(y + 400, m, d) - MS_PER_400_YEARS;\n        } else {\n            return new Date(y, m, d).valueOf();\n        }\n    }\n\n    function utcStartOfDate(y, m, d) {\n        // Date.UTC remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;\n        } else {\n            return Date.UTC(y, m, d);\n        }\n    }\n\n    function startOf (units) {\n        var time;\n        units = normalizeUnits(units);\n        if (units === undefined || units === 'millisecond' || !this.isValid()) {\n            return this;\n        }\n\n        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n\n        switch (units) {\n            case 'year':\n                time = startOfDate(this.year(), 0, 1);\n                break;\n            case 'quarter':\n                time = startOfDate(this.year(), this.month() - this.month() % 3, 1);\n                break;\n            case 'month':\n                time = startOfDate(this.year(), this.month(), 1);\n                break;\n            case 'week':\n                time = startOfDate(this.year(), this.month(), this.date() - this.weekday());\n                break;\n            case 'isoWeek':\n                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));\n                break;\n            case 'day':\n            case 'date':\n                time = startOfDate(this.year(), this.month(), this.date());\n                break;\n            case 'hour':\n                time = this._d.valueOf();\n                time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);\n                break;\n            case 'minute':\n                time = this._d.valueOf();\n                time -= mod$1(time, MS_PER_MINUTE);\n                break;\n            case 'second':\n                time = this._d.valueOf();\n                time -= mod$1(time, MS_PER_SECOND);\n                break;\n        }\n\n        this._d.setTime(time);\n        hooks.updateOffset(this, true);\n        return this;\n    }\n\n    function endOf (units) {\n        var time;\n        units = normalizeUnits(units);\n        if (units === undefined || units === 'millisecond' || !this.isValid()) {\n            return this;\n        }\n\n        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n\n        switch (units) {\n            case 'year':\n                time = startOfDate(this.year() + 1, 0, 1) - 1;\n                break;\n            case 'quarter':\n                time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;\n                break;\n            case 'month':\n                time = startOfDate(this.year(), this.month() + 1, 1) - 1;\n                break;\n            case 'week':\n                time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;\n                break;\n            case 'isoWeek':\n                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1;\n                break;\n            case 'day':\n            case 'date':\n                time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;\n                break;\n            case 'hour':\n                time = this._d.valueOf();\n                time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;\n                break;\n            case 'minute':\n                time = this._d.valueOf();\n                time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;\n                break;\n            case 'second':\n                time = this._d.valueOf();\n                time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;\n                break;\n        }\n\n        this._d.setTime(time);\n        hooks.updateOffset(this, true);\n        return this;\n    }\n\n    function valueOf () {\n        return this._d.valueOf() - ((this._offset || 0) * 60000);\n    }\n\n    function unix () {\n        return Math.floor(this.valueOf() / 1000);\n    }\n\n    function toDate () {\n        return new Date(this.valueOf());\n    }\n\n    function toArray () {\n        var m = this;\n        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n    }\n\n    function toObject () {\n        var m = this;\n        return {\n            years: m.year(),\n            months: m.month(),\n            date: m.date(),\n            hours: m.hours(),\n            minutes: m.minutes(),\n            seconds: m.seconds(),\n            milliseconds: m.milliseconds()\n        };\n    }\n\n    function toJSON () {\n        // new Date(NaN).toJSON() === null\n        return this.isValid() ? this.toISOString() : null;\n    }\n\n    function isValid$2 () {\n        return isValid(this);\n    }\n\n    function parsingFlags () {\n        return extend({}, getParsingFlags(this));\n    }\n\n    function invalidAt () {\n        return getParsingFlags(this).overflow;\n    }\n\n    function creationData() {\n        return {\n            input: this._i,\n            format: this._f,\n            locale: this._locale,\n            isUTC: this._isUTC,\n            strict: this._strict\n        };\n    }\n\n    // FORMATTING\n\n    addFormatToken(0, ['gg', 2], 0, function () {\n        return this.weekYear() % 100;\n    });\n\n    addFormatToken(0, ['GG', 2], 0, function () {\n        return this.isoWeekYear() % 100;\n    });\n\n    function addWeekYearFormatToken (token, getter) {\n        addFormatToken(0, [token, token.length], 0, getter);\n    }\n\n    addWeekYearFormatToken('gggg',     'weekYear');\n    addWeekYearFormatToken('ggggg',    'weekYear');\n    addWeekYearFormatToken('GGGG',  'isoWeekYear');\n    addWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n    // ALIASES\n\n    addUnitAlias('weekYear', 'gg');\n    addUnitAlias('isoWeekYear', 'GG');\n\n    // PRIORITY\n\n    addUnitPriority('weekYear', 1);\n    addUnitPriority('isoWeekYear', 1);\n\n\n    // PARSING\n\n    addRegexToken('G',      matchSigned);\n    addRegexToken('g',      matchSigned);\n    addRegexToken('GG',     match1to2, match2);\n    addRegexToken('gg',     match1to2, match2);\n    addRegexToken('GGGG',   match1to4, match4);\n    addRegexToken('gggg',   match1to4, match4);\n    addRegexToken('GGGGG',  match1to6, match6);\n    addRegexToken('ggggg',  match1to6, match6);\n\n    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n        week[token.substr(0, 2)] = toInt(input);\n    });\n\n    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n        week[token] = hooks.parseTwoDigitYear(input);\n    });\n\n    // MOMENTS\n\n    function getSetWeekYear (input) {\n        return getSetWeekYearHelper.call(this,\n                input,\n                this.week(),\n                this.weekday(),\n                this.localeData()._week.dow,\n                this.localeData()._week.doy);\n    }\n\n    function getSetISOWeekYear (input) {\n        return getSetWeekYearHelper.call(this,\n                input, this.isoWeek(), this.isoWeekday(), 1, 4);\n    }\n\n    function getISOWeeksInYear () {\n        return weeksInYear(this.year(), 1, 4);\n    }\n\n    function getWeeksInYear () {\n        var weekInfo = this.localeData()._week;\n        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n    }\n\n    function getSetWeekYearHelper(input, week, weekday, dow, doy) {\n        var weeksTarget;\n        if (input == null) {\n            return weekOfYear(this, dow, doy).year;\n        } else {\n            weeksTarget = weeksInYear(input, dow, doy);\n            if (week > weeksTarget) {\n                week = weeksTarget;\n            }\n            return setWeekAll.call(this, input, week, weekday, dow, doy);\n        }\n    }\n\n    function setWeekAll(weekYear, week, weekday, dow, doy) {\n        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n        this.year(date.getUTCFullYear());\n        this.month(date.getUTCMonth());\n        this.date(date.getUTCDate());\n        return this;\n    }\n\n    // FORMATTING\n\n    addFormatToken('Q', 0, 'Qo', 'quarter');\n\n    // ALIASES\n\n    addUnitAlias('quarter', 'Q');\n\n    // PRIORITY\n\n    addUnitPriority('quarter', 7);\n\n    // PARSING\n\n    addRegexToken('Q', match1);\n    addParseToken('Q', function (input, array) {\n        array[MONTH] = (toInt(input) - 1) * 3;\n    });\n\n    // MOMENTS\n\n    function getSetQuarter (input) {\n        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n    }\n\n    // FORMATTING\n\n    addFormatToken('D', ['DD', 2], 'Do', 'date');\n\n    // ALIASES\n\n    addUnitAlias('date', 'D');\n\n    // PRIORITY\n    addUnitPriority('date', 9);\n\n    // PARSING\n\n    addRegexToken('D',  match1to2);\n    addRegexToken('DD', match1to2, match2);\n    addRegexToken('Do', function (isStrict, locale) {\n        // TODO: Remove \"ordinalParse\" fallback in next major release.\n        return isStrict ?\n          (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :\n          locale._dayOfMonthOrdinalParseLenient;\n    });\n\n    addParseToken(['D', 'DD'], DATE);\n    addParseToken('Do', function (input, array) {\n        array[DATE] = toInt(input.match(match1to2)[0]);\n    });\n\n    // MOMENTS\n\n    var getSetDayOfMonth = makeGetSet('Date', true);\n\n    // FORMATTING\n\n    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n    // ALIASES\n\n    addUnitAlias('dayOfYear', 'DDD');\n\n    // PRIORITY\n    addUnitPriority('dayOfYear', 4);\n\n    // PARSING\n\n    addRegexToken('DDD',  match1to3);\n    addRegexToken('DDDD', match3);\n    addParseToken(['DDD', 'DDDD'], function (input, array, config) {\n        config._dayOfYear = toInt(input);\n    });\n\n    // HELPERS\n\n    // MOMENTS\n\n    function getSetDayOfYear (input) {\n        var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n        return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');\n    }\n\n    // FORMATTING\n\n    addFormatToken('m', ['mm', 2], 0, 'minute');\n\n    // ALIASES\n\n    addUnitAlias('minute', 'm');\n\n    // PRIORITY\n\n    addUnitPriority('minute', 14);\n\n    // PARSING\n\n    addRegexToken('m',  match1to2);\n    addRegexToken('mm', match1to2, match2);\n    addParseToken(['m', 'mm'], MINUTE);\n\n    // MOMENTS\n\n    var getSetMinute = makeGetSet('Minutes', false);\n\n    // FORMATTING\n\n    addFormatToken('s', ['ss', 2], 0, 'second');\n\n    // ALIASES\n\n    addUnitAlias('second', 's');\n\n    // PRIORITY\n\n    addUnitPriority('second', 15);\n\n    // PARSING\n\n    addRegexToken('s',  match1to2);\n    addRegexToken('ss', match1to2, match2);\n    addParseToken(['s', 'ss'], SECOND);\n\n    // MOMENTS\n\n    var getSetSecond = makeGetSet('Seconds', false);\n\n    // FORMATTING\n\n    addFormatToken('S', 0, 0, function () {\n        return ~~(this.millisecond() / 100);\n    });\n\n    addFormatToken(0, ['SS', 2], 0, function () {\n        return ~~(this.millisecond() / 10);\n    });\n\n    addFormatToken(0, ['SSS', 3], 0, 'millisecond');\n    addFormatToken(0, ['SSSS', 4], 0, function () {\n        return this.millisecond() * 10;\n    });\n    addFormatToken(0, ['SSSSS', 5], 0, function () {\n        return this.millisecond() * 100;\n    });\n    addFormatToken(0, ['SSSSSS', 6], 0, function () {\n        return this.millisecond() * 1000;\n    });\n    addFormatToken(0, ['SSSSSSS', 7], 0, function () {\n        return this.millisecond() * 10000;\n    });\n    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n        return this.millisecond() * 100000;\n    });\n    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n        return this.millisecond() * 1000000;\n    });\n\n\n    // ALIASES\n\n    addUnitAlias('millisecond', 'ms');\n\n    // PRIORITY\n\n    addUnitPriority('millisecond', 16);\n\n    // PARSING\n\n    addRegexToken('S',    match1to3, match1);\n    addRegexToken('SS',   match1to3, match2);\n    addRegexToken('SSS',  match1to3, match3);\n\n    var token;\n    for (token = 'SSSS'; token.length <= 9; token += 'S') {\n        addRegexToken(token, matchUnsigned);\n    }\n\n    function parseMs(input, array) {\n        array[MILLISECOND] = toInt(('0.' + input) * 1000);\n    }\n\n    for (token = 'S'; token.length <= 9; token += 'S') {\n        addParseToken(token, parseMs);\n    }\n    // MOMENTS\n\n    var getSetMillisecond = makeGetSet('Milliseconds', false);\n\n    // FORMATTING\n\n    addFormatToken('z',  0, 0, 'zoneAbbr');\n    addFormatToken('zz', 0, 0, 'zoneName');\n\n    // MOMENTS\n\n    function getZoneAbbr () {\n        return this._isUTC ? 'UTC' : '';\n    }\n\n    function getZoneName () {\n        return this._isUTC ? 'Coordinated Universal Time' : '';\n    }\n\n    var proto = Moment.prototype;\n\n    proto.add               = add;\n    proto.calendar          = calendar$1;\n    proto.clone             = clone;\n    proto.diff              = diff;\n    proto.endOf             = endOf;\n    proto.format            = format;\n    proto.from              = from;\n    proto.fromNow           = fromNow;\n    proto.to                = to;\n    proto.toNow             = toNow;\n    proto.get               = stringGet;\n    proto.invalidAt         = invalidAt;\n    proto.isAfter           = isAfter;\n    proto.isBefore          = isBefore;\n    proto.isBetween         = isBetween;\n    proto.isSame            = isSame;\n    proto.isSameOrAfter     = isSameOrAfter;\n    proto.isSameOrBefore    = isSameOrBefore;\n    proto.isValid           = isValid$2;\n    proto.lang              = lang;\n    proto.locale            = locale;\n    proto.localeData        = localeData;\n    proto.max               = prototypeMax;\n    proto.min               = prototypeMin;\n    proto.parsingFlags      = parsingFlags;\n    proto.set               = stringSet;\n    proto.startOf           = startOf;\n    proto.subtract          = subtract;\n    proto.toArray           = toArray;\n    proto.toObject          = toObject;\n    proto.toDate            = toDate;\n    proto.toISOString       = toISOString;\n    proto.inspect           = inspect;\n    proto.toJSON            = toJSON;\n    proto.toString          = toString;\n    proto.unix              = unix;\n    proto.valueOf           = valueOf;\n    proto.creationData      = creationData;\n    proto.year       = getSetYear;\n    proto.isLeapYear = getIsLeapYear;\n    proto.weekYear    = getSetWeekYear;\n    proto.isoWeekYear = getSetISOWeekYear;\n    proto.quarter = proto.quarters = getSetQuarter;\n    proto.month       = getSetMonth;\n    proto.daysInMonth = getDaysInMonth;\n    proto.week           = proto.weeks        = getSetWeek;\n    proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;\n    proto.weeksInYear    = getWeeksInYear;\n    proto.isoWeeksInYear = getISOWeeksInYear;\n    proto.date       = getSetDayOfMonth;\n    proto.day        = proto.days             = getSetDayOfWeek;\n    proto.weekday    = getSetLocaleDayOfWeek;\n    proto.isoWeekday = getSetISODayOfWeek;\n    proto.dayOfYear  = getSetDayOfYear;\n    proto.hour = proto.hours = getSetHour;\n    proto.minute = proto.minutes = getSetMinute;\n    proto.second = proto.seconds = getSetSecond;\n    proto.millisecond = proto.milliseconds = getSetMillisecond;\n    proto.utcOffset            = getSetOffset;\n    proto.utc                  = setOffsetToUTC;\n    proto.local                = setOffsetToLocal;\n    proto.parseZone            = setOffsetToParsedOffset;\n    proto.hasAlignedHourOffset = hasAlignedHourOffset;\n    proto.isDST                = isDaylightSavingTime;\n    proto.isLocal              = isLocal;\n    proto.isUtcOffset          = isUtcOffset;\n    proto.isUtc                = isUtc;\n    proto.isUTC                = isUtc;\n    proto.zoneAbbr = getZoneAbbr;\n    proto.zoneName = getZoneName;\n    proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\n    proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\n    proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);\n    proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\n    proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\n    function createUnix (input) {\n        return createLocal(input * 1000);\n    }\n\n    function createInZone () {\n        return createLocal.apply(null, arguments).parseZone();\n    }\n\n    function preParsePostFormat (string) {\n        return string;\n    }\n\n    var proto$1 = Locale.prototype;\n\n    proto$1.calendar        = calendar;\n    proto$1.longDateFormat  = longDateFormat;\n    proto$1.invalidDate     = invalidDate;\n    proto$1.ordinal         = ordinal;\n    proto$1.preparse        = preParsePostFormat;\n    proto$1.postformat      = preParsePostFormat;\n    proto$1.relativeTime    = relativeTime;\n    proto$1.pastFuture      = pastFuture;\n    proto$1.set             = set;\n\n    proto$1.months            =        localeMonths;\n    proto$1.monthsShort       =        localeMonthsShort;\n    proto$1.monthsParse       =        localeMonthsParse;\n    proto$1.monthsRegex       = monthsRegex;\n    proto$1.monthsShortRegex  = monthsShortRegex;\n    proto$1.week = localeWeek;\n    proto$1.firstDayOfYear = localeFirstDayOfYear;\n    proto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n    proto$1.weekdays       =        localeWeekdays;\n    proto$1.weekdaysMin    =        localeWeekdaysMin;\n    proto$1.weekdaysShort  =        localeWeekdaysShort;\n    proto$1.weekdaysParse  =        localeWeekdaysParse;\n\n    proto$1.weekdaysRegex       =        weekdaysRegex;\n    proto$1.weekdaysShortRegex  =        weekdaysShortRegex;\n    proto$1.weekdaysMinRegex    =        weekdaysMinRegex;\n\n    proto$1.isPM = localeIsPM;\n    proto$1.meridiem = localeMeridiem;\n\n    function get$1 (format, index, field, setter) {\n        var locale = getLocale();\n        var utc = createUTC().set(setter, index);\n        return locale[field](utc, format);\n    }\n\n    function listMonthsImpl (format, index, field) {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n\n        if (index != null) {\n            return get$1(format, index, field, 'month');\n        }\n\n        var i;\n        var out = [];\n        for (i = 0; i < 12; i++) {\n            out[i] = get$1(format, i, field, 'month');\n        }\n        return out;\n    }\n\n    // ()\n    // (5)\n    // (fmt, 5)\n    // (fmt)\n    // (true)\n    // (true, 5)\n    // (true, fmt, 5)\n    // (true, fmt)\n    function listWeekdaysImpl (localeSorted, format, index, field) {\n        if (typeof localeSorted === 'boolean') {\n            if (isNumber(format)) {\n                index = format;\n                format = undefined;\n            }\n\n            format = format || '';\n        } else {\n            format = localeSorted;\n            index = format;\n            localeSorted = false;\n\n            if (isNumber(format)) {\n                index = format;\n                format = undefined;\n            }\n\n            format = format || '';\n        }\n\n        var locale = getLocale(),\n            shift = localeSorted ? locale._week.dow : 0;\n\n        if (index != null) {\n            return get$1(format, (index + shift) % 7, field, 'day');\n        }\n\n        var i;\n        var out = [];\n        for (i = 0; i < 7; i++) {\n            out[i] = get$1(format, (i + shift) % 7, field, 'day');\n        }\n        return out;\n    }\n\n    function listMonths (format, index) {\n        return listMonthsImpl(format, index, 'months');\n    }\n\n    function listMonthsShort (format, index) {\n        return listMonthsImpl(format, index, 'monthsShort');\n    }\n\n    function listWeekdays (localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n    }\n\n    function listWeekdaysShort (localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n    }\n\n    function listWeekdaysMin (localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n    }\n\n    getSetGlobalLocale('en', {\n        dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n        ordinal : function (number) {\n            var b = number % 10,\n                output = (toInt(number % 100 / 10) === 1) ? 'th' :\n                (b === 1) ? 'st' :\n                (b === 2) ? 'nd' :\n                (b === 3) ? 'rd' : 'th';\n            return number + output;\n        }\n    });\n\n    // Side effect imports\n\n    hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\n    hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\n    var mathAbs = Math.abs;\n\n    function abs () {\n        var data           = this._data;\n\n        this._milliseconds = mathAbs(this._milliseconds);\n        this._days         = mathAbs(this._days);\n        this._months       = mathAbs(this._months);\n\n        data.milliseconds  = mathAbs(data.milliseconds);\n        data.seconds       = mathAbs(data.seconds);\n        data.minutes       = mathAbs(data.minutes);\n        data.hours         = mathAbs(data.hours);\n        data.months        = mathAbs(data.months);\n        data.years         = mathAbs(data.years);\n\n        return this;\n    }\n\n    function addSubtract$1 (duration, input, value, direction) {\n        var other = createDuration(input, value);\n\n        duration._milliseconds += direction * other._milliseconds;\n        duration._days         += direction * other._days;\n        duration._months       += direction * other._months;\n\n        return duration._bubble();\n    }\n\n    // supports only 2.0-style add(1, 's') or add(duration)\n    function add$1 (input, value) {\n        return addSubtract$1(this, input, value, 1);\n    }\n\n    // supports only 2.0-style subtract(1, 's') or subtract(duration)\n    function subtract$1 (input, value) {\n        return addSubtract$1(this, input, value, -1);\n    }\n\n    function absCeil (number) {\n        if (number < 0) {\n            return Math.floor(number);\n        } else {\n            return Math.ceil(number);\n        }\n    }\n\n    function bubble () {\n        var milliseconds = this._milliseconds;\n        var days         = this._days;\n        var months       = this._months;\n        var data         = this._data;\n        var seconds, minutes, hours, years, monthsFromDays;\n\n        // if we have a mix of positive and negative values, bubble down first\n        // check: https://github.com/moment/moment/issues/2166\n        if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||\n                (milliseconds <= 0 && days <= 0 && months <= 0))) {\n            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n            days = 0;\n            months = 0;\n        }\n\n        // The following code bubbles up values, see the tests for\n        // examples of what that means.\n        data.milliseconds = milliseconds % 1000;\n\n        seconds           = absFloor(milliseconds / 1000);\n        data.seconds      = seconds % 60;\n\n        minutes           = absFloor(seconds / 60);\n        data.minutes      = minutes % 60;\n\n        hours             = absFloor(minutes / 60);\n        data.hours        = hours % 24;\n\n        days += absFloor(hours / 24);\n\n        // convert days to months\n        monthsFromDays = absFloor(daysToMonths(days));\n        months += monthsFromDays;\n        days -= absCeil(monthsToDays(monthsFromDays));\n\n        // 12 months -> 1 year\n        years = absFloor(months / 12);\n        months %= 12;\n\n        data.days   = days;\n        data.months = months;\n        data.years  = years;\n\n        return this;\n    }\n\n    function daysToMonths (days) {\n        // 400 years have 146097 days (taking into account leap year rules)\n        // 400 years have 12 months === 4800\n        return days * 4800 / 146097;\n    }\n\n    function monthsToDays (months) {\n        // the reverse of daysToMonths\n        return months * 146097 / 4800;\n    }\n\n    function as (units) {\n        if (!this.isValid()) {\n            return NaN;\n        }\n        var days;\n        var months;\n        var milliseconds = this._milliseconds;\n\n        units = normalizeUnits(units);\n\n        if (units === 'month' || units === 'quarter' || units === 'year') {\n            days = this._days + milliseconds / 864e5;\n            months = this._months + daysToMonths(days);\n            switch (units) {\n                case 'month':   return months;\n                case 'quarter': return months / 3;\n                case 'year':    return months / 12;\n            }\n        } else {\n            // handle milliseconds separately because of floating point math errors (issue #1867)\n            days = this._days + Math.round(monthsToDays(this._months));\n            switch (units) {\n                case 'week'   : return days / 7     + milliseconds / 6048e5;\n                case 'day'    : return days         + milliseconds / 864e5;\n                case 'hour'   : return days * 24    + milliseconds / 36e5;\n                case 'minute' : return days * 1440  + milliseconds / 6e4;\n                case 'second' : return days * 86400 + milliseconds / 1000;\n                // Math.floor prevents floating point math errors here\n                case 'millisecond': return Math.floor(days * 864e5) + milliseconds;\n                default: throw new Error('Unknown unit ' + units);\n            }\n        }\n    }\n\n    // TODO: Use this.as('ms')?\n    function valueOf$1 () {\n        if (!this.isValid()) {\n            return NaN;\n        }\n        return (\n            this._milliseconds +\n            this._days * 864e5 +\n            (this._months % 12) * 2592e6 +\n            toInt(this._months / 12) * 31536e6\n        );\n    }\n\n    function makeAs (alias) {\n        return function () {\n            return this.as(alias);\n        };\n    }\n\n    var asMilliseconds = makeAs('ms');\n    var asSeconds      = makeAs('s');\n    var asMinutes      = makeAs('m');\n    var asHours        = makeAs('h');\n    var asDays         = makeAs('d');\n    var asWeeks        = makeAs('w');\n    var asMonths       = makeAs('M');\n    var asQuarters     = makeAs('Q');\n    var asYears        = makeAs('y');\n\n    function clone$1 () {\n        return createDuration(this);\n    }\n\n    function get$2 (units) {\n        units = normalizeUnits(units);\n        return this.isValid() ? this[units + 's']() : NaN;\n    }\n\n    function makeGetter(name) {\n        return function () {\n            return this.isValid() ? this._data[name] : NaN;\n        };\n    }\n\n    var milliseconds = makeGetter('milliseconds');\n    var seconds      = makeGetter('seconds');\n    var minutes      = makeGetter('minutes');\n    var hours        = makeGetter('hours');\n    var days         = makeGetter('days');\n    var months       = makeGetter('months');\n    var years        = makeGetter('years');\n\n    function weeks () {\n        return absFloor(this.days() / 7);\n    }\n\n    var round = Math.round;\n    var thresholds = {\n        ss: 44,         // a few seconds to seconds\n        s : 45,         // seconds to minute\n        m : 45,         // minutes to hour\n        h : 22,         // hours to day\n        d : 26,         // days to month\n        M : 11          // months to year\n    };\n\n    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\n    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n    }\n\n    function relativeTime$1 (posNegDuration, withoutSuffix, locale) {\n        var duration = createDuration(posNegDuration).abs();\n        var seconds  = round(duration.as('s'));\n        var minutes  = round(duration.as('m'));\n        var hours    = round(duration.as('h'));\n        var days     = round(duration.as('d'));\n        var months   = round(duration.as('M'));\n        var years    = round(duration.as('y'));\n\n        var a = seconds <= thresholds.ss && ['s', seconds]  ||\n                seconds < thresholds.s   && ['ss', seconds] ||\n                minutes <= 1             && ['m']           ||\n                minutes < thresholds.m   && ['mm', minutes] ||\n                hours   <= 1             && ['h']           ||\n                hours   < thresholds.h   && ['hh', hours]   ||\n                days    <= 1             && ['d']           ||\n                days    < thresholds.d   && ['dd', days]    ||\n                months  <= 1             && ['M']           ||\n                months  < thresholds.M   && ['MM', months]  ||\n                years   <= 1             && ['y']           || ['yy', years];\n\n        a[2] = withoutSuffix;\n        a[3] = +posNegDuration > 0;\n        a[4] = locale;\n        return substituteTimeAgo.apply(null, a);\n    }\n\n    // This function allows you to set the rounding function for relative time strings\n    function getSetRelativeTimeRounding (roundingFunction) {\n        if (roundingFunction === undefined) {\n            return round;\n        }\n        if (typeof(roundingFunction) === 'function') {\n            round = roundingFunction;\n            return true;\n        }\n        return false;\n    }\n\n    // This function allows you to set a threshold for relative time strings\n    function getSetRelativeTimeThreshold (threshold, limit) {\n        if (thresholds[threshold] === undefined) {\n            return false;\n        }\n        if (limit === undefined) {\n            return thresholds[threshold];\n        }\n        thresholds[threshold] = limit;\n        if (threshold === 's') {\n            thresholds.ss = limit - 1;\n        }\n        return true;\n    }\n\n    function humanize (withSuffix) {\n        if (!this.isValid()) {\n            return this.localeData().invalidDate();\n        }\n\n        var locale = this.localeData();\n        var output = relativeTime$1(this, !withSuffix, locale);\n\n        if (withSuffix) {\n            output = locale.pastFuture(+this, output);\n        }\n\n        return locale.postformat(output);\n    }\n\n    var abs$1 = Math.abs;\n\n    function sign(x) {\n        return ((x > 0) - (x < 0)) || +x;\n    }\n\n    function toISOString$1() {\n        // for ISO strings we do not use the normal bubbling rules:\n        //  * milliseconds bubble up until they become hours\n        //  * days do not bubble at all\n        //  * months bubble up until they become years\n        // This is because there is no context-free conversion between hours and days\n        // (think of clock changes)\n        // and also not between days and months (28-31 days per month)\n        if (!this.isValid()) {\n            return this.localeData().invalidDate();\n        }\n\n        var seconds = abs$1(this._milliseconds) / 1000;\n        var days         = abs$1(this._days);\n        var months       = abs$1(this._months);\n        var minutes, hours, years;\n\n        // 3600 seconds -> 60 minutes -> 1 hour\n        minutes           = absFloor(seconds / 60);\n        hours             = absFloor(minutes / 60);\n        seconds %= 60;\n        minutes %= 60;\n\n        // 12 months -> 1 year\n        years  = absFloor(months / 12);\n        months %= 12;\n\n\n        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n        var Y = years;\n        var M = months;\n        var D = days;\n        var h = hours;\n        var m = minutes;\n        var s = seconds ? seconds.toFixed(3).replace(/\\.?0+$/, '') : '';\n        var total = this.asSeconds();\n\n        if (!total) {\n            // this is the same as C#'s (Noda) and python (isodate)...\n            // but not other JS (goog.date)\n            return 'P0D';\n        }\n\n        var totalSign = total < 0 ? '-' : '';\n        var ymSign = sign(this._months) !== sign(total) ? '-' : '';\n        var daysSign = sign(this._days) !== sign(total) ? '-' : '';\n        var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';\n\n        return totalSign + 'P' +\n            (Y ? ymSign + Y + 'Y' : '') +\n            (M ? ymSign + M + 'M' : '') +\n            (D ? daysSign + D + 'D' : '') +\n            ((h || m || s) ? 'T' : '') +\n            (h ? hmsSign + h + 'H' : '') +\n            (m ? hmsSign + m + 'M' : '') +\n            (s ? hmsSign + s + 'S' : '');\n    }\n\n    var proto$2 = Duration.prototype;\n\n    proto$2.isValid        = isValid$1;\n    proto$2.abs            = abs;\n    proto$2.add            = add$1;\n    proto$2.subtract       = subtract$1;\n    proto$2.as             = as;\n    proto$2.asMilliseconds = asMilliseconds;\n    proto$2.asSeconds      = asSeconds;\n    proto$2.asMinutes      = asMinutes;\n    proto$2.asHours        = asHours;\n    proto$2.asDays         = asDays;\n    proto$2.asWeeks        = asWeeks;\n    proto$2.asMonths       = asMonths;\n    proto$2.asQuarters     = asQuarters;\n    proto$2.asYears        = asYears;\n    proto$2.valueOf        = valueOf$1;\n    proto$2._bubble        = bubble;\n    proto$2.clone          = clone$1;\n    proto$2.get            = get$2;\n    proto$2.milliseconds   = milliseconds;\n    proto$2.seconds        = seconds;\n    proto$2.minutes        = minutes;\n    proto$2.hours          = hours;\n    proto$2.days           = days;\n    proto$2.weeks          = weeks;\n    proto$2.months         = months;\n    proto$2.years          = years;\n    proto$2.humanize       = humanize;\n    proto$2.toISOString    = toISOString$1;\n    proto$2.toString       = toISOString$1;\n    proto$2.toJSON         = toISOString$1;\n    proto$2.locale         = locale;\n    proto$2.localeData     = localeData;\n\n    proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\n    proto$2.lang = lang;\n\n    // Side effect imports\n\n    // FORMATTING\n\n    addFormatToken('X', 0, 0, 'unix');\n    addFormatToken('x', 0, 0, 'valueOf');\n\n    // PARSING\n\n    addRegexToken('x', matchSigned);\n    addRegexToken('X', matchTimestamp);\n    addParseToken('X', function (input, array, config) {\n        config._d = new Date(parseFloat(input, 10) * 1000);\n    });\n    addParseToken('x', function (input, array, config) {\n        config._d = new Date(toInt(input));\n    });\n\n    // Side effect imports\n\n\n    hooks.version = '2.24.0';\n\n    setHookCallback(createLocal);\n\n    hooks.fn                    = proto;\n    hooks.min                   = min;\n    hooks.max                   = max;\n    hooks.now                   = now;\n    hooks.utc                   = createUTC;\n    hooks.unix                  = createUnix;\n    hooks.months                = listMonths;\n    hooks.isDate                = isDate;\n    hooks.locale                = getSetGlobalLocale;\n    hooks.invalid               = createInvalid;\n    hooks.duration              = createDuration;\n    hooks.isMoment              = isMoment;\n    hooks.weekdays              = listWeekdays;\n    hooks.parseZone             = createInZone;\n    hooks.localeData            = getLocale;\n    hooks.isDuration            = isDuration;\n    hooks.monthsShort           = listMonthsShort;\n    hooks.weekdaysMin           = listWeekdaysMin;\n    hooks.defineLocale          = defineLocale;\n    hooks.updateLocale          = updateLocale;\n    hooks.locales               = listLocales;\n    hooks.weekdaysShort         = listWeekdaysShort;\n    hooks.normalizeUnits        = normalizeUnits;\n    hooks.relativeTimeRounding  = getSetRelativeTimeRounding;\n    hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\n    hooks.calendarFormat        = getCalendarFormat;\n    hooks.prototype             = proto;\n\n    // currently HTML5 input type only supports 24-hour formats\n    hooks.HTML5_FMT = {\n        DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm',             // <input type=\"datetime-local\" />\n        DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss',  // <input type=\"datetime-local\" step=\"1\" />\n        DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS',   // <input type=\"datetime-local\" step=\"0.001\" />\n        DATE: 'YYYY-MM-DD',                             // <input type=\"date\" />\n        TIME: 'HH:mm',                                  // <input type=\"time\" />\n        TIME_SECONDS: 'HH:mm:ss',                       // <input type=\"time\" step=\"1\" />\n        TIME_MS: 'HH:mm:ss.SSS',                        // <input type=\"time\" step=\"0.001\" />\n        WEEK: 'GGGG-[W]WW',                             // <input type=\"week\" />\n        MONTH: 'YYYY-MM'                                // <input type=\"month\" />\n    };\n\n    return hooks;\n\n})));\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","require('../../../modules/es.string.trim');\nvar entryVirtual = require('../../../internals/entry-virtual');\n\nmodule.exports = entryVirtual('String').trim;\n","module.exports = require(\"core-js-pure/stable/object/create\");"],"sourceRoot":""}