//! moment.js
-//! version : 2.8.1
+//! version : 2.8.3
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
//! license : MIT
//! momentjs.com
************************************/
var moment,
- VERSION = '2.8.1',
+ VERSION = '2.8.3',
// the global-scope this is NOT the global object in Node.js
globalScope = typeof global !== 'undefined' ? global : this,
oldGlobalMoment,
round = Math.round,
+ hasOwnProperty = Object.prototype.hasOwnProperty,
i,
YEAR = 0,
['HH', /(T| )\d\d/]
],
- // timezone chunker "+10:00" > ["10", "00"] or "-1530" > ["-15", "30"]
+ // timezone chunker '+10:00' > ['10', '00'] or '-1530' > ['-15', '30']
parseTimezoneChunker = /([\+\-]|\d\d)/gi,
// getter and setter names
}
}
+ function hasOwnProp(a, b) {
+ return hasOwnProperty.call(a, b);
+ }
+
function defaultParsingFlags() {
// We need to deep clone this object, and es5 standard is not very
// helpful.
function printMsg(msg) {
if (moment.suppressDeprecationWarnings === false &&
typeof console !== 'undefined' && console.warn) {
- console.warn("Deprecation warning: " + msg);
+ console.warn('Deprecation warning: ' + msg);
}
}
function extend(a, b) {
for (var i in b) {
- if (b.hasOwnProperty(i)) {
+ if (hasOwnProp(b, i)) {
a[i] = b[i];
}
}
- if (b.hasOwnProperty('toString')) {
+ if (hasOwnProp(b, 'toString')) {
a.toString = b.toString;
}
- if (b.hasOwnProperty('valueOf')) {
+ if (hasOwnProp(b, 'valueOf')) {
a.valueOf = b.valueOf;
}
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).");
+ deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
tmp = val; val = period; period = tmp;
}
prop;
for (prop in inputObject) {
- if (inputObject.hasOwnProperty(prop)) {
+ if (hasOwnProp(inputObject, prop)) {
normalizedProp = normalizeUnits(prop);
if (normalizedProp) {
normalizedInput[normalizedProp] = inputObject[prop];
for (i = 0; i < config._f.length; i++) {
currentScore = 0;
tempConfig = copyConfig({}, config);
+ if (config._useUTC != null) {
+ tempConfig._useUTC = config._useUTC;
+ }
tempConfig._pf = defaultParsingFlags();
tempConfig._f = config._f[i];
makeDateFromStringAndFormat(tempConfig);
config._pf.iso = true;
for (i = 0, l = isoDates.length; i < l; i++) {
if (isoDates[i][1].exec(string)) {
- // match[5] should be "T" or undefined
+ // match[5] should be 'T' or undefined
config._f = isoDates[i][0] + (match[6] || ' ');
break;
}
}
}
+ function map(arr, fn) {
+ var res = [], i;
+ for (i = 0; i < arr.length; ++i) {
+ res.push(fn(arr[i], i));
+ }
+ return res;
+ }
+
function makeDateFromInput(config) {
var input = config._i, matched;
if (input === undefined) {
} else if (typeof input === 'string') {
makeDateFromString(config);
} else if (isArray(input)) {
- config._a = input.slice(0);
+ config._a = map(input.slice(0), function (obj) {
+ return parseInt(obj, 10);
+ });
dateFromConfig(config);
} else if (typeof(input) === 'object') {
dateFromObject(config);
moment = function (input, format, locale, strict) {
var c;
- if (typeof(locale) === "boolean") {
+ if (typeof(locale) === 'boolean') {
strict = locale;
locale = undefined;
}
moment.utc = function (input, format, locale, strict) {
var c;
- if (typeof(locale) === "boolean") {
+ if (typeof(locale) === 'boolean') {
strict = locale;
locale = undefined;
}
ret = new Duration(duration);
- if (moment.isDuration(input) && input.hasOwnProperty('_locale')) {
+ if (moment.isDuration(input) && hasOwnProp(input, '_locale')) {
ret._locale = input._locale;
}
};
moment.lang = deprecate(
- "moment.lang is deprecated. Use moment.locale instead.",
+ 'moment.lang is deprecated. Use moment.locale instead.',
function (key, value) {
return moment.locale(key, value);
}
moment.locale = function (key, values) {
var data;
if (key) {
- if (typeof(values) !== "undefined") {
+ if (typeof(values) !== 'undefined') {
data = moment.defineLocale(key, values);
}
else {
};
moment.langData = deprecate(
- "moment.langData is deprecated. Use moment.localeData instead.",
+ 'moment.langData is deprecated. Use moment.localeData instead.',
function (key) {
return moment.localeData(key);
}
// compare moment object
moment.isMoment = function (obj) {
return obj instanceof Moment ||
- (obj != null && obj.hasOwnProperty('_isAMomentObject'));
+ (obj != null && hasOwnProp(obj, '_isAMomentObject'));
};
// for typechecking Duration objects
},
toString : function () {
- return this.clone().locale('en').format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
+ return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
},
toDate : function () {
this._isUTC = false;
if (keepLocalTime) {
- this.add(this._d.getTimezoneOffset(), 'm');
+ this.add(this._dateTzOffset(), 'm');
}
}
return this;
diff : function (input, units, asFloat) {
var that = makeAs(input, this),
zoneDiff = (this.zone() - that.zone()) * 6e4,
- diff, output;
+ diff, output, daysAdjust;
units = normalizeUnits(units);
output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
// adjust by taking difference in days, average number of days
// and dst in the given months.
- output += ((this - moment(this).startOf('month')) -
- (that - moment(that).startOf('month'))) / diff;
+ daysAdjust = (this - moment(this).startOf('month')) -
+ (that - moment(that).startOf('month'));
// same as above but with zones, to negate all dst
- output -= ((this.zone() - moment(this).startOf('month').zone()) -
- (that.zone() - moment(that).startOf('month').zone())) * 6e4 / diff;
+ daysAdjust -= ((this.zone() - moment(this).startOf('month').zone()) -
+ (that.zone() - moment(that).startOf('month').zone())) * 6e4;
+ output += daysAdjust / diff;
if (units === 'year') {
output = output / 12;
}
},
isAfter: function (input, units) {
- units = typeof units !== 'undefined' ? units : 'millisecond';
- return +this.clone().startOf(units) > +moment(input).startOf(units);
+ units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+ if (units === 'millisecond') {
+ input = moment.isMoment(input) ? input : moment(input);
+ return +this > +input;
+ } else {
+ return +this.clone().startOf(units) > +moment(input).startOf(units);
+ }
},
isBefore: function (input, units) {
- units = typeof units !== 'undefined' ? units : 'millisecond';
- return +this.clone().startOf(units) < +moment(input).startOf(units);
+ units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+ if (units === 'millisecond') {
+ input = moment.isMoment(input) ? input : moment(input);
+ return +this < +input;
+ } else {
+ return +this.clone().startOf(units) < +moment(input).startOf(units);
+ }
},
isSame: function (input, units) {
- units = units || 'ms';
- return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
+ units = normalizeUnits(units || 'millisecond');
+ if (units === 'millisecond') {
+ input = moment.isMoment(input) ? input : moment(input);
+ return +this === +input;
+ } else {
+ return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
+ }
},
min: deprecate(
input = input * 60;
}
if (!this._isUTC && keepLocalTime) {
- localAdjust = this._d.getTimezoneOffset();
+ localAdjust = this._dateTzOffset();
}
this._offset = input;
this._isUTC = true;
}
}
} else {
- return this._isUTC ? offset : this._d.getTimezoneOffset();
+ return this._isUTC ? offset : this._dateTzOffset();
}
return this;
},
// instance. Otherwise, it will return the locale configuration
// variables for this instance.
locale : function (key) {
+ var newLocaleData;
+
if (key === undefined) {
return this._locale._abbr;
} else {
- this._locale = moment.localeData(key);
+ newLocaleData = moment.localeData(key);
+ if (newLocaleData != null) {
+ this._locale = newLocaleData;
+ }
return this;
}
},
lang : deprecate(
- "moment().lang() is deprecated. Use moment().localeData() instead.",
+ 'moment().lang() is deprecated. Use moment().localeData() instead.',
function (key) {
if (key === undefined) {
return this.localeData();
} else {
- this._locale = moment.localeData(key);
- return this;
+ return this.locale(key);
}
}
),
localeData : function () {
return this._locale;
+ },
+
+ _dateTzOffset : function () {
+ // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+ // https://github.com/moment/moment/pull/1871
+ return Math.round(this._d.getTimezoneOffset() / 15) * 15;
}
});
var days, months;
units = normalizeUnits(units);
- days = this._days + this._milliseconds / 864e5;
if (units === 'month' || units === 'year') {
+ days = this._days + this._milliseconds / 864e5;
months = this._months + daysToYears(days) * 12;
return units === 'month' ? months : months / 12;
} else {
- days += yearsToDays(this._months / 12);
+ // handle milliseconds separately because of floating point math errors (issue #1867)
+ days = this._days + yearsToDays(this._months / 12);
switch (units) {
- case 'week': return days / 7;
- case 'day': return days;
- case 'hour': return days * 24;
- case 'minute': return days * 24 * 60;
- case 'second': return days * 24 * 60 * 60;
- case 'millisecond': return days * 24 * 60 * 60 * 1000;
+ case 'week': return days / 7 + this._milliseconds / 6048e5;
+ case 'day': return days + this._milliseconds / 864e5;
+ case 'hour': return days * 24 + this._milliseconds / 36e5;
+ case 'minute': return days * 24 * 60 + this._milliseconds / 6e4;
+ case 'second': return days * 24 * 60 * 60 + this._milliseconds / 1000;
+ // Math.floor prevents floating point math errors here
+ case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + this._milliseconds;
default: throw new Error('Unknown unit ' + units);
}
}
locale : moment.fn.locale,
toIsoString : deprecate(
- "toIsoString() is deprecated. Please use toISOString() instead " +
- "(notice the capitals)",
+ 'toIsoString() is deprecated. Please use toISOString() instead ' +
+ '(notice the capitals)',
function () {
return this.toISOString();
}
}
});
+ moment.duration.fn.toString = moment.duration.fn.toISOString;
+
function makeDurationGetter(name) {
moment.duration.fn[name] = function () {
return this._data[name];
}
for (i in unitMillisecondFactors) {
- if (unitMillisecondFactors.hasOwnProperty(i)) {
+ if (hasOwnProp(unitMillisecondFactors, i)) {
makeDurationGetter(i.toLowerCase());
}
}