diff --git a/dist/vue-moment.cjs.js b/dist/vue-moment.cjs.js new file mode 100644 index 0000000..1078af5 --- /dev/null +++ b/dist/vue-moment.cjs.js @@ -0,0 +1,274 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; +} : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; +}; + +function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + }return arr2; + } else { + return Array.from(arr); + } +} + +module.exports = { + install: function install(Vue, options) { + var moment = options && options.moment ? options.moment : require('moment'); + + Object.defineProperties(Vue.prototype, { + $moment: { + get: function get() { + return moment; + } + } + }); + + Vue.moment = moment; + + Vue.filter('moment', function () { + var arguments$1 = arguments; + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments$1[_key]; + } + + args = Array.prototype.slice.call(args); + var input = args.shift(); + var date = void 0; + + if (Array.isArray(input) && typeof input[0] === 'string') { + // If input is array, assume we're being passed a format pattern to parse against. + // Format pattern will accept an array of potential formats to parse against. + // Date string should be at [0], format pattern(s) should be at [1] + date = moment(input[0], input[1], true); + } else if (typeof input === 'number') { + if (input.toString().length < 12) { + // If input is an integer with fewer than 12 digits, assume Unix seconds... + date = moment.unix(input); + } else { + // ..otherwise, assume milliseconds. + date = moment(input); + } + } else { + // Otherwise, throw the input at moment and see what happens... + date = moment(input); + } + + if (!input || !date.isValid()) { + // Log a warning if moment couldn't reconcile the input. Better than throwing an error? + console.warn('Could not build a valid `moment` object from input.'); + return input; + } + + function parse() { + var arguments$1 = arguments; + + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments$1[_key2]; + } + + args = Array.prototype.slice.call(args); + var method = args.shift(); + + switch (method) { + case 'add': + { + /* + * Mutates the original moment by adding time. + * http://momentjs.com/docs/#/manipulating/add/ + */ + + var addends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var obj = {}; + + for (var n = 0; n < addends.length; n++) { + var addend = addends[n].split(' '); + obj[addend[1]] = addend[0]; + } + date.add(obj); + break; + } + + case 'subtract': + { + /* + * Mutates the original moment by subtracting time. + * http://momentjs.com/docs/#/manipulating/subtract/ + */ + + var subtrahends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var _obj = {}; + + for (var _n = 0; _n < subtrahends.length; _n++) { + var subtrahend = subtrahends[_n].split(' '); + _obj[subtrahend[1]] = subtrahend[0]; + } + date.subtract(_obj); + break; + } + + case 'from': + { + /* + * Display a moment in relative time, either from now or from a specified date. + * http://momentjs.com/docs/#/displaying/fromnow/ + */ + + var from = 'now'; + var removeSuffix = false; + + if (args[0] === 'now') { args.shift(); } + // If valid, assume it is a date we want the output computed against. + if (moment(args[0]).isValid()) { from = moment(args.shift()); } + + if (args[0] === true) { + args.shift(); + removeSuffix = true; + } + + if (from !== 'now') { + date = date.from(from, removeSuffix); + } else { + date = date.fromNow(removeSuffix); + } + break; + } + + case 'diff': + { + /* + * Mutates the original moment by doing a difference with another date. + * http://momentjs.com/docs/#/displaying/difference/ + */ + + var referenceTime = moment(); + var units = ''; + var float = false; + + if (moment(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + referenceTime = moment(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (args[0]) { units = args.shift(); } + + if (args[0] === true) { float = args.shift(); } + + date = date.diff(referenceTime, units, float); + break; + } + + case 'calendar': + { + /* + * Formats a date with different strings depending on how close + * to a certain date (today by default) the date is. + * http://momentjs.com/docs/#/displaying/calendar-time/ + */ + + var _referenceTime = moment(); + var formats = {}; + + if (moment(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + _referenceTime = moment(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (_typeof(args[0]) === 'object') { formats = args.shift(); } + + date = date.calendar(_referenceTime, formats); + break; + } + + case 'utc': + { + /* + * Mutates the original moment by converting to UTC + * https://momentjs.com/docs/#/manipulating/utc/ + */ + date.utc(); + break; + } + + case 'timezone': + { + /* + * Mutates the original moment by converting to a new timezone. + * https://momentjs.com/timezone/docs/#/using-timezones/converting-to-zone/ + */ + date.tz(args.shift()); + break; + } + + default: + { + /* + * Formats a date by taking a string of tokens and replacing + * them with their corresponding values. + * http://momentjs.com/docs/#/displaying/format/ + */ + + var format = method; + date = date.format(format); + } + } + + if (args.length) { parse.apply(parse, args); } + } + + parse.apply(parse, args); + + return date; + }); + + Vue.filter('duration', function () { + var arguments$1 = arguments; + + for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments$1[_key3]; + } + + /* + * Basic pass-through filter for leveraging moment.js's ability + * to manipulate and display durations. + * https://momentjs.com/docs/#/durations/ + */ + args = Array.prototype.slice.call(args); + var input = args.shift(); + var method = args.shift(); + + function createDuration(time) { + if (!Array.isArray(time)) { time = [time]; } + var result = moment.duration.apply(moment, _toConsumableArray(time)); + if (!result.isValid()) { console.warn('Could not build a valid `duration` object from input.'); } + return result; + } + var duration = createDuration(input); + + if (method === 'add' || method === 'subtract') { + // Generates a duration object and either adds or subtracts it + // from our original duration. + var durationChange = createDuration(args); + duration[method](durationChange); + } else if (duration && duration[method]) { + var _duration; + + // This gives a full proxy to moment.duration functions. + duration = (_duration = duration)[method].apply(_duration, _toConsumableArray(args)); + } + + return duration; + }); + } +}; diff --git a/dist/vue-moment.es.js b/dist/vue-moment.es.js new file mode 100644 index 0000000..1133db4 --- /dev/null +++ b/dist/vue-moment.es.js @@ -0,0 +1,272 @@ +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; +} : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; +}; + +function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + }return arr2; + } else { + return Array.from(arr); + } +} + +module.exports = { + install: function install(Vue, options) { + var moment = options && options.moment ? options.moment : require('moment'); + + Object.defineProperties(Vue.prototype, { + $moment: { + get: function get() { + return moment; + } + } + }); + + Vue.moment = moment; + + Vue.filter('moment', function () { + var arguments$1 = arguments; + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments$1[_key]; + } + + args = Array.prototype.slice.call(args); + var input = args.shift(); + var date = void 0; + + if (Array.isArray(input) && typeof input[0] === 'string') { + // If input is array, assume we're being passed a format pattern to parse against. + // Format pattern will accept an array of potential formats to parse against. + // Date string should be at [0], format pattern(s) should be at [1] + date = moment(input[0], input[1], true); + } else if (typeof input === 'number') { + if (input.toString().length < 12) { + // If input is an integer with fewer than 12 digits, assume Unix seconds... + date = moment.unix(input); + } else { + // ..otherwise, assume milliseconds. + date = moment(input); + } + } else { + // Otherwise, throw the input at moment and see what happens... + date = moment(input); + } + + if (!input || !date.isValid()) { + // Log a warning if moment couldn't reconcile the input. Better than throwing an error? + console.warn('Could not build a valid `moment` object from input.'); + return input; + } + + function parse() { + var arguments$1 = arguments; + + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments$1[_key2]; + } + + args = Array.prototype.slice.call(args); + var method = args.shift(); + + switch (method) { + case 'add': + { + /* + * Mutates the original moment by adding time. + * http://momentjs.com/docs/#/manipulating/add/ + */ + + var addends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var obj = {}; + + for (var n = 0; n < addends.length; n++) { + var addend = addends[n].split(' '); + obj[addend[1]] = addend[0]; + } + date.add(obj); + break; + } + + case 'subtract': + { + /* + * Mutates the original moment by subtracting time. + * http://momentjs.com/docs/#/manipulating/subtract/ + */ + + var subtrahends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var _obj = {}; + + for (var _n = 0; _n < subtrahends.length; _n++) { + var subtrahend = subtrahends[_n].split(' '); + _obj[subtrahend[1]] = subtrahend[0]; + } + date.subtract(_obj); + break; + } + + case 'from': + { + /* + * Display a moment in relative time, either from now or from a specified date. + * http://momentjs.com/docs/#/displaying/fromnow/ + */ + + var from = 'now'; + var removeSuffix = false; + + if (args[0] === 'now') { args.shift(); } + // If valid, assume it is a date we want the output computed against. + if (moment(args[0]).isValid()) { from = moment(args.shift()); } + + if (args[0] === true) { + args.shift(); + removeSuffix = true; + } + + if (from !== 'now') { + date = date.from(from, removeSuffix); + } else { + date = date.fromNow(removeSuffix); + } + break; + } + + case 'diff': + { + /* + * Mutates the original moment by doing a difference with another date. + * http://momentjs.com/docs/#/displaying/difference/ + */ + + var referenceTime = moment(); + var units = ''; + var float = false; + + if (moment(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + referenceTime = moment(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (args[0]) { units = args.shift(); } + + if (args[0] === true) { float = args.shift(); } + + date = date.diff(referenceTime, units, float); + break; + } + + case 'calendar': + { + /* + * Formats a date with different strings depending on how close + * to a certain date (today by default) the date is. + * http://momentjs.com/docs/#/displaying/calendar-time/ + */ + + var _referenceTime = moment(); + var formats = {}; + + if (moment(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + _referenceTime = moment(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (_typeof(args[0]) === 'object') { formats = args.shift(); } + + date = date.calendar(_referenceTime, formats); + break; + } + + case 'utc': + { + /* + * Mutates the original moment by converting to UTC + * https://momentjs.com/docs/#/manipulating/utc/ + */ + date.utc(); + break; + } + + case 'timezone': + { + /* + * Mutates the original moment by converting to a new timezone. + * https://momentjs.com/timezone/docs/#/using-timezones/converting-to-zone/ + */ + date.tz(args.shift()); + break; + } + + default: + { + /* + * Formats a date by taking a string of tokens and replacing + * them with their corresponding values. + * http://momentjs.com/docs/#/displaying/format/ + */ + + var format = method; + date = date.format(format); + } + } + + if (args.length) { parse.apply(parse, args); } + } + + parse.apply(parse, args); + + return date; + }); + + Vue.filter('duration', function () { + var arguments$1 = arguments; + + for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments$1[_key3]; + } + + /* + * Basic pass-through filter for leveraging moment.js's ability + * to manipulate and display durations. + * https://momentjs.com/docs/#/durations/ + */ + args = Array.prototype.slice.call(args); + var input = args.shift(); + var method = args.shift(); + + function createDuration(time) { + if (!Array.isArray(time)) { time = [time]; } + var result = moment.duration.apply(moment, _toConsumableArray(time)); + if (!result.isValid()) { console.warn('Could not build a valid `duration` object from input.'); } + return result; + } + var duration = createDuration(input); + + if (method === 'add' || method === 'subtract') { + // Generates a duration object and either adds or subtracts it + // from our original duration. + var durationChange = createDuration(args); + duration[method](durationChange); + } else if (duration && duration[method]) { + var _duration; + + // This gives a full proxy to moment.duration functions. + duration = (_duration = duration)[method].apply(_duration, _toConsumableArray(args)); + } + + return duration; + }); + } +}; diff --git a/dist/vue-moment.js b/dist/vue-moment.js new file mode 100644 index 0000000..d6377dc --- /dev/null +++ b/dist/vue-moment.js @@ -0,0 +1,4704 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (factory((global.vueMoment = {}))); +}(this, (function (exports) { 'use strict'; + +var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function commonjsRequire () { + throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs'); +} + + + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var moment = createCommonjsModule(function (module, exports) { +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +//! moment.js +//! version : 2.19.1 +//! authors : Tim Wood, Iskren Chernev, Moment.js contributors +//! license : MIT +//! momentjs.com + +(function (global, factory) { + (_typeof(exports)) === 'object' && 'object' !== 'undefined' ? module.exports = factory() : typeof undefined === 'function' && undefined.amd ? undefined(factory) : global.moment = factory(); +})(commonjsGlobal, function () { + var hookCallback; + + function hooks() { + return hookCallback.apply(null, arguments); + } + + // This is done to register the method called with moment() + // without creating circular dependencies. + function setHookCallback(callback) { + hookCallback = callback; + } + + function isArray(input) { + return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'; + } + + function isObject(input) { + // IE8 will treat undefined and null as object if it wasn't for + // input != null + return input != null && Object.prototype.toString.call(input) === '[object Object]'; + } + + function isObjectEmpty(obj) { + if (Object.getOwnPropertyNames) { + return Object.getOwnPropertyNames(obj).length === 0; + } else { + var k; + for (k in obj) { + if (obj.hasOwnProperty(k)) { + return false; + } + } + return true; + } + } + + function isUndefined(input) { + return input === void 0; + } + + function isNumber(input) { + return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]'; + } + + function isDate(input) { + return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; + } + + function map(arr, fn) { + var res = [], + i; + for (i = 0; i < arr.length; ++i) { + res.push(fn(arr[i], i)); + } + return res; + } + + function hasOwnProp(a, b) { + return Object.prototype.hasOwnProperty.call(a, b); + } + + function extend(a, b) { + for (var i in b) { + if (hasOwnProp(b, i)) { + a[i] = b[i]; + } + } + + if (hasOwnProp(b, 'toString')) { + a.toString = b.toString; + } + + if (hasOwnProp(b, 'valueOf')) { + a.valueOf = b.valueOf; + } + + return a; + } + + function createUTC(input, format, locale, strict) { + return createLocalOrUTC(input, format, locale, strict, true).utc(); + } + + function defaultParsingFlags() { + // We need to deep clone this object. + return { + empty: false, + unusedTokens: [], + unusedInput: [], + overflow: -2, + charsLeftOver: 0, + nullInput: false, + invalidMonth: null, + invalidFormat: false, + userInvalidated: false, + iso: false, + parsedDateParts: [], + meridiem: null, + rfc2822: false, + weekdayMismatch: false + }; + } + + function getParsingFlags(m) { + if (m._pf == null) { + m._pf = defaultParsingFlags(); + } + return m._pf; + } + + var some; + if (Array.prototype.some) { + some = Array.prototype.some; + } else { + some = function some(fun) { + var t = Object(this); + var len = t.length >>> 0; + + for (var i = 0; i < len; i++) { + if (i in t && fun.call(this, t[i], i, t)) { + return true; + } + } + + return false; + }; + } + + function isValid(m) { + if (m._isValid == null) { + var flags = getParsingFlags(m); + var parsedParts = some.call(flags.parsedDateParts, function (i) { + return i != null; + }); + var isNowValid = !isNaN(m._d.getTime()) && flags.overflow < 0 && !flags.empty && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts); + + if (m._strict) { + isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === undefined; + } + + if (Object.isFrozen == null || !Object.isFrozen(m)) { + m._isValid = isNowValid; + } else { + return isNowValid; + } + } + return m._isValid; + } + + function createInvalid(flags) { + var m = createUTC(NaN); + if (flags != null) { + extend(getParsingFlags(m), flags); + } else { + getParsingFlags(m).userInvalidated = true; + } + + return m; + } + + // Plugins that add properties should also add the key here (null value), + // so we can properly clone ourselves. + var momentProperties = hooks.momentProperties = []; + + function copyConfig(to, from) { + var i, prop, val; + + if (!isUndefined(from._isAMomentObject)) { + to._isAMomentObject = from._isAMomentObject; + } + if (!isUndefined(from._i)) { + to._i = from._i; + } + if (!isUndefined(from._f)) { + to._f = from._f; + } + if (!isUndefined(from._l)) { + to._l = from._l; + } + if (!isUndefined(from._strict)) { + to._strict = from._strict; + } + if (!isUndefined(from._tzm)) { + to._tzm = from._tzm; + } + if (!isUndefined(from._isUTC)) { + to._isUTC = from._isUTC; + } + if (!isUndefined(from._offset)) { + to._offset = from._offset; + } + if (!isUndefined(from._pf)) { + to._pf = getParsingFlags(from); + } + if (!isUndefined(from._locale)) { + to._locale = from._locale; + } + + if (momentProperties.length > 0) { + for (i = 0; i < momentProperties.length; i++) { + prop = momentProperties[i]; + val = from[prop]; + if (!isUndefined(val)) { + to[prop] = val; + } + } + } + + return to; + } + + var updateInProgress = false; + + // Moment prototype object + function Moment(config) { + copyConfig(this, config); + this._d = new Date(config._d != null ? config._d.getTime() : NaN); + if (!this.isValid()) { + this._d = new Date(NaN); + } + // Prevent infinite loop in case updateOffset creates new moment + // objects. + if (updateInProgress === false) { + updateInProgress = true; + hooks.updateOffset(this); + updateInProgress = false; + } + } + + function isMoment(obj) { + return obj instanceof Moment || obj != null && obj._isAMomentObject != null; + } + + function absFloor(number) { + if (number < 0) { + // -0 -> 0 + return Math.ceil(number) || 0; + } else { + return Math.floor(number); + } + } + + function toInt(argumentForCoercion) { + var coercedNumber = +argumentForCoercion, + value = 0; + + if (coercedNumber !== 0 && isFinite(coercedNumber)) { + value = absFloor(coercedNumber); + } + + return value; + } + + // compare two arrays, return the number of differences + function compareArrays(array1, array2, dontConvert) { + var len = Math.min(array1.length, array2.length), + lengthDiff = Math.abs(array1.length - array2.length), + diffs = 0, + i; + for (i = 0; i < len; i++) { + if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) { + diffs++; + } + } + return diffs + lengthDiff; + } + + function warn(msg) { + if (hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) { + console.warn('Deprecation warning: ' + msg); + } + } + + function deprecate(msg, fn) { + var firstTime = true; + + return extend(function () { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(null, msg); + } + if (firstTime) { + var args = []; + var arg; + for (var i = 0; i < arguments.length; i++) { + arg = ''; + if (_typeof(arguments[i]) === 'object') { + arg += '\n[' + i + '] '; + for (var key in arguments[0]) { + arg += key + ': ' + arguments[0][key] + ', '; + } + arg = arg.slice(0, -2); // Remove trailing comma and space + } else { + arg = arguments[i]; + } + args.push(arg); + } + warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + new Error().stack); + firstTime = false; + } + return fn.apply(this, arguments); + }, fn); + } + + var deprecations = {}; + + function deprecateSimple(name, msg) { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(name, msg); + } + if (!deprecations[name]) { + warn(msg); + deprecations[name] = true; + } + } + + hooks.suppressDeprecationWarnings = false; + hooks.deprecationHandler = null; + + function isFunction(input) { + return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'; + } + + function set(config) { + var prop, i; + for (i in config) { + prop = config[i]; + if (isFunction(prop)) { + this[i] = prop; + } else { + this['_' + i] = prop; + } + } + this._config = config; + // Lenient ordinal parsing accepts just a number in addition to + // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. + // TODO: Remove "ordinalParse" fallback in next major release. + this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + '|' + /\d{1,2}/.source); + } + + function mergeConfigs(parentConfig, childConfig) { + var res = extend({}, parentConfig), + prop; + for (prop in childConfig) { + if (hasOwnProp(childConfig, prop)) { + if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { + res[prop] = {}; + extend(res[prop], parentConfig[prop]); + extend(res[prop], childConfig[prop]); + } else if (childConfig[prop] != null) { + res[prop] = childConfig[prop]; + } else { + delete res[prop]; + } + } + } + for (prop in parentConfig) { + if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) { + // make sure changes to properties don't modify parent config + res[prop] = extend({}, res[prop]); + } + } + return res; + } + + function Locale(config) { + if (config != null) { + this.set(config); + } + } + + var keys; + + if (Object.keys) { + keys = Object.keys; + } else { + keys = function keys(obj) { + var i, + res = []; + for (i in obj) { + if (hasOwnProp(obj, i)) { + res.push(i); + } + } + return res; + }; + } + + var defaultCalendar = { + sameDay: '[Today at] LT', + nextDay: '[Tomorrow at] LT', + nextWeek: 'dddd [at] LT', + lastDay: '[Yesterday at] LT', + lastWeek: '[Last] dddd [at] LT', + sameElse: 'L' + }; + + function calendar(key, mom, now) { + var output = this._calendar[key] || this._calendar['sameElse']; + return isFunction(output) ? output.call(mom, now) : output; + } + + var defaultLongDateFormat = { + LTS: 'h:mm:ss A', + LT: 'h:mm A', + L: 'MM/DD/YYYY', + LL: 'MMMM D, YYYY', + LLL: 'MMMM D, YYYY h:mm A', + LLLL: 'dddd, MMMM D, YYYY h:mm A' + }; + + function longDateFormat(key) { + var format = this._longDateFormat[key], + formatUpper = this._longDateFormat[key.toUpperCase()]; + + if (format || !formatUpper) { + return format; + } + + this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) { + return val.slice(1); + }); + + return this._longDateFormat[key]; + } + + var defaultInvalidDate = 'Invalid date'; + + function invalidDate() { + return this._invalidDate; + } + + var defaultOrdinal = '%d'; + var defaultDayOfMonthOrdinalParse = /\d{1,2}/; + + function ordinal(number) { + return this._ordinal.replace('%d', number); + } + + var defaultRelativeTime = { + future: 'in %s', + past: '%s ago', + s: 'a few seconds', + ss: '%d seconds', + m: 'a minute', + mm: '%d minutes', + h: 'an hour', + hh: '%d hours', + d: 'a day', + dd: '%d days', + M: 'a month', + MM: '%d months', + y: 'a year', + yy: '%d years' + }; + + function relativeTime(number, withoutSuffix, string, isFuture) { + var output = this._relativeTime[string]; + return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number); + } + + function pastFuture(diff, output) { + var format = this._relativeTime[diff > 0 ? 'future' : 'past']; + return isFunction(format) ? format(output) : format.replace(/%s/i, output); + } + + var aliases = {}; + + function addUnitAlias(unit, shorthand) { + var lowerCase = unit.toLowerCase(); + aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; + } + + function normalizeUnits(units) { + return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined; + } + + function normalizeObjectUnits(inputObject) { + var normalizedInput = {}, + normalizedProp, + prop; + + for (prop in inputObject) { + if (hasOwnProp(inputObject, prop)) { + normalizedProp = normalizeUnits(prop); + if (normalizedProp) { + normalizedInput[normalizedProp] = inputObject[prop]; + } + } + } + + return normalizedInput; + } + + var priorities = {}; + + function addUnitPriority(unit, priority) { + priorities[unit] = priority; + } + + function getPrioritizedUnits(unitsObj) { + var units = []; + for (var u in unitsObj) { + units.push({ unit: u, priority: priorities[u] }); + } + units.sort(function (a, b) { + return a.priority - b.priority; + }); + return units; + } + + function zeroFill(number, targetLength, forceSign) { + var absNumber = '' + Math.abs(number), + zerosToFill = targetLength - absNumber.length, + sign = number >= 0; + return (sign ? forceSign ? '+' : '' : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; + } + + 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; + + var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g; + + var formatFunctions = {}; + + var formatTokenFunctions = {}; + + // token: 'M' + // padded: ['MM', 2] + // ordinal: 'Mo' + // callback: function () { this.month() + 1 } + function addFormatToken(token, padded, ordinal, callback) { + var func = callback; + if (typeof callback === 'string') { + func = function func() { + return this[callback](); + }; + } + if (token) { + formatTokenFunctions[token] = func; + } + if (padded) { + formatTokenFunctions[padded[0]] = function () { + return zeroFill(func.apply(this, arguments), padded[1], padded[2]); + }; + } + if (ordinal) { + formatTokenFunctions[ordinal] = function () { + return this.localeData().ordinal(func.apply(this, arguments), token); + }; + } + } + + function removeFormattingTokens(input) { + if (input.match(/\[[\s\S]/)) { + return input.replace(/^\[|\]$/g, ''); + } + return input.replace(/\\/g, ''); + } + + function makeFormatFunction(format) { + var array = format.match(formattingTokens), + i, + length; + + for (i = 0, length = array.length; i < length; i++) { + if (formatTokenFunctions[array[i]]) { + array[i] = formatTokenFunctions[array[i]]; + } else { + array[i] = removeFormattingTokens(array[i]); + } + } + + return function (mom) { + var output = '', + i; + for (i = 0; i < length; i++) { + output += isFunction(array[i]) ? array[i].call(mom, format) : array[i]; + } + return output; + }; + } + + // format date using native date object + function formatMoment(m, format) { + if (!m.isValid()) { + return m.localeData().invalidDate(); + } + + format = expandFormat(format, m.localeData()); + formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format); + + return formatFunctions[format](m); + } + + function expandFormat(format, locale) { + var i = 5; + + function replaceLongDateFormatTokens(input) { + return locale.longDateFormat(input) || input; + } + + localFormattingTokens.lastIndex = 0; + while (i >= 0 && localFormattingTokens.test(format)) { + format = format.replace(localFormattingTokens, replaceLongDateFormatTokens); + localFormattingTokens.lastIndex = 0; + i -= 1; + } + + return format; + } + + var match1 = /\d/; // 0 - 9 + var match2 = /\d\d/; // 00 - 99 + var match3 = /\d{3}/; // 000 - 999 + var match4 = /\d{4}/; // 0000 - 9999 + var match6 = /[+-]?\d{6}/; // -999999 - 999999 + var match1to2 = /\d\d?/; // 0 - 99 + var match3to4 = /\d\d\d\d?/; // 999 - 9999 + var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999 + var match1to3 = /\d{1,3}/; // 0 - 999 + var match1to4 = /\d{1,4}/; // 0 - 9999 + var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999 + + var matchUnsigned = /\d+/; // 0 - inf + var matchSigned = /[+-]?\d+/; // -inf - inf + + var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z + var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z + + var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123 + + // any word (or two) characters or numbers including two/three word month in arabic. + // includes scottish gaelic two word and hyphenated months + var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i; + + var regexes = {}; + + function addRegexToken(token, regex, strictRegex) { + regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) { + return isStrict && strictRegex ? strictRegex : regex; + }; + } + + function getParseRegexForToken(token, config) { + if (!hasOwnProp(regexes, token)) { + return new RegExp(unescapeFormat(token)); + } + + return regexes[token](config._strict, config._locale); + } + + // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript + function unescapeFormat(s) { + return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { + return p1 || p2 || p3 || p4; + })); + } + + function regexEscape(s) { + return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); + } + + var tokens = {}; + + function addParseToken(token, callback) { + var i, + func = callback; + if (typeof token === 'string') { + token = [token]; + } + if (isNumber(callback)) { + func = function func(input, array) { + array[callback] = toInt(input); + }; + } + for (i = 0; i < token.length; i++) { + tokens[token[i]] = func; + } + } + + function addWeekParseToken(token, callback) { + addParseToken(token, function (input, array, config, token) { + config._w = config._w || {}; + callback(input, config._w, config, token); + }); + } + + function addTimeToArrayFromToken(token, input, config) { + if (input != null && hasOwnProp(tokens, token)) { + tokens[token](input, config._a, config, token); + } + } + + var YEAR = 0; + var MONTH = 1; + var DATE = 2; + var HOUR = 3; + var MINUTE = 4; + var SECOND = 5; + var MILLISECOND = 6; + var WEEK = 7; + var WEEKDAY = 8; + + // FORMATTING + + addFormatToken('Y', 0, 0, function () { + var y = this.year(); + return y <= 9999 ? '' + y : '+' + y; + }); + + addFormatToken(0, ['YY', 2], 0, function () { + return this.year() % 100; + }); + + addFormatToken(0, ['YYYY', 4], 0, 'year'); + addFormatToken(0, ['YYYYY', 5], 0, 'year'); + addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); + + // ALIASES + + addUnitAlias('year', 'y'); + + // PRIORITIES + + addUnitPriority('year', 1); + + // PARSING + + addRegexToken('Y', matchSigned); + addRegexToken('YY', match1to2, match2); + addRegexToken('YYYY', match1to4, match4); + addRegexToken('YYYYY', match1to6, match6); + addRegexToken('YYYYYY', match1to6, match6); + + addParseToken(['YYYYY', 'YYYYYY'], YEAR); + addParseToken('YYYY', function (input, array) { + array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); + }); + addParseToken('YY', function (input, array) { + array[YEAR] = hooks.parseTwoDigitYear(input); + }); + addParseToken('Y', function (input, array) { + array[YEAR] = parseInt(input, 10); + }); + + // HELPERS + + function daysInYear(year) { + return isLeapYear(year) ? 366 : 365; + } + + function isLeapYear(year) { + return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0; + } + + // HOOKS + + hooks.parseTwoDigitYear = function (input) { + return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); + }; + + // MOMENTS + + var getSetYear = makeGetSet('FullYear', true); + + function getIsLeapYear() { + return isLeapYear(this.year()); + } + + function makeGetSet(unit, keepTime) { + return function (value) { + if (value != null) { + set$1(this, unit, value); + hooks.updateOffset(this, keepTime); + return this; + } else { + return get(this, unit); + } + }; + } + + function get(mom, unit) { + return mom.isValid() ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN; + } + + function set$1(mom, unit, value) { + if (mom.isValid() && !isNaN(value)) { + if (unit === 'FullYear' && isLeapYear(mom.year())) { + mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month())); + } else { + mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); + } + } + } + + // MOMENTS + + function stringGet(units) { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](); + } + return this; + } + + function stringSet(units, value) { + if ((typeof units === 'undefined' ? 'undefined' : _typeof(units)) === 'object') { + units = normalizeObjectUnits(units); + var prioritized = getPrioritizedUnits(units); + for (var i = 0; i < prioritized.length; i++) { + this[prioritized[i].unit](units[prioritized[i].unit]); + } + } else { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](value); + } + } + return this; + } + + function mod(n, x) { + return (n % x + x) % x; + } + + var indexOf; + + if (Array.prototype.indexOf) { + indexOf = Array.prototype.indexOf; + } else { + indexOf = function indexOf(o) { + // I know + var i; + for (i = 0; i < this.length; ++i) { + if (this[i] === o) { + return i; + } + } + return -1; + }; + } + + function daysInMonth(year, month) { + if (isNaN(year) || isNaN(month)) { + return NaN; + } + var modMonth = mod(month, 12); + year += (month - modMonth) / 12; + return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2; + } + + // FORMATTING + + addFormatToken('M', ['MM', 2], 'Mo', function () { + return this.month() + 1; + }); + + addFormatToken('MMM', 0, 0, function (format) { + return this.localeData().monthsShort(this, format); + }); + + addFormatToken('MMMM', 0, 0, function (format) { + return this.localeData().months(this, format); + }); + + // ALIASES + + addUnitAlias('month', 'M'); + + // PRIORITY + + addUnitPriority('month', 8); + + // PARSING + + addRegexToken('M', match1to2); + addRegexToken('MM', match1to2, match2); + addRegexToken('MMM', function (isStrict, locale) { + return locale.monthsShortRegex(isStrict); + }); + addRegexToken('MMMM', function (isStrict, locale) { + return locale.monthsRegex(isStrict); + }); + + addParseToken(['M', 'MM'], function (input, array) { + array[MONTH] = toInt(input) - 1; + }); + + addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { + var month = config._locale.monthsParse(input, token, config._strict); + // if we didn't find a month name, mark the date as invalid. + if (month != null) { + array[MONTH] = month; + } else { + getParsingFlags(config).invalidMonth = input; + } + }); + + // LOCALES + + var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/; + var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); + function localeMonths(m, format) { + if (!m) { + return isArray(this._months) ? this._months : this._months['standalone']; + } + return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()]; + } + + var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); + function localeMonthsShort(m, format) { + if (!m) { + return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort['standalone']; + } + return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]; + } + + function handleStrictParse(monthName, format, strict) { + var i, + ii, + mom, + llc = monthName.toLocaleLowerCase(); + if (!this._monthsParse) { + // this is not used + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + for (i = 0; i < 12; ++i) { + mom = createUTC([2000, i]); + this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase(); + this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); + } + } + + if (strict) { + if (format === 'MMM') { + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format === 'MMM') { + ii = indexOf.call(this._shortMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } + } + + function localeMonthsParse(monthName, format, strict) { + var i, mom, regex; + + if (this._monthsParseExact) { + return handleStrictParse.call(this, monthName, format, strict); + } + + if (!this._monthsParse) { + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + } + + // TODO: add sorting + // Sorting makes sure if one month (or abbr) is a prefix of another + // see sorting in computeMonthsParse + for (i = 0; i < 12; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, i]); + if (strict && !this._longMonthsParse[i]) { + this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i'); + this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i'); + } + if (!strict && !this._monthsParse[i]) { + regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); + this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); + } + // test the regex + if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) { + return i; + } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) { + return i; + } else if (!strict && this._monthsParse[i].test(monthName)) { + return i; + } + } + } + + // MOMENTS + + function setMonth(mom, value) { + var dayOfMonth; + + if (!mom.isValid()) { + // No op + return mom; + } + + if (typeof value === 'string') { + if (/^\d+$/.test(value)) { + value = toInt(value); + } else { + value = mom.localeData().monthsParse(value); + // TODO: Another silent failure? + if (!isNumber(value)) { + return mom; + } + } + } + + dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); + mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); + return mom; + } + + function getSetMonth(value) { + if (value != null) { + setMonth(this, value); + hooks.updateOffset(this, true); + return this; + } else { + return get(this, 'Month'); + } + } + + function getDaysInMonth() { + return daysInMonth(this.year(), this.month()); + } + + var defaultMonthsShortRegex = matchWord; + function monthsShortRegex(isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, '_monthsRegex')) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsShortStrictRegex; + } else { + return this._monthsShortRegex; + } + } else { + if (!hasOwnProp(this, '_monthsShortRegex')) { + this._monthsShortRegex = defaultMonthsShortRegex; + } + return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex; + } + } + + var defaultMonthsRegex = matchWord; + function monthsRegex(isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, '_monthsRegex')) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsStrictRegex; + } else { + return this._monthsRegex; + } + } else { + if (!hasOwnProp(this, '_monthsRegex')) { + this._monthsRegex = defaultMonthsRegex; + } + return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex; + } + } + + function computeMonthsParse() { + function cmpLenRev(a, b) { + return b.length - a.length; + } + + var shortPieces = [], + longPieces = [], + mixedPieces = [], + i, + mom; + for (i = 0; i < 12; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, i]); + shortPieces.push(this.monthsShort(mom, '')); + longPieces.push(this.months(mom, '')); + mixedPieces.push(this.months(mom, '')); + mixedPieces.push(this.monthsShort(mom, '')); + } + // Sorting makes sure if one month (or abbr) is a prefix of another it + // will match the longer piece. + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + for (i = 0; i < 12; i++) { + shortPieces[i] = regexEscape(shortPieces[i]); + longPieces[i] = regexEscape(longPieces[i]); + } + for (i = 0; i < 24; i++) { + mixedPieces[i] = regexEscape(mixedPieces[i]); + } + + this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); + this._monthsShortRegex = this._monthsRegex; + this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); + this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); + } + + function createDate(y, m, d, h, M, s, ms) { + // can't just apply() to create a date: + // https://stackoverflow.com/q/181348 + var date = new Date(y, m, d, h, M, s, ms); + + // the date constructor remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0 && isFinite(date.getFullYear())) { + date.setFullYear(y); + } + return date; + } + + function createUTCDate(y) { + var date = new Date(Date.UTC.apply(null, arguments)); + + // the Date.UTC function remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) { + date.setUTCFullYear(y); + } + return date; + } + + // start-of-first-week - start-of-year + function firstWeekOffset(year, dow, doy) { + var // first-week day -- which january is always in the first week (4 for iso, 1 for other) + fwd = 7 + dow - doy, + + // first-week day local weekday -- which local weekday is fwd + fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; + + return -fwdlw + fwd - 1; + } + + // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday + function dayOfYearFromWeeks(year, week, weekday, dow, doy) { + var localWeekday = (7 + weekday - dow) % 7, + weekOffset = firstWeekOffset(year, dow, doy), + dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, + resYear, + resDayOfYear; + + if (dayOfYear <= 0) { + resYear = year - 1; + resDayOfYear = daysInYear(resYear) + dayOfYear; + } else if (dayOfYear > daysInYear(year)) { + resYear = year + 1; + resDayOfYear = dayOfYear - daysInYear(year); + } else { + resYear = year; + resDayOfYear = dayOfYear; + } + + return { + year: resYear, + dayOfYear: resDayOfYear + }; + } + + function weekOfYear(mom, dow, doy) { + var weekOffset = firstWeekOffset(mom.year(), dow, doy), + week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, + resWeek, + resYear; + + if (week < 1) { + resYear = mom.year() - 1; + resWeek = week + weeksInYear(resYear, dow, doy); + } else if (week > weeksInYear(mom.year(), dow, doy)) { + resWeek = week - weeksInYear(mom.year(), dow, doy); + resYear = mom.year() + 1; + } else { + resYear = mom.year(); + resWeek = week; + } + + return { + week: resWeek, + year: resYear + }; + } + + function weeksInYear(year, dow, doy) { + var weekOffset = firstWeekOffset(year, dow, doy), + weekOffsetNext = firstWeekOffset(year + 1, dow, doy); + return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; + } + + // FORMATTING + + addFormatToken('w', ['ww', 2], 'wo', 'week'); + addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); + + // ALIASES + + addUnitAlias('week', 'w'); + addUnitAlias('isoWeek', 'W'); + + // PRIORITIES + + addUnitPriority('week', 5); + addUnitPriority('isoWeek', 5); + + // PARSING + + addRegexToken('w', match1to2); + addRegexToken('ww', match1to2, match2); + addRegexToken('W', match1to2); + addRegexToken('WW', match1to2, match2); + + addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) { + week[token.substr(0, 1)] = toInt(input); + }); + + // HELPERS + + // LOCALES + + function localeWeek(mom) { + return weekOfYear(mom, this._week.dow, this._week.doy).week; + } + + var defaultLocaleWeek = { + dow: 0, // Sunday is the first day of the week. + doy: 6 // The week that contains Jan 1st is the first week of the year. + }; + + function localeFirstDayOfWeek() { + return this._week.dow; + } + + function localeFirstDayOfYear() { + return this._week.doy; + } + + // MOMENTS + + function getSetWeek(input) { + var week = this.localeData().week(this); + return input == null ? week : this.add((input - week) * 7, 'd'); + } + + function getSetISOWeek(input) { + var week = weekOfYear(this, 1, 4).week; + return input == null ? week : this.add((input - week) * 7, 'd'); + } + + // FORMATTING + + addFormatToken('d', 0, 'do', 'day'); + + addFormatToken('dd', 0, 0, function (format) { + return this.localeData().weekdaysMin(this, format); + }); + + addFormatToken('ddd', 0, 0, function (format) { + return this.localeData().weekdaysShort(this, format); + }); + + addFormatToken('dddd', 0, 0, function (format) { + return this.localeData().weekdays(this, format); + }); + + addFormatToken('e', 0, 0, 'weekday'); + addFormatToken('E', 0, 0, 'isoWeekday'); + + // ALIASES + + addUnitAlias('day', 'd'); + addUnitAlias('weekday', 'e'); + addUnitAlias('isoWeekday', 'E'); + + // PRIORITY + addUnitPriority('day', 11); + addUnitPriority('weekday', 11); + addUnitPriority('isoWeekday', 11); + + // PARSING + + addRegexToken('d', match1to2); + addRegexToken('e', match1to2); + addRegexToken('E', match1to2); + addRegexToken('dd', function (isStrict, locale) { + return locale.weekdaysMinRegex(isStrict); + }); + addRegexToken('ddd', function (isStrict, locale) { + return locale.weekdaysShortRegex(isStrict); + }); + addRegexToken('dddd', function (isStrict, locale) { + return locale.weekdaysRegex(isStrict); + }); + + addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { + var weekday = config._locale.weekdaysParse(input, token, config._strict); + // if we didn't get a weekday name, mark the date as invalid + if (weekday != null) { + week.d = weekday; + } else { + getParsingFlags(config).invalidWeekday = input; + } + }); + + addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { + week[token] = toInt(input); + }); + + // HELPERS + + function parseWeekday(input, locale) { + if (typeof input !== 'string') { + return input; + } + + if (!isNaN(input)) { + return parseInt(input, 10); + } + + input = locale.weekdaysParse(input); + if (typeof input === 'number') { + return input; + } + + return null; + } + + function parseIsoWeekday(input, locale) { + if (typeof input === 'string') { + return locale.weekdaysParse(input) % 7 || 7; + } + return isNaN(input) ? null : input; + } + + // LOCALES + + var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); + function localeWeekdays(m, format) { + if (!m) { + return isArray(this._weekdays) ? this._weekdays : this._weekdays['standalone']; + } + return isArray(this._weekdays) ? this._weekdays[m.day()] : this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()]; + } + + var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); + function localeWeekdaysShort(m) { + return m ? this._weekdaysShort[m.day()] : this._weekdaysShort; + } + + var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); + function localeWeekdaysMin(m) { + return m ? this._weekdaysMin[m.day()] : this._weekdaysMin; + } + + function handleStrictParse$1(weekdayName, format, strict) { + var i, + ii, + mom, + llc = weekdayName.toLocaleLowerCase(); + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._shortWeekdaysParse = []; + this._minWeekdaysParse = []; + + for (i = 0; i < 7; ++i) { + mom = createUTC([2000, 1]).day(i); + this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase(); + this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase(); + this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); + } + } + + if (strict) { + if (format === 'dddd') { + ii = indexOf.call(this._weekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format === 'ddd') { + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format === 'dddd') { + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format === 'ddd') { + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } + } + + function localeWeekdaysParse(weekdayName, format, strict) { + var i, mom, regex; + + if (this._weekdaysParseExact) { + return handleStrictParse$1.call(this, weekdayName, format, strict); + } + + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._minWeekdaysParse = []; + this._shortWeekdaysParse = []; + this._fullWeekdaysParse = []; + } + + for (i = 0; i < 7; i++) { + // make the regex if we don't have it already + + mom = createUTC([2000, 1]).day(i); + if (strict && !this._fullWeekdaysParse[i]) { + this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i'); + this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i'); + this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i'); + } + if (!this._weekdaysParse[i]) { + regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, ''); + this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); + } + // test the regex + if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { + return i; + } + } + } + + // MOMENTS + + function getSetDayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); + if (input != null) { + input = parseWeekday(input, this.localeData()); + return this.add(input - day, 'd'); + } else { + return day; + } + } + + function getSetLocaleDayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; + return input == null ? weekday : this.add(input - weekday, 'd'); + } + + function getSetISODayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + + // behaves the same as moment#day except + // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) + // as a setter, sunday should belong to the previous week. + + if (input != null) { + var weekday = parseIsoWeekday(input, this.localeData()); + return this.day(this.day() % 7 ? weekday : weekday - 7); + } else { + return this.day() || 7; + } + } + + var defaultWeekdaysRegex = matchWord; + function weekdaysRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysStrictRegex; + } else { + return this._weekdaysRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysRegex')) { + this._weekdaysRegex = defaultWeekdaysRegex; + } + return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex; + } + } + + var defaultWeekdaysShortRegex = matchWord; + function weekdaysShortRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysShortStrictRegex; + } else { + return this._weekdaysShortRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysShortRegex')) { + this._weekdaysShortRegex = defaultWeekdaysShortRegex; + } + return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex; + } + } + + var defaultWeekdaysMinRegex = matchWord; + function weekdaysMinRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysMinStrictRegex; + } else { + return this._weekdaysMinRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysMinRegex')) { + this._weekdaysMinRegex = defaultWeekdaysMinRegex; + } + return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex; + } + } + + function computeWeekdaysParse() { + function cmpLenRev(a, b) { + return b.length - a.length; + } + + var minPieces = [], + shortPieces = [], + longPieces = [], + mixedPieces = [], + i, + mom, + minp, + shortp, + longp; + for (i = 0; i < 7; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, 1]).day(i); + minp = this.weekdaysMin(mom, ''); + shortp = this.weekdaysShort(mom, ''); + longp = this.weekdays(mom, ''); + minPieces.push(minp); + shortPieces.push(shortp); + longPieces.push(longp); + mixedPieces.push(minp); + mixedPieces.push(shortp); + mixedPieces.push(longp); + } + // Sorting makes sure if one weekday (or abbr) is a prefix of another it + // will match the longer piece. + minPieces.sort(cmpLenRev); + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + for (i = 0; i < 7; i++) { + shortPieces[i] = regexEscape(shortPieces[i]); + longPieces[i] = regexEscape(longPieces[i]); + mixedPieces[i] = regexEscape(mixedPieces[i]); + } + + this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); + this._weekdaysShortRegex = this._weekdaysRegex; + this._weekdaysMinRegex = this._weekdaysRegex; + + this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); + this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); + this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i'); + } + + // FORMATTING + + function hFormat() { + return this.hours() % 12 || 12; + } + + function kFormat() { + return this.hours() || 24; + } + + addFormatToken('H', ['HH', 2], 0, 'hour'); + addFormatToken('h', ['hh', 2], 0, hFormat); + addFormatToken('k', ['kk', 2], 0, kFormat); + + addFormatToken('hmm', 0, 0, function () { + return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); + }); + + addFormatToken('hmmss', 0, 0, function () { + return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2); + }); + + addFormatToken('Hmm', 0, 0, function () { + return '' + this.hours() + zeroFill(this.minutes(), 2); + }); + + addFormatToken('Hmmss', 0, 0, function () { + return '' + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2); + }); + + function meridiem(token, lowercase) { + addFormatToken(token, 0, 0, function () { + return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); + }); + } + + meridiem('a', true); + meridiem('A', false); + + // ALIASES + + addUnitAlias('hour', 'h'); + + // PRIORITY + addUnitPriority('hour', 13); + + // PARSING + + function matchMeridiem(isStrict, locale) { + return locale._meridiemParse; + } + + addRegexToken('a', matchMeridiem); + addRegexToken('A', matchMeridiem); + addRegexToken('H', match1to2); + addRegexToken('h', match1to2); + addRegexToken('k', match1to2); + addRegexToken('HH', match1to2, match2); + addRegexToken('hh', match1to2, match2); + addRegexToken('kk', match1to2, match2); + + addRegexToken('hmm', match3to4); + addRegexToken('hmmss', match5to6); + addRegexToken('Hmm', match3to4); + addRegexToken('Hmmss', match5to6); + + addParseToken(['H', 'HH'], HOUR); + addParseToken(['k', 'kk'], function (input, array, config) { + var kInput = toInt(input); + array[HOUR] = kInput === 24 ? 0 : kInput; + }); + addParseToken(['a', 'A'], function (input, array, config) { + config._isPm = config._locale.isPM(input); + config._meridiem = input; + }); + addParseToken(['h', 'hh'], function (input, array, config) { + array[HOUR] = toInt(input); + getParsingFlags(config).bigHour = true; + }); + addParseToken('hmm', function (input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); + getParsingFlags(config).bigHour = true; + }); + addParseToken('hmmss', function (input, array, config) { + var pos1 = input.length - 4; + var pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); + getParsingFlags(config).bigHour = true; + }); + addParseToken('Hmm', function (input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); + }); + addParseToken('Hmmss', function (input, array, config) { + var pos1 = input.length - 4; + var pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); + }); + + // LOCALES + + function localeIsPM(input) { + // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays + // Using charAt should be more compatible. + return (input + '').toLowerCase().charAt(0) === 'p'; + } + + var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i; + function localeMeridiem(hours, minutes, isLower) { + if (hours > 11) { + return isLower ? 'pm' : 'PM'; + } else { + return isLower ? 'am' : 'AM'; + } + } + + // MOMENTS + + // Setting the hour should keep the time, because the user explicitly + // specified which hour he wants. So trying to maintain the same hour (in + // a new timezone) makes sense. Adding/subtracting hours does not follow + // this rule. + var getSetHour = makeGetSet('Hours', true); + + // months + // week + // weekdays + // meridiem + var baseConfig = { + calendar: defaultCalendar, + longDateFormat: defaultLongDateFormat, + invalidDate: defaultInvalidDate, + ordinal: defaultOrdinal, + dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, + relativeTime: defaultRelativeTime, + + months: defaultLocaleMonths, + monthsShort: defaultLocaleMonthsShort, + + week: defaultLocaleWeek, + + weekdays: defaultLocaleWeekdays, + weekdaysMin: defaultLocaleWeekdaysMin, + weekdaysShort: defaultLocaleWeekdaysShort, + + meridiemParse: defaultLocaleMeridiemParse + }; + + // internal storage for locale config files + var locales = {}; + var localeFamilies = {}; + var globalLocale; + + function normalizeLocale(key) { + return key ? key.toLowerCase().replace('_', '-') : key; + } + + // pick the locale from the array + // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each + // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root + function chooseLocale(names) { + var i = 0, + j, + next, + locale, + split; + + while (i < names.length) { + split = normalizeLocale(names[i]).split('-'); + j = split.length; + next = normalizeLocale(names[i + 1]); + next = next ? next.split('-') : null; + while (j > 0) { + locale = loadLocale(split.slice(0, j).join('-')); + if (locale) { + return locale; + } + if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) { + //the next array item is better than a shallower substring of this one + break; + } + j--; + } + i++; + } + return null; + } + + function loadLocale(name) { + var oldLocale = null; + // TODO: Find a better way to register and load all the locales in Node + if (!locales[name] && 'object' !== 'undefined' && module && module.exports) { + try { + oldLocale = globalLocale._abbr; + var aliasedRequire = commonjsRequire; + aliasedRequire('./locale/' + name); + getSetGlobalLocale(oldLocale); + } catch (e) {} + } + return locales[name]; + } + + // This function will load locale and then set the global locale. If + // no arguments are passed in, it will simply return the current global + // locale key. + function getSetGlobalLocale(key, values) { + var data; + if (key) { + if (isUndefined(values)) { + data = getLocale(key); + } else { + data = defineLocale(key, values); + } + + if (data) { + // moment.duration._locale = moment._locale = data; + globalLocale = data; + } + } + + return globalLocale._abbr; + } + + function defineLocale(name, config) { + if (config !== null) { + var parentConfig = baseConfig; + config.abbr = name; + if (locales[name] != null) { + deprecateSimple('defineLocaleOverride', 'use moment.updateLocale(localeName, config) to change ' + 'an existing locale. moment.defineLocale(localeName, ' + 'config) should only be used for creating a new locale ' + 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'); + parentConfig = locales[name]._config; + } else if (config.parentLocale != null) { + if (locales[config.parentLocale] != null) { + parentConfig = locales[config.parentLocale]._config; + } else { + if (!localeFamilies[config.parentLocale]) { + localeFamilies[config.parentLocale] = []; + } + localeFamilies[config.parentLocale].push({ + name: name, + config: config + }); + return null; + } + } + locales[name] = new Locale(mergeConfigs(parentConfig, config)); + + if (localeFamilies[name]) { + localeFamilies[name].forEach(function (x) { + defineLocale(x.name, x.config); + }); + } + + // backwards compat for now: also set the locale + // make sure we set the locale AFTER all child locales have been + // created, so we won't end up with the child locale set. + getSetGlobalLocale(name); + + return locales[name]; + } else { + // useful for testing + delete locales[name]; + return null; + } + } + + function updateLocale(name, config) { + if (config != null) { + var locale, + parentConfig = baseConfig; + // MERGE + if (locales[name] != null) { + parentConfig = locales[name]._config; + } + config = mergeConfigs(parentConfig, config); + locale = new Locale(config); + locale.parentLocale = locales[name]; + locales[name] = locale; + + // backwards compat for now: also set the locale + getSetGlobalLocale(name); + } else { + // pass null for config to unupdate, useful for tests + if (locales[name] != null) { + if (locales[name].parentLocale != null) { + locales[name] = locales[name].parentLocale; + } else if (locales[name] != null) { + delete locales[name]; + } + } + } + return locales[name]; + } + + // returns locale data + function getLocale(key) { + var locale; + + if (key && key._locale && key._locale._abbr) { + key = key._locale._abbr; + } + + if (!key) { + return globalLocale; + } + + if (!isArray(key)) { + //short-circuit everything else + locale = loadLocale(key); + if (locale) { + return locale; + } + key = [key]; + } + + return chooseLocale(key); + } + + function listLocales() { + return keys(locales); + } + + function checkOverflow(m) { + var overflow; + var a = m._a; + + if (a && getParsingFlags(m).overflow === -2) { + overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1; + + if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { + overflow = DATE; + } + if (getParsingFlags(m)._overflowWeeks && overflow === -1) { + overflow = WEEK; + } + if (getParsingFlags(m)._overflowWeekday && overflow === -1) { + overflow = WEEKDAY; + } + + getParsingFlags(m).overflow = overflow; + } + + return m; + } + + // Pick the first defined of two or three arguments. + function defaults(a, b, c) { + if (a != null) { + return a; + } + if (b != null) { + return b; + } + return c; + } + + function currentDateArray(config) { + // hooks is actually the exported moment object + var nowValue = new Date(hooks.now()); + if (config._useUTC) { + return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()]; + } + return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; + } + + // convert an array to a date. + // the array should mirror the parameters below + // note: all values past the year are optional and will default to the lowest possible value. + // [year, month, day , hour, minute, second, millisecond] + function configFromArray(config) { + var i, + date, + input = [], + currentDate, + yearToUse; + + if (config._d) { + return; + } + + currentDate = currentDateArray(config); + + //compute day of the year from weeks and weekdays + if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { + dayOfYearFromWeekInfo(config); + } + + //if the day of the year is set, figure out what it is + if (config._dayOfYear != null) { + yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); + + if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) { + getParsingFlags(config)._overflowDayOfYear = true; + } + + date = createUTCDate(yearToUse, 0, config._dayOfYear); + config._a[MONTH] = date.getUTCMonth(); + config._a[DATE] = date.getUTCDate(); + } + + // Default to current date. + // * if no year, month, day of month are given, default to today + // * if day of month is given, default month and year + // * if month is given, default only year + // * if year is given, don't default anything + for (i = 0; i < 3 && config._a[i] == null; ++i) { + config._a[i] = input[i] = currentDate[i]; + } + + // Zero out whatever was not defaulted, including time + for (; i < 7; i++) { + config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i]; + } + + // Check for 24:00:00.000 + if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) { + config._nextDay = true; + config._a[HOUR] = 0; + } + + config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); + // Apply timezone offset from input. The actual utcOffset can be changed + // with parseZone. + if (config._tzm != null) { + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + } + + if (config._nextDay) { + config._a[HOUR] = 24; + } + + // check for mismatching day of week + if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== config._d.getDay()) { + getParsingFlags(config).weekdayMismatch = true; + } + } + + function dayOfYearFromWeekInfo(config) { + var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow; + + w = config._w; + if (w.GG != null || w.W != null || w.E != null) { + dow = 1; + doy = 4; + + // TODO: We need to take the current isoWeekYear, but that depends on + // how we interpret now (local, utc, fixed offset). So create + // a now version of current config (take local/utc/offset flags, and + // create now). + weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year); + week = defaults(w.W, 1); + weekday = defaults(w.E, 1); + if (weekday < 1 || weekday > 7) { + weekdayOverflow = true; + } + } else { + dow = config._locale._week.dow; + doy = config._locale._week.doy; + + var curWeek = weekOfYear(createLocal(), dow, doy); + + weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); + + // Default to current week. + week = defaults(w.w, curWeek.week); + + if (w.d != null) { + // weekday -- low day numbers are considered next week + weekday = w.d; + if (weekday < 0 || weekday > 6) { + weekdayOverflow = true; + } + } else if (w.e != null) { + // local weekday -- counting starts from begining of week + weekday = w.e + dow; + if (w.e < 0 || w.e > 6) { + weekdayOverflow = true; + } + } else { + // default to begining of week + weekday = dow; + } + } + if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { + getParsingFlags(config)._overflowWeeks = true; + } else if (weekdayOverflow != null) { + getParsingFlags(config)._overflowWeekday = true; + } else { + temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); + config._a[YEAR] = temp.year; + config._dayOfYear = temp.dayOfYear; + } + } + + // iso 8601 regex + // 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) + 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)?)?$/; + 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)?)?$/; + + var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/; + + var isoDates = [['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], ['GGGG-[W]WW', /\d{4}-W\d\d/, false], ['YYYY-DDD', /\d{4}-\d{3}/], ['YYYY-MM', /\d{4}-\d\d/, false], ['YYYYYYMMDD', /[+-]\d{10}/], ['YYYYMMDD', /\d{8}/], + // YYYYMM is NOT allowed by the standard + ['GGGG[W]WWE', /\d{4}W\d{3}/], ['GGGG[W]WW', /\d{4}W\d{2}/, false], ['YYYYDDD', /\d{7}/]]; + + // iso time formats and regexes + var isoTimes = [['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], ['HH:mm:ss', /\d\d:\d\d:\d\d/], ['HH:mm', /\d\d:\d\d/], ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], ['HHmmss', /\d\d\d\d\d\d/], ['HHmm', /\d\d\d\d/], ['HH', /\d\d/]]; + + var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i; + + // date from iso format + function configFromISO(config) { + var i, + l, + string = config._i, + match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), + allowTime, + dateFormat, + timeFormat, + tzFormat; + + if (match) { + getParsingFlags(config).iso = true; + + for (i = 0, l = isoDates.length; i < l; i++) { + if (isoDates[i][1].exec(match[1])) { + dateFormat = isoDates[i][0]; + allowTime = isoDates[i][2] !== false; + break; + } + } + if (dateFormat == null) { + config._isValid = false; + return; + } + if (match[3]) { + for (i = 0, l = isoTimes.length; i < l; i++) { + if (isoTimes[i][1].exec(match[3])) { + // match[2] should be 'T' or space + timeFormat = (match[2] || ' ') + isoTimes[i][0]; + break; + } + } + if (timeFormat == null) { + config._isValid = false; + return; + } + } + if (!allowTime && timeFormat != null) { + config._isValid = false; + return; + } + if (match[4]) { + if (tzRegex.exec(match[4])) { + tzFormat = 'Z'; + } else { + config._isValid = false; + return; + } + } + config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); + configFromStringAndFormat(config); + } else { + config._isValid = false; + } + } + + // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 + 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}))$/; + + function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { + var result = [untruncateYear(yearStr), defaultLocaleMonthsShort.indexOf(monthStr), parseInt(dayStr, 10), parseInt(hourStr, 10), parseInt(minuteStr, 10)]; + + if (secondStr) { + result.push(parseInt(secondStr, 10)); + } + + return result; + } + + function untruncateYear(yearStr) { + var year = parseInt(yearStr, 10); + if (year <= 49) { + return 2000 + year; + } else if (year <= 999) { + return 1900 + year; + } + return year; + } + + function preprocessRFC2822(s) { + // Remove comments and folding whitespace and replace multiple-spaces with a single space + return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').trim(); + } + + function checkWeekday(weekdayStr, parsedInput, config) { + if (weekdayStr) { + // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check. + var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), + weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay(); + if (weekdayProvided !== weekdayActual) { + getParsingFlags(config).weekdayMismatch = true; + config._isValid = false; + return false; + } + } + return true; + } + + var obsOffsets = { + UT: 0, + GMT: 0, + EDT: -4 * 60, + EST: -5 * 60, + CDT: -5 * 60, + CST: -6 * 60, + MDT: -6 * 60, + MST: -7 * 60, + PDT: -7 * 60, + PST: -8 * 60 + }; + + function calculateOffset(obsOffset, militaryOffset, numOffset) { + if (obsOffset) { + return obsOffsets[obsOffset]; + } else if (militaryOffset) { + // the only allowed military tz is Z + return 0; + } else { + var hm = parseInt(numOffset, 10); + var m = hm % 100, + h = (hm - m) / 100; + return h * 60 + m; + } + } + + // date and time from ref 2822 format + function configFromRFC2822(config) { + var match = rfc2822.exec(preprocessRFC2822(config._i)); + if (match) { + var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]); + if (!checkWeekday(match[1], parsedArray, config)) { + return; + } + + config._a = parsedArray; + config._tzm = calculateOffset(match[8], match[9], match[10]); + + config._d = createUTCDate.apply(null, config._a); + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + + getParsingFlags(config).rfc2822 = true; + } else { + config._isValid = false; + } + } + + // date from iso format or fallback + function configFromString(config) { + var matched = aspNetJsonRegex.exec(config._i); + + if (matched !== null) { + config._d = new Date(+matched[1]); + return; + } + + configFromISO(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + + configFromRFC2822(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + + // Final attempt, use Input Fallback + hooks.createFromInputFallback(config); + } + + hooks.createFromInputFallback = deprecate('value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 'discouraged and will be removed in an upcoming major release. Please refer to ' + 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', function (config) { + config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); + }); + + // constant that refers to the ISO standard + hooks.ISO_8601 = function () {}; + + // constant that refers to the RFC 2822 form + hooks.RFC_2822 = function () {}; + + // date from string and format string + function configFromStringAndFormat(config) { + // TODO: Move this to another part of the creation flow to prevent circular deps + if (config._f === hooks.ISO_8601) { + configFromISO(config); + return; + } + if (config._f === hooks.RFC_2822) { + configFromRFC2822(config); + return; + } + config._a = []; + getParsingFlags(config).empty = true; + + // This array is used to make a Date, either with `new Date` or `Date.UTC` + var string = '' + config._i, + i, + parsedInput, + tokens, + token, + skipped, + stringLength = string.length, + totalParsedInputLength = 0; + + tokens = expandFormat(config._f, config._locale).match(formattingTokens) || []; + + for (i = 0; i < tokens.length; i++) { + token = tokens[i]; + parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0]; + // console.log('token', token, 'parsedInput', parsedInput, + // 'regex', getParseRegexForToken(token, config)); + if (parsedInput) { + skipped = string.substr(0, string.indexOf(parsedInput)); + if (skipped.length > 0) { + getParsingFlags(config).unusedInput.push(skipped); + } + string = string.slice(string.indexOf(parsedInput) + parsedInput.length); + totalParsedInputLength += parsedInput.length; + } + // don't parse if it's not a known token + if (formatTokenFunctions[token]) { + if (parsedInput) { + getParsingFlags(config).empty = false; + } else { + getParsingFlags(config).unusedTokens.push(token); + } + addTimeToArrayFromToken(token, parsedInput, config); + } else if (config._strict && !parsedInput) { + getParsingFlags(config).unusedTokens.push(token); + } + } + + // add remaining unparsed input length to the string + getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; + if (string.length > 0) { + getParsingFlags(config).unusedInput.push(string); + } + + // clear _12h flag if hour is <= 12 + if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) { + getParsingFlags(config).bigHour = undefined; + } + + getParsingFlags(config).parsedDateParts = config._a.slice(0); + getParsingFlags(config).meridiem = config._meridiem; + // handle meridiem + config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); + + configFromArray(config); + checkOverflow(config); + } + + function meridiemFixWrap(locale, hour, meridiem) { + var isPm; + + if (meridiem == null) { + // nothing to do + return hour; + } + if (locale.meridiemHour != null) { + return locale.meridiemHour(hour, meridiem); + } else if (locale.isPM != null) { + // Fallback + isPm = locale.isPM(meridiem); + if (isPm && hour < 12) { + hour += 12; + } + if (!isPm && hour === 12) { + hour = 0; + } + return hour; + } else { + // this is not supposed to happen + return hour; + } + } + + // date from string and array of format strings + function configFromStringAndArray(config) { + var tempConfig, bestMoment, scoreToBeat, i, currentScore; + + if (config._f.length === 0) { + getParsingFlags(config).invalidFormat = true; + config._d = new Date(NaN); + return; + } + + for (i = 0; i < config._f.length; i++) { + currentScore = 0; + tempConfig = copyConfig({}, config); + if (config._useUTC != null) { + tempConfig._useUTC = config._useUTC; + } + tempConfig._f = config._f[i]; + configFromStringAndFormat(tempConfig); + + if (!isValid(tempConfig)) { + continue; + } + + // if there is any input that was not parsed add a penalty for that format + currentScore += getParsingFlags(tempConfig).charsLeftOver; + + //or tokens + currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; + + getParsingFlags(tempConfig).score = currentScore; + + if (scoreToBeat == null || currentScore < scoreToBeat) { + scoreToBeat = currentScore; + bestMoment = tempConfig; + } + } + + extend(config, bestMoment || tempConfig); + } + + function configFromObject(config) { + if (config._d) { + return; + } + + var i = normalizeObjectUnits(config._i); + config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) { + return obj && parseInt(obj, 10); + }); + + configFromArray(config); + } + + function createFromConfig(config) { + var res = new Moment(checkOverflow(prepareConfig(config))); + if (res._nextDay) { + // Adding is smart enough around DST + res.add(1, 'd'); + res._nextDay = undefined; + } + + return res; + } + + function prepareConfig(config) { + var input = config._i, + format = config._f; + + config._locale = config._locale || getLocale(config._l); + + if (input === null || format === undefined && input === '') { + return createInvalid({ nullInput: true }); + } + + if (typeof input === 'string') { + config._i = input = config._locale.preparse(input); + } + + if (isMoment(input)) { + return new Moment(checkOverflow(input)); + } else if (isDate(input)) { + config._d = input; + } else if (isArray(format)) { + configFromStringAndArray(config); + } else if (format) { + configFromStringAndFormat(config); + } else { + configFromInput(config); + } + + if (!isValid(config)) { + config._d = null; + } + + return config; + } + + function configFromInput(config) { + var input = config._i; + if (isUndefined(input)) { + config._d = new Date(hooks.now()); + } else if (isDate(input)) { + config._d = new Date(input.valueOf()); + } else if (typeof input === 'string') { + configFromString(config); + } else if (isArray(input)) { + config._a = map(input.slice(0), function (obj) { + return parseInt(obj, 10); + }); + configFromArray(config); + } else if (isObject(input)) { + configFromObject(config); + } else if (isNumber(input)) { + // from milliseconds + config._d = new Date(input); + } else { + hooks.createFromInputFallback(config); + } + } + + function createLocalOrUTC(input, format, locale, strict, isUTC) { + var c = {}; + + if (locale === true || locale === false) { + strict = locale; + locale = undefined; + } + + if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) { + input = undefined; + } + // object construction must be done this way. + // https://github.com/moment/moment/issues/1423 + c._isAMomentObject = true; + c._useUTC = c._isUTC = isUTC; + c._l = locale; + c._i = input; + c._f = format; + c._strict = strict; + + return createFromConfig(c); + } + + function createLocal(input, format, locale, strict) { + return createLocalOrUTC(input, format, locale, strict, false); + } + + var prototypeMin = deprecate('moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', function () { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other < this ? this : other; + } else { + return createInvalid(); + } + }); + + var prototypeMax = deprecate('moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', function () { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other > this ? this : other; + } else { + return createInvalid(); + } + }); + + // Pick a moment m from moments so that m[fn](other) is true for all + // other. This relies on the function fn to be transitive. + // + // moments should either be an array of moment objects or an array, whose + // first element is an array of moment objects. + function pickBy(fn, moments) { + var res, i; + if (moments.length === 1 && isArray(moments[0])) { + moments = moments[0]; + } + if (!moments.length) { + return createLocal(); + } + res = moments[0]; + for (i = 1; i < moments.length; ++i) { + if (!moments[i].isValid() || moments[i][fn](res)) { + res = moments[i]; + } + } + return res; + } + + // TODO: Use [].sort instead? + function min() { + var args = [].slice.call(arguments, 0); + + return pickBy('isBefore', args); + } + + function max() { + var args = [].slice.call(arguments, 0); + + return pickBy('isAfter', args); + } + + var now = function now() { + return Date.now ? Date.now() : +new Date(); + }; + + var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond']; + + function isDurationValid(m) { + for (var key in m) { + if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) { + return false; + } + } + + var unitHasDecimal = false; + for (var i = 0; i < ordering.length; ++i) { + if (m[ordering[i]]) { + if (unitHasDecimal) { + return false; // only allow non-integers for smallest unit + } + if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { + unitHasDecimal = true; + } + } + } + + return true; + } + + function isValid$1() { + return this._isValid; + } + + function createInvalid$1() { + return createDuration(NaN); + } + + function Duration(duration) { + var normalizedInput = normalizeObjectUnits(duration), + years = normalizedInput.year || 0, + quarters = normalizedInput.quarter || 0, + months = normalizedInput.month || 0, + weeks = normalizedInput.week || 0, + days = normalizedInput.day || 0, + hours = normalizedInput.hour || 0, + minutes = normalizedInput.minute || 0, + seconds = normalizedInput.second || 0, + milliseconds = normalizedInput.millisecond || 0; + + this._isValid = isDurationValid(normalizedInput); + + // representation for dateAddRemove + this._milliseconds = +milliseconds + seconds * 1e3 + // 1000 + minutes * 6e4 + // 1000 * 60 + hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 + // Because of dateAddRemove treats 24 hours as different from a + // day when working around DST, we need to store them separately + this._days = +days + weeks * 7; + // It is impossible to translate months into days without knowing + // which months you are are talking about, so we have to store + // it separately. + this._months = +months + quarters * 3 + years * 12; + + this._data = {}; + + this._locale = getLocale(); + + this._bubble(); + } + + function isDuration(obj) { + return obj instanceof Duration; + } + + function absRound(number) { + if (number < 0) { + return Math.round(-1 * number) * -1; + } else { + return Math.round(number); + } + } + + // FORMATTING + + function offset(token, separator) { + addFormatToken(token, 0, 0, function () { + var offset = this.utcOffset(); + var sign = '+'; + if (offset < 0) { + offset = -offset; + sign = '-'; + } + return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~offset % 60, 2); + }); + } + + offset('Z', ':'); + offset('ZZ', ''); + + // PARSING + + addRegexToken('Z', matchShortOffset); + addRegexToken('ZZ', matchShortOffset); + addParseToken(['Z', 'ZZ'], function (input, array, config) { + config._useUTC = true; + config._tzm = offsetFromString(matchShortOffset, input); + }); + + // HELPERS + + // timezone chunker + // '+10:00' > ['10', '00'] + // '-1530' > ['-15', '30'] + var chunkOffset = /([\+\-]|\d\d)/gi; + + function offsetFromString(matcher, string) { + var matches = (string || '').match(matcher); + + if (matches === null) { + return null; + } + + var chunk = matches[matches.length - 1] || []; + var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; + var minutes = +(parts[1] * 60) + toInt(parts[2]); + + return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes; + } + + // Return a moment from input, that is local/utc/zone equivalent to model. + function cloneWithOffset(input, model) { + var res, diff; + if (model._isUTC) { + res = model.clone(); + diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf(); + // Use low-level api, because this fn is low-level api. + res._d.setTime(res._d.valueOf() + diff); + hooks.updateOffset(res, false); + return res; + } else { + return createLocal(input).local(); + } + } + + function getDateOffset(m) { + // On Firefox.24 Date#getTimezoneOffset returns a floating point. + // https://github.com/moment/moment/pull/1871 + return -Math.round(m._d.getTimezoneOffset() / 15) * 15; + } + + // HOOKS + + // This function will be called whenever a moment is mutated. + // It is intended to keep the offset in sync with the timezone. + hooks.updateOffset = function () {}; + + // MOMENTS + + // keepLocalTime = true means only change the timezone, without + // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> + // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset + // +0200, so we adjust the time as needed, to be valid. + // + // Keeping the time actually adds/subtracts (one hour) + // from the actual represented time. That is why we call updateOffset + // a second time. In case it wants us to change the offset again + // _changeInProgress == true case, then we have to adjust, because + // there is no such time in the given timezone. + function getSetOffset(input, keepLocalTime, keepMinutes) { + var offset = this._offset || 0, + localAdjust; + if (!this.isValid()) { + return input != null ? this : NaN; + } + if (input != null) { + if (typeof input === 'string') { + input = offsetFromString(matchShortOffset, input); + if (input === null) { + return this; + } + } else if (Math.abs(input) < 16 && !keepMinutes) { + input = input * 60; + } + if (!this._isUTC && keepLocalTime) { + localAdjust = getDateOffset(this); + } + this._offset = input; + this._isUTC = true; + if (localAdjust != null) { + this.add(localAdjust, 'm'); + } + if (offset !== input) { + if (!keepLocalTime || this._changeInProgress) { + addSubtract(this, createDuration(input - offset, 'm'), 1, false); + } else if (!this._changeInProgress) { + this._changeInProgress = true; + hooks.updateOffset(this, true); + this._changeInProgress = null; + } + } + return this; + } else { + return this._isUTC ? offset : getDateOffset(this); + } + } + + function getSetZone(input, keepLocalTime) { + if (input != null) { + if (typeof input !== 'string') { + input = -input; + } + + this.utcOffset(input, keepLocalTime); + + return this; + } else { + return -this.utcOffset(); + } + } + + function setOffsetToUTC(keepLocalTime) { + return this.utcOffset(0, keepLocalTime); + } + + function setOffsetToLocal(keepLocalTime) { + if (this._isUTC) { + this.utcOffset(0, keepLocalTime); + this._isUTC = false; + + if (keepLocalTime) { + this.subtract(getDateOffset(this), 'm'); + } + } + return this; + } + + function setOffsetToParsedOffset() { + if (this._tzm != null) { + this.utcOffset(this._tzm, false, true); + } else if (typeof this._i === 'string') { + var tZone = offsetFromString(matchOffset, this._i); + if (tZone != null) { + this.utcOffset(tZone); + } else { + this.utcOffset(0, true); + } + } + return this; + } + + function hasAlignedHourOffset(input) { + if (!this.isValid()) { + return false; + } + input = input ? createLocal(input).utcOffset() : 0; + + return (this.utcOffset() - input) % 60 === 0; + } + + function isDaylightSavingTime() { + return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset(); + } + + function isDaylightSavingTimeShifted() { + if (!isUndefined(this._isDSTShifted)) { + return this._isDSTShifted; + } + + var c = {}; + + copyConfig(c, this); + c = prepareConfig(c); + + if (c._a) { + var other = c._isUTC ? createUTC(c._a) : createLocal(c._a); + this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0; + } else { + this._isDSTShifted = false; + } + + return this._isDSTShifted; + } + + function isLocal() { + return this.isValid() ? !this._isUTC : false; + } + + function isUtcOffset() { + return this.isValid() ? this._isUTC : false; + } + + function isUtc() { + return this.isValid() ? this._isUTC && this._offset === 0 : false; + } + + // ASP.NET json date format regex + var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/; + + // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html + // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere + // and further modified to allow for strings containing both week and day + 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)?)?$/; + + function createDuration(input, key) { + var duration = input, + + // matching against regexp is expensive, do it on demand + match = null, + sign, + ret, + diffRes; + + if (isDuration(input)) { + duration = { + ms: input._milliseconds, + d: input._days, + M: input._months + }; + } else if (isNumber(input)) { + duration = {}; + if (key) { + duration[key] = input; + } else { + duration.milliseconds = input; + } + } else if (!!(match = aspNetRegex.exec(input))) { + sign = match[1] === '-' ? -1 : 1; + duration = { + y: 0, + d: toInt(match[DATE]) * sign, + h: toInt(match[HOUR]) * sign, + m: toInt(match[MINUTE]) * sign, + s: toInt(match[SECOND]) * sign, + ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match + }; + } else if (!!(match = isoRegex.exec(input))) { + sign = match[1] === '-' ? -1 : match[1] === '+' ? 1 : 1; + duration = { + y: parseIso(match[2], sign), + M: parseIso(match[3], sign), + w: parseIso(match[4], sign), + d: parseIso(match[5], sign), + h: parseIso(match[6], sign), + m: parseIso(match[7], sign), + s: parseIso(match[8], sign) + }; + } else if (duration == null) { + // checks for null or undefined + duration = {}; + } else if ((typeof duration === 'undefined' ? 'undefined' : _typeof(duration)) === 'object' && ('from' in duration || 'to' in duration)) { + diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to)); + + duration = {}; + duration.ms = diffRes.milliseconds; + duration.M = diffRes.months; + } + + ret = new Duration(duration); + + if (isDuration(input) && hasOwnProp(input, '_locale')) { + ret._locale = input._locale; + } + + return ret; + } + + createDuration.fn = Duration.prototype; + createDuration.invalid = createInvalid$1; + + function parseIso(inp, sign) { + // We'd normally use ~~inp for this, but unfortunately it also + // converts floats to ints. + // inp may be undefined, so careful calling replace on it. + var res = inp && parseFloat(inp.replace(',', '.')); + // apply sign while we're at it + return (isNaN(res) ? 0 : res) * sign; + } + + function positiveMomentsDifference(base, other) { + var res = { milliseconds: 0, months: 0 }; + + res.months = other.month() - base.month() + (other.year() - base.year()) * 12; + if (base.clone().add(res.months, 'M').isAfter(other)) { + --res.months; + } + + res.milliseconds = +other - +base.clone().add(res.months, 'M'); + + return res; + } + + function momentsDifference(base, other) { + var res; + if (!(base.isValid() && other.isValid())) { + return { milliseconds: 0, months: 0 }; + } + + other = cloneWithOffset(other, base); + if (base.isBefore(other)) { + res = positiveMomentsDifference(base, other); + } else { + res = positiveMomentsDifference(other, base); + res.milliseconds = -res.milliseconds; + res.months = -res.months; + } + + return res; + } + + // TODO: remove 'name' arg after deprecation is removed + function createAdder(direction, name) { + return function (val, period) { + var dur, tmp; + //invert the arguments, but complain about it + if (period !== null && !isNaN(+period)) { + deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'); + tmp = val;val = period;period = tmp; + } + + val = typeof val === 'string' ? +val : val; + dur = createDuration(val, period); + addSubtract(this, dur, direction); + return this; + }; + } + + function addSubtract(mom, duration, isAdding, updateOffset) { + var milliseconds = duration._milliseconds, + days = absRound(duration._days), + months = absRound(duration._months); + + if (!mom.isValid()) { + // No op + return; + } + + updateOffset = updateOffset == null ? true : updateOffset; + + if (months) { + setMonth(mom, get(mom, 'Month') + months * isAdding); + } + if (days) { + set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); + } + if (milliseconds) { + mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); + } + if (updateOffset) { + hooks.updateOffset(mom, days || months); + } + } + + var add = createAdder(1, 'add'); + var subtract = createAdder(-1, 'subtract'); + + function getCalendarFormat(myMoment, now) { + var diff = myMoment.diff(now, 'days', true); + return diff < -6 ? 'sameElse' : diff < -1 ? 'lastWeek' : diff < 0 ? 'lastDay' : diff < 1 ? 'sameDay' : diff < 2 ? 'nextDay' : diff < 7 ? 'nextWeek' : 'sameElse'; + } + + function calendar$1(time, formats) { + // We want to compare the start of today, vs this. + // Getting start-of-today depends on whether we're local/utc/offset or not. + var now = time || createLocal(), + sod = cloneWithOffset(now, this).startOf('day'), + format = hooks.calendarFormat(this, sod) || 'sameElse'; + + var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]); + + return this.format(output || this.localeData().calendar(format, this, createLocal(now))); + } + + function clone() { + return new Moment(this); + } + + function isAfter(input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); + if (units === 'millisecond') { + return this.valueOf() > localInput.valueOf(); + } else { + return localInput.valueOf() < this.clone().startOf(units).valueOf(); + } + } + + function isBefore(input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); + if (units === 'millisecond') { + return this.valueOf() < localInput.valueOf(); + } else { + return this.clone().endOf(units).valueOf() < localInput.valueOf(); + } + } + + function isBetween(from, to, units, inclusivity) { + inclusivity = inclusivity || '()'; + return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) && (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units)); + } + + function isSame(input, units) { + var localInput = isMoment(input) ? input : createLocal(input), + inputMs; + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units || 'millisecond'); + if (units === 'millisecond') { + return this.valueOf() === localInput.valueOf(); + } else { + inputMs = localInput.valueOf(); + return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf(); + } + } + + function isSameOrAfter(input, units) { + return this.isSame(input, units) || this.isAfter(input, units); + } + + function isSameOrBefore(input, units) { + return this.isSame(input, units) || this.isBefore(input, units); + } + + function diff(input, units, asFloat) { + var that, zoneDelta, delta, output; + + if (!this.isValid()) { + return NaN; + } + + that = cloneWithOffset(input, this); + + if (!that.isValid()) { + return NaN; + } + + zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; + + units = normalizeUnits(units); + + switch (units) { + case 'year': + output = monthDiff(this, that) / 12;break; + case 'month': + output = monthDiff(this, that);break; + case 'quarter': + output = monthDiff(this, that) / 3;break; + case 'second': + output = (this - that) / 1e3;break; // 1000 + case 'minute': + output = (this - that) / 6e4;break; // 1000 * 60 + case 'hour': + output = (this - that) / 36e5;break; // 1000 * 60 * 60 + case 'day': + output = (this - that - zoneDelta) / 864e5;break; // 1000 * 60 * 60 * 24, negate dst + case 'week': + output = (this - that - zoneDelta) / 6048e5;break; // 1000 * 60 * 60 * 24 * 7, negate dst + default: + output = this - that; + } + + return asFloat ? output : absFloor(output); + } + + function monthDiff(a, b) { + // difference in months + var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), + + // b is in (anchor - 1 month, anchor + 1 month) + anchor = a.clone().add(wholeMonthDiff, 'months'), + anchor2, + adjust; + + if (b - anchor < 0) { + anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); + // linear across the month + adjust = (b - anchor) / (anchor - anchor2); + } else { + anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); + // linear across the month + adjust = (b - anchor) / (anchor2 - anchor); + } + + //check for negative zero, return zero if negative zero + return -(wholeMonthDiff + adjust) || 0; + } + + hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; + hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; + + function toString() { + return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); + } + + function toISOString() { + if (!this.isValid()) { + return null; + } + var m = this.clone().utc(); + if (m.year() < 0 || m.year() > 9999) { + return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); + } + if (isFunction(Date.prototype.toISOString)) { + // native implementation is ~50x faster, use it when we can + return this.toDate().toISOString(); + } + return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); + } + + /** + * Return a human readable representation of a moment that can + * also be evaluated to get a new moment which is the same + * + * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects + */ + function inspect() { + if (!this.isValid()) { + return 'moment.invalid(/* ' + this._i + ' */)'; + } + var func = 'moment'; + var zone = ''; + if (!this.isLocal()) { + func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; + zone = 'Z'; + } + var prefix = '[' + func + '("]'; + var year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY'; + var datetime = '-MM-DD[T]HH:mm:ss.SSS'; + var suffix = zone + '[")]'; + + return this.format(prefix + year + datetime + suffix); + } + + function format(inputString) { + if (!inputString) { + inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat; + } + var output = formatMoment(this, inputString); + return this.localeData().postformat(output); + } + + function from(time, withoutSuffix) { + if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) { + return createDuration({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } + } + + function fromNow(withoutSuffix) { + return this.from(createLocal(), withoutSuffix); + } + + function to(time, withoutSuffix) { + if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) { + return createDuration({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } + } + + function toNow(withoutSuffix) { + return this.to(createLocal(), withoutSuffix); + } + + // If passed a locale key, it will set the locale for this + // instance. Otherwise, it will return the locale configuration + // variables for this instance. + function locale(key) { + var newLocaleData; + + if (key === undefined) { + return this._locale._abbr; + } else { + newLocaleData = getLocale(key); + if (newLocaleData != null) { + this._locale = newLocaleData; + } + return this; + } + } + + var lang = deprecate('moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', function (key) { + if (key === undefined) { + return this.localeData(); + } else { + return this.locale(key); + } + }); + + function localeData() { + return this._locale; + } + + function startOf(units) { + units = normalizeUnits(units); + // the following switch intentionally omits break keywords + // to utilize falling through the cases. + switch (units) { + case 'year': + this.month(0); + /* falls through */ + case 'quarter': + case 'month': + this.date(1); + /* falls through */ + case 'week': + case 'isoWeek': + case 'day': + case 'date': + this.hours(0); + /* falls through */ + case 'hour': + this.minutes(0); + /* falls through */ + case 'minute': + this.seconds(0); + /* falls through */ + case 'second': + this.milliseconds(0); + } + + // weeks are a special case + if (units === 'week') { + this.weekday(0); + } + if (units === 'isoWeek') { + this.isoWeekday(1); + } + + // quarters are also special + if (units === 'quarter') { + this.month(Math.floor(this.month() / 3) * 3); + } + + return this; + } + + function endOf(units) { + units = normalizeUnits(units); + if (units === undefined || units === 'millisecond') { + return this; + } + + // 'date' is an alias for 'day', so it should be considered as such. + if (units === 'date') { + units = 'day'; + } + + return this.startOf(units).add(1, units === 'isoWeek' ? 'week' : units).subtract(1, 'ms'); + } + + function valueOf() { + return this._d.valueOf() - (this._offset || 0) * 60000; + } + + function unix() { + return Math.floor(this.valueOf() / 1000); + } + + function toDate() { + return new Date(this.valueOf()); + } + + function toArray() { + var m = this; + return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()]; + } + + function toObject() { + var m = this; + return { + years: m.year(), + months: m.month(), + date: m.date(), + hours: m.hours(), + minutes: m.minutes(), + seconds: m.seconds(), + milliseconds: m.milliseconds() + }; + } + + function toJSON() { + // new Date(NaN).toJSON() === null + return this.isValid() ? this.toISOString() : null; + } + + function isValid$2() { + return isValid(this); + } + + function parsingFlags() { + return extend({}, getParsingFlags(this)); + } + + function invalidAt() { + return getParsingFlags(this).overflow; + } + + function creationData() { + return { + input: this._i, + format: this._f, + locale: this._locale, + isUTC: this._isUTC, + strict: this._strict + }; + } + + // FORMATTING + + addFormatToken(0, ['gg', 2], 0, function () { + return this.weekYear() % 100; + }); + + addFormatToken(0, ['GG', 2], 0, function () { + return this.isoWeekYear() % 100; + }); + + function addWeekYearFormatToken(token, getter) { + addFormatToken(0, [token, token.length], 0, getter); + } + + addWeekYearFormatToken('gggg', 'weekYear'); + addWeekYearFormatToken('ggggg', 'weekYear'); + addWeekYearFormatToken('GGGG', 'isoWeekYear'); + addWeekYearFormatToken('GGGGG', 'isoWeekYear'); + + // ALIASES + + addUnitAlias('weekYear', 'gg'); + addUnitAlias('isoWeekYear', 'GG'); + + // PRIORITY + + addUnitPriority('weekYear', 1); + addUnitPriority('isoWeekYear', 1); + + // PARSING + + addRegexToken('G', matchSigned); + addRegexToken('g', matchSigned); + addRegexToken('GG', match1to2, match2); + addRegexToken('gg', match1to2, match2); + addRegexToken('GGGG', match1to4, match4); + addRegexToken('gggg', match1to4, match4); + addRegexToken('GGGGG', match1to6, match6); + addRegexToken('ggggg', match1to6, match6); + + addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) { + week[token.substr(0, 2)] = toInt(input); + }); + + addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { + week[token] = hooks.parseTwoDigitYear(input); + }); + + // MOMENTS + + function getSetWeekYear(input) { + return getSetWeekYearHelper.call(this, input, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy); + } + + function getSetISOWeekYear(input) { + return getSetWeekYearHelper.call(this, input, this.isoWeek(), this.isoWeekday(), 1, 4); + } + + function getISOWeeksInYear() { + return weeksInYear(this.year(), 1, 4); + } + + function getWeeksInYear() { + var weekInfo = this.localeData()._week; + return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); + } + + function getSetWeekYearHelper(input, week, weekday, dow, doy) { + var weeksTarget; + if (input == null) { + return weekOfYear(this, dow, doy).year; + } else { + weeksTarget = weeksInYear(input, dow, doy); + if (week > weeksTarget) { + week = weeksTarget; + } + return setWeekAll.call(this, input, week, weekday, dow, doy); + } + } + + function setWeekAll(weekYear, week, weekday, dow, doy) { + var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), + date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); + + this.year(date.getUTCFullYear()); + this.month(date.getUTCMonth()); + this.date(date.getUTCDate()); + return this; + } + + // FORMATTING + + addFormatToken('Q', 0, 'Qo', 'quarter'); + + // ALIASES + + addUnitAlias('quarter', 'Q'); + + // PRIORITY + + addUnitPriority('quarter', 7); + + // PARSING + + addRegexToken('Q', match1); + addParseToken('Q', function (input, array) { + array[MONTH] = (toInt(input) - 1) * 3; + }); + + // MOMENTS + + function getSetQuarter(input) { + return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); + } + + // FORMATTING + + addFormatToken('D', ['DD', 2], 'Do', 'date'); + + // ALIASES + + addUnitAlias('date', 'D'); + + // PRIOROITY + addUnitPriority('date', 9); + + // PARSING + + addRegexToken('D', match1to2); + addRegexToken('DD', match1to2, match2); + addRegexToken('Do', function (isStrict, locale) { + // TODO: Remove "ordinalParse" fallback in next major release. + return isStrict ? locale._dayOfMonthOrdinalParse || locale._ordinalParse : locale._dayOfMonthOrdinalParseLenient; + }); + + addParseToken(['D', 'DD'], DATE); + addParseToken('Do', function (input, array) { + array[DATE] = toInt(input.match(match1to2)[0], 10); + }); + + // MOMENTS + + var getSetDayOfMonth = makeGetSet('Date', true); + + // FORMATTING + + addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); + + // ALIASES + + addUnitAlias('dayOfYear', 'DDD'); + + // PRIORITY + addUnitPriority('dayOfYear', 4); + + // PARSING + + addRegexToken('DDD', match1to3); + addRegexToken('DDDD', match3); + addParseToken(['DDD', 'DDDD'], function (input, array, config) { + config._dayOfYear = toInt(input); + }); + + // HELPERS + + // MOMENTS + + function getSetDayOfYear(input) { + var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1; + return input == null ? dayOfYear : this.add(input - dayOfYear, 'd'); + } + + // FORMATTING + + addFormatToken('m', ['mm', 2], 0, 'minute'); + + // ALIASES + + addUnitAlias('minute', 'm'); + + // PRIORITY + + addUnitPriority('minute', 14); + + // PARSING + + addRegexToken('m', match1to2); + addRegexToken('mm', match1to2, match2); + addParseToken(['m', 'mm'], MINUTE); + + // MOMENTS + + var getSetMinute = makeGetSet('Minutes', false); + + // FORMATTING + + addFormatToken('s', ['ss', 2], 0, 'second'); + + // ALIASES + + addUnitAlias('second', 's'); + + // PRIORITY + + addUnitPriority('second', 15); + + // PARSING + + addRegexToken('s', match1to2); + addRegexToken('ss', match1to2, match2); + addParseToken(['s', 'ss'], SECOND); + + // MOMENTS + + var getSetSecond = makeGetSet('Seconds', false); + + // FORMATTING + + addFormatToken('S', 0, 0, function () { + return ~~(this.millisecond() / 100); + }); + + addFormatToken(0, ['SS', 2], 0, function () { + return ~~(this.millisecond() / 10); + }); + + addFormatToken(0, ['SSS', 3], 0, 'millisecond'); + addFormatToken(0, ['SSSS', 4], 0, function () { + return this.millisecond() * 10; + }); + addFormatToken(0, ['SSSSS', 5], 0, function () { + return this.millisecond() * 100; + }); + addFormatToken(0, ['SSSSSS', 6], 0, function () { + return this.millisecond() * 1000; + }); + addFormatToken(0, ['SSSSSSS', 7], 0, function () { + return this.millisecond() * 10000; + }); + addFormatToken(0, ['SSSSSSSS', 8], 0, function () { + return this.millisecond() * 100000; + }); + addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { + return this.millisecond() * 1000000; + }); + + // ALIASES + + addUnitAlias('millisecond', 'ms'); + + // PRIORITY + + addUnitPriority('millisecond', 16); + + // PARSING + + addRegexToken('S', match1to3, match1); + addRegexToken('SS', match1to3, match2); + addRegexToken('SSS', match1to3, match3); + + var token; + for (token = 'SSSS'; token.length <= 9; token += 'S') { + addRegexToken(token, matchUnsigned); + } + + function parseMs(input, array) { + array[MILLISECOND] = toInt(('0.' + input) * 1000); + } + + for (token = 'S'; token.length <= 9; token += 'S') { + addParseToken(token, parseMs); + } + // MOMENTS + + var getSetMillisecond = makeGetSet('Milliseconds', false); + + // FORMATTING + + addFormatToken('z', 0, 0, 'zoneAbbr'); + addFormatToken('zz', 0, 0, 'zoneName'); + + // MOMENTS + + function getZoneAbbr() { + return this._isUTC ? 'UTC' : ''; + } + + function getZoneName() { + return this._isUTC ? 'Coordinated Universal Time' : ''; + } + + var proto = Moment.prototype; + + proto.add = add; + proto.calendar = calendar$1; + proto.clone = clone; + proto.diff = diff; + proto.endOf = endOf; + proto.format = format; + proto.from = from; + proto.fromNow = fromNow; + proto.to = to; + proto.toNow = toNow; + proto.get = stringGet; + proto.invalidAt = invalidAt; + proto.isAfter = isAfter; + proto.isBefore = isBefore; + proto.isBetween = isBetween; + proto.isSame = isSame; + proto.isSameOrAfter = isSameOrAfter; + proto.isSameOrBefore = isSameOrBefore; + proto.isValid = isValid$2; + proto.lang = lang; + proto.locale = locale; + proto.localeData = localeData; + proto.max = prototypeMax; + proto.min = prototypeMin; + proto.parsingFlags = parsingFlags; + proto.set = stringSet; + proto.startOf = startOf; + proto.subtract = subtract; + proto.toArray = toArray; + proto.toObject = toObject; + proto.toDate = toDate; + proto.toISOString = toISOString; + proto.inspect = inspect; + proto.toJSON = toJSON; + proto.toString = toString; + proto.unix = unix; + proto.valueOf = valueOf; + proto.creationData = creationData; + + // Year + proto.year = getSetYear; + proto.isLeapYear = getIsLeapYear; + + // Week Year + proto.weekYear = getSetWeekYear; + proto.isoWeekYear = getSetISOWeekYear; + + // Quarter + proto.quarter = proto.quarters = getSetQuarter; + + // Month + proto.month = getSetMonth; + proto.daysInMonth = getDaysInMonth; + + // Week + proto.week = proto.weeks = getSetWeek; + proto.isoWeek = proto.isoWeeks = getSetISOWeek; + proto.weeksInYear = getWeeksInYear; + proto.isoWeeksInYear = getISOWeeksInYear; + + // Day + proto.date = getSetDayOfMonth; + proto.day = proto.days = getSetDayOfWeek; + proto.weekday = getSetLocaleDayOfWeek; + proto.isoWeekday = getSetISODayOfWeek; + proto.dayOfYear = getSetDayOfYear; + + // Hour + proto.hour = proto.hours = getSetHour; + + // Minute + proto.minute = proto.minutes = getSetMinute; + + // Second + proto.second = proto.seconds = getSetSecond; + + // Millisecond + proto.millisecond = proto.milliseconds = getSetMillisecond; + + // Offset + proto.utcOffset = getSetOffset; + proto.utc = setOffsetToUTC; + proto.local = setOffsetToLocal; + proto.parseZone = setOffsetToParsedOffset; + proto.hasAlignedHourOffset = hasAlignedHourOffset; + proto.isDST = isDaylightSavingTime; + proto.isLocal = isLocal; + proto.isUtcOffset = isUtcOffset; + proto.isUtc = isUtc; + proto.isUTC = isUtc; + + // Timezone + proto.zoneAbbr = getZoneAbbr; + proto.zoneName = getZoneName; + + // Deprecations + proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); + proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); + proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); + proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone); + proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted); + + function createUnix(input) { + return createLocal(input * 1000); + } + + function createInZone() { + return createLocal.apply(null, arguments).parseZone(); + } + + function preParsePostFormat(string) { + return string; + } + + var proto$1 = Locale.prototype; + + proto$1.calendar = calendar; + proto$1.longDateFormat = longDateFormat; + proto$1.invalidDate = invalidDate; + proto$1.ordinal = ordinal; + proto$1.preparse = preParsePostFormat; + proto$1.postformat = preParsePostFormat; + proto$1.relativeTime = relativeTime; + proto$1.pastFuture = pastFuture; + proto$1.set = set; + + // Month + proto$1.months = localeMonths; + proto$1.monthsShort = localeMonthsShort; + proto$1.monthsParse = localeMonthsParse; + proto$1.monthsRegex = monthsRegex; + proto$1.monthsShortRegex = monthsShortRegex; + + // Week + proto$1.week = localeWeek; + proto$1.firstDayOfYear = localeFirstDayOfYear; + proto$1.firstDayOfWeek = localeFirstDayOfWeek; + + // Day of Week + proto$1.weekdays = localeWeekdays; + proto$1.weekdaysMin = localeWeekdaysMin; + proto$1.weekdaysShort = localeWeekdaysShort; + proto$1.weekdaysParse = localeWeekdaysParse; + + proto$1.weekdaysRegex = weekdaysRegex; + proto$1.weekdaysShortRegex = weekdaysShortRegex; + proto$1.weekdaysMinRegex = weekdaysMinRegex; + + // Hours + proto$1.isPM = localeIsPM; + proto$1.meridiem = localeMeridiem; + + function get$1(format, index, field, setter) { + var locale = getLocale(); + var utc = createUTC().set(setter, index); + return locale[field](utc, format); + } + + function listMonthsImpl(format, index, field) { + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + + if (index != null) { + return get$1(format, index, field, 'month'); + } + + var i; + var out = []; + for (i = 0; i < 12; i++) { + out[i] = get$1(format, i, field, 'month'); + } + return out; + } + + // () + // (5) + // (fmt, 5) + // (fmt) + // (true) + // (true, 5) + // (true, fmt, 5) + // (true, fmt) + function listWeekdaysImpl(localeSorted, format, index, field) { + if (typeof localeSorted === 'boolean') { + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + } else { + format = localeSorted; + index = format; + localeSorted = false; + + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + } + + var locale = getLocale(), + shift = localeSorted ? locale._week.dow : 0; + + if (index != null) { + return get$1(format, (index + shift) % 7, field, 'day'); + } + + var i; + var out = []; + for (i = 0; i < 7; i++) { + out[i] = get$1(format, (i + shift) % 7, field, 'day'); + } + return out; + } + + function listMonths(format, index) { + return listMonthsImpl(format, index, 'months'); + } + + function listMonthsShort(format, index) { + return listMonthsImpl(format, index, 'monthsShort'); + } + + function listWeekdays(localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); + } + + function listWeekdaysShort(localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); + } + + function listWeekdaysMin(localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); + } + + getSetGlobalLocale('en', { + dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, + ordinal: function ordinal(number) { + var b = number % 10, + output = toInt(number % 100 / 10) === 1 ? 'th' : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th'; + return number + output; + } + }); + + // Side effect imports + hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale); + hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale); + + var mathAbs = Math.abs; + + function abs() { + var data = this._data; + + this._milliseconds = mathAbs(this._milliseconds); + this._days = mathAbs(this._days); + this._months = mathAbs(this._months); + + data.milliseconds = mathAbs(data.milliseconds); + data.seconds = mathAbs(data.seconds); + data.minutes = mathAbs(data.minutes); + data.hours = mathAbs(data.hours); + data.months = mathAbs(data.months); + data.years = mathAbs(data.years); + + return this; + } + + function addSubtract$1(duration, input, value, direction) { + var other = createDuration(input, value); + + duration._milliseconds += direction * other._milliseconds; + duration._days += direction * other._days; + duration._months += direction * other._months; + + return duration._bubble(); + } + + // supports only 2.0-style add(1, 's') or add(duration) + function add$1(input, value) { + return addSubtract$1(this, input, value, 1); + } + + // supports only 2.0-style subtract(1, 's') or subtract(duration) + function subtract$1(input, value) { + return addSubtract$1(this, input, value, -1); + } + + function absCeil(number) { + if (number < 0) { + return Math.floor(number); + } else { + return Math.ceil(number); + } + } + + function bubble() { + var milliseconds = this._milliseconds; + var days = this._days; + var months = this._months; + var data = this._data; + var seconds, minutes, hours, years, monthsFromDays; + + // if we have a mix of positive and negative values, bubble down first + // check: https://github.com/moment/moment/issues/2166 + if (!(milliseconds >= 0 && days >= 0 && months >= 0 || milliseconds <= 0 && days <= 0 && months <= 0)) { + milliseconds += absCeil(monthsToDays(months) + days) * 864e5; + days = 0; + months = 0; + } + + // The following code bubbles up values, see the tests for + // examples of what that means. + data.milliseconds = milliseconds % 1000; + + seconds = absFloor(milliseconds / 1000); + data.seconds = seconds % 60; + + minutes = absFloor(seconds / 60); + data.minutes = minutes % 60; + + hours = absFloor(minutes / 60); + data.hours = hours % 24; + + days += absFloor(hours / 24); + + // convert days to months + monthsFromDays = absFloor(daysToMonths(days)); + months += monthsFromDays; + days -= absCeil(monthsToDays(monthsFromDays)); + + // 12 months -> 1 year + years = absFloor(months / 12); + months %= 12; + + data.days = days; + data.months = months; + data.years = years; + + return this; + } + + function daysToMonths(days) { + // 400 years have 146097 days (taking into account leap year rules) + // 400 years have 12 months === 4800 + return days * 4800 / 146097; + } + + function monthsToDays(months) { + // the reverse of daysToMonths + return months * 146097 / 4800; + } + + function as(units) { + if (!this.isValid()) { + return NaN; + } + var days; + var months; + var milliseconds = this._milliseconds; + + units = normalizeUnits(units); + + if (units === 'month' || units === 'year') { + days = this._days + milliseconds / 864e5; + months = this._months + daysToMonths(days); + return units === 'month' ? months : months / 12; + } else { + // handle milliseconds separately because of floating point math errors (issue #1867) + days = this._days + Math.round(monthsToDays(this._months)); + switch (units) { + case 'week': + return days / 7 + milliseconds / 6048e5; + case 'day': + return days + milliseconds / 864e5; + case 'hour': + return days * 24 + milliseconds / 36e5; + case 'minute': + return days * 1440 + milliseconds / 6e4; + case 'second': + return days * 86400 + milliseconds / 1000; + // Math.floor prevents floating point math errors here + case 'millisecond': + return Math.floor(days * 864e5) + milliseconds; + default: + throw new Error('Unknown unit ' + units); + } + } + } + + // TODO: Use this.as('ms')? + function valueOf$1() { + if (!this.isValid()) { + return NaN; + } + return this._milliseconds + this._days * 864e5 + this._months % 12 * 2592e6 + toInt(this._months / 12) * 31536e6; + } + + function makeAs(alias) { + return function () { + return this.as(alias); + }; + } + + var asMilliseconds = makeAs('ms'); + var asSeconds = makeAs('s'); + var asMinutes = makeAs('m'); + var asHours = makeAs('h'); + var asDays = makeAs('d'); + var asWeeks = makeAs('w'); + var asMonths = makeAs('M'); + var asYears = makeAs('y'); + + function clone$1() { + return createDuration(this); + } + + function get$2(units) { + units = normalizeUnits(units); + return this.isValid() ? this[units + 's']() : NaN; + } + + function makeGetter(name) { + return function () { + return this.isValid() ? this._data[name] : NaN; + }; + } + + var milliseconds = makeGetter('milliseconds'); + var seconds = makeGetter('seconds'); + var minutes = makeGetter('minutes'); + var hours = makeGetter('hours'); + var days = makeGetter('days'); + var months = makeGetter('months'); + var years = makeGetter('years'); + + function weeks() { + return absFloor(this.days() / 7); + } + + var round = Math.round; + var thresholds = { + ss: 44, // a few seconds to seconds + s: 45, // seconds to minute + m: 45, // minutes to hour + h: 22, // hours to day + d: 26, // days to month + M: 11 // months to year + }; + + // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize + function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { + return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); + } + + function relativeTime$1(posNegDuration, withoutSuffix, locale) { + var duration = createDuration(posNegDuration).abs(); + var seconds = round(duration.as('s')); + var minutes = round(duration.as('m')); + var hours = round(duration.as('h')); + var days = round(duration.as('d')); + var months = round(duration.as('M')); + var years = round(duration.as('y')); + + var a = seconds <= thresholds.ss && ['s', seconds] || seconds < thresholds.s && ['ss', seconds] || minutes <= 1 && ['m'] || minutes < thresholds.m && ['mm', minutes] || hours <= 1 && ['h'] || hours < thresholds.h && ['hh', hours] || days <= 1 && ['d'] || days < thresholds.d && ['dd', days] || months <= 1 && ['M'] || months < thresholds.M && ['MM', months] || years <= 1 && ['y'] || ['yy', years]; + + a[2] = withoutSuffix; + a[3] = +posNegDuration > 0; + a[4] = locale; + return substituteTimeAgo.apply(null, a); + } + + // This function allows you to set the rounding function for relative time strings + function getSetRelativeTimeRounding(roundingFunction) { + if (roundingFunction === undefined) { + return round; + } + if (typeof roundingFunction === 'function') { + round = roundingFunction; + return true; + } + return false; + } + + // This function allows you to set a threshold for relative time strings + function getSetRelativeTimeThreshold(threshold, limit) { + if (thresholds[threshold] === undefined) { + return false; + } + if (limit === undefined) { + return thresholds[threshold]; + } + thresholds[threshold] = limit; + if (threshold === 's') { + thresholds.ss = limit - 1; + } + return true; + } + + function humanize(withSuffix) { + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + + var locale = this.localeData(); + var output = relativeTime$1(this, !withSuffix, locale); + + if (withSuffix) { + output = locale.pastFuture(+this, output); + } + + return locale.postformat(output); + } + + var abs$1 = Math.abs; + + function sign(x) { + return (x > 0) - (x < 0) || +x; + } + + function toISOString$1() { + // for ISO strings we do not use the normal bubbling rules: + // * milliseconds bubble up until they become hours + // * days do not bubble at all + // * months bubble up until they become years + // This is because there is no context-free conversion between hours and days + // (think of clock changes) + // and also not between days and months (28-31 days per month) + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + + var seconds = abs$1(this._milliseconds) / 1000; + var days = abs$1(this._days); + var months = abs$1(this._months); + var minutes, hours, years; + + // 3600 seconds -> 60 minutes -> 1 hour + minutes = absFloor(seconds / 60); + hours = absFloor(minutes / 60); + seconds %= 60; + minutes %= 60; + + // 12 months -> 1 year + years = absFloor(months / 12); + months %= 12; + + // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js + var Y = years; + var M = months; + var D = days; + var h = hours; + var m = minutes; + var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; + var total = this.asSeconds(); + + if (!total) { + // this is the same as C#'s (Noda) and python (isodate)... + // but not other JS (goog.date) + return 'P0D'; + } + + var totalSign = total < 0 ? '-' : ''; + var ymSign = sign(this._months) !== sign(total) ? '-' : ''; + var daysSign = sign(this._days) !== sign(total) ? '-' : ''; + var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; + + return totalSign + 'P' + (Y ? ymSign + Y + 'Y' : '') + (M ? ymSign + M + 'M' : '') + (D ? daysSign + D + 'D' : '') + (h || m || s ? 'T' : '') + (h ? hmsSign + h + 'H' : '') + (m ? hmsSign + m + 'M' : '') + (s ? hmsSign + s + 'S' : ''); + } + + var proto$2 = Duration.prototype; + + proto$2.isValid = isValid$1; + proto$2.abs = abs; + proto$2.add = add$1; + proto$2.subtract = subtract$1; + proto$2.as = as; + proto$2.asMilliseconds = asMilliseconds; + proto$2.asSeconds = asSeconds; + proto$2.asMinutes = asMinutes; + proto$2.asHours = asHours; + proto$2.asDays = asDays; + proto$2.asWeeks = asWeeks; + proto$2.asMonths = asMonths; + proto$2.asYears = asYears; + proto$2.valueOf = valueOf$1; + proto$2._bubble = bubble; + proto$2.clone = clone$1; + proto$2.get = get$2; + proto$2.milliseconds = milliseconds; + proto$2.seconds = seconds; + proto$2.minutes = minutes; + proto$2.hours = hours; + proto$2.days = days; + proto$2.weeks = weeks; + proto$2.months = months; + proto$2.years = years; + proto$2.humanize = humanize; + proto$2.toISOString = toISOString$1; + proto$2.toString = toISOString$1; + proto$2.toJSON = toISOString$1; + proto$2.locale = locale; + proto$2.localeData = localeData; + + // Deprecations + proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1); + proto$2.lang = lang; + + // Side effect imports + + // FORMATTING + + addFormatToken('X', 0, 0, 'unix'); + addFormatToken('x', 0, 0, 'valueOf'); + + // PARSING + + addRegexToken('x', matchSigned); + addRegexToken('X', matchTimestamp); + addParseToken('X', function (input, array, config) { + config._d = new Date(parseFloat(input, 10) * 1000); + }); + addParseToken('x', function (input, array, config) { + config._d = new Date(toInt(input)); + }); + + // Side effect imports + + + hooks.version = '2.19.1'; + + setHookCallback(createLocal); + + hooks.fn = proto; + hooks.min = min; + hooks.max = max; + hooks.now = now; + hooks.utc = createUTC; + hooks.unix = createUnix; + hooks.months = listMonths; + hooks.isDate = isDate; + hooks.locale = getSetGlobalLocale; + hooks.invalid = createInvalid; + hooks.duration = createDuration; + hooks.isMoment = isMoment; + hooks.weekdays = listWeekdays; + hooks.parseZone = createInZone; + hooks.localeData = getLocale; + hooks.isDuration = isDuration; + hooks.monthsShort = listMonthsShort; + hooks.weekdaysMin = listWeekdaysMin; + hooks.defineLocale = defineLocale; + hooks.updateLocale = updateLocale; + hooks.locales = listLocales; + hooks.weekdaysShort = listWeekdaysShort; + hooks.normalizeUnits = normalizeUnits; + hooks.relativeTimeRounding = getSetRelativeTimeRounding; + hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; + hooks.calendarFormat = getCalendarFormat; + hooks.prototype = proto; + + return hooks; +}); +}); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; +} : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; +}; + +function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + }return arr2; + } else { + return Array.from(arr); + } +} + +var vueMoment = { + install: function install(Vue, options) { + var moment$$1 = options && options.moment ? options.moment : moment; + + Object.defineProperties(Vue.prototype, { + $moment: { + get: function get() { + return moment$$1; + } + } + }); + + Vue.moment = moment$$1; + + Vue.filter('moment', function () { + var arguments$1 = arguments; + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments$1[_key]; + } + + args = Array.prototype.slice.call(args); + var input = args.shift(); + var date = void 0; + + if (Array.isArray(input) && typeof input[0] === 'string') { + // If input is array, assume we're being passed a format pattern to parse against. + // Format pattern will accept an array of potential formats to parse against. + // Date string should be at [0], format pattern(s) should be at [1] + date = moment$$1(input[0], input[1], true); + } else if (typeof input === 'number') { + if (input.toString().length < 12) { + // If input is an integer with fewer than 12 digits, assume Unix seconds... + date = moment$$1.unix(input); + } else { + // ..otherwise, assume milliseconds. + date = moment$$1(input); + } + } else { + // Otherwise, throw the input at moment and see what happens... + date = moment$$1(input); + } + + if (!input || !date.isValid()) { + // Log a warning if moment couldn't reconcile the input. Better than throwing an error? + console.warn('Could not build a valid `moment` object from input.'); + return input; + } + + function parse() { + var arguments$1 = arguments; + + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments$1[_key2]; + } + + args = Array.prototype.slice.call(args); + var method = args.shift(); + + switch (method) { + case 'add': + { + /* + * Mutates the original moment by adding time. + * http://momentjs.com/docs/#/manipulating/add/ + */ + + var addends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var obj = {}; + + for (var n = 0; n < addends.length; n++) { + var addend = addends[n].split(' '); + obj[addend[1]] = addend[0]; + } + date.add(obj); + break; + } + + case 'subtract': + { + /* + * Mutates the original moment by subtracting time. + * http://momentjs.com/docs/#/manipulating/subtract/ + */ + + var subtrahends = args.shift().split(',').map(Function.prototype.call, String.prototype.trim); + var _obj = {}; + + for (var _n = 0; _n < subtrahends.length; _n++) { + var subtrahend = subtrahends[_n].split(' '); + _obj[subtrahend[1]] = subtrahend[0]; + } + date.subtract(_obj); + break; + } + + case 'from': + { + /* + * Display a moment in relative time, either from now or from a specified date. + * http://momentjs.com/docs/#/displaying/fromnow/ + */ + + var from = 'now'; + var removeSuffix = false; + + if (args[0] === 'now') { args.shift(); } + // If valid, assume it is a date we want the output computed against. + if (moment$$1(args[0]).isValid()) { from = moment$$1(args.shift()); } + + if (args[0] === true) { + args.shift(); + removeSuffix = true; + } + + if (from !== 'now') { + date = date.from(from, removeSuffix); + } else { + date = date.fromNow(removeSuffix); + } + break; + } + + case 'diff': + { + /* + * Mutates the original moment by doing a difference with another date. + * http://momentjs.com/docs/#/displaying/difference/ + */ + + var referenceTime = moment$$1(); + var units = ''; + var float = false; + + if (moment$$1(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + referenceTime = moment$$1(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (args[0]) { units = args.shift(); } + + if (args[0] === true) { float = args.shift(); } + + date = date.diff(referenceTime, units, float); + break; + } + + case 'calendar': + { + /* + * Formats a date with different strings depending on how close + * to a certain date (today by default) the date is. + * http://momentjs.com/docs/#/displaying/calendar-time/ + */ + + var _referenceTime = moment$$1(); + var formats = {}; + + if (moment$$1(args[0]).isValid()) { + // If valid, assume it is a date we want the output computed against. + _referenceTime = moment$$1(args.shift()); + } else if (args[0] === null || args[0] === 'now') { + // If null or 'now', remove argument and proceed with default referenceTime. + args.shift(); + } + + if (_typeof(args[0]) === 'object') { formats = args.shift(); } + + date = date.calendar(_referenceTime, formats); + break; + } + + case 'utc': + { + /* + * Mutates the original moment by converting to UTC + * https://momentjs.com/docs/#/manipulating/utc/ + */ + date.utc(); + break; + } + + case 'timezone': + { + /* + * Mutates the original moment by converting to a new timezone. + * https://momentjs.com/timezone/docs/#/using-timezones/converting-to-zone/ + */ + date.tz(args.shift()); + break; + } + + default: + { + /* + * Formats a date by taking a string of tokens and replacing + * them with their corresponding values. + * http://momentjs.com/docs/#/displaying/format/ + */ + + var format = method; + date = date.format(format); + } + } + + if (args.length) { parse.apply(parse, args); } + } + + parse.apply(parse, args); + + return date; + }); + + Vue.filter('duration', function () { + var arguments$1 = arguments; + + for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments$1[_key3]; + } + + /* + * Basic pass-through filter for leveraging moment.js's ability + * to manipulate and display durations. + * https://momentjs.com/docs/#/durations/ + */ + args = Array.prototype.slice.call(args); + var input = args.shift(); + var method = args.shift(); + + function createDuration(time) { + if (!Array.isArray(time)) { time = [time]; } + var result = moment$$1.duration.apply(moment$$1, _toConsumableArray(time)); + if (!result.isValid()) { console.warn('Could not build a valid `duration` object from input.'); } + return result; + } + var duration = createDuration(input); + + if (method === 'add' || method === 'subtract') { + // Generates a duration object and either adds or subtracts it + // from our original duration. + var durationChange = createDuration(args); + duration[method](durationChange); + } else if (duration && duration[method]) { + var _duration; + + // This gives a full proxy to moment.duration functions. + duration = (_duration = duration)[method].apply(_duration, _toConsumableArray(args)); + } + + return duration; + }); + } +}; + +var vueMoment_1 = vueMoment.install; + +exports['default'] = vueMoment; +exports.install = vueMoment_1; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}))); diff --git a/dist/vue-moment.min.js b/dist/vue-moment.min.js new file mode 100644 index 0000000..a34d50c --- /dev/null +++ b/dist/vue-moment.min.js @@ -0,0 +1,2 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e(t.vueMoment={})}(this,function(t){"use strict";var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function n(){throw new Error("Dynamic requires are not currently supported by rollup-plugin-commonjs")}var i,s=(function(t,i){var s,r,a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t};s=e,r=function(){var e,i;function s(){return e.apply(null,arguments)}function r(t){return t instanceof Array||"[object Array]"===Object.prototype.toString.call(t)}function o(t){return null!=t&&"[object Object]"===Object.prototype.toString.call(t)}function u(t){return void 0===t}function l(t){return"number"==typeof t||"[object Number]"===Object.prototype.toString.call(t)}function d(t){return t instanceof Date||"[object Date]"===Object.prototype.toString.call(t)}function h(t,e){var n,i=[];for(n=0;n>>0,i=0;i0)for(n=0;n=0?n?"+":"":"-")+Math.pow(10,Math.max(0,s)).toString().substr(1)+i}var A=/(\[[^\[]*\])|(\\)?([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,j=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,E={},I={};function z(t,e,n,i){var s=i;"string"==typeof i&&(s=function(){return this[i]()}),t&&(I[t]=s),e&&(I[e[0]]=function(){return G(s.apply(this,arguments),e[1],e[2])}),n&&(I[n]=function(){return this.localeData().ordinal(s.apply(this,arguments),t)})}function Z(t,e){return t.isValid()?(e=$(e,t.localeData()),E[e]=E[e]||function(t){var e,n,i,s=t.match(A);for(e=0,n=s.length;e=0&&j.test(t);)t=t.replace(j,i),j.lastIndex=0,n-=1;return t}var q=/\d/,J=/\d\d/,B=/\d{3}/,Q=/\d{4}/,X=/[+-]?\d{6}/,K=/\d\d?/,tt=/\d\d\d\d?/,et=/\d\d\d\d\d\d?/,nt=/\d{1,3}/,it=/\d{1,4}/,st=/[+-]?\d{1,6}/,rt=/\d+/,at=/[+-]?\d+/,ot=/Z|[+-]\d\d:?\d\d/gi,ut=/Z|[+-]\d\d(?::?\d\d)?/gi,lt=/[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,dt={};function ht(t,e,n){dt[t]=W(e)?e:function(t,i){return t&&n?n:e}}function ct(t,e){return c(dt,t)?dt[t](e._strict,e._locale):new RegExp(ft(t.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(t,e,n,i,s){return e||n||i||s})))}function ft(t){return t.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}var mt={};function _t(t,e){var n,i=e;for("string"==typeof t&&(t=[t]),l(e)&&(i=function(t,n){n[e]=D(t)}),n=0;n68?1900:2e3)};var Tt,Pt=Wt("FullYear",!0);function Wt(t,e){return function(n){return null!=n?(Ct(this,t,n),s.updateOffset(this,e),this):Rt(this,t)}}function Rt(t,e){return t.isValid()?t._d["get"+(t._isUTC?"UTC":"")+e]():NaN}function Ct(t,e,n){t.isValid()&&!isNaN(n)&&("FullYear"===e&&xt(t.year())?t._d["set"+(t._isUTC?"UTC":"")+e](n,t.month(),Ft(n,t.month())):t._d["set"+(t._isUTC?"UTC":"")+e](n))}function Ft(t,e){if(isNaN(t)||isNaN(e))return NaN;var n,i=(e%(n=12)+n)%n;return t+=(e-i)/12,1===i?xt(t)?29:28:31-i%7%2}Tt=Array.prototype.indexOf?Array.prototype.indexOf:function(t){var e;for(e=0;e=0&&isFinite(e.getUTCFullYear())&&e.setUTCFullYear(t),e}function It(t,e,n){var i=7+e-n;return-((7+Et(t,0,i).getUTCDay()-e)%7)+i-1}function zt(t,e,n,i,s){var r,a,o=1+7*(e-1)+(7+n-i)%7+It(t,i,s);return o<=0?a=Ot(r=t-1)+o:o>Ot(t)?(r=t+1,a=o-Ot(t)):(r=t,a=o),{year:r,dayOfYear:a}}function Zt(t,e,n){var i,s,r=It(t.year(),e,n),a=Math.floor((t.dayOfYear()-r-1)/7)+1;return a<1?i=a+$t(s=t.year()-1,e,n):a>$t(t.year(),e,n)?(i=a-$t(t.year(),e,n),s=t.year()+1):(s=t.year(),i=a),{week:i,year:s}}function $t(t,e,n){var i=It(t,e,n),s=It(t+1,e,n);return(Ot(t)-i+s)/7}z("w",["ww",2],"wo","week"),z("W",["WW",2],"Wo","isoWeek"),U("week","w"),U("isoWeek","W"),L("week",5),L("isoWeek",5),ht("w",K),ht("ww",K,J),ht("W",K),ht("WW",K,J),yt(["w","ww","W","WW"],function(t,e,n,i){e[i.substr(0,1)]=D(t)});z("d",0,"do","day"),z("dd",0,0,function(t){return this.localeData().weekdaysMin(this,t)}),z("ddd",0,0,function(t){return this.localeData().weekdaysShort(this,t)}),z("dddd",0,0,function(t){return this.localeData().weekdays(this,t)}),z("e",0,0,"weekday"),z("E",0,0,"isoWeekday"),U("day","d"),U("weekday","e"),U("isoWeekday","E"),L("day",11),L("weekday",11),L("isoWeekday",11),ht("d",K),ht("e",K),ht("E",K),ht("dd",function(t,e){return e.weekdaysMinRegex(t)}),ht("ddd",function(t,e){return e.weekdaysShortRegex(t)}),ht("dddd",function(t,e){return e.weekdaysRegex(t)}),yt(["dd","ddd","dddd"],function(t,e,n,i){var s=n._locale.weekdaysParse(t,i,n._strict);null!=s?e.d=s:_(n).invalidWeekday=t}),yt(["d","e","E"],function(t,e,n,i){e[i]=D(t)});var qt="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_");var Jt="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_");var Bt="Su_Mo_Tu_We_Th_Fr_Sa".split("_");var Qt=lt;var Xt=lt;var Kt=lt;function te(){function t(t,e){return e.length-t.length}var e,n,i,s,r,a=[],o=[],u=[],l=[];for(e=0;e<7;e++)n=m([2e3,1]).day(e),i=this.weekdaysMin(n,""),s=this.weekdaysShort(n,""),r=this.weekdays(n,""),a.push(i),o.push(s),u.push(r),l.push(i),l.push(s),l.push(r);for(a.sort(t),o.sort(t),u.sort(t),l.sort(t),e=0;e<7;e++)o[e]=ft(o[e]),u[e]=ft(u[e]),l[e]=ft(l[e]);this._weekdaysRegex=new RegExp("^("+l.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+o.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+a.join("|")+")","i")}function ee(){return this.hours()%12||12}function ne(t,e){z(t,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),e)})}function ie(t,e){return e._meridiemParse}z("H",["HH",2],0,"hour"),z("h",["hh",2],0,ee),z("k",["kk",2],0,function(){return this.hours()||24}),z("hmm",0,0,function(){return""+ee.apply(this)+G(this.minutes(),2)}),z("hmmss",0,0,function(){return""+ee.apply(this)+G(this.minutes(),2)+G(this.seconds(),2)}),z("Hmm",0,0,function(){return""+this.hours()+G(this.minutes(),2)}),z("Hmmss",0,0,function(){return""+this.hours()+G(this.minutes(),2)+G(this.seconds(),2)}),ne("a",!0),ne("A",!1),U("hour","h"),L("hour",13),ht("a",ie),ht("A",ie),ht("H",K),ht("h",K),ht("k",K),ht("HH",K,J),ht("hh",K,J),ht("kk",K,J),ht("hmm",tt),ht("hmmss",et),ht("Hmm",tt),ht("Hmmss",et),_t(["H","HH"],St),_t(["k","kk"],function(t,e,n){var i=D(t);e[St]=24===i?0:i}),_t(["a","A"],function(t,e,n){n._isPm=n._locale.isPM(t),n._meridiem=t}),_t(["h","hh"],function(t,e,n){e[St]=D(t),_(n).bigHour=!0}),_t("hmm",function(t,e,n){var i=t.length-2;e[St]=D(t.substr(0,i)),e[kt]=D(t.substr(i)),_(n).bigHour=!0}),_t("hmmss",function(t,e,n){var i=t.length-4,s=t.length-2;e[St]=D(t.substr(0,i)),e[kt]=D(t.substr(i,2)),e[Mt]=D(t.substr(s)),_(n).bigHour=!0}),_t("Hmm",function(t,e,n){var i=t.length-2;e[St]=D(t.substr(0,i)),e[kt]=D(t.substr(i))}),_t("Hmmss",function(t,e,n){var i=t.length-4,s=t.length-2;e[St]=D(t.substr(0,i)),e[kt]=D(t.substr(i,2)),e[Mt]=D(t.substr(s))});var se,re=Wt("Hours",!0),ae={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:Nt,monthsShort:Vt,week:{dow:0,doy:6},weekdays:qt,weekdaysMin:Bt,weekdaysShort:Jt,meridiemParse:/[ap]\.?m?\.?/i},oe={},ue={};function le(t){return t?t.toLowerCase().replace("_","-"):t}function de(e){var i=null;if(!oe[e]&&t&&t.exports)try{i=se._abbr,n("./locale/"+e),he(i)}catch(t){}return oe[e]}function he(t,e){var n;return t&&(n=u(e)?fe(t):ce(t,e))&&(se=n),se._abbr}function ce(t,e){if(null!==e){var n=ae;if(e.abbr=t,null!=oe[t])P("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=oe[t]._config;else if(null!=e.parentLocale){if(null==oe[e.parentLocale])return ue[e.parentLocale]||(ue[e.parentLocale]=[]),ue[e.parentLocale].push({name:t,config:e}),null;n=oe[e.parentLocale]._config}return oe[t]=new C(R(n,e)),ue[t]&&ue[t].forEach(function(t){ce(t.name,t.config)}),he(t),oe[t]}return delete oe[t],null}function fe(t){var e;if(t&&t._locale&&t._locale._abbr&&(t=t._locale._abbr),!t)return se;if(!r(t)){if(e=de(t))return e;t=[t]}return function(t){for(var e,n,i,s,r=0;r0;){if(i=de(s.slice(0,e).join("-")))return i;if(n&&n.length>=e&&Y(s,n,!0)>=e-1)break;e--}r++}return null}(t)}function me(t){var e,n=t._a;return n&&-2===_(t).overflow&&(e=n[vt]<0||n[vt]>11?vt:n[wt]<1||n[wt]>Ft(n[pt],n[vt])?wt:n[St]<0||n[St]>24||24===n[St]&&(0!==n[kt]||0!==n[Mt]||0!==n[Dt])?St:n[kt]<0||n[kt]>59?kt:n[Mt]<0||n[Mt]>59?Mt:n[Dt]<0||n[Dt]>999?Dt:-1,_(t)._overflowDayOfYear&&(ewt)&&(e=wt),_(t)._overflowWeeks&&-1===e&&(e=Yt),_(t)._overflowWeekday&&-1===e&&(e=bt),_(t).overflow=e),t}function _e(t,e,n){return null!=t?t:null!=e?e:n}function ye(t){var e,n,i,r,a=[];if(!t._d){for(i=function(t){var e=new Date(s.now());return t._useUTC?[e.getUTCFullYear(),e.getUTCMonth(),e.getUTCDate()]:[e.getFullYear(),e.getMonth(),e.getDate()]}(t),t._w&&null==t._a[wt]&&null==t._a[vt]&&function(t){var e,n,i,s,r,a,o,u;if(null!=(e=t._w).GG||null!=e.W||null!=e.E)r=1,a=4,n=_e(e.GG,t._a[pt],Zt(We(),1,4).year),i=_e(e.W,1),((s=_e(e.E,1))<1||s>7)&&(u=!0);else{r=t._locale._week.dow,a=t._locale._week.doy;var l=Zt(We(),r,a);n=_e(e.gg,t._a[pt],l.year),i=_e(e.w,l.week),null!=e.d?((s=e.d)<0||s>6)&&(u=!0):null!=e.e?(s=e.e+r,(e.e<0||e.e>6)&&(u=!0)):s=r}i<1||i>$t(n,r,a)?_(t)._overflowWeeks=!0:null!=u?_(t)._overflowWeekday=!0:(o=zt(n,i,s,r,a),t._a[pt]=o.year,t._dayOfYear=o.dayOfYear)}(t),null!=t._dayOfYear&&(r=_e(t._a[pt],i[pt]),(t._dayOfYear>Ot(r)||0===t._dayOfYear)&&(_(t)._overflowDayOfYear=!0),n=Et(r,0,t._dayOfYear),t._a[vt]=n.getUTCMonth(),t._a[wt]=n.getUTCDate()),e=0;e<3&&null==t._a[e];++e)t._a[e]=a[e]=i[e];for(;e<7;e++)t._a[e]=a[e]=null==t._a[e]?2===e?1:0:t._a[e];24===t._a[St]&&0===t._a[kt]&&0===t._a[Mt]&&0===t._a[Dt]&&(t._nextDay=!0,t._a[St]=0),t._d=(t._useUTC?Et:function(t,e,n,i,s,r,a){var o=new Date(t,e,n,i,s,r,a);return t<100&&t>=0&&isFinite(o.getFullYear())&&o.setFullYear(t),o}).apply(null,a),null!=t._tzm&&t._d.setUTCMinutes(t._d.getUTCMinutes()-t._tzm),t._nextDay&&(t._a[St]=24),t._w&&void 0!==t._w.d&&t._w.d!==t._d.getDay()&&(_(t).weekdayMismatch=!0)}}var ge=/^\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)?)?$/,pe=/^\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)?)?$/,ve=/Z|[+-]\d\d(?::?\d\d)?/,we=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],Se=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],ke=/^\/?Date\((\-?\d+)/i;function Me(t){var e,n,i,s,r,a,o=t._i,u=ge.exec(o)||pe.exec(o);if(u){for(_(t).iso=!0,e=0,n=we.length;e0&&_(t).unusedInput.push(a),o=o.slice(o.indexOf(n)+n.length),l+=n.length),I[r]?(n?_(t).empty=!1:_(t).unusedTokens.push(r),gt(r,n,t)):t._strict&&!n&&_(t).unusedTokens.push(r);_(t).charsLeftOver=u-l,o.length>0&&_(t).unusedInput.push(o),t._a[St]<=12&&!0===_(t).bigHour&&t._a[St]>0&&(_(t).bigHour=void 0),_(t).parsedDateParts=t._a.slice(0),_(t).meridiem=t._meridiem,t._a[St]=function(t,e,n){var i;if(null==n)return e;return null!=t.meridiemHour?t.meridiemHour(e,n):null!=t.isPM?((i=t.isPM(n))&&e<12&&(e+=12),i||12!==e||(e=0),e):e}(t._locale,t._a[St],t._meridiem),ye(t),me(t)}else Oe(t);else Me(t)}function Te(t){var e=t._i,n=t._f;return t._locale=t._locale||fe(t._l),null===e||void 0===n&&""===e?g({nullInput:!0}):("string"==typeof e&&(t._i=e=t._locale.preparse(e)),k(e)?new S(me(e)):(d(e)?t._d=e:r(n)?function(t){var e,n,i,s,r;if(0===t._f.length)return _(t).invalidFormat=!0,void(t._d=new Date(NaN));for(s=0;sthis?this:t:g()});function Fe(t,e){var n,i;if(1===e.length&&r(e[0])&&(e=e[0]),!e.length)return We();for(n=e[0],i=1;i(r=$t(t,i,s))&&(e=r),function(t,e,n,i,s){var r=zt(t,e,n,i,s),a=Et(r.year,0,r.dayOfYear);return this.year(a.getUTCFullYear()),this.month(a.getUTCMonth()),this.date(a.getUTCDate()),this}.call(this,t,e,n,i,s))}z(0,["gg",2],0,function(){return this.weekYear()%100}),z(0,["GG",2],0,function(){return this.isoWeekYear()%100}),rn("gggg","weekYear"),rn("ggggg","weekYear"),rn("GGGG","isoWeekYear"),rn("GGGGG","isoWeekYear"),U("weekYear","gg"),U("isoWeekYear","GG"),L("weekYear",1),L("isoWeekYear",1),ht("G",at),ht("g",at),ht("GG",K,J),ht("gg",K,J),ht("GGGG",it,Q),ht("gggg",it,Q),ht("GGGGG",st,X),ht("ggggg",st,X),yt(["gggg","ggggg","GGGG","GGGGG"],function(t,e,n,i){e[i.substr(0,2)]=D(t)}),yt(["gg","GG"],function(t,e,n,i){e[i]=s.parseTwoDigitYear(t)}),z("Q",0,"Qo","quarter"),U("quarter","Q"),L("quarter",7),ht("Q",q),_t("Q",function(t,e){e[vt]=3*(D(t)-1)}),z("D",["DD",2],"Do","date"),U("date","D"),L("date",9),ht("D",K),ht("DD",K,J),ht("Do",function(t,e){return t?e._dayOfMonthOrdinalParse||e._ordinalParse:e._dayOfMonthOrdinalParseLenient}),_t(["D","DD"],wt),_t("Do",function(t,e){e[wt]=D(t.match(K)[0])});var on=Wt("Date",!0);z("DDD",["DDDD",3],"DDDo","dayOfYear"),U("dayOfYear","DDD"),L("dayOfYear",4),ht("DDD",nt),ht("DDDD",B),_t(["DDD","DDDD"],function(t,e,n){n._dayOfYear=D(t)}),z("m",["mm",2],0,"minute"),U("minute","m"),L("minute",14),ht("m",K),ht("mm",K,J),_t(["m","mm"],kt);var un=Wt("Minutes",!1);z("s",["ss",2],0,"second"),U("second","s"),L("second",15),ht("s",K),ht("ss",K,J),_t(["s","ss"],Mt);var ln,dn=Wt("Seconds",!1);for(z("S",0,0,function(){return~~(this.millisecond()/100)}),z(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),z(0,["SSS",3],0,"millisecond"),z(0,["SSSS",4],0,function(){return 10*this.millisecond()}),z(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),z(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),z(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),z(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),z(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),U("millisecond","ms"),L("millisecond",16),ht("S",nt,q),ht("SS",nt,J),ht("SSS",nt,B),ln="SSSS";ln.length<=9;ln+="S")ht(ln,rt);function hn(t,e){e[Dt]=D(1e3*("0."+t))}for(ln="S";ln.length<=9;ln+="S")_t(ln,hn);var cn=Wt("Milliseconds",!1);z("z",0,0,"zoneAbbr"),z("zz",0,0,"zoneName");var fn=S.prototype;function mn(t){return t}fn.add=Xe,fn.calendar=function(t,e){var n=t||We(),i=je(n,this).startOf("day"),r=s.calendarFormat(this,i)||"sameElse",a=e&&(W(e[r])?e[r].call(this,n):e[r]);return this.format(a||this.localeData().calendar(r,this,We(n)))},fn.clone=function(){return new S(this)},fn.diff=function(t,e,n){var i,s,r;if(!this.isValid())return NaN;if(!(i=je(t,this)).isValid())return NaN;switch(s=6e4*(i.utcOffset()-this.utcOffset()),e=N(e)){case"year":r=tn(this,i)/12;break;case"month":r=tn(this,i);break;case"quarter":r=tn(this,i)/3;break;case"second":r=(this-i)/1e3;break;case"minute":r=(this-i)/6e4;break;case"hour":r=(this-i)/36e5;break;case"day":r=(this-i-s)/864e5;break;case"week":r=(this-i-s)/6048e5;break;default:r=this-i}return n?r:M(r)},fn.endOf=function(t){return void 0===(t=N(t))||"millisecond"===t?this:("date"===t&&(t="day"),this.startOf(t).add(1,"isoWeek"===t?"week":t).subtract(1,"ms"))},fn.format=function(t){t||(t=this.isUtc()?s.defaultFormatUtc:s.defaultFormat);var e=Z(this,t);return this.localeData().postformat(e)},fn.from=function(t,e){return this.isValid()&&(k(t)&&t.isValid()||We(t).isValid())?$e({to:this,from:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},fn.fromNow=function(t){return this.from(We(),t)},fn.to=function(t,e){return this.isValid()&&(k(t)&&t.isValid()||We(t).isValid())?$e({from:this,to:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},fn.toNow=function(t){return this.to(We(),t)},fn.get=function(t){return W(this[t=N(t)])?this[t]():this},fn.invalidAt=function(){return _(this).overflow},fn.isAfter=function(t,e){var n=k(t)?t:We(t);return!(!this.isValid()||!n.isValid())&&("millisecond"===(e=N(u(e)?"millisecond":e))?this.valueOf()>n.valueOf():n.valueOf()9999?Z(t,"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]"):W(Date.prototype.toISOString)?this.toDate().toISOString():Z(t,"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]")},fn.inspect=function(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var t="moment",e="";this.isLocal()||(t=0===this.utcOffset()?"moment.utc":"moment.parseZone",e="Z");var n="["+t+'("]',i=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",s=e+'[")]';return this.format(n+i+"-MM-DD[T]HH:mm:ss.SSS"+s)},fn.toJSON=function(){return this.isValid()?this.toISOString():null},fn.toString=function(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},fn.unix=function(){return Math.floor(this.valueOf()/1e3)},fn.valueOf=function(){return this._d.valueOf()-6e4*(this._offset||0)},fn.creationData=function(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}},fn.year=Pt,fn.isLeapYear=function(){return xt(this.year())},fn.weekYear=function(t){return an.call(this,t,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)},fn.isoWeekYear=function(t){return an.call(this,t,this.isoWeek(),this.isoWeekday(),1,4)},fn.quarter=fn.quarters=function(t){return null==t?Math.ceil((this.month()+1)/3):this.month(3*(t-1)+this.month()%3)},fn.month=Lt,fn.daysInMonth=function(){return Ft(this.year(),this.month())},fn.week=fn.weeks=function(t){var e=this.localeData().week(this);return null==t?e:this.add(7*(t-e),"d")},fn.isoWeek=fn.isoWeeks=function(t){var e=Zt(this,1,4).week;return null==t?e:this.add(7*(t-e),"d")},fn.weeksInYear=function(){var t=this.localeData()._week;return $t(this.year(),t.dow,t.doy)},fn.isoWeeksInYear=function(){return $t(this.year(),1,4)},fn.date=on,fn.day=fn.days=function(t){if(!this.isValid())return null!=t?this:NaN;var e=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=t?(t=function(t,e){return"string"!=typeof t?t:isNaN(t)?"number"==typeof(t=e.weekdaysParse(t))?t:null:parseInt(t,10)}(t,this.localeData()),this.add(t-e,"d")):e},fn.weekday=function(t){if(!this.isValid())return null!=t?this:NaN;var e=(this.day()+7-this.localeData()._week.dow)%7;return null==t?e:this.add(t-e,"d")},fn.isoWeekday=function(t){if(!this.isValid())return null!=t?this:NaN;if(null!=t){var e=function(t,e){return"string"==typeof t?e.weekdaysParse(t)%7||7:isNaN(t)?null:t}(t,this.localeData());return this.day(this.day()%7?e:e-7)}return this.day()||7},fn.dayOfYear=function(t){var e=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==t?e:this.add(t-e,"d")},fn.hour=fn.hours=re,fn.minute=fn.minutes=un,fn.second=fn.seconds=dn,fn.millisecond=fn.milliseconds=cn,fn.utcOffset=function(t,e,n){var i,r=this._offset||0;if(!this.isValid())return null!=t?this:NaN;if(null!=t){if("string"==typeof t){if(null===(t=Ae(ut,t)))return this}else Math.abs(t)<16&&!n&&(t*=60);return!this._isUTC&&e&&(i=Ee(this)),this._offset=t,this._isUTC=!0,null!=i&&this.add(i,"m"),r!==t&&(!e||this._changeInProgress?Qe(this,$e(t-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,s.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:Ee(this)},fn.utc=function(t){return this.utcOffset(0,t)},fn.local=function(t){return this._isUTC&&(this.utcOffset(0,t),this._isUTC=!1,t&&this.subtract(Ee(this),"m")),this},fn.parseZone=function(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var t=Ae(ot,this._i);null!=t?this.utcOffset(t):this.utcOffset(0,!0)}return this},fn.hasAlignedHourOffset=function(t){return!!this.isValid()&&(t=t?We(t).utcOffset():0,(this.utcOffset()-t)%60==0)},fn.isDST=function(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},fn.isLocal=function(){return!!this.isValid()&&!this._isUTC},fn.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},fn.isUtc=Ie,fn.isUTC=Ie,fn.zoneAbbr=function(){return this._isUTC?"UTC":""},fn.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},fn.dates=O("dates accessor is deprecated. Use date instead.",on),fn.months=O("months accessor is deprecated. Use month instead",Lt),fn.years=O("years accessor is deprecated. Use year instead",Pt),fn.zone=O("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",function(t,e){return null!=t?("string"!=typeof t&&(t=-t),this.utcOffset(t,e),this):-this.utcOffset()}),fn.isDSTShifted=O("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",function(){if(!u(this._isDSTShifted))return this._isDSTShifted;var t={};if(v(t,this),(t=Te(t))._a){var e=t._isUTC?m(t._a):We(t._a);this._isDSTShifted=this.isValid()&&Y(t._a,e.toArray())>0}else this._isDSTShifted=!1;return this._isDSTShifted});var _n=C.prototype;function yn(t,e,n,i){var s=fe(),r=m().set(i,e);return s[n](r,t)}function gn(t,e,n){if(l(t)&&(e=t,t=void 0),t=t||"",null!=e)return yn(t,e,n,"month");var i,s=[];for(i=0;i<12;i++)s[i]=yn(t,i,n,"month");return s}function pn(t,e,n,i){"boolean"==typeof t?(l(e)&&(n=e,e=void 0),e=e||""):(n=e=t,t=!1,l(e)&&(n=e,e=void 0),e=e||"");var s,r=fe(),a=t?r._week.dow:0;if(null!=n)return yn(e,(n+a)%7,i,"day");var o=[];for(s=0;s<7;s++)o[s]=yn(e,(s+a)%7,i,"day");return o}_n.calendar=function(t,e,n){var i=this._calendar[t]||this._calendar.sameElse;return W(i)?i.call(e,n):i},_n.longDateFormat=function(t){var e=this._longDateFormat[t],n=this._longDateFormat[t.toUpperCase()];return e||!n?e:(this._longDateFormat[t]=n.replace(/MMMM|MM|DD|dddd/g,function(t){return t.slice(1)}),this._longDateFormat[t])},_n.invalidDate=function(){return this._invalidDate},_n.ordinal=function(t){return this._ordinal.replace("%d",t)},_n.preparse=mn,_n.postformat=mn,_n.relativeTime=function(t,e,n,i){var s=this._relativeTime[n];return W(s)?s(t,e,n,i):s.replace(/%d/i,t)},_n.pastFuture=function(t,e){var n=this._relativeTime[t>0?"future":"past"];return W(n)?n(e):n.replace(/%s/i,e)},_n.set=function(t){var e,n;for(n in t)W(e=t[n])?this[n]=e:this["_"+n]=e;this._config=t,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)},_n.months=function(t,e){return t?r(this._months)?this._months[t.month()]:this._months[(this._months.isFormat||Ut).test(e)?"format":"standalone"][t.month()]:r(this._months)?this._months:this._months.standalone},_n.monthsShort=function(t,e){return t?r(this._monthsShort)?this._monthsShort[t.month()]:this._monthsShort[Ut.test(e)?"format":"standalone"][t.month()]:r(this._monthsShort)?this._monthsShort:this._monthsShort.standalone},_n.monthsParse=function(t,e,n){var i,s,r;if(this._monthsParseExact)return function(t,e,n){var i,s,r,a=t.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],i=0;i<12;++i)r=m([2e3,i]),this._shortMonthsParse[i]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[i]=this.months(r,"").toLocaleLowerCase();return n?"MMM"===e?-1!==(s=Tt.call(this._shortMonthsParse,a))?s:null:-1!==(s=Tt.call(this._longMonthsParse,a))?s:null:"MMM"===e?-1!==(s=Tt.call(this._shortMonthsParse,a))?s:-1!==(s=Tt.call(this._longMonthsParse,a))?s:null:-1!==(s=Tt.call(this._longMonthsParse,a))?s:-1!==(s=Tt.call(this._shortMonthsParse,a))?s:null}.call(this,t,e,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),i=0;i<12;i++){if(s=m([2e3,i]),n&&!this._longMonthsParse[i]&&(this._longMonthsParse[i]=new RegExp("^"+this.months(s,"").replace(".","")+"$","i"),this._shortMonthsParse[i]=new RegExp("^"+this.monthsShort(s,"").replace(".","")+"$","i")),n||this._monthsParse[i]||(r="^"+this.months(s,"")+"|^"+this.monthsShort(s,""),this._monthsParse[i]=new RegExp(r.replace(".",""),"i")),n&&"MMMM"===e&&this._longMonthsParse[i].test(t))return i;if(n&&"MMM"===e&&this._shortMonthsParse[i].test(t))return i;if(!n&&this._monthsParse[i].test(t))return i}},_n.monthsRegex=function(t){return this._monthsParseExact?(c(this,"_monthsRegex")||jt.call(this),t?this._monthsStrictRegex:this._monthsRegex):(c(this,"_monthsRegex")||(this._monthsRegex=At),this._monthsStrictRegex&&t?this._monthsStrictRegex:this._monthsRegex)},_n.monthsShortRegex=function(t){return this._monthsParseExact?(c(this,"_monthsRegex")||jt.call(this),t?this._monthsShortStrictRegex:this._monthsShortRegex):(c(this,"_monthsShortRegex")||(this._monthsShortRegex=Gt),this._monthsShortStrictRegex&&t?this._monthsShortStrictRegex:this._monthsShortRegex)},_n.week=function(t){return Zt(t,this._week.dow,this._week.doy).week},_n.firstDayOfYear=function(){return this._week.doy},_n.firstDayOfWeek=function(){return this._week.dow},_n.weekdays=function(t,e){return t?r(this._weekdays)?this._weekdays[t.day()]:this._weekdays[this._weekdays.isFormat.test(e)?"format":"standalone"][t.day()]:r(this._weekdays)?this._weekdays:this._weekdays.standalone},_n.weekdaysMin=function(t){return t?this._weekdaysMin[t.day()]:this._weekdaysMin},_n.weekdaysShort=function(t){return t?this._weekdaysShort[t.day()]:this._weekdaysShort},_n.weekdaysParse=function(t,e,n){var i,s,r;if(this._weekdaysParseExact)return function(t,e,n){var i,s,r,a=t.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],i=0;i<7;++i)r=m([2e3,1]).day(i),this._minWeekdaysParse[i]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[i]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[i]=this.weekdays(r,"").toLocaleLowerCase();return n?"dddd"===e?-1!==(s=Tt.call(this._weekdaysParse,a))?s:null:"ddd"===e?-1!==(s=Tt.call(this._shortWeekdaysParse,a))?s:null:-1!==(s=Tt.call(this._minWeekdaysParse,a))?s:null:"dddd"===e?-1!==(s=Tt.call(this._weekdaysParse,a))?s:-1!==(s=Tt.call(this._shortWeekdaysParse,a))?s:-1!==(s=Tt.call(this._minWeekdaysParse,a))?s:null:"ddd"===e?-1!==(s=Tt.call(this._shortWeekdaysParse,a))?s:-1!==(s=Tt.call(this._weekdaysParse,a))?s:-1!==(s=Tt.call(this._minWeekdaysParse,a))?s:null:-1!==(s=Tt.call(this._minWeekdaysParse,a))?s:-1!==(s=Tt.call(this._weekdaysParse,a))?s:-1!==(s=Tt.call(this._shortWeekdaysParse,a))?s:null}.call(this,t,e,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),i=0;i<7;i++){if(s=m([2e3,1]).day(i),n&&!this._fullWeekdaysParse[i]&&(this._fullWeekdaysParse[i]=new RegExp("^"+this.weekdays(s,"").replace(".",".?")+"$","i"),this._shortWeekdaysParse[i]=new RegExp("^"+this.weekdaysShort(s,"").replace(".",".?")+"$","i"),this._minWeekdaysParse[i]=new RegExp("^"+this.weekdaysMin(s,"").replace(".",".?")+"$","i")),this._weekdaysParse[i]||(r="^"+this.weekdays(s,"")+"|^"+this.weekdaysShort(s,"")+"|^"+this.weekdaysMin(s,""),this._weekdaysParse[i]=new RegExp(r.replace(".",""),"i")),n&&"dddd"===e&&this._fullWeekdaysParse[i].test(t))return i;if(n&&"ddd"===e&&this._shortWeekdaysParse[i].test(t))return i;if(n&&"dd"===e&&this._minWeekdaysParse[i].test(t))return i;if(!n&&this._weekdaysParse[i].test(t))return i}},_n.weekdaysRegex=function(t){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||te.call(this),t?this._weekdaysStrictRegex:this._weekdaysRegex):(c(this,"_weekdaysRegex")||(this._weekdaysRegex=Qt),this._weekdaysStrictRegex&&t?this._weekdaysStrictRegex:this._weekdaysRegex)},_n.weekdaysShortRegex=function(t){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||te.call(this),t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(c(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=Xt),this._weekdaysShortStrictRegex&&t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)},_n.weekdaysMinRegex=function(t){return this._weekdaysParseExact?(c(this,"_weekdaysRegex")||te.call(this),t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(c(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=Kt),this._weekdaysMinStrictRegex&&t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)},_n.isPM=function(t){return"p"===(t+"").toLowerCase().charAt(0)},_n.meridiem=function(t,e,n){return t>11?n?"pm":"PM":n?"am":"AM"},he("en",{dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(t){var e=t%10;return t+(1===D(t%100/10)?"th":1===e?"st":2===e?"nd":3===e?"rd":"th")}}),s.lang=O("moment.lang is deprecated. Use moment.locale instead.",he),s.langData=O("moment.langData is deprecated. Use moment.localeData instead.",fe);var vn=Math.abs;function wn(t,e,n,i){var s=$e(e,n);return t._milliseconds+=i*s._milliseconds,t._days+=i*s._days,t._months+=i*s._months,t._bubble()}function Sn(t){return t<0?Math.floor(t):Math.ceil(t)}function kn(t){return 4800*t/146097}function Mn(t){return 146097*t/4800}function Dn(t){return function(){return this.as(t)}}var Yn=Dn("ms"),bn=Dn("s"),On=Dn("m"),xn=Dn("h"),Tn=Dn("d"),Pn=Dn("w"),Wn=Dn("M"),Rn=Dn("y");function Cn(t){return function(){return this.isValid()?this._data[t]:NaN}}var Fn=Cn("milliseconds"),Un=Cn("seconds"),Nn=Cn("minutes"),Vn=Cn("hours"),Hn=Cn("days"),Ln=Cn("months"),Gn=Cn("years");var An=Math.round,jn={ss:44,s:45,m:45,h:22,d:26,M:11};var En=Math.abs;function In(t){return(t>0)-(t<0)||+t}function zn(){if(!this.isValid())return this.localeData().invalidDate();var t,e,n=En(this._milliseconds)/1e3,i=En(this._days),s=En(this._months);e=M((t=M(n/60))/60),n%=60,t%=60;var r=M(s/12),a=s%=12,o=i,u=e,l=t,d=n?n.toFixed(3).replace(/\.?0+$/,""):"",h=this.asSeconds();if(!h)return"P0D";var c=h<0?"-":"",f=In(this._months)!==In(h)?"-":"",m=In(this._days)!==In(h)?"-":"",_=In(this._milliseconds)!==In(h)?"-":"";return c+"P"+(r?f+r+"Y":"")+(a?f+a+"M":"")+(o?m+o+"D":"")+(u||l||d?"T":"")+(u?_+u+"H":"")+(l?_+l+"M":"")+(d?_+d+"S":"")}var Zn=Ne.prototype;return Zn.isValid=function(){return this._isValid},Zn.abs=function(){var t=this._data;return this._milliseconds=vn(this._milliseconds),this._days=vn(this._days),this._months=vn(this._months),t.milliseconds=vn(t.milliseconds),t.seconds=vn(t.seconds),t.minutes=vn(t.minutes),t.hours=vn(t.hours),t.months=vn(t.months),t.years=vn(t.years),this},Zn.add=function(t,e){return wn(this,t,e,1)},Zn.subtract=function(t,e){return wn(this,t,e,-1)},Zn.as=function(t){if(!this.isValid())return NaN;var e,n,i=this._milliseconds;if("month"===(t=N(t))||"year"===t)return e=this._days+i/864e5,n=this._months+kn(e),"month"===t?n:n/12;switch(e=this._days+Math.round(Mn(this._months)),t){case"week":return e/7+i/6048e5;case"day":return e+i/864e5;case"hour":return 24*e+i/36e5;case"minute":return 1440*e+i/6e4;case"second":return 86400*e+i/1e3;case"millisecond":return Math.floor(864e5*e)+i;default:throw new Error("Unknown unit "+t)}},Zn.asMilliseconds=Yn,Zn.asSeconds=bn,Zn.asMinutes=On,Zn.asHours=xn,Zn.asDays=Tn,Zn.asWeeks=Pn,Zn.asMonths=Wn,Zn.asYears=Rn,Zn.valueOf=function(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*D(this._months/12):NaN},Zn._bubble=function(){var t,e,n,i,s,r=this._milliseconds,a=this._days,o=this._months,u=this._data;return r>=0&&a>=0&&o>=0||r<=0&&a<=0&&o<=0||(r+=864e5*Sn(Mn(o)+a),a=0,o=0),u.milliseconds=r%1e3,t=M(r/1e3),u.seconds=t%60,e=M(t/60),u.minutes=e%60,n=M(e/60),u.hours=n%24,o+=s=M(kn(a+=M(n/24))),a-=Sn(Mn(s)),i=M(o/12),o%=12,u.days=a,u.months=o,u.years=i,this},Zn.clone=function(){return $e(this)},Zn.get=function(t){return t=N(t),this.isValid()?this[t+"s"]():NaN},Zn.milliseconds=Fn,Zn.seconds=Un,Zn.minutes=Nn,Zn.hours=Vn,Zn.days=Hn,Zn.weeks=function(){return M(this.days()/7)},Zn.months=Ln,Zn.years=Gn,Zn.humanize=function(t){if(!this.isValid())return this.localeData().invalidDate();var e=this.localeData(),n=function(t,e,n){var i=$e(t).abs(),s=An(i.as("s")),r=An(i.as("m")),a=An(i.as("h")),o=An(i.as("d")),u=An(i.as("M")),l=An(i.as("y")),d=s<=jn.ss&&["s",s]||s0,d[4]=n,function(t,e,n,i,s){return s.relativeTime(e||1,!!n,t,i)}.apply(null,d)}(this,!t,e);return t&&(n=e.pastFuture(+this,n)),e.postformat(n)},Zn.toISOString=zn,Zn.toString=zn,Zn.toJSON=zn,Zn.locale=en,Zn.localeData=sn,Zn.toIsoString=O("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",zn),Zn.lang=nn,z("X",0,0,"unix"),z("x",0,0,"valueOf"),ht("x",at),ht("X",/[+-]?\d+(\.\d{1,3})?/),_t("X",function(t,e,n){n._d=new Date(1e3*parseFloat(t,10))}),_t("x",function(t,e,n){n._d=new Date(D(t))}),s.version="2.19.1",e=We,s.fn=fn,s.min=function(){return Fe("isBefore",[].slice.call(arguments,0))},s.max=function(){return Fe("isAfter",[].slice.call(arguments,0))},s.now=function(){return Date.now?Date.now():+new Date},s.utc=m,s.unix=function(t){return We(1e3*t)},s.months=function(t,e){return gn(t,e,"months")},s.isDate=d,s.locale=he,s.invalid=g,s.duration=$e,s.isMoment=k,s.weekdays=function(t,e,n){return pn(t,e,n,"weekdays")},s.parseZone=function(){return We.apply(null,arguments).parseZone()},s.localeData=fe,s.isDuration=Ve,s.monthsShort=function(t,e){return gn(t,e,"monthsShort")},s.weekdaysMin=function(t,e,n){return pn(t,e,n,"weekdaysMin")},s.defineLocale=ce,s.updateLocale=function(t,e){if(null!=e){var n,i=ae;null!=oe[t]&&(i=oe[t]._config),(n=new C(e=R(i,e))).parentLocale=oe[t],oe[t]=n,he(t)}else null!=oe[t]&&(null!=oe[t].parentLocale?oe[t]=oe[t].parentLocale:null!=oe[t]&&delete oe[t]);return oe[t]},s.locales=function(){return x(oe)},s.weekdaysShort=function(t,e,n){return pn(t,e,n,"weekdaysShort")},s.normalizeUnits=N,s.relativeTimeRounding=function(t){return void 0===t?An:"function"==typeof t&&(An=t,!0)},s.relativeTimeThreshold=function(t,e){return void 0!==jn[t]&&(void 0===e?jn[t]:(jn[t]=e,"s"===t&&(jn.ss=e-1),!0))},s.calendarFormat=function(t,e){var n=t.diff(e,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"},s.prototype=fn,s},"object"===a(i)?t.exports=r():s.moment=r()}(i={exports:{}},i.exports),i.exports),r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t};function a(t){if(Array.isArray(t)){for(var e=0,n=Array(t.length);e>> 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\nfunction 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\nfunction 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.\nvar momentProperties = hooks.momentProperties = [];\n\nfunction 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\nvar updateInProgress = false;\n\n// Moment prototype object\nfunction 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\nfunction isMoment (obj) {\n return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n}\n\nfunction 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\nfunction 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\nfunction 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\nfunction warn(msg) {\n if (hooks.suppressDeprecationWarnings === false &&\n (typeof console !== 'undefined') && console.warn) {\n console.warn('Deprecation warning: ' + msg);\n }\n}\n\nfunction 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\nvar deprecations = {};\n\nfunction 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\nhooks.suppressDeprecationWarnings = false;\nhooks.deprecationHandler = null;\n\nfunction isFunction(input) {\n return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n}\n\nfunction 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\nfunction 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\nfunction Locale(config) {\n if (config != null) {\n this.set(config);\n }\n}\n\nvar keys;\n\nif (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\nvar 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\nfunction calendar (key, mom, now) {\n var output = this._calendar[key] || this._calendar['sameElse'];\n return isFunction(output) ? output.call(mom, now) : output;\n}\n\nvar 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\nfunction 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\nvar defaultInvalidDate = 'Invalid date';\n\nfunction invalidDate () {\n return this._invalidDate;\n}\n\nvar defaultOrdinal = '%d';\nvar defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\nfunction ordinal (number) {\n return this._ordinal.replace('%d', number);\n}\n\nvar 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\nfunction 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\nfunction 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\nvar aliases = {};\n\nfunction addUnitAlias (unit, shorthand) {\n var lowerCase = unit.toLowerCase();\n aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n}\n\nfunction normalizeUnits(units) {\n return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n}\n\nfunction 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\nvar priorities = {};\n\nfunction addUnitPriority(unit, priority) {\n priorities[unit] = priority;\n}\n\nfunction 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\nfunction 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\nvar 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\nvar localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\nvar formatFunctions = {};\n\nvar formatTokenFunctions = {};\n\n// token: 'M'\n// padded: ['MM', 2]\n// ordinal: 'Mo'\n// callback: function () { this.month() + 1 }\nfunction 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\nfunction removeFormattingTokens(input) {\n if (input.match(/\\[[\\s\\S]/)) {\n return input.replace(/^\\[|\\]$/g, '');\n }\n return input.replace(/\\\\/g, '');\n}\n\nfunction 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\nfunction 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\nfunction 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\nvar match1 = /\\d/; // 0 - 9\nvar match2 = /\\d\\d/; // 00 - 99\nvar match3 = /\\d{3}/; // 000 - 999\nvar match4 = /\\d{4}/; // 0000 - 9999\nvar match6 = /[+-]?\\d{6}/; // -999999 - 999999\nvar match1to2 = /\\d\\d?/; // 0 - 99\nvar match3to4 = /\\d\\d\\d\\d?/; // 999 - 9999\nvar match5to6 = /\\d\\d\\d\\d\\d\\d?/; // 99999 - 999999\nvar match1to3 = /\\d{1,3}/; // 0 - 999\nvar match1to4 = /\\d{1,4}/; // 0 - 9999\nvar match1to6 = /[+-]?\\d{1,6}/; // -999999 - 999999\n\nvar matchUnsigned = /\\d+/; // 0 - inf\nvar matchSigned = /[+-]?\\d+/; // -inf - inf\n\nvar matchOffset = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\nvar matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\nvar 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\nvar matchWord = /[0-9]*['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF\\/]+(\\s*?[\\u0600-\\u06FF]+){1,2}/i;\n\n\nvar regexes = {};\n\nfunction addRegexToken (token, regex, strictRegex) {\n regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n return (isStrict && strictRegex) ? strictRegex : regex;\n };\n}\n\nfunction 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\nfunction unescapeFormat(s) {\n return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n return p1 || p2 || p3 || p4;\n }));\n}\n\nfunction regexEscape(s) {\n return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nvar tokens = {};\n\nfunction 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\nfunction 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\nfunction addTimeToArrayFromToken(token, input, config) {\n if (input != null && hasOwnProp(tokens, token)) {\n tokens[token](input, config._a, config, token);\n }\n}\n\nvar YEAR = 0;\nvar MONTH = 1;\nvar DATE = 2;\nvar HOUR = 3;\nvar MINUTE = 4;\nvar SECOND = 5;\nvar MILLISECOND = 6;\nvar WEEK = 7;\nvar WEEKDAY = 8;\n\n// FORMATTING\n\naddFormatToken('Y', 0, 0, function () {\n var y = this.year();\n return y <= 9999 ? '' + y : '+' + y;\n});\n\naddFormatToken(0, ['YY', 2], 0, function () {\n return this.year() % 100;\n});\n\naddFormatToken(0, ['YYYY', 4], 0, 'year');\naddFormatToken(0, ['YYYYY', 5], 0, 'year');\naddFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n// ALIASES\n\naddUnitAlias('year', 'y');\n\n// PRIORITIES\n\naddUnitPriority('year', 1);\n\n// PARSING\n\naddRegexToken('Y', matchSigned);\naddRegexToken('YY', match1to2, match2);\naddRegexToken('YYYY', match1to4, match4);\naddRegexToken('YYYYY', match1to6, match6);\naddRegexToken('YYYYYY', match1to6, match6);\n\naddParseToken(['YYYYY', 'YYYYYY'], YEAR);\naddParseToken('YYYY', function (input, array) {\n array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n});\naddParseToken('YY', function (input, array) {\n array[YEAR] = hooks.parseTwoDigitYear(input);\n});\naddParseToken('Y', function (input, array) {\n array[YEAR] = parseInt(input, 10);\n});\n\n// HELPERS\n\nfunction daysInYear(year) {\n return isLeapYear(year) ? 366 : 365;\n}\n\nfunction isLeapYear(year) {\n return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n}\n\n// HOOKS\n\nhooks.parseTwoDigitYear = function (input) {\n return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n};\n\n// MOMENTS\n\nvar getSetYear = makeGetSet('FullYear', true);\n\nfunction getIsLeapYear () {\n return isLeapYear(this.year());\n}\n\nfunction 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\nfunction get (mom, unit) {\n return mom.isValid() ?\n mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n}\n\nfunction set$1 (mom, unit, value) {\n if (mom.isValid() && !isNaN(value)) {\n if (unit === 'FullYear' && isLeapYear(mom.year())) {\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\nfunction stringGet (units) {\n units = normalizeUnits(units);\n if (isFunction(this[units])) {\n return this[units]();\n }\n return this;\n}\n\n\nfunction 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\nfunction mod(n, x) {\n return ((n % x) + x) % x;\n}\n\nvar indexOf;\n\nif (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\nfunction 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\naddFormatToken('M', ['MM', 2], 'Mo', function () {\n return this.month() + 1;\n});\n\naddFormatToken('MMM', 0, 0, function (format) {\n return this.localeData().monthsShort(this, format);\n});\n\naddFormatToken('MMMM', 0, 0, function (format) {\n return this.localeData().months(this, format);\n});\n\n// ALIASES\n\naddUnitAlias('month', 'M');\n\n// PRIORITY\n\naddUnitPriority('month', 8);\n\n// PARSING\n\naddRegexToken('M', match1to2);\naddRegexToken('MM', match1to2, match2);\naddRegexToken('MMM', function (isStrict, locale) {\n return locale.monthsShortRegex(isStrict);\n});\naddRegexToken('MMMM', function (isStrict, locale) {\n return locale.monthsRegex(isStrict);\n});\n\naddParseToken(['M', 'MM'], function (input, array) {\n array[MONTH] = toInt(input) - 1;\n});\n\naddParseToken(['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\nvar MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\nvar defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\nfunction 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\nvar defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction getDaysInMonth () {\n return daysInMonth(this.year(), this.month());\n}\n\nvar defaultMonthsShortRegex = matchWord;\nfunction 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\nvar defaultMonthsRegex = matchWord;\nfunction 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\nfunction 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\nfunction 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 = new Date(y, m, d, h, M, s, ms);\n\n // the date constructor remaps years 0-99 to 1900-1999\n if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {\n date.setFullYear(y);\n }\n return date;\n}\n\nfunction createUTCDate (y) {\n var date = new Date(Date.UTC.apply(null, arguments));\n\n // the Date.UTC function remaps years 0-99 to 1900-1999\n if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {\n date.setUTCFullYear(y);\n }\n return date;\n}\n\n// start-of-first-week - start-of-year\nfunction 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\nfunction 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\nfunction 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\nfunction 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\naddFormatToken('w', ['ww', 2], 'wo', 'week');\naddFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n// ALIASES\n\naddUnitAlias('week', 'w');\naddUnitAlias('isoWeek', 'W');\n\n// PRIORITIES\n\naddUnitPriority('week', 5);\naddUnitPriority('isoWeek', 5);\n\n// PARSING\n\naddRegexToken('w', match1to2);\naddRegexToken('ww', match1to2, match2);\naddRegexToken('W', match1to2);\naddRegexToken('WW', match1to2, match2);\n\naddWeekParseToken(['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\nfunction localeWeek (mom) {\n return weekOfYear(mom, this._week.dow, this._week.doy).week;\n}\n\nvar defaultLocaleWeek = {\n dow : 0, // Sunday is the first day of the week.\n doy : 6 // The week that contains Jan 1st is the first week of the year.\n};\n\nfunction localeFirstDayOfWeek () {\n return this._week.dow;\n}\n\nfunction localeFirstDayOfYear () {\n return this._week.doy;\n}\n\n// MOMENTS\n\nfunction getSetWeek (input) {\n var week = this.localeData().week(this);\n return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\nfunction 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\naddFormatToken('d', 0, 'do', 'day');\n\naddFormatToken('dd', 0, 0, function (format) {\n return this.localeData().weekdaysMin(this, format);\n});\n\naddFormatToken('ddd', 0, 0, function (format) {\n return this.localeData().weekdaysShort(this, format);\n});\n\naddFormatToken('dddd', 0, 0, function (format) {\n return this.localeData().weekdays(this, format);\n});\n\naddFormatToken('e', 0, 0, 'weekday');\naddFormatToken('E', 0, 0, 'isoWeekday');\n\n// ALIASES\n\naddUnitAlias('day', 'd');\naddUnitAlias('weekday', 'e');\naddUnitAlias('isoWeekday', 'E');\n\n// PRIORITY\naddUnitPriority('day', 11);\naddUnitPriority('weekday', 11);\naddUnitPriority('isoWeekday', 11);\n\n// PARSING\n\naddRegexToken('d', match1to2);\naddRegexToken('e', match1to2);\naddRegexToken('E', match1to2);\naddRegexToken('dd', function (isStrict, locale) {\n return locale.weekdaysMinRegex(isStrict);\n});\naddRegexToken('ddd', function (isStrict, locale) {\n return locale.weekdaysShortRegex(isStrict);\n});\naddRegexToken('dddd', function (isStrict, locale) {\n return locale.weekdaysRegex(isStrict);\n});\n\naddWeekParseToken(['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\naddWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n week[token] = toInt(input);\n});\n\n// HELPERS\n\nfunction 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\nfunction 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\nvar defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\nfunction localeWeekdays (m, format) {\n if (!m) {\n return isArray(this._weekdays) ? this._weekdays :\n this._weekdays['standalone'];\n }\n return isArray(this._weekdays) ? this._weekdays[m.day()] :\n this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];\n}\n\nvar defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\nfunction localeWeekdaysShort (m) {\n return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n}\n\nvar defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\nfunction localeWeekdaysMin (m) {\n return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n}\n\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nvar defaultWeekdaysRegex = matchWord;\nfunction 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\nvar defaultWeekdaysShortRegex = matchWord;\nfunction 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\nvar defaultWeekdaysMinRegex = matchWord;\nfunction 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\nfunction 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\nfunction hFormat() {\n return this.hours() % 12 || 12;\n}\n\nfunction kFormat() {\n return this.hours() || 24;\n}\n\naddFormatToken('H', ['HH', 2], 0, 'hour');\naddFormatToken('h', ['hh', 2], 0, hFormat);\naddFormatToken('k', ['kk', 2], 0, kFormat);\n\naddFormatToken('hmm', 0, 0, function () {\n return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('hmmss', 0, 0, function () {\n return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n zeroFill(this.seconds(), 2);\n});\n\naddFormatToken('Hmm', 0, 0, function () {\n return '' + this.hours() + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('Hmmss', 0, 0, function () {\n return '' + this.hours() + zeroFill(this.minutes(), 2) +\n zeroFill(this.seconds(), 2);\n});\n\nfunction meridiem (token, lowercase) {\n addFormatToken(token, 0, 0, function () {\n return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n });\n}\n\nmeridiem('a', true);\nmeridiem('A', false);\n\n// ALIASES\n\naddUnitAlias('hour', 'h');\n\n// PRIORITY\naddUnitPriority('hour', 13);\n\n// PARSING\n\nfunction matchMeridiem (isStrict, locale) {\n return locale._meridiemParse;\n}\n\naddRegexToken('a', matchMeridiem);\naddRegexToken('A', matchMeridiem);\naddRegexToken('H', match1to2);\naddRegexToken('h', match1to2);\naddRegexToken('k', match1to2);\naddRegexToken('HH', match1to2, match2);\naddRegexToken('hh', match1to2, match2);\naddRegexToken('kk', match1to2, match2);\n\naddRegexToken('hmm', match3to4);\naddRegexToken('hmmss', match5to6);\naddRegexToken('Hmm', match3to4);\naddRegexToken('Hmmss', match5to6);\n\naddParseToken(['H', 'HH'], HOUR);\naddParseToken(['k', 'kk'], function (input, array, config) {\n var kInput = toInt(input);\n array[HOUR] = kInput === 24 ? 0 : kInput;\n});\naddParseToken(['a', 'A'], function (input, array, config) {\n config._isPm = config._locale.isPM(input);\n config._meridiem = input;\n});\naddParseToken(['h', 'hh'], function (input, array, config) {\n array[HOUR] = toInt(input);\n getParsingFlags(config).bigHour = true;\n});\naddParseToken('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});\naddParseToken('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});\naddParseToken('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});\naddParseToken('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\nfunction 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\nvar defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\nfunction 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 he wants. So trying to maintain the same hour (in\n// a new timezone) makes sense. Adding/subtracting hours does not follow\n// this rule.\nvar getSetHour = makeGetSet('Hours', true);\n\n// months\n// week\n// weekdays\n// meridiem\nvar 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\nvar locales = {};\nvar localeFamilies = {};\nvar globalLocale;\n\nfunction 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\nfunction 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 null;\n}\n\nfunction 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.\nfunction 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 }\n\n return globalLocale._abbr;\n}\n\nfunction defineLocale (name, config) {\n if (config !== null) {\n var 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 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 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\nfunction updateLocale(name, config) {\n if (config != null) {\n var locale, parentConfig = baseConfig;\n // MERGE\n if (locales[name] != null) {\n parentConfig = locales[name]._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\nfunction 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\nfunction listLocales() {\n return keys(locales);\n}\n\nfunction 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.\nfunction 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\nfunction 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]\nfunction configFromArray (config) {\n var i, date, input = [], currentDate, 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 // 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 !== config._d.getDay()) {\n getParsingFlags(config).weekdayMismatch = true;\n }\n}\n\nfunction 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 begining of week\n weekday = w.e + dow;\n if (w.e < 0 || w.e > 6) {\n weekdayOverflow = true;\n }\n } else {\n // default to begining 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)\nvar 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)?)?$/;\nvar 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\nvar tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nvar 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\nvar 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\nvar aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n// date from iso format\nfunction 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\nvar 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\nfunction 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\nfunction 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\nfunction 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, ' ').trim();\n}\n\nfunction 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\nvar 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\nfunction 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\nfunction 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\nfunction 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\nhooks.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\nhooks.ISO_8601 = function () {};\n\n// constant that refers to the RFC 2822 form\nhooks.RFC_2822 = function () {};\n\n// date from string and format string\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nfunction createLocal (input, format, locale, strict) {\n return createLocalOrUTC(input, format, locale, strict, false);\n}\n\nvar 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\nvar 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.\nfunction 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?\nfunction min () {\n var args = [].slice.call(arguments, 0);\n\n return pickBy('isBefore', args);\n}\n\nfunction max () {\n var args = [].slice.call(arguments, 0);\n\n return pickBy('isAfter', args);\n}\n\nvar now = function () {\n return Date.now ? Date.now() : +(new Date());\n};\n\nvar ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\nfunction 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\nfunction isValid$1() {\n return this._isValid;\n}\n\nfunction createInvalid$1() {\n return createDuration(NaN);\n}\n\nfunction 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 || 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\nfunction isDuration (obj) {\n return obj instanceof Duration;\n}\n\nfunction 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\nfunction 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\noffset('Z', ':');\noffset('ZZ', '');\n\n// PARSING\n\naddRegexToken('Z', matchShortOffset);\naddRegexToken('ZZ', matchShortOffset);\naddParseToken(['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']\nvar chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction 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.\nfunction 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\nfunction 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.\nhooks.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.\nfunction 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\nfunction 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\nfunction setOffsetToUTC (keepLocalTime) {\n return this.utcOffset(0, keepLocalTime);\n}\n\nfunction 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\nfunction 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\nfunction 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\nfunction isDaylightSavingTime () {\n return (\n this.utcOffset() > this.clone().month(0).utcOffset() ||\n this.utcOffset() > this.clone().month(5).utcOffset()\n );\n}\n\nfunction 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\nfunction isLocal () {\n return this.isValid() ? !this._isUTC : false;\n}\n\nfunction isUtcOffset () {\n return this.isValid() ? this._isUTC : false;\n}\n\nfunction isUtc () {\n return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}\n\n// ASP.NET json date format regex\nvar 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\nvar 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\nfunction 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 : (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\ncreateDuration.fn = Duration.prototype;\ncreateDuration.invalid = createInvalid$1;\n\nfunction 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\nfunction positiveMomentsDifference(base, other) {\n var res = {milliseconds: 0, months: 0};\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\nfunction 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\nfunction 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\nfunction 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\nvar add = createAdder(1, 'add');\nvar subtract = createAdder(-1, 'subtract');\n\nfunction 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\nfunction 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\nfunction clone () {\n return new Moment(this);\n}\n\nfunction isAfter (input, units) {\n var localInput = isMoment(input) ? input : createLocal(input);\n if (!(this.isValid() && localInput.isValid())) {\n return false;\n }\n units = normalizeUnits(!isUndefined(units) ? 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\nfunction isBefore (input, units) {\n var localInput = isMoment(input) ? input : createLocal(input);\n if (!(this.isValid() && localInput.isValid())) {\n return false;\n }\n units = normalizeUnits(!isUndefined(units) ? 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\nfunction isBetween (from, to, units, inclusivity) {\n inclusivity = inclusivity || '()';\n return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&\n (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));\n}\n\nfunction 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\nfunction isSameOrAfter (input, units) {\n return this.isSame(input, units) || this.isAfter(input,units);\n}\n\nfunction isSameOrBefore (input, units) {\n return this.isSame(input, units) || this.isBefore(input,units);\n}\n\nfunction diff (input, units, asFloat) {\n var that,\n zoneDelta,\n delta, 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\nfunction 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\nhooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\nhooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\nfunction toString () {\n return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n}\n\nfunction toISOString() {\n if (!this.isValid()) {\n return null;\n }\n var m = this.clone().utc();\n if (m.year() < 0 || m.year() > 9999) {\n return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n }\n if (isFunction(Date.prototype.toISOString)) {\n // native implementation is ~50x faster, use it when we can\n return this.toDate().toISOString();\n }\n return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\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 */\nfunction 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\nfunction 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\nfunction 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\nfunction fromNow (withoutSuffix) {\n return this.from(createLocal(), withoutSuffix);\n}\n\nfunction 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\nfunction 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.\nfunction 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\nvar 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\nfunction localeData () {\n return this._locale;\n}\n\nfunction startOf (units) {\n units = normalizeUnits(units);\n // the following switch intentionally omits break keywords\n // to utilize falling through the cases.\n switch (units) {\n case 'year':\n this.month(0);\n /* falls through */\n case 'quarter':\n case 'month':\n this.date(1);\n /* falls through */\n case 'week':\n case 'isoWeek':\n case 'day':\n case 'date':\n this.hours(0);\n /* falls through */\n case 'hour':\n this.minutes(0);\n /* falls through */\n case 'minute':\n this.seconds(0);\n /* falls through */\n case 'second':\n this.milliseconds(0);\n }\n\n // weeks are a special case\n if (units === 'week') {\n this.weekday(0);\n }\n if (units === 'isoWeek') {\n this.isoWeekday(1);\n }\n\n // quarters are also special\n if (units === 'quarter') {\n this.month(Math.floor(this.month() / 3) * 3);\n }\n\n return this;\n}\n\nfunction endOf (units) {\n units = normalizeUnits(units);\n if (units === undefined || units === 'millisecond') {\n return this;\n }\n\n // 'date' is an alias for 'day', so it should be considered as such.\n if (units === 'date') {\n units = 'day';\n }\n\n return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');\n}\n\nfunction valueOf () {\n return this._d.valueOf() - ((this._offset || 0) * 60000);\n}\n\nfunction unix () {\n return Math.floor(this.valueOf() / 1000);\n}\n\nfunction toDate () {\n return new Date(this.valueOf());\n}\n\nfunction toArray () {\n var m = this;\n return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n}\n\nfunction 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\nfunction toJSON () {\n // new Date(NaN).toJSON() === null\n return this.isValid() ? this.toISOString() : null;\n}\n\nfunction isValid$2 () {\n return isValid(this);\n}\n\nfunction parsingFlags () {\n return extend({}, getParsingFlags(this));\n}\n\nfunction invalidAt () {\n return getParsingFlags(this).overflow;\n}\n\nfunction 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\naddFormatToken(0, ['gg', 2], 0, function () {\n return this.weekYear() % 100;\n});\n\naddFormatToken(0, ['GG', 2], 0, function () {\n return this.isoWeekYear() % 100;\n});\n\nfunction addWeekYearFormatToken (token, getter) {\n addFormatToken(0, [token, token.length], 0, getter);\n}\n\naddWeekYearFormatToken('gggg', 'weekYear');\naddWeekYearFormatToken('ggggg', 'weekYear');\naddWeekYearFormatToken('GGGG', 'isoWeekYear');\naddWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n// ALIASES\n\naddUnitAlias('weekYear', 'gg');\naddUnitAlias('isoWeekYear', 'GG');\n\n// PRIORITY\n\naddUnitPriority('weekYear', 1);\naddUnitPriority('isoWeekYear', 1);\n\n\n// PARSING\n\naddRegexToken('G', matchSigned);\naddRegexToken('g', matchSigned);\naddRegexToken('GG', match1to2, match2);\naddRegexToken('gg', match1to2, match2);\naddRegexToken('GGGG', match1to4, match4);\naddRegexToken('gggg', match1to4, match4);\naddRegexToken('GGGGG', match1to6, match6);\naddRegexToken('ggggg', match1to6, match6);\n\naddWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n week[token.substr(0, 2)] = toInt(input);\n});\n\naddWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n week[token] = hooks.parseTwoDigitYear(input);\n});\n\n// MOMENTS\n\nfunction 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\nfunction getSetISOWeekYear (input) {\n return getSetWeekYearHelper.call(this,\n input, this.isoWeek(), this.isoWeekday(), 1, 4);\n}\n\nfunction getISOWeeksInYear () {\n return weeksInYear(this.year(), 1, 4);\n}\n\nfunction getWeeksInYear () {\n var weekInfo = this.localeData()._week;\n return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n}\n\nfunction 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\nfunction 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\naddFormatToken('Q', 0, 'Qo', 'quarter');\n\n// ALIASES\n\naddUnitAlias('quarter', 'Q');\n\n// PRIORITY\n\naddUnitPriority('quarter', 7);\n\n// PARSING\n\naddRegexToken('Q', match1);\naddParseToken('Q', function (input, array) {\n array[MONTH] = (toInt(input) - 1) * 3;\n});\n\n// MOMENTS\n\nfunction 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\naddFormatToken('D', ['DD', 2], 'Do', 'date');\n\n// ALIASES\n\naddUnitAlias('date', 'D');\n\n// PRIOROITY\naddUnitPriority('date', 9);\n\n// PARSING\n\naddRegexToken('D', match1to2);\naddRegexToken('DD', match1to2, match2);\naddRegexToken('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\naddParseToken(['D', 'DD'], DATE);\naddParseToken('Do', function (input, array) {\n array[DATE] = toInt(input.match(match1to2)[0], 10);\n});\n\n// MOMENTS\n\nvar getSetDayOfMonth = makeGetSet('Date', true);\n\n// FORMATTING\n\naddFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n// ALIASES\n\naddUnitAlias('dayOfYear', 'DDD');\n\n// PRIORITY\naddUnitPriority('dayOfYear', 4);\n\n// PARSING\n\naddRegexToken('DDD', match1to3);\naddRegexToken('DDDD', match3);\naddParseToken(['DDD', 'DDDD'], function (input, array, config) {\n config._dayOfYear = toInt(input);\n});\n\n// HELPERS\n\n// MOMENTS\n\nfunction 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\naddFormatToken('m', ['mm', 2], 0, 'minute');\n\n// ALIASES\n\naddUnitAlias('minute', 'm');\n\n// PRIORITY\n\naddUnitPriority('minute', 14);\n\n// PARSING\n\naddRegexToken('m', match1to2);\naddRegexToken('mm', match1to2, match2);\naddParseToken(['m', 'mm'], MINUTE);\n\n// MOMENTS\n\nvar getSetMinute = makeGetSet('Minutes', false);\n\n// FORMATTING\n\naddFormatToken('s', ['ss', 2], 0, 'second');\n\n// ALIASES\n\naddUnitAlias('second', 's');\n\n// PRIORITY\n\naddUnitPriority('second', 15);\n\n// PARSING\n\naddRegexToken('s', match1to2);\naddRegexToken('ss', match1to2, match2);\naddParseToken(['s', 'ss'], SECOND);\n\n// MOMENTS\n\nvar getSetSecond = makeGetSet('Seconds', false);\n\n// FORMATTING\n\naddFormatToken('S', 0, 0, function () {\n return ~~(this.millisecond() / 100);\n});\n\naddFormatToken(0, ['SS', 2], 0, function () {\n return ~~(this.millisecond() / 10);\n});\n\naddFormatToken(0, ['SSS', 3], 0, 'millisecond');\naddFormatToken(0, ['SSSS', 4], 0, function () {\n return this.millisecond() * 10;\n});\naddFormatToken(0, ['SSSSS', 5], 0, function () {\n return this.millisecond() * 100;\n});\naddFormatToken(0, ['SSSSSS', 6], 0, function () {\n return this.millisecond() * 1000;\n});\naddFormatToken(0, ['SSSSSSS', 7], 0, function () {\n return this.millisecond() * 10000;\n});\naddFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n return this.millisecond() * 100000;\n});\naddFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n return this.millisecond() * 1000000;\n});\n\n\n// ALIASES\n\naddUnitAlias('millisecond', 'ms');\n\n// PRIORITY\n\naddUnitPriority('millisecond', 16);\n\n// PARSING\n\naddRegexToken('S', match1to3, match1);\naddRegexToken('SS', match1to3, match2);\naddRegexToken('SSS', match1to3, match3);\n\nvar token;\nfor (token = 'SSSS'; token.length <= 9; token += 'S') {\n addRegexToken(token, matchUnsigned);\n}\n\nfunction parseMs(input, array) {\n array[MILLISECOND] = toInt(('0.' + input) * 1000);\n}\n\nfor (token = 'S'; token.length <= 9; token += 'S') {\n addParseToken(token, parseMs);\n}\n// MOMENTS\n\nvar getSetMillisecond = makeGetSet('Milliseconds', false);\n\n// FORMATTING\n\naddFormatToken('z', 0, 0, 'zoneAbbr');\naddFormatToken('zz', 0, 0, 'zoneName');\n\n// MOMENTS\n\nfunction getZoneAbbr () {\n return this._isUTC ? 'UTC' : '';\n}\n\nfunction getZoneName () {\n return this._isUTC ? 'Coordinated Universal Time' : '';\n}\n\nvar proto = Moment.prototype;\n\nproto.add = add;\nproto.calendar = calendar$1;\nproto.clone = clone;\nproto.diff = diff;\nproto.endOf = endOf;\nproto.format = format;\nproto.from = from;\nproto.fromNow = fromNow;\nproto.to = to;\nproto.toNow = toNow;\nproto.get = stringGet;\nproto.invalidAt = invalidAt;\nproto.isAfter = isAfter;\nproto.isBefore = isBefore;\nproto.isBetween = isBetween;\nproto.isSame = isSame;\nproto.isSameOrAfter = isSameOrAfter;\nproto.isSameOrBefore = isSameOrBefore;\nproto.isValid = isValid$2;\nproto.lang = lang;\nproto.locale = locale;\nproto.localeData = localeData;\nproto.max = prototypeMax;\nproto.min = prototypeMin;\nproto.parsingFlags = parsingFlags;\nproto.set = stringSet;\nproto.startOf = startOf;\nproto.subtract = subtract;\nproto.toArray = toArray;\nproto.toObject = toObject;\nproto.toDate = toDate;\nproto.toISOString = toISOString;\nproto.inspect = inspect;\nproto.toJSON = toJSON;\nproto.toString = toString;\nproto.unix = unix;\nproto.valueOf = valueOf;\nproto.creationData = creationData;\n\n// Year\nproto.year = getSetYear;\nproto.isLeapYear = getIsLeapYear;\n\n// Week Year\nproto.weekYear = getSetWeekYear;\nproto.isoWeekYear = getSetISOWeekYear;\n\n// Quarter\nproto.quarter = proto.quarters = getSetQuarter;\n\n// Month\nproto.month = getSetMonth;\nproto.daysInMonth = getDaysInMonth;\n\n// Week\nproto.week = proto.weeks = getSetWeek;\nproto.isoWeek = proto.isoWeeks = getSetISOWeek;\nproto.weeksInYear = getWeeksInYear;\nproto.isoWeeksInYear = getISOWeeksInYear;\n\n// Day\nproto.date = getSetDayOfMonth;\nproto.day = proto.days = getSetDayOfWeek;\nproto.weekday = getSetLocaleDayOfWeek;\nproto.isoWeekday = getSetISODayOfWeek;\nproto.dayOfYear = getSetDayOfYear;\n\n// Hour\nproto.hour = proto.hours = getSetHour;\n\n// Minute\nproto.minute = proto.minutes = getSetMinute;\n\n// Second\nproto.second = proto.seconds = getSetSecond;\n\n// Millisecond\nproto.millisecond = proto.milliseconds = getSetMillisecond;\n\n// Offset\nproto.utcOffset = getSetOffset;\nproto.utc = setOffsetToUTC;\nproto.local = setOffsetToLocal;\nproto.parseZone = setOffsetToParsedOffset;\nproto.hasAlignedHourOffset = hasAlignedHourOffset;\nproto.isDST = isDaylightSavingTime;\nproto.isLocal = isLocal;\nproto.isUtcOffset = isUtcOffset;\nproto.isUtc = isUtc;\nproto.isUTC = isUtc;\n\n// Timezone\nproto.zoneAbbr = getZoneAbbr;\nproto.zoneName = getZoneName;\n\n// Deprecations\nproto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\nproto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\nproto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);\nproto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\nproto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\nfunction createUnix (input) {\n return createLocal(input * 1000);\n}\n\nfunction createInZone () {\n return createLocal.apply(null, arguments).parseZone();\n}\n\nfunction preParsePostFormat (string) {\n return string;\n}\n\nvar proto$1 = Locale.prototype;\n\nproto$1.calendar = calendar;\nproto$1.longDateFormat = longDateFormat;\nproto$1.invalidDate = invalidDate;\nproto$1.ordinal = ordinal;\nproto$1.preparse = preParsePostFormat;\nproto$1.postformat = preParsePostFormat;\nproto$1.relativeTime = relativeTime;\nproto$1.pastFuture = pastFuture;\nproto$1.set = set;\n\n// Month\nproto$1.months = localeMonths;\nproto$1.monthsShort = localeMonthsShort;\nproto$1.monthsParse = localeMonthsParse;\nproto$1.monthsRegex = monthsRegex;\nproto$1.monthsShortRegex = monthsShortRegex;\n\n// Week\nproto$1.week = localeWeek;\nproto$1.firstDayOfYear = localeFirstDayOfYear;\nproto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n// Day of Week\nproto$1.weekdays = localeWeekdays;\nproto$1.weekdaysMin = localeWeekdaysMin;\nproto$1.weekdaysShort = localeWeekdaysShort;\nproto$1.weekdaysParse = localeWeekdaysParse;\n\nproto$1.weekdaysRegex = weekdaysRegex;\nproto$1.weekdaysShortRegex = weekdaysShortRegex;\nproto$1.weekdaysMinRegex = weekdaysMinRegex;\n\n// Hours\nproto$1.isPM = localeIsPM;\nproto$1.meridiem = localeMeridiem;\n\nfunction 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\nfunction 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)\nfunction 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\nfunction listMonths (format, index) {\n return listMonthsImpl(format, index, 'months');\n}\n\nfunction listMonthsShort (format, index) {\n return listMonthsImpl(format, index, 'monthsShort');\n}\n\nfunction listWeekdays (localeSorted, format, index) {\n return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n}\n\nfunction listWeekdaysShort (localeSorted, format, index) {\n return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n}\n\nfunction listWeekdaysMin (localeSorted, format, index) {\n return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n}\n\ngetSetGlobalLocale('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\nhooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\nhooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\nvar mathAbs = Math.abs;\n\nfunction 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\nfunction 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)\nfunction 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)\nfunction subtract$1 (input, value) {\n return addSubtract$1(this, input, value, -1);\n}\n\nfunction absCeil (number) {\n if (number < 0) {\n return Math.floor(number);\n } else {\n return Math.ceil(number);\n }\n}\n\nfunction 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\nfunction 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\nfunction monthsToDays (months) {\n // the reverse of daysToMonths\n return months * 146097 / 4800;\n}\n\nfunction 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 === 'year') {\n days = this._days + milliseconds / 864e5;\n months = this._months + daysToMonths(days);\n return units === 'month' ? months : months / 12;\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')?\nfunction 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\nfunction makeAs (alias) {\n return function () {\n return this.as(alias);\n };\n}\n\nvar asMilliseconds = makeAs('ms');\nvar asSeconds = makeAs('s');\nvar asMinutes = makeAs('m');\nvar asHours = makeAs('h');\nvar asDays = makeAs('d');\nvar asWeeks = makeAs('w');\nvar asMonths = makeAs('M');\nvar asYears = makeAs('y');\n\nfunction clone$1 () {\n return createDuration(this);\n}\n\nfunction get$2 (units) {\n units = normalizeUnits(units);\n return this.isValid() ? this[units + 's']() : NaN;\n}\n\nfunction makeGetter(name) {\n return function () {\n return this.isValid() ? this._data[name] : NaN;\n };\n}\n\nvar milliseconds = makeGetter('milliseconds');\nvar seconds = makeGetter('seconds');\nvar minutes = makeGetter('minutes');\nvar hours = makeGetter('hours');\nvar days = makeGetter('days');\nvar months = makeGetter('months');\nvar years = makeGetter('years');\n\nfunction weeks () {\n return absFloor(this.days() / 7);\n}\n\nvar round = Math.round;\nvar 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\nfunction substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n}\n\nfunction 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\nfunction 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\nfunction 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\nfunction 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\nvar abs$1 = Math.abs;\n\nfunction sign(x) {\n return ((x > 0) - (x < 0)) || +x;\n}\n\nfunction 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\nvar proto$2 = Duration.prototype;\n\nproto$2.isValid = isValid$1;\nproto$2.abs = abs;\nproto$2.add = add$1;\nproto$2.subtract = subtract$1;\nproto$2.as = as;\nproto$2.asMilliseconds = asMilliseconds;\nproto$2.asSeconds = asSeconds;\nproto$2.asMinutes = asMinutes;\nproto$2.asHours = asHours;\nproto$2.asDays = asDays;\nproto$2.asWeeks = asWeeks;\nproto$2.asMonths = asMonths;\nproto$2.asYears = asYears;\nproto$2.valueOf = valueOf$1;\nproto$2._bubble = bubble;\nproto$2.clone = clone$1;\nproto$2.get = get$2;\nproto$2.milliseconds = milliseconds;\nproto$2.seconds = seconds;\nproto$2.minutes = minutes;\nproto$2.hours = hours;\nproto$2.days = days;\nproto$2.weeks = weeks;\nproto$2.months = months;\nproto$2.years = years;\nproto$2.humanize = humanize;\nproto$2.toISOString = toISOString$1;\nproto$2.toString = toISOString$1;\nproto$2.toJSON = toISOString$1;\nproto$2.locale = locale;\nproto$2.localeData = localeData;\n\n// Deprecations\nproto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\nproto$2.lang = lang;\n\n// Side effect imports\n\n// FORMATTING\n\naddFormatToken('X', 0, 0, 'unix');\naddFormatToken('x', 0, 0, 'valueOf');\n\n// PARSING\n\naddRegexToken('x', matchSigned);\naddRegexToken('X', matchTimestamp);\naddParseToken('X', function (input, array, config) {\n config._d = new Date(parseFloat(input, 10) * 1000);\n});\naddParseToken('x', function (input, array, config) {\n config._d = new Date(toInt(input));\n});\n\n// Side effect imports\n\n\nhooks.version = '2.19.1';\n\nsetHookCallback(createLocal);\n\nhooks.fn = proto;\nhooks.min = min;\nhooks.max = max;\nhooks.now = now;\nhooks.utc = createUTC;\nhooks.unix = createUnix;\nhooks.months = listMonths;\nhooks.isDate = isDate;\nhooks.locale = getSetGlobalLocale;\nhooks.invalid = createInvalid;\nhooks.duration = createDuration;\nhooks.isMoment = isMoment;\nhooks.weekdays = listWeekdays;\nhooks.parseZone = createInZone;\nhooks.localeData = getLocale;\nhooks.isDuration = isDuration;\nhooks.monthsShort = listMonthsShort;\nhooks.weekdaysMin = listWeekdaysMin;\nhooks.defineLocale = defineLocale;\nhooks.updateLocale = updateLocale;\nhooks.locales = listLocales;\nhooks.weekdaysShort = listWeekdaysShort;\nhooks.normalizeUnits = normalizeUnits;\nhooks.relativeTimeRounding = getSetRelativeTimeRounding;\nhooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\nhooks.calendarFormat = getCalendarFormat;\nhooks.prototype = proto;\n\nreturn hooks;\n\n})));\n","module.exports = {\n install(Vue, options) {\n var moment = options && options.moment ? options.moment : require('moment');\n\n Object.defineProperties(Vue.prototype, {\n $moment: {\n get() {\n return moment;\n },\n },\n });\n\n Vue.moment = moment;\n\n Vue.filter('moment', (...args) => {\n args = Array.prototype.slice.call(args);\n const input = args.shift();\n let date;\n\n if (Array.isArray(input) && typeof input[0] === 'string') {\n // If input is array, assume we're being passed a format pattern to parse against.\n // Format pattern will accept an array of potential formats to parse against.\n // Date string should be at [0], format pattern(s) should be at [1]\n date = moment(input[0], input[1], true);\n } else if (typeof input === 'number') {\n if (input.toString().length < 12) {\n // If input is an integer with fewer than 12 digits, assume Unix seconds...\n date = moment.unix(input);\n } else {\n // ..otherwise, assume milliseconds.\n date = moment(input);\n }\n } else {\n // Otherwise, throw the input at moment and see what happens...\n date = moment(input);\n }\n\n if (!input || !date.isValid()) {\n // Log a warning if moment couldn't reconcile the input. Better than throwing an error?\n console.warn('Could not build a valid `moment` object from input.');\n return input;\n }\n\n function parse(...args) {\n args = Array.prototype.slice.call(args);\n const method = args.shift();\n\n switch (method) {\n case 'add': {\n /*\n * Mutates the original moment by adding time.\n * http://momentjs.com/docs/#/manipulating/add/\n */\n\n const addends = args.shift()\n .split(',')\n .map(Function.prototype.call, String.prototype.trim);\n const obj = {};\n\n for (let n = 0; n < addends.length; n++) {\n const addend = addends[n].split(' ');\n obj[addend[1]] = addend[0];\n }\n date.add(obj);\n break;\n }\n\n case 'subtract': {\n /*\n * Mutates the original moment by subtracting time.\n * http://momentjs.com/docs/#/manipulating/subtract/\n */\n\n const subtrahends = args.shift()\n .split(',')\n .map(Function.prototype.call, String.prototype.trim);\n const obj = {};\n\n for (let n = 0; n < subtrahends.length; n++) {\n const subtrahend = subtrahends[n].split(' ');\n obj[subtrahend[1]] = subtrahend[0];\n }\n date.subtract(obj);\n break;\n }\n\n case 'from': {\n /*\n * Display a moment in relative time, either from now or from a specified date.\n * http://momentjs.com/docs/#/displaying/fromnow/\n */\n\n let from = 'now';\n let removeSuffix = false;\n\n if (args[0] === 'now') args.shift();\n // If valid, assume it is a date we want the output computed against.\n if (moment(args[0]).isValid()) from = moment(args.shift());\n\n if (args[0] === true) {\n args.shift();\n removeSuffix = true;\n }\n\n if (from !== 'now') {\n date = date.from(from, removeSuffix);\n } else {\n date = date.fromNow(removeSuffix);\n }\n break;\n }\n\n case 'diff': {\n /*\n * Mutates the original moment by doing a difference with another date.\n * http://momentjs.com/docs/#/displaying/difference/\n */\n\n let referenceTime = moment();\n let units = '';\n let float = false;\n\n if (moment(args[0]).isValid()) {\n // If valid, assume it is a date we want the output computed against.\n referenceTime = moment(args.shift());\n } else if (args[0] === null || args[0] === 'now') {\n // If null or 'now', remove argument and proceed with default referenceTime.\n args.shift();\n }\n\n if (args[0]) units = args.shift();\n\n if (args[0] === true) float = args.shift();\n\n date = date.diff(referenceTime, units, float);\n break;\n }\n\n case 'calendar': {\n /*\n * Formats a date with different strings depending on how close\n * to a certain date (today by default) the date is.\n * http://momentjs.com/docs/#/displaying/calendar-time/\n */\n\n let referenceTime = moment();\n let formats = {};\n\n if (moment(args[0]).isValid()) {\n // If valid, assume it is a date we want the output computed against.\n referenceTime = moment(args.shift());\n } else if (args[0] === null || args[0] === 'now') {\n // If null or 'now', remove argument and proceed with default referenceTime.\n args.shift();\n }\n\n if (typeof args[0] === 'object') formats = args.shift();\n\n date = date.calendar(referenceTime, formats);\n break;\n }\n\n case 'utc': {\n /*\n * Mutates the original moment by converting to UTC\n * https://momentjs.com/docs/#/manipulating/utc/\n */\n date.utc();\n break;\n }\n\n case 'timezone': {\n /*\n * Mutates the original moment by converting to a new timezone.\n * https://momentjs.com/timezone/docs/#/using-timezones/converting-to-zone/\n */\n date.tz(args.shift());\n break;\n }\n\n default: {\n /*\n * Formats a date by taking a string of tokens and replacing\n * them with their corresponding values.\n * http://momentjs.com/docs/#/displaying/format/\n */\n\n const format = method;\n date = date.format(format);\n }\n }\n\n if (args.length) parse.apply(parse, args);\n }\n\n parse.apply(parse, args);\n\n return date;\n });\n\n Vue.filter('duration', (...args) => {\n /*\n * Basic pass-through filter for leveraging moment.js's ability\n * to manipulate and display durations.\n * https://momentjs.com/docs/#/durations/\n */\n args = Array.prototype.slice.call(args);\n const input = args.shift();\n const method = args.shift();\n\n function createDuration(time) {\n if (!Array.isArray(time)) time = [time];\n const result = moment.duration(...time);\n if (!result.isValid()) console.warn('Could not build a valid `duration` object from input.');\n return result;\n }\n let duration = createDuration(input);\n\n if (method === 'add' || method === 'subtract') {\n // Generates a duration object and either adds or subtracts it\n // from our original duration.\n const durationChange = createDuration(args);\n duration[method](durationChange);\n } else if (duration && duration[method]) {\n // This gives a full proxy to moment.duration functions.\n duration = duration[method](...args);\n }\n\n return duration;\n });\n },\n};\n"],"names":["global","factory","this","hookCallback","some","hooks","apply","arguments","isArray","input","Array","Object","prototype","toString","call","isObject","isUndefined","isNumber","isDate","Date","map","arr","fn","i","res","length","push","hasOwnProp","a","b","hasOwnProperty","extend","valueOf","createUTC","format","locale","strict","createLocalOrUTC","utc","getParsingFlags","m","_pf","isValid","_isValid","flags","parsedParts","parsedDateParts","isNowValid","isNaN","_d","getTime","overflow","empty","invalidMonth","invalidWeekday","weekdayMismatch","nullInput","invalidFormat","userInvalidated","meridiem","_strict","charsLeftOver","unusedTokens","undefined","bigHour","isFrozen","createInvalid","NaN","fun","t","len","momentProperties","copyConfig","to","from","prop","val","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","updateInProgress","Moment","config","updateOffset","isMoment","obj","absFloor","number","Math","ceil","floor","toInt","argumentForCoercion","coercedNumber","value","isFinite","compareArrays","array1","array2","dontConvert","min","lengthDiff","abs","diffs","warn","msg","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","arg","args","_typeof","key","slice","join","Error","stack","keys","deprecations","deprecateSimple","name","isFunction","Function","mergeConfigs","parentConfig","childConfig","Locale","set","aliases","addUnitAlias","unit","shorthand","lowerCase","toLowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","priorities","addUnitPriority","priority","zeroFill","targetLength","forceSign","absNumber","zerosToFill","pow","max","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","token","padded","ordinal","callback","func","localeData","formatMoment","expandFormat","array","match","replace","mom","output","makeFormatFunction","invalidDate","replaceLongDateFormatTokens","longDateFormat","lastIndex","test","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchWord","regexes","addRegexToken","regex","strictRegex","isStrict","getParseRegexForToken","RegExp","regexEscape","matched","p1","p2","p3","p4","s","tokens","addParseToken","addWeekParseToken","_w","addTimeToArrayFromToken","_a","YEAR","MONTH","DATE","HOUR","MINUTE","SECOND","MILLISECOND","WEEK","WEEKDAY","daysInYear","year","isLeapYear","y","parseTwoDigitYear","parseInt","indexOf","getSetYear","makeGetSet","keepTime","get","set$1","month","daysInMonth","x","modMonth","o","monthsShort","months","monthsShortRegex","monthsRegex","monthsParse","MONTHS_IN_FORMAT","defaultLocaleMonths","split","defaultLocaleMonthsShort","setMonth","dayOfMonth","date","getSetMonth","defaultMonthsShortRegex","defaultMonthsRegex","computeMonthsParse","cmpLenRev","shortPieces","longPieces","mixedPieces","sort","_monthsRegex","_monthsShortRegex","_monthsStrictRegex","_monthsShortStrictRegex","createUTCDate","UTC","getUTCFullYear","setUTCFullYear","firstWeekOffset","dow","doy","fwd","getUTCDay","dayOfYearFromWeeks","week","weekday","resYear","resDayOfYear","dayOfYear","weekOfYear","resWeek","weekOffset","weeksInYear","weekOffsetNext","weekdaysMin","weekdaysShort","weekdays","weekdaysMinRegex","weekdaysShortRegex","weekdaysRegex","weekdaysParse","d","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","defaultWeekdaysRegex","defaultWeekdaysShortRegex","defaultWeekdaysMinRegex","computeWeekdaysParse","minp","shortp","longp","minPieces","day","_weekdaysRegex","_weekdaysShortRegex","_weekdaysMinRegex","_weekdaysStrictRegex","_weekdaysShortStrictRegex","_weekdaysMinStrictRegex","hFormat","hours","lowercase","minutes","matchMeridiem","_meridiemParse","seconds","kInput","_isPm","isPM","_meridiem","pos","pos1","pos2","globalLocale","getSetHour","baseConfig","locales","localeFamilies","normalizeLocale","loadLocale","oldLocale","module","exports","_abbr","require","e","getSetGlobalLocale","values","data","getLocale","defineLocale","abbr","_config","parentLocale","forEach","names","j","next","chooseLocale","checkOverflow","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","defaults","c","configFromArray","currentDate","yearToUse","nowValue","now","_useUTC","getUTCMonth","getUTCDate","getFullYear","getMonth","getDate","currentDateArray","w","weekYear","temp","weekdayOverflow","GG","W","E","createLocal","_week","curWeek","gg","_dayOfYear","_nextDay","h","M","ms","setFullYear","setUTCMinutes","getUTCMinutes","getDay","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","configFromISO","l","allowTime","dateFormat","timeFormat","tzFormat","string","exec","iso","rfc2822","extractFromRFC2822Strings","yearStr","monthStr","dayStr","hourStr","minuteStr","secondStr","result","untruncateYear","obsOffsets","configFromRFC2822","trim","parsedArray","weekdayStr","parsedInput","checkWeekday","obsOffset","militaryOffset","numOffset","hm","calculateOffset","configFromStringAndFormat","ISO_8601","RFC_2822","skipped","stringLength","totalParsedInputLength","unusedInput","hour","isPm","meridiemHour","meridiemFixWrap","prepareConfig","preparse","tempConfig","bestMoment","scoreToBeat","currentScore","score","createFromInputFallback","minute","second","millisecond","isUTC","getOwnPropertyNames","k","isObjectEmpty","add","prototypeMin","other","prototypeMax","pickBy","moments","ordering","Duration","duration","years","quarters","quarter","weeks","days","milliseconds","unitHasDecimal","parseFloat","isDurationValid","_milliseconds","_days","_months","_data","_bubble","isDuration","absRound","round","offset","separator","utcOffset","sign","offsetFromString","chunkOffset","matcher","matches","parts","cloneWithOffset","model","diff","clone","setTime","local","getDateOffset","getTimezoneOffset","isUtc","aspNetRegex","isoRegex","createDuration","ret","diffRes","parseIso","base","isBefore","positiveMomentsDifference","momentsDifference","inp","isAfter","createAdder","direction","period","tmp","addSubtract","isAdding","invalid","subtract","monthDiff","wholeMonthDiff","anchor","newLocaleData","defaultFormat","defaultFormatUtc","lang","addWeekYearFormatToken","getter","getSetWeekYearHelper","weeksTarget","dayOfYearData","isoWeekYear","_dayOfMonthOrdinalParse","_ordinalParse","_dayOfMonthOrdinalParseLenient","getSetDayOfMonth","getSetMinute","getSetSecond","parseMs","getSetMillisecond","proto","preParsePostFormat","calendar","time","formats","sod","startOf","calendarFormat","asFloat","that","zoneDelta","endOf","inputString","postformat","withoutSuffix","humanize","fromNow","toNow","invalidAt","localInput","isBetween","inclusivity","isSame","inputMs","isSameOrAfter","isSameOrBefore","parsingFlags","prioritized","unitsObj","u","getPrioritizedUnits","isoWeekday","toArray","toObject","toDate","toISOString","inspect","zone","isLocal","prefix","suffix","toJSON","unix","creationData","isoWeek","isoWeeks","weekInfo","isoWeeksInYear","parseWeekday","parseIsoWeekday","keepLocalTime","keepMinutes","localAdjust","_changeInProgress","parseZone","tZone","hasAlignedHourOffset","isDST","isUtcOffset","zoneAbbr","zoneName","dates","isDSTShifted","_isDSTShifted","proto$1","get$1","index","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","shift","_calendar","_longDateFormat","formatUpper","toUpperCase","_invalidDate","_ordinal","relativeTime","isFuture","_relativeTime","pastFuture","source","isFormat","_monthsShort","monthName","_monthsParseExact","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","firstDayOfYear","firstDayOfWeek","_weekdays","_weekdaysMin","_weekdaysShort","weekdayName","_weekdaysParseExact","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","_fullWeekdaysParse","charAt","isLower","langData","mathAbs","addSubtract$1","absCeil","daysToMonths","monthsToDays","makeAs","alias","as","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asYears","makeGetter","thresholds","abs$1","toISOString$1","Y","D","toFixed","total","totalSign","ymSign","daysSign","hmsSign","proto$2","monthsFromDays","withSuffix","posNegDuration","ss","relativeTime$1","toIsoString","version","updateLocale","relativeTimeRounding","roundingFunction","relativeTimeThreshold","threshold","limit","myMoment","moment","Vue","options","defineProperties","filter","parse","method","addends","String","n","addend","subtrahends","subtrahend","removeSuffix","referenceTime","float","tz","durationChange"],"mappings":"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"} \ No newline at end of file