|
0
|
1 //! moment.js
|
|
|
2 //! version : 2.5.1
|
|
|
3 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
|
|
|
4 //! license : MIT
|
|
|
5 //! momentjs.com
|
|
|
6
|
|
|
7 (function (undefined) {
|
|
|
8
|
|
|
9 /************************************
|
|
|
10 Constants
|
|
|
11 ************************************/
|
|
|
12
|
|
|
13 var moment,
|
|
|
14 VERSION = "2.5.1",
|
|
|
15 global = this,
|
|
|
16 round = Math.round,
|
|
|
17 i,
|
|
|
18
|
|
|
19 YEAR = 0,
|
|
|
20 MONTH = 1,
|
|
|
21 DATE = 2,
|
|
|
22 HOUR = 3,
|
|
|
23 MINUTE = 4,
|
|
|
24 SECOND = 5,
|
|
|
25 MILLISECOND = 6,
|
|
|
26
|
|
|
27 // internal storage for language config files
|
|
|
28 languages = {},
|
|
|
29
|
|
|
30 // moment internal properties
|
|
|
31 momentProperties = {
|
|
|
32 _isAMomentObject: null,
|
|
|
33 _i : null,
|
|
|
34 _f : null,
|
|
|
35 _l : null,
|
|
|
36 _strict : null,
|
|
|
37 _isUTC : null,
|
|
|
38 _offset : null, // optional. Combine with _isUTC
|
|
|
39 _pf : null,
|
|
|
40 _lang : null // optional
|
|
|
41 },
|
|
|
42
|
|
|
43 // check for nodeJS
|
|
|
44 hasModule = (typeof module !== 'undefined' && module.exports && typeof require !== 'undefined'),
|
|
|
45
|
|
|
46 // ASP.NET json date format regex
|
|
|
47 aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
|
|
|
48 aspNetTimeSpanJsonRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,
|
|
|
49
|
|
|
50 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
|
|
|
51 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
|
|
|
52 isoDurationRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,
|
|
|
53
|
|
|
54 // format tokens
|
|
|
55 formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|X|zz?|ZZ?|.)/g,
|
|
|
56 localFormattingTokens = /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,
|
|
|
57
|
|
|
58 // parsing token regexes
|
|
|
59 parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
|
|
|
60 parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
|
|
|
61 parseTokenOneToFourDigits = /\d{1,4}/, // 0 - 9999
|
|
|
62 parseTokenOneToSixDigits = /[+\-]?\d{1,6}/, // -999,999 - 999,999
|
|
|
63 parseTokenDigits = /\d+/, // nonzero number of digits
|
|
|
64 parseTokenWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, // any word (or two) characters or numbers including two/three word month in arabic.
|
|
|
65 parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
|
|
|
66 parseTokenT = /T/i, // T (ISO separator)
|
|
|
67 parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
|
|
|
68
|
|
|
69 //strict parsing regexes
|
|
|
70 parseTokenOneDigit = /\d/, // 0 - 9
|
|
|
71 parseTokenTwoDigits = /\d\d/, // 00 - 99
|
|
|
72 parseTokenThreeDigits = /\d{3}/, // 000 - 999
|
|
|
73 parseTokenFourDigits = /\d{4}/, // 0000 - 9999
|
|
|
74 parseTokenSixDigits = /[+-]?\d{6}/, // -999,999 - 999,999
|
|
|
75 parseTokenSignedNumber = /[+-]?\d+/, // -inf - inf
|
|
|
76
|
|
|
77 // iso 8601 regex
|
|
|
78 // 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)
|
|
|
79 isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
|
|
80
|
|
|
81 isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',
|
|
|
82
|
|
|
83 isoDates = [
|
|
|
84 ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
|
|
|
85 ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
|
|
|
86 ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
|
|
|
87 ['GGGG-[W]WW', /\d{4}-W\d{2}/],
|
|
|
88 ['YYYY-DDD', /\d{4}-\d{3}/]
|
|
|
89 ],
|
|
|
90
|
|
|
91 // iso time formats and regexes
|
|
|
92 isoTimes = [
|
|
|
93 ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d{1,3}/],
|
|
|
94 ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
|
|
|
95 ['HH:mm', /(T| )\d\d:\d\d/],
|
|
|
96 ['HH', /(T| )\d\d/]
|
|
|
97 ],
|
|
|
98
|
|
|
99 // timezone chunker "+10:00" > ["10", "00"] or "-1530" > ["-15", "30"]
|
|
|
100 parseTimezoneChunker = /([\+\-]|\d\d)/gi,
|
|
|
101
|
|
|
102 // getter and setter names
|
|
|
103 proxyGettersAndSetters = 'Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
|
|
|
104 unitMillisecondFactors = {
|
|
|
105 'Milliseconds' : 1,
|
|
|
106 'Seconds' : 1e3,
|
|
|
107 'Minutes' : 6e4,
|
|
|
108 'Hours' : 36e5,
|
|
|
109 'Days' : 864e5,
|
|
|
110 'Months' : 2592e6,
|
|
|
111 'Years' : 31536e6
|
|
|
112 },
|
|
|
113
|
|
|
114 unitAliases = {
|
|
|
115 ms : 'millisecond',
|
|
|
116 s : 'second',
|
|
|
117 m : 'minute',
|
|
|
118 h : 'hour',
|
|
|
119 d : 'day',
|
|
|
120 D : 'date',
|
|
|
121 w : 'week',
|
|
|
122 W : 'isoWeek',
|
|
|
123 M : 'month',
|
|
|
124 y : 'year',
|
|
|
125 DDD : 'dayOfYear',
|
|
|
126 e : 'weekday',
|
|
|
127 E : 'isoWeekday',
|
|
|
128 gg: 'weekYear',
|
|
|
129 GG: 'isoWeekYear'
|
|
|
130 },
|
|
|
131
|
|
|
132 camelFunctions = {
|
|
|
133 dayofyear : 'dayOfYear',
|
|
|
134 isoweekday : 'isoWeekday',
|
|
|
135 isoweek : 'isoWeek',
|
|
|
136 weekyear : 'weekYear',
|
|
|
137 isoweekyear : 'isoWeekYear'
|
|
|
138 },
|
|
|
139
|
|
|
140 // format function strings
|
|
|
141 formatFunctions = {},
|
|
|
142
|
|
|
143 // tokens to ordinalize and pad
|
|
|
144 ordinalizeTokens = 'DDD w W M D d'.split(' '),
|
|
|
145 paddedTokens = 'M D H h m s w W'.split(' '),
|
|
|
146
|
|
|
147 formatTokenFunctions = {
|
|
|
148 M : function () {
|
|
|
149 return this.month() + 1;
|
|
|
150 },
|
|
|
151 MMM : function (format) {
|
|
|
152 return this.lang().monthsShort(this, format);
|
|
|
153 },
|
|
|
154 MMMM : function (format) {
|
|
|
155 return this.lang().months(this, format);
|
|
|
156 },
|
|
|
157 D : function () {
|
|
|
158 return this.date();
|
|
|
159 },
|
|
|
160 DDD : function () {
|
|
|
161 return this.dayOfYear();
|
|
|
162 },
|
|
|
163 d : function () {
|
|
|
164 return this.day();
|
|
|
165 },
|
|
|
166 dd : function (format) {
|
|
|
167 return this.lang().weekdaysMin(this, format);
|
|
|
168 },
|
|
|
169 ddd : function (format) {
|
|
|
170 return this.lang().weekdaysShort(this, format);
|
|
|
171 },
|
|
|
172 dddd : function (format) {
|
|
|
173 return this.lang().weekdays(this, format);
|
|
|
174 },
|
|
|
175 w : function () {
|
|
|
176 return this.week();
|
|
|
177 },
|
|
|
178 W : function () {
|
|
|
179 return this.isoWeek();
|
|
|
180 },
|
|
|
181 YY : function () {
|
|
|
182 return leftZeroFill(this.year() % 100, 2);
|
|
|
183 },
|
|
|
184 YYYY : function () {
|
|
|
185 return leftZeroFill(this.year(), 4);
|
|
|
186 },
|
|
|
187 YYYYY : function () {
|
|
|
188 return leftZeroFill(this.year(), 5);
|
|
|
189 },
|
|
|
190 YYYYYY : function () {
|
|
|
191 var y = this.year(), sign = y >= 0 ? '+' : '-';
|
|
|
192 return sign + leftZeroFill(Math.abs(y), 6);
|
|
|
193 },
|
|
|
194 gg : function () {
|
|
|
195 return leftZeroFill(this.weekYear() % 100, 2);
|
|
|
196 },
|
|
|
197 gggg : function () {
|
|
|
198 return leftZeroFill(this.weekYear(), 4);
|
|
|
199 },
|
|
|
200 ggggg : function () {
|
|
|
201 return leftZeroFill(this.weekYear(), 5);
|
|
|
202 },
|
|
|
203 GG : function () {
|
|
|
204 return leftZeroFill(this.isoWeekYear() % 100, 2);
|
|
|
205 },
|
|
|
206 GGGG : function () {
|
|
|
207 return leftZeroFill(this.isoWeekYear(), 4);
|
|
|
208 },
|
|
|
209 GGGGG : function () {
|
|
|
210 return leftZeroFill(this.isoWeekYear(), 5);
|
|
|
211 },
|
|
|
212 e : function () {
|
|
|
213 return this.weekday();
|
|
|
214 },
|
|
|
215 E : function () {
|
|
|
216 return this.isoWeekday();
|
|
|
217 },
|
|
|
218 a : function () {
|
|
|
219 return this.lang().meridiem(this.hours(), this.minutes(), true);
|
|
|
220 },
|
|
|
221 A : function () {
|
|
|
222 return this.lang().meridiem(this.hours(), this.minutes(), false);
|
|
|
223 },
|
|
|
224 H : function () {
|
|
|
225 return this.hours();
|
|
|
226 },
|
|
|
227 h : function () {
|
|
|
228 return this.hours() % 12 || 12;
|
|
|
229 },
|
|
|
230 m : function () {
|
|
|
231 return this.minutes();
|
|
|
232 },
|
|
|
233 s : function () {
|
|
|
234 return this.seconds();
|
|
|
235 },
|
|
|
236 S : function () {
|
|
|
237 return toInt(this.milliseconds() / 100);
|
|
|
238 },
|
|
|
239 SS : function () {
|
|
|
240 return leftZeroFill(toInt(this.milliseconds() / 10), 2);
|
|
|
241 },
|
|
|
242 SSS : function () {
|
|
|
243 return leftZeroFill(this.milliseconds(), 3);
|
|
|
244 },
|
|
|
245 SSSS : function () {
|
|
|
246 return leftZeroFill(this.milliseconds(), 3);
|
|
|
247 },
|
|
|
248 Z : function () {
|
|
|
249 var a = -this.zone(),
|
|
|
250 b = "+";
|
|
|
251 if (a < 0) {
|
|
|
252 a = -a;
|
|
|
253 b = "-";
|
|
|
254 }
|
|
|
255 return b + leftZeroFill(toInt(a / 60), 2) + ":" + leftZeroFill(toInt(a) % 60, 2);
|
|
|
256 },
|
|
|
257 ZZ : function () {
|
|
|
258 var a = -this.zone(),
|
|
|
259 b = "+";
|
|
|
260 if (a < 0) {
|
|
|
261 a = -a;
|
|
|
262 b = "-";
|
|
|
263 }
|
|
|
264 return b + leftZeroFill(toInt(a / 60), 2) + leftZeroFill(toInt(a) % 60, 2);
|
|
|
265 },
|
|
|
266 z : function () {
|
|
|
267 return this.zoneAbbr();
|
|
|
268 },
|
|
|
269 zz : function () {
|
|
|
270 return this.zoneName();
|
|
|
271 },
|
|
|
272 X : function () {
|
|
|
273 return this.unix();
|
|
|
274 },
|
|
|
275 Q : function () {
|
|
|
276 return this.quarter();
|
|
|
277 }
|
|
|
278 },
|
|
|
279
|
|
|
280 lists = ['months', 'monthsShort', 'weekdays', 'weekdaysShort', 'weekdaysMin'];
|
|
|
281
|
|
|
282 function defaultParsingFlags() {
|
|
|
283 // We need to deep clone this object, and es5 standard is not very
|
|
|
284 // helpful.
|
|
|
285 return {
|
|
|
286 empty : false,
|
|
|
287 unusedTokens : [],
|
|
|
288 unusedInput : [],
|
|
|
289 overflow : -2,
|
|
|
290 charsLeftOver : 0,
|
|
|
291 nullInput : false,
|
|
|
292 invalidMonth : null,
|
|
|
293 invalidFormat : false,
|
|
|
294 userInvalidated : false,
|
|
|
295 iso: false
|
|
|
296 };
|
|
|
297 }
|
|
|
298
|
|
|
299 function padToken(func, count) {
|
|
|
300 return function (a) {
|
|
|
301 return leftZeroFill(func.call(this, a), count);
|
|
|
302 };
|
|
|
303 }
|
|
|
304 function ordinalizeToken(func, period) {
|
|
|
305 return function (a) {
|
|
|
306 return this.lang().ordinal(func.call(this, a), period);
|
|
|
307 };
|
|
|
308 }
|
|
|
309
|
|
|
310 while (ordinalizeTokens.length) {
|
|
|
311 i = ordinalizeTokens.pop();
|
|
|
312 formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i], i);
|
|
|
313 }
|
|
|
314 while (paddedTokens.length) {
|
|
|
315 i = paddedTokens.pop();
|
|
|
316 formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
|
|
|
317 }
|
|
|
318 formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);
|
|
|
319
|
|
|
320
|
|
|
321 /************************************
|
|
|
322 Constructors
|
|
|
323 ************************************/
|
|
|
324
|
|
|
325 function Language() {
|
|
|
326
|
|
|
327 }
|
|
|
328
|
|
|
329 // Moment prototype object
|
|
|
330 function Moment(config) {
|
|
|
331 checkOverflow(config);
|
|
|
332 extend(this, config);
|
|
|
333 }
|
|
|
334
|
|
|
335 // Duration Constructor
|
|
|
336 function Duration(duration) {
|
|
|
337 var normalizedInput = normalizeObjectUnits(duration),
|
|
|
338 years = normalizedInput.year || 0,
|
|
|
339 months = normalizedInput.month || 0,
|
|
|
340 weeks = normalizedInput.week || 0,
|
|
|
341 days = normalizedInput.day || 0,
|
|
|
342 hours = normalizedInput.hour || 0,
|
|
|
343 minutes = normalizedInput.minute || 0,
|
|
|
344 seconds = normalizedInput.second || 0,
|
|
|
345 milliseconds = normalizedInput.millisecond || 0;
|
|
|
346
|
|
|
347 // representation for dateAddRemove
|
|
|
348 this._milliseconds = +milliseconds +
|
|
|
349 seconds * 1e3 + // 1000
|
|
|
350 minutes * 6e4 + // 1000 * 60
|
|
|
351 hours * 36e5; // 1000 * 60 * 60
|
|
|
352 // Because of dateAddRemove treats 24 hours as different from a
|
|
|
353 // day when working around DST, we need to store them separately
|
|
|
354 this._days = +days +
|
|
|
355 weeks * 7;
|
|
|
356 // It is impossible translate months into days without knowing
|
|
|
357 // which months you are are talking about, so we have to store
|
|
|
358 // it separately.
|
|
|
359 this._months = +months +
|
|
|
360 years * 12;
|
|
|
361
|
|
|
362 this._data = {};
|
|
|
363
|
|
|
364 this._bubble();
|
|
|
365 }
|
|
|
366
|
|
|
367 /************************************
|
|
|
368 Helpers
|
|
|
369 ************************************/
|
|
|
370
|
|
|
371
|
|
|
372 function extend(a, b) {
|
|
|
373 for (var i in b) {
|
|
|
374 if (b.hasOwnProperty(i)) {
|
|
|
375 a[i] = b[i];
|
|
|
376 }
|
|
|
377 }
|
|
|
378
|
|
|
379 if (b.hasOwnProperty("toString")) {
|
|
|
380 a.toString = b.toString;
|
|
|
381 }
|
|
|
382
|
|
|
383 if (b.hasOwnProperty("valueOf")) {
|
|
|
384 a.valueOf = b.valueOf;
|
|
|
385 }
|
|
|
386
|
|
|
387 return a;
|
|
|
388 }
|
|
|
389
|
|
|
390 function cloneMoment(m) {
|
|
|
391 var result = {}, i;
|
|
|
392 for (i in m) {
|
|
|
393 if (m.hasOwnProperty(i) && momentProperties.hasOwnProperty(i)) {
|
|
|
394 result[i] = m[i];
|
|
|
395 }
|
|
|
396 }
|
|
|
397
|
|
|
398 return result;
|
|
|
399 }
|
|
|
400
|
|
|
401 function absRound(number) {
|
|
|
402 if (number < 0) {
|
|
|
403 return Math.ceil(number);
|
|
|
404 } else {
|
|
|
405 return Math.floor(number);
|
|
|
406 }
|
|
|
407 }
|
|
|
408
|
|
|
409 // left zero fill a number
|
|
|
410 // see http://jsperf.com/left-zero-filling for performance comparison
|
|
|
411 function leftZeroFill(number, targetLength, forceSign) {
|
|
|
412 var output = '' + Math.abs(number),
|
|
|
413 sign = number >= 0;
|
|
|
414
|
|
|
415 while (output.length < targetLength) {
|
|
|
416 output = '0' + output;
|
|
|
417 }
|
|
|
418 return (sign ? (forceSign ? '+' : '') : '-') + output;
|
|
|
419 }
|
|
|
420
|
|
|
421 // helper function for _.addTime and _.subtractTime
|
|
|
422 function addOrSubtractDurationFromMoment(mom, duration, isAdding, ignoreUpdateOffset) {
|
|
|
423 var milliseconds = duration._milliseconds,
|
|
|
424 days = duration._days,
|
|
|
425 months = duration._months,
|
|
|
426 minutes,
|
|
|
427 hours;
|
|
|
428
|
|
|
429 if (milliseconds) {
|
|
|
430 mom._d.setTime(+mom._d + milliseconds * isAdding);
|
|
|
431 }
|
|
|
432 // store the minutes and hours so we can restore them
|
|
|
433 if (days || months) {
|
|
|
434 minutes = mom.minute();
|
|
|
435 hours = mom.hour();
|
|
|
436 }
|
|
|
437 if (days) {
|
|
|
438 mom.date(mom.date() + days * isAdding);
|
|
|
439 }
|
|
|
440 if (months) {
|
|
|
441 mom.month(mom.month() + months * isAdding);
|
|
|
442 }
|
|
|
443 if (milliseconds && !ignoreUpdateOffset) {
|
|
|
444 moment.updateOffset(mom);
|
|
|
445 }
|
|
|
446 // restore the minutes and hours after possibly changing dst
|
|
|
447 if (days || months) {
|
|
|
448 mom.minute(minutes);
|
|
|
449 mom.hour(hours);
|
|
|
450 }
|
|
|
451 }
|
|
|
452
|
|
|
453 // check if is an array
|
|
|
454 function isArray(input) {
|
|
|
455 return Object.prototype.toString.call(input) === '[object Array]';
|
|
|
456 }
|
|
|
457
|
|
|
458 function isDate(input) {
|
|
|
459 return Object.prototype.toString.call(input) === '[object Date]' ||
|
|
|
460 input instanceof Date;
|
|
|
461 }
|
|
|
462
|
|
|
463 // compare two arrays, return the number of differences
|
|
|
464 function compareArrays(array1, array2, dontConvert) {
|
|
|
465 var len = Math.min(array1.length, array2.length),
|
|
|
466 lengthDiff = Math.abs(array1.length - array2.length),
|
|
|
467 diffs = 0,
|
|
|
468 i;
|
|
|
469 for (i = 0; i < len; i++) {
|
|
|
470 if ((dontConvert && array1[i] !== array2[i]) ||
|
|
|
471 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
|
|
|
472 diffs++;
|
|
|
473 }
|
|
|
474 }
|
|
|
475 return diffs + lengthDiff;
|
|
|
476 }
|
|
|
477
|
|
|
478 function normalizeUnits(units) {
|
|
|
479 if (units) {
|
|
|
480 var lowered = units.toLowerCase().replace(/(.)s$/, '$1');
|
|
|
481 units = unitAliases[units] || camelFunctions[lowered] || lowered;
|
|
|
482 }
|
|
|
483 return units;
|
|
|
484 }
|
|
|
485
|
|
|
486 function normalizeObjectUnits(inputObject) {
|
|
|
487 var normalizedInput = {},
|
|
|
488 normalizedProp,
|
|
|
489 prop;
|
|
|
490
|
|
|
491 for (prop in inputObject) {
|
|
|
492 if (inputObject.hasOwnProperty(prop)) {
|
|
|
493 normalizedProp = normalizeUnits(prop);
|
|
|
494 if (normalizedProp) {
|
|
|
495 normalizedInput[normalizedProp] = inputObject[prop];
|
|
|
496 }
|
|
|
497 }
|
|
|
498 }
|
|
|
499
|
|
|
500 return normalizedInput;
|
|
|
501 }
|
|
|
502
|
|
|
503 function makeList(field) {
|
|
|
504 var count, setter;
|
|
|
505
|
|
|
506 if (field.indexOf('week') === 0) {
|
|
|
507 count = 7;
|
|
|
508 setter = 'day';
|
|
|
509 }
|
|
|
510 else if (field.indexOf('month') === 0) {
|
|
|
511 count = 12;
|
|
|
512 setter = 'month';
|
|
|
513 }
|
|
|
514 else {
|
|
|
515 return;
|
|
|
516 }
|
|
|
517
|
|
|
518 moment[field] = function (format, index) {
|
|
|
519 var i, getter,
|
|
|
520 method = moment.fn._lang[field],
|
|
|
521 results = [];
|
|
|
522
|
|
|
523 if (typeof format === 'number') {
|
|
|
524 index = format;
|
|
|
525 format = undefined;
|
|
|
526 }
|
|
|
527
|
|
|
528 getter = function (i) {
|
|
|
529 var m = moment().utc().set(setter, i);
|
|
|
530 return method.call(moment.fn._lang, m, format || '');
|
|
|
531 };
|
|
|
532
|
|
|
533 if (index != null) {
|
|
|
534 return getter(index);
|
|
|
535 }
|
|
|
536 else {
|
|
|
537 for (i = 0; i < count; i++) {
|
|
|
538 results.push(getter(i));
|
|
|
539 }
|
|
|
540 return results;
|
|
|
541 }
|
|
|
542 };
|
|
|
543 }
|
|
|
544
|
|
|
545 function toInt(argumentForCoercion) {
|
|
|
546 var coercedNumber = +argumentForCoercion,
|
|
|
547 value = 0;
|
|
|
548
|
|
|
549 if (coercedNumber !== 0 && isFinite(coercedNumber)) {
|
|
|
550 if (coercedNumber >= 0) {
|
|
|
551 value = Math.floor(coercedNumber);
|
|
|
552 } else {
|
|
|
553 value = Math.ceil(coercedNumber);
|
|
|
554 }
|
|
|
555 }
|
|
|
556
|
|
|
557 return value;
|
|
|
558 }
|
|
|
559
|
|
|
560 function daysInMonth(year, month) {
|
|
|
561 return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
|
|
|
562 }
|
|
|
563
|
|
|
564 function daysInYear(year) {
|
|
|
565 return isLeapYear(year) ? 366 : 365;
|
|
|
566 }
|
|
|
567
|
|
|
568 function isLeapYear(year) {
|
|
|
569 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
|
|
|
570 }
|
|
|
571
|
|
|
572 function checkOverflow(m) {
|
|
|
573 var overflow;
|
|
|
574 if (m._a && m._pf.overflow === -2) {
|
|
|
575 overflow =
|
|
|
576 m._a[MONTH] < 0 || m._a[MONTH] > 11 ? MONTH :
|
|
|
577 m._a[DATE] < 1 || m._a[DATE] > daysInMonth(m._a[YEAR], m._a[MONTH]) ? DATE :
|
|
|
578 m._a[HOUR] < 0 || m._a[HOUR] > 23 ? HOUR :
|
|
|
579 m._a[MINUTE] < 0 || m._a[MINUTE] > 59 ? MINUTE :
|
|
|
580 m._a[SECOND] < 0 || m._a[SECOND] > 59 ? SECOND :
|
|
|
581 m._a[MILLISECOND] < 0 || m._a[MILLISECOND] > 999 ? MILLISECOND :
|
|
|
582 -1;
|
|
|
583
|
|
|
584 if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
|
|
|
585 overflow = DATE;
|
|
|
586 }
|
|
|
587
|
|
|
588 m._pf.overflow = overflow;
|
|
|
589 }
|
|
|
590 }
|
|
|
591
|
|
|
592 function isValid(m) {
|
|
|
593 if (m._isValid == null) {
|
|
|
594 m._isValid = !isNaN(m._d.getTime()) &&
|
|
|
595 m._pf.overflow < 0 &&
|
|
|
596 !m._pf.empty &&
|
|
|
597 !m._pf.invalidMonth &&
|
|
|
598 !m._pf.nullInput &&
|
|
|
599 !m._pf.invalidFormat &&
|
|
|
600 !m._pf.userInvalidated;
|
|
|
601
|
|
|
602 if (m._strict) {
|
|
|
603 m._isValid = m._isValid &&
|
|
|
604 m._pf.charsLeftOver === 0 &&
|
|
|
605 m._pf.unusedTokens.length === 0;
|
|
|
606 }
|
|
|
607 }
|
|
|
608 return m._isValid;
|
|
|
609 }
|
|
|
610
|
|
|
611 function normalizeLanguage(key) {
|
|
|
612 return key ? key.toLowerCase().replace('_', '-') : key;
|
|
|
613 }
|
|
|
614
|
|
|
615 // Return a moment from input, that is local/utc/zone equivalent to model.
|
|
|
616 function makeAs(input, model) {
|
|
|
617 return model._isUTC ? moment(input).zone(model._offset || 0) :
|
|
|
618 moment(input).local();
|
|
|
619 }
|
|
|
620
|
|
|
621 /************************************
|
|
|
622 Languages
|
|
|
623 ************************************/
|
|
|
624
|
|
|
625
|
|
|
626 extend(Language.prototype, {
|
|
|
627
|
|
|
628 set : function (config) {
|
|
|
629 var prop, i;
|
|
|
630 for (i in config) {
|
|
|
631 prop = config[i];
|
|
|
632 if (typeof prop === 'function') {
|
|
|
633 this[i] = prop;
|
|
|
634 } else {
|
|
|
635 this['_' + i] = prop;
|
|
|
636 }
|
|
|
637 }
|
|
|
638 },
|
|
|
639
|
|
|
640 _months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
|
|
|
641 months : function (m) {
|
|
|
642 return this._months[m.month()];
|
|
|
643 },
|
|
|
644
|
|
|
645 _monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
|
|
|
646 monthsShort : function (m) {
|
|
|
647 return this._monthsShort[m.month()];
|
|
|
648 },
|
|
|
649
|
|
|
650 monthsParse : function (monthName) {
|
|
|
651 var i, mom, regex;
|
|
|
652
|
|
|
653 if (!this._monthsParse) {
|
|
|
654 this._monthsParse = [];
|
|
|
655 }
|
|
|
656
|
|
|
657 for (i = 0; i < 12; i++) {
|
|
|
658 // make the regex if we don't have it already
|
|
|
659 if (!this._monthsParse[i]) {
|
|
|
660 mom = moment.utc([2000, i]);
|
|
|
661 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
|
|
|
662 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
|
|
|
663 }
|
|
|
664 // test the regex
|
|
|
665 if (this._monthsParse[i].test(monthName)) {
|
|
|
666 return i;
|
|
|
667 }
|
|
|
668 }
|
|
|
669 },
|
|
|
670
|
|
|
671 _weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
|
|
|
672 weekdays : function (m) {
|
|
|
673 return this._weekdays[m.day()];
|
|
|
674 },
|
|
|
675
|
|
|
676 _weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
|
|
|
677 weekdaysShort : function (m) {
|
|
|
678 return this._weekdaysShort[m.day()];
|
|
|
679 },
|
|
|
680
|
|
|
681 _weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
|
|
|
682 weekdaysMin : function (m) {
|
|
|
683 return this._weekdaysMin[m.day()];
|
|
|
684 },
|
|
|
685
|
|
|
686 weekdaysParse : function (weekdayName) {
|
|
|
687 var i, mom, regex;
|
|
|
688
|
|
|
689 if (!this._weekdaysParse) {
|
|
|
690 this._weekdaysParse = [];
|
|
|
691 }
|
|
|
692
|
|
|
693 for (i = 0; i < 7; i++) {
|
|
|
694 // make the regex if we don't have it already
|
|
|
695 if (!this._weekdaysParse[i]) {
|
|
|
696 mom = moment([2000, 1]).day(i);
|
|
|
697 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
|
|
|
698 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
|
|
|
699 }
|
|
|
700 // test the regex
|
|
|
701 if (this._weekdaysParse[i].test(weekdayName)) {
|
|
|
702 return i;
|
|
|
703 }
|
|
|
704 }
|
|
|
705 },
|
|
|
706
|
|
|
707 _longDateFormat : {
|
|
|
708 LT : "h:mm A",
|
|
|
709 L : "MM/DD/YYYY",
|
|
|
710 LL : "MMMM D YYYY",
|
|
|
711 LLL : "MMMM D YYYY LT",
|
|
|
712 LLLL : "dddd, MMMM D YYYY LT"
|
|
|
713 },
|
|
|
714 longDateFormat : function (key) {
|
|
|
715 var output = this._longDateFormat[key];
|
|
|
716 if (!output && this._longDateFormat[key.toUpperCase()]) {
|
|
|
717 output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
|
|
|
718 return val.slice(1);
|
|
|
719 });
|
|
|
720 this._longDateFormat[key] = output;
|
|
|
721 }
|
|
|
722 return output;
|
|
|
723 },
|
|
|
724
|
|
|
725 isPM : function (input) {
|
|
|
726 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
|
|
|
727 // Using charAt should be more compatible.
|
|
|
728 return ((input + '').toLowerCase().charAt(0) === 'p');
|
|
|
729 },
|
|
|
730
|
|
|
731 _meridiemParse : /[ap]\.?m?\.?/i,
|
|
|
732 meridiem : function (hours, minutes, isLower) {
|
|
|
733 if (hours > 11) {
|
|
|
734 return isLower ? 'pm' : 'PM';
|
|
|
735 } else {
|
|
|
736 return isLower ? 'am' : 'AM';
|
|
|
737 }
|
|
|
738 },
|
|
|
739
|
|
|
740 _calendar : {
|
|
|
741 sameDay : '[Today at] LT',
|
|
|
742 nextDay : '[Tomorrow at] LT',
|
|
|
743 nextWeek : 'dddd [at] LT',
|
|
|
744 lastDay : '[Yesterday at] LT',
|
|
|
745 lastWeek : '[Last] dddd [at] LT',
|
|
|
746 sameElse : 'L'
|
|
|
747 },
|
|
|
748 calendar : function (key, mom) {
|
|
|
749 var output = this._calendar[key];
|
|
|
750 return typeof output === 'function' ? output.apply(mom) : output;
|
|
|
751 },
|
|
|
752
|
|
|
753 _relativeTime : {
|
|
|
754 future : "in %s",
|
|
|
755 past : "%s ago",
|
|
|
756 s : "a few seconds",
|
|
|
757 m : "a minute",
|
|
|
758 mm : "%d minutes",
|
|
|
759 h : "an hour",
|
|
|
760 hh : "%d hours",
|
|
|
761 d : "a day",
|
|
|
762 dd : "%d days",
|
|
|
763 M : "a month",
|
|
|
764 MM : "%d months",
|
|
|
765 y : "a year",
|
|
|
766 yy : "%d years"
|
|
|
767 },
|
|
|
768 relativeTime : function (number, withoutSuffix, string, isFuture) {
|
|
|
769 var output = this._relativeTime[string];
|
|
|
770 return (typeof output === 'function') ?
|
|
|
771 output(number, withoutSuffix, string, isFuture) :
|
|
|
772 output.replace(/%d/i, number);
|
|
|
773 },
|
|
|
774 pastFuture : function (diff, output) {
|
|
|
775 var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
|
|
|
776 return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
|
|
|
777 },
|
|
|
778
|
|
|
779 ordinal : function (number) {
|
|
|
780 return this._ordinal.replace("%d", number);
|
|
|
781 },
|
|
|
782 _ordinal : "%d",
|
|
|
783
|
|
|
784 preparse : function (string) {
|
|
|
785 return string;
|
|
|
786 },
|
|
|
787
|
|
|
788 postformat : function (string) {
|
|
|
789 return string;
|
|
|
790 },
|
|
|
791
|
|
|
792 week : function (mom) {
|
|
|
793 return weekOfYear(mom, this._week.dow, this._week.doy).week;
|
|
|
794 },
|
|
|
795
|
|
|
796 _week : {
|
|
|
797 dow : 0, // Sunday is the first day of the week.
|
|
|
798 doy : 6 // The week that contains Jan 1st is the first week of the year.
|
|
|
799 },
|
|
|
800
|
|
|
801 _invalidDate: 'Invalid date',
|
|
|
802 invalidDate: function () {
|
|
|
803 return this._invalidDate;
|
|
|
804 }
|
|
|
805 });
|
|
|
806
|
|
|
807 // Loads a language definition into the `languages` cache. The function
|
|
|
808 // takes a key and optionally values. If not in the browser and no values
|
|
|
809 // are provided, it will load the language file module. As a convenience,
|
|
|
810 // this function also returns the language values.
|
|
|
811 function loadLang(key, values) {
|
|
|
812 values.abbr = key;
|
|
|
813 if (!languages[key]) {
|
|
|
814 languages[key] = new Language();
|
|
|
815 }
|
|
|
816 languages[key].set(values);
|
|
|
817 return languages[key];
|
|
|
818 }
|
|
|
819
|
|
|
820 // Remove a language from the `languages` cache. Mostly useful in tests.
|
|
|
821 function unloadLang(key) {
|
|
|
822 delete languages[key];
|
|
|
823 }
|
|
|
824
|
|
|
825 // Determines which language definition to use and returns it.
|
|
|
826 //
|
|
|
827 // With no parameters, it will return the global language. If you
|
|
|
828 // pass in a language key, such as 'en', it will return the
|
|
|
829 // definition for 'en', so long as 'en' has already been loaded using
|
|
|
830 // moment.lang.
|
|
|
831 function getLangDefinition(key) {
|
|
|
832 var i = 0, j, lang, next, split,
|
|
|
833 get = function (k) {
|
|
|
834 if (!languages[k] && hasModule) {
|
|
|
835 try {
|
|
|
836 require('./lang/' + k);
|
|
|
837 } catch (e) { }
|
|
|
838 }
|
|
|
839 return languages[k];
|
|
|
840 };
|
|
|
841
|
|
|
842 if (!key) {
|
|
|
843 return moment.fn._lang;
|
|
|
844 }
|
|
|
845
|
|
|
846 if (!isArray(key)) {
|
|
|
847 //short-circuit everything else
|
|
|
848 lang = get(key);
|
|
|
849 if (lang) {
|
|
|
850 return lang;
|
|
|
851 }
|
|
|
852 key = [key];
|
|
|
853 }
|
|
|
854
|
|
|
855 //pick the language from the array
|
|
|
856 //try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
|
|
|
857 //substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
|
|
|
858 while (i < key.length) {
|
|
|
859 split = normalizeLanguage(key[i]).split('-');
|
|
|
860 j = split.length;
|
|
|
861 next = normalizeLanguage(key[i + 1]);
|
|
|
862 next = next ? next.split('-') : null;
|
|
|
863 while (j > 0) {
|
|
|
864 lang = get(split.slice(0, j).join('-'));
|
|
|
865 if (lang) {
|
|
|
866 return lang;
|
|
|
867 }
|
|
|
868 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
|
|
|
869 //the next array item is better than a shallower substring of this one
|
|
|
870 break;
|
|
|
871 }
|
|
|
872 j--;
|
|
|
873 }
|
|
|
874 i++;
|
|
|
875 }
|
|
|
876 return moment.fn._lang;
|
|
|
877 }
|
|
|
878
|
|
|
879 /************************************
|
|
|
880 Formatting
|
|
|
881 ************************************/
|
|
|
882
|
|
|
883
|
|
|
884 function removeFormattingTokens(input) {
|
|
|
885 if (input.match(/\[[\s\S]/)) {
|
|
|
886 return input.replace(/^\[|\]$/g, "");
|
|
|
887 }
|
|
|
888 return input.replace(/\\/g, "");
|
|
|
889 }
|
|
|
890
|
|
|
891 function makeFormatFunction(format) {
|
|
|
892 var array = format.match(formattingTokens), i, length;
|
|
|
893
|
|
|
894 for (i = 0, length = array.length; i < length; i++) {
|
|
|
895 if (formatTokenFunctions[array[i]]) {
|
|
|
896 array[i] = formatTokenFunctions[array[i]];
|
|
|
897 } else {
|
|
|
898 array[i] = removeFormattingTokens(array[i]);
|
|
|
899 }
|
|
|
900 }
|
|
|
901
|
|
|
902 return function (mom) {
|
|
|
903 var output = "";
|
|
|
904 for (i = 0; i < length; i++) {
|
|
|
905 output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
|
|
|
906 }
|
|
|
907 return output;
|
|
|
908 };
|
|
|
909 }
|
|
|
910
|
|
|
911 // format date using native date object
|
|
|
912 function formatMoment(m, format) {
|
|
|
913
|
|
|
914 if (!m.isValid()) {
|
|
|
915 return m.lang().invalidDate();
|
|
|
916 }
|
|
|
917
|
|
|
918 format = expandFormat(format, m.lang());
|
|
|
919
|
|
|
920 if (!formatFunctions[format]) {
|
|
|
921 formatFunctions[format] = makeFormatFunction(format);
|
|
|
922 }
|
|
|
923
|
|
|
924 return formatFunctions[format](m);
|
|
|
925 }
|
|
|
926
|
|
|
927 function expandFormat(format, lang) {
|
|
|
928 var i = 5;
|
|
|
929
|
|
|
930 function replaceLongDateFormatTokens(input) {
|
|
|
931 return lang.longDateFormat(input) || input;
|
|
|
932 }
|
|
|
933
|
|
|
934 localFormattingTokens.lastIndex = 0;
|
|
|
935 while (i >= 0 && localFormattingTokens.test(format)) {
|
|
|
936 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
|
|
|
937 localFormattingTokens.lastIndex = 0;
|
|
|
938 i -= 1;
|
|
|
939 }
|
|
|
940
|
|
|
941 return format;
|
|
|
942 }
|
|
|
943
|
|
|
944
|
|
|
945 /************************************
|
|
|
946 Parsing
|
|
|
947 ************************************/
|
|
|
948
|
|
|
949
|
|
|
950 // get the regex to find the next token
|
|
|
951 function getParseRegexForToken(token, config) {
|
|
|
952 var a, strict = config._strict;
|
|
|
953 switch (token) {
|
|
|
954 case 'DDDD':
|
|
|
955 return parseTokenThreeDigits;
|
|
|
956 case 'YYYY':
|
|
|
957 case 'GGGG':
|
|
|
958 case 'gggg':
|
|
|
959 return strict ? parseTokenFourDigits : parseTokenOneToFourDigits;
|
|
|
960 case 'Y':
|
|
|
961 case 'G':
|
|
|
962 case 'g':
|
|
|
963 return parseTokenSignedNumber;
|
|
|
964 case 'YYYYYY':
|
|
|
965 case 'YYYYY':
|
|
|
966 case 'GGGGG':
|
|
|
967 case 'ggggg':
|
|
|
968 return strict ? parseTokenSixDigits : parseTokenOneToSixDigits;
|
|
|
969 case 'S':
|
|
|
970 if (strict) { return parseTokenOneDigit; }
|
|
|
971 /* falls through */
|
|
|
972 case 'SS':
|
|
|
973 if (strict) { return parseTokenTwoDigits; }
|
|
|
974 /* falls through */
|
|
|
975 case 'SSS':
|
|
|
976 if (strict) { return parseTokenThreeDigits; }
|
|
|
977 /* falls through */
|
|
|
978 case 'DDD':
|
|
|
979 return parseTokenOneToThreeDigits;
|
|
|
980 case 'MMM':
|
|
|
981 case 'MMMM':
|
|
|
982 case 'dd':
|
|
|
983 case 'ddd':
|
|
|
984 case 'dddd':
|
|
|
985 return parseTokenWord;
|
|
|
986 case 'a':
|
|
|
987 case 'A':
|
|
|
988 return getLangDefinition(config._l)._meridiemParse;
|
|
|
989 case 'X':
|
|
|
990 return parseTokenTimestampMs;
|
|
|
991 case 'Z':
|
|
|
992 case 'ZZ':
|
|
|
993 return parseTokenTimezone;
|
|
|
994 case 'T':
|
|
|
995 return parseTokenT;
|
|
|
996 case 'SSSS':
|
|
|
997 return parseTokenDigits;
|
|
|
998 case 'MM':
|
|
|
999 case 'DD':
|
|
|
1000 case 'YY':
|
|
|
1001 case 'GG':
|
|
|
1002 case 'gg':
|
|
|
1003 case 'HH':
|
|
|
1004 case 'hh':
|
|
|
1005 case 'mm':
|
|
|
1006 case 'ss':
|
|
|
1007 case 'ww':
|
|
|
1008 case 'WW':
|
|
|
1009 return strict ? parseTokenTwoDigits : parseTokenOneOrTwoDigits;
|
|
|
1010 case 'M':
|
|
|
1011 case 'D':
|
|
|
1012 case 'd':
|
|
|
1013 case 'H':
|
|
|
1014 case 'h':
|
|
|
1015 case 'm':
|
|
|
1016 case 's':
|
|
|
1017 case 'w':
|
|
|
1018 case 'W':
|
|
|
1019 case 'e':
|
|
|
1020 case 'E':
|
|
|
1021 return parseTokenOneOrTwoDigits;
|
|
|
1022 default :
|
|
|
1023 a = new RegExp(regexpEscape(unescapeFormat(token.replace('\\', '')), "i"));
|
|
|
1024 return a;
|
|
|
1025 }
|
|
|
1026 }
|
|
|
1027
|
|
|
1028 function timezoneMinutesFromString(string) {
|
|
|
1029 string = string || "";
|
|
|
1030 var possibleTzMatches = (string.match(parseTokenTimezone) || []),
|
|
|
1031 tzChunk = possibleTzMatches[possibleTzMatches.length - 1] || [],
|
|
|
1032 parts = (tzChunk + '').match(parseTimezoneChunker) || ['-', 0, 0],
|
|
|
1033 minutes = +(parts[1] * 60) + toInt(parts[2]);
|
|
|
1034
|
|
|
1035 return parts[0] === '+' ? -minutes : minutes;
|
|
|
1036 }
|
|
|
1037
|
|
|
1038 // function to convert string input to date
|
|
|
1039 function addTimeToArrayFromToken(token, input, config) {
|
|
|
1040 var a, datePartArray = config._a;
|
|
|
1041
|
|
|
1042 switch (token) {
|
|
|
1043 // MONTH
|
|
|
1044 case 'M' : // fall through to MM
|
|
|
1045 case 'MM' :
|
|
|
1046 if (input != null) {
|
|
|
1047 datePartArray[MONTH] = toInt(input) - 1;
|
|
|
1048 }
|
|
|
1049 break;
|
|
|
1050 case 'MMM' : // fall through to MMMM
|
|
|
1051 case 'MMMM' :
|
|
|
1052 a = getLangDefinition(config._l).monthsParse(input);
|
|
|
1053 // if we didn't find a month name, mark the date as invalid.
|
|
|
1054 if (a != null) {
|
|
|
1055 datePartArray[MONTH] = a;
|
|
|
1056 } else {
|
|
|
1057 config._pf.invalidMonth = input;
|
|
|
1058 }
|
|
|
1059 break;
|
|
|
1060 // DAY OF MONTH
|
|
|
1061 case 'D' : // fall through to DD
|
|
|
1062 case 'DD' :
|
|
|
1063 if (input != null) {
|
|
|
1064 datePartArray[DATE] = toInt(input);
|
|
|
1065 }
|
|
|
1066 break;
|
|
|
1067 // DAY OF YEAR
|
|
|
1068 case 'DDD' : // fall through to DDDD
|
|
|
1069 case 'DDDD' :
|
|
|
1070 if (input != null) {
|
|
|
1071 config._dayOfYear = toInt(input);
|
|
|
1072 }
|
|
|
1073
|
|
|
1074 break;
|
|
|
1075 // YEAR
|
|
|
1076 case 'YY' :
|
|
|
1077 datePartArray[YEAR] = toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
|
|
|
1078 break;
|
|
|
1079 case 'YYYY' :
|
|
|
1080 case 'YYYYY' :
|
|
|
1081 case 'YYYYYY' :
|
|
|
1082 datePartArray[YEAR] = toInt(input);
|
|
|
1083 break;
|
|
|
1084 // AM / PM
|
|
|
1085 case 'a' : // fall through to A
|
|
|
1086 case 'A' :
|
|
|
1087 config._isPm = getLangDefinition(config._l).isPM(input);
|
|
|
1088 break;
|
|
|
1089 // 24 HOUR
|
|
|
1090 case 'H' : // fall through to hh
|
|
|
1091 case 'HH' : // fall through to hh
|
|
|
1092 case 'h' : // fall through to hh
|
|
|
1093 case 'hh' :
|
|
|
1094 datePartArray[HOUR] = toInt(input);
|
|
|
1095 break;
|
|
|
1096 // MINUTE
|
|
|
1097 case 'm' : // fall through to mm
|
|
|
1098 case 'mm' :
|
|
|
1099 datePartArray[MINUTE] = toInt(input);
|
|
|
1100 break;
|
|
|
1101 // SECOND
|
|
|
1102 case 's' : // fall through to ss
|
|
|
1103 case 'ss' :
|
|
|
1104 datePartArray[SECOND] = toInt(input);
|
|
|
1105 break;
|
|
|
1106 // MILLISECOND
|
|
|
1107 case 'S' :
|
|
|
1108 case 'SS' :
|
|
|
1109 case 'SSS' :
|
|
|
1110 case 'SSSS' :
|
|
|
1111 datePartArray[MILLISECOND] = toInt(('0.' + input) * 1000);
|
|
|
1112 break;
|
|
|
1113 // UNIX TIMESTAMP WITH MS
|
|
|
1114 case 'X':
|
|
|
1115 config._d = new Date(parseFloat(input) * 1000);
|
|
|
1116 break;
|
|
|
1117 // TIMEZONE
|
|
|
1118 case 'Z' : // fall through to ZZ
|
|
|
1119 case 'ZZ' :
|
|
|
1120 config._useUTC = true;
|
|
|
1121 config._tzm = timezoneMinutesFromString(input);
|
|
|
1122 break;
|
|
|
1123 case 'w':
|
|
|
1124 case 'ww':
|
|
|
1125 case 'W':
|
|
|
1126 case 'WW':
|
|
|
1127 case 'd':
|
|
|
1128 case 'dd':
|
|
|
1129 case 'ddd':
|
|
|
1130 case 'dddd':
|
|
|
1131 case 'e':
|
|
|
1132 case 'E':
|
|
|
1133 token = token.substr(0, 1);
|
|
|
1134 /* falls through */
|
|
|
1135 case 'gg':
|
|
|
1136 case 'gggg':
|
|
|
1137 case 'GG':
|
|
|
1138 case 'GGGG':
|
|
|
1139 case 'GGGGG':
|
|
|
1140 token = token.substr(0, 2);
|
|
|
1141 if (input) {
|
|
|
1142 config._w = config._w || {};
|
|
|
1143 config._w[token] = input;
|
|
|
1144 }
|
|
|
1145 break;
|
|
|
1146 }
|
|
|
1147 }
|
|
|
1148
|
|
|
1149 // convert an array to a date.
|
|
|
1150 // the array should mirror the parameters below
|
|
|
1151 // note: all values past the year are optional and will default to the lowest possible value.
|
|
|
1152 // [year, month, day , hour, minute, second, millisecond]
|
|
|
1153 function dateFromConfig(config) {
|
|
|
1154 var i, date, input = [], currentDate,
|
|
|
1155 yearToUse, fixYear, w, temp, lang, weekday, week;
|
|
|
1156
|
|
|
1157 if (config._d) {
|
|
|
1158 return;
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 currentDate = currentDateArray(config);
|
|
|
1162
|
|
|
1163 //compute day of the year from weeks and weekdays
|
|
|
1164 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
|
|
|
1165 fixYear = function (val) {
|
|
|
1166 var int_val = parseInt(val, 10);
|
|
|
1167 return val ?
|
|
|
1168 (val.length < 3 ? (int_val > 68 ? 1900 + int_val : 2000 + int_val) : int_val) :
|
|
|
1169 (config._a[YEAR] == null ? moment().weekYear() : config._a[YEAR]);
|
|
|
1170 };
|
|
|
1171
|
|
|
1172 w = config._w;
|
|
|
1173 if (w.GG != null || w.W != null || w.E != null) {
|
|
|
1174 temp = dayOfYearFromWeeks(fixYear(w.GG), w.W || 1, w.E, 4, 1);
|
|
|
1175 }
|
|
|
1176 else {
|
|
|
1177 lang = getLangDefinition(config._l);
|
|
|
1178 weekday = w.d != null ? parseWeekday(w.d, lang) :
|
|
|
1179 (w.e != null ? parseInt(w.e, 10) + lang._week.dow : 0);
|
|
|
1180
|
|
|
1181 week = parseInt(w.w, 10) || 1;
|
|
|
1182
|
|
|
1183 //if we're parsing 'd', then the low day numbers may be next week
|
|
|
1184 if (w.d != null && weekday < lang._week.dow) {
|
|
|
1185 week++;
|
|
|
1186 }
|
|
|
1187
|
|
|
1188 temp = dayOfYearFromWeeks(fixYear(w.gg), week, weekday, lang._week.doy, lang._week.dow);
|
|
|
1189 }
|
|
|
1190
|
|
|
1191 config._a[YEAR] = temp.year;
|
|
|
1192 config._dayOfYear = temp.dayOfYear;
|
|
|
1193 }
|
|
|
1194
|
|
|
1195 //if the day of the year is set, figure out what it is
|
|
|
1196 if (config._dayOfYear) {
|
|
|
1197 yearToUse = config._a[YEAR] == null ? currentDate[YEAR] : config._a[YEAR];
|
|
|
1198
|
|
|
1199 if (config._dayOfYear > daysInYear(yearToUse)) {
|
|
|
1200 config._pf._overflowDayOfYear = true;
|
|
|
1201 }
|
|
|
1202
|
|
|
1203 date = makeUTCDate(yearToUse, 0, config._dayOfYear);
|
|
|
1204 config._a[MONTH] = date.getUTCMonth();
|
|
|
1205 config._a[DATE] = date.getUTCDate();
|
|
|
1206 }
|
|
|
1207
|
|
|
1208 // Default to current date.
|
|
|
1209 // * if no year, month, day of month are given, default to today
|
|
|
1210 // * if day of month is given, default month and year
|
|
|
1211 // * if month is given, default only year
|
|
|
1212 // * if year is given, don't default anything
|
|
|
1213 for (i = 0; i < 3 && config._a[i] == null; ++i) {
|
|
|
1214 config._a[i] = input[i] = currentDate[i];
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 // Zero out whatever was not defaulted, including time
|
|
|
1218 for (; i < 7; i++) {
|
|
|
1219 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
|
|
|
1220 }
|
|
|
1221
|
|
|
1222 // add the offsets to the time to be parsed so that we can have a clean array for checking isValid
|
|
|
1223 input[HOUR] += toInt((config._tzm || 0) / 60);
|
|
|
1224 input[MINUTE] += toInt((config._tzm || 0) % 60);
|
|
|
1225
|
|
|
1226 config._d = (config._useUTC ? makeUTCDate : makeDate).apply(null, input);
|
|
|
1227 }
|
|
|
1228
|
|
|
1229 function dateFromObject(config) {
|
|
|
1230 var normalizedInput;
|
|
|
1231
|
|
|
1232 if (config._d) {
|
|
|
1233 return;
|
|
|
1234 }
|
|
|
1235
|
|
|
1236 normalizedInput = normalizeObjectUnits(config._i);
|
|
|
1237 config._a = [
|
|
|
1238 normalizedInput.year,
|
|
|
1239 normalizedInput.month,
|
|
|
1240 normalizedInput.day,
|
|
|
1241 normalizedInput.hour,
|
|
|
1242 normalizedInput.minute,
|
|
|
1243 normalizedInput.second,
|
|
|
1244 normalizedInput.millisecond
|
|
|
1245 ];
|
|
|
1246
|
|
|
1247 dateFromConfig(config);
|
|
|
1248 }
|
|
|
1249
|
|
|
1250 function currentDateArray(config) {
|
|
|
1251 var now = new Date();
|
|
|
1252 if (config._useUTC) {
|
|
|
1253 return [
|
|
|
1254 now.getUTCFullYear(),
|
|
|
1255 now.getUTCMonth(),
|
|
|
1256 now.getUTCDate()
|
|
|
1257 ];
|
|
|
1258 } else {
|
|
|
1259 return [now.getFullYear(), now.getMonth(), now.getDate()];
|
|
|
1260 }
|
|
|
1261 }
|
|
|
1262
|
|
|
1263 // date from string and format string
|
|
|
1264 function makeDateFromStringAndFormat(config) {
|
|
|
1265
|
|
|
1266 config._a = [];
|
|
|
1267 config._pf.empty = true;
|
|
|
1268
|
|
|
1269 // This array is used to make a Date, either with `new Date` or `Date.UTC`
|
|
|
1270 var lang = getLangDefinition(config._l),
|
|
|
1271 string = '' + config._i,
|
|
|
1272 i, parsedInput, tokens, token, skipped,
|
|
|
1273 stringLength = string.length,
|
|
|
1274 totalParsedInputLength = 0;
|
|
|
1275
|
|
|
1276 tokens = expandFormat(config._f, lang).match(formattingTokens) || [];
|
|
|
1277
|
|
|
1278 for (i = 0; i < tokens.length; i++) {
|
|
|
1279 token = tokens[i];
|
|
|
1280 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
|
|
|
1281 if (parsedInput) {
|
|
|
1282 skipped = string.substr(0, string.indexOf(parsedInput));
|
|
|
1283 if (skipped.length > 0) {
|
|
|
1284 config._pf.unusedInput.push(skipped);
|
|
|
1285 }
|
|
|
1286 string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
|
|
|
1287 totalParsedInputLength += parsedInput.length;
|
|
|
1288 }
|
|
|
1289 // don't parse if it's not a known token
|
|
|
1290 if (formatTokenFunctions[token]) {
|
|
|
1291 if (parsedInput) {
|
|
|
1292 config._pf.empty = false;
|
|
|
1293 }
|
|
|
1294 else {
|
|
|
1295 config._pf.unusedTokens.push(token);
|
|
|
1296 }
|
|
|
1297 addTimeToArrayFromToken(token, parsedInput, config);
|
|
|
1298 }
|
|
|
1299 else if (config._strict && !parsedInput) {
|
|
|
1300 config._pf.unusedTokens.push(token);
|
|
|
1301 }
|
|
|
1302 }
|
|
|
1303
|
|
|
1304 // add remaining unparsed input length to the string
|
|
|
1305 config._pf.charsLeftOver = stringLength - totalParsedInputLength;
|
|
|
1306 if (string.length > 0) {
|
|
|
1307 config._pf.unusedInput.push(string);
|
|
|
1308 }
|
|
|
1309
|
|
|
1310 // handle am pm
|
|
|
1311 if (config._isPm && config._a[HOUR] < 12) {
|
|
|
1312 config._a[HOUR] += 12;
|
|
|
1313 }
|
|
|
1314 // if is 12 am, change hours to 0
|
|
|
1315 if (config._isPm === false && config._a[HOUR] === 12) {
|
|
|
1316 config._a[HOUR] = 0;
|
|
|
1317 }
|
|
|
1318
|
|
|
1319 dateFromConfig(config);
|
|
|
1320 checkOverflow(config);
|
|
|
1321 }
|
|
|
1322
|
|
|
1323 function unescapeFormat(s) {
|
|
|
1324 return s.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
|
|
|
1325 return p1 || p2 || p3 || p4;
|
|
|
1326 });
|
|
|
1327 }
|
|
|
1328
|
|
|
1329 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
|
|
|
1330 function regexpEscape(s) {
|
|
|
1331 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
|
|
|
1332 }
|
|
|
1333
|
|
|
1334 // date from string and array of format strings
|
|
|
1335 function makeDateFromStringAndArray(config) {
|
|
|
1336 var tempConfig,
|
|
|
1337 bestMoment,
|
|
|
1338
|
|
|
1339 scoreToBeat,
|
|
|
1340 i,
|
|
|
1341 currentScore;
|
|
|
1342
|
|
|
1343 if (config._f.length === 0) {
|
|
|
1344 config._pf.invalidFormat = true;
|
|
|
1345 config._d = new Date(NaN);
|
|
|
1346 return;
|
|
|
1347 }
|
|
|
1348
|
|
|
1349 for (i = 0; i < config._f.length; i++) {
|
|
|
1350 currentScore = 0;
|
|
|
1351 tempConfig = extend({}, config);
|
|
|
1352 tempConfig._pf = defaultParsingFlags();
|
|
|
1353 tempConfig._f = config._f[i];
|
|
|
1354 makeDateFromStringAndFormat(tempConfig);
|
|
|
1355
|
|
|
1356 if (!isValid(tempConfig)) {
|
|
|
1357 continue;
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 // if there is any input that was not parsed add a penalty for that format
|
|
|
1361 currentScore += tempConfig._pf.charsLeftOver;
|
|
|
1362
|
|
|
1363 //or tokens
|
|
|
1364 currentScore += tempConfig._pf.unusedTokens.length * 10;
|
|
|
1365
|
|
|
1366 tempConfig._pf.score = currentScore;
|
|
|
1367
|
|
|
1368 if (scoreToBeat == null || currentScore < scoreToBeat) {
|
|
|
1369 scoreToBeat = currentScore;
|
|
|
1370 bestMoment = tempConfig;
|
|
|
1371 }
|
|
|
1372 }
|
|
|
1373
|
|
|
1374 extend(config, bestMoment || tempConfig);
|
|
|
1375 }
|
|
|
1376
|
|
|
1377 // date from iso format
|
|
|
1378 function makeDateFromString(config) {
|
|
|
1379 var i, l,
|
|
|
1380 string = config._i,
|
|
|
1381 match = isoRegex.exec(string);
|
|
|
1382
|
|
|
1383 if (match) {
|
|
|
1384 config._pf.iso = true;
|
|
|
1385 for (i = 0, l = isoDates.length; i < l; i++) {
|
|
|
1386 if (isoDates[i][1].exec(string)) {
|
|
|
1387 // match[5] should be "T" or undefined
|
|
|
1388 config._f = isoDates[i][0] + (match[6] || " ");
|
|
|
1389 break;
|
|
|
1390 }
|
|
|
1391 }
|
|
|
1392 for (i = 0, l = isoTimes.length; i < l; i++) {
|
|
|
1393 if (isoTimes[i][1].exec(string)) {
|
|
|
1394 config._f += isoTimes[i][0];
|
|
|
1395 break;
|
|
|
1396 }
|
|
|
1397 }
|
|
|
1398 if (string.match(parseTokenTimezone)) {
|
|
|
1399 config._f += "Z";
|
|
|
1400 }
|
|
|
1401 makeDateFromStringAndFormat(config);
|
|
|
1402 }
|
|
|
1403 else {
|
|
|
1404 config._d = new Date(string);
|
|
|
1405 }
|
|
|
1406 }
|
|
|
1407
|
|
|
1408 function makeDateFromInput(config) {
|
|
|
1409 var input = config._i,
|
|
|
1410 matched = aspNetJsonRegex.exec(input);
|
|
|
1411
|
|
|
1412 if (input === undefined) {
|
|
|
1413 config._d = new Date();
|
|
|
1414 } else if (matched) {
|
|
|
1415 config._d = new Date(+matched[1]);
|
|
|
1416 } else if (typeof input === 'string') {
|
|
|
1417 makeDateFromString(config);
|
|
|
1418 } else if (isArray(input)) {
|
|
|
1419 config._a = input.slice(0);
|
|
|
1420 dateFromConfig(config);
|
|
|
1421 } else if (isDate(input)) {
|
|
|
1422 config._d = new Date(+input);
|
|
|
1423 } else if (typeof(input) === 'object') {
|
|
|
1424 dateFromObject(config);
|
|
|
1425 } else {
|
|
|
1426 config._d = new Date(input);
|
|
|
1427 }
|
|
|
1428 }
|
|
|
1429
|
|
|
1430 function makeDate(y, m, d, h, M, s, ms) {
|
|
|
1431 //can't just apply() to create a date:
|
|
|
1432 //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
|
|
|
1433 var date = new Date(y, m, d, h, M, s, ms);
|
|
|
1434
|
|
|
1435 //the date constructor doesn't accept years < 1970
|
|
|
1436 if (y < 1970) {
|
|
|
1437 date.setFullYear(y);
|
|
|
1438 }
|
|
|
1439 return date;
|
|
|
1440 }
|
|
|
1441
|
|
|
1442 function makeUTCDate(y) {
|
|
|
1443 var date = new Date(Date.UTC.apply(null, arguments));
|
|
|
1444 if (y < 1970) {
|
|
|
1445 date.setUTCFullYear(y);
|
|
|
1446 }
|
|
|
1447 return date;
|
|
|
1448 }
|
|
|
1449
|
|
|
1450 function parseWeekday(input, language) {
|
|
|
1451 if (typeof input === 'string') {
|
|
|
1452 if (!isNaN(input)) {
|
|
|
1453 input = parseInt(input, 10);
|
|
|
1454 }
|
|
|
1455 else {
|
|
|
1456 input = language.weekdaysParse(input);
|
|
|
1457 if (typeof input !== 'number') {
|
|
|
1458 return null;
|
|
|
1459 }
|
|
|
1460 }
|
|
|
1461 }
|
|
|
1462 return input;
|
|
|
1463 }
|
|
|
1464
|
|
|
1465 /************************************
|
|
|
1466 Relative Time
|
|
|
1467 ************************************/
|
|
|
1468
|
|
|
1469
|
|
|
1470 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
|
|
|
1471 function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
|
|
|
1472 return lang.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
|
|
|
1473 }
|
|
|
1474
|
|
|
1475 function relativeTime(milliseconds, withoutSuffix, lang) {
|
|
|
1476 var seconds = round(Math.abs(milliseconds) / 1000),
|
|
|
1477 minutes = round(seconds / 60),
|
|
|
1478 hours = round(minutes / 60),
|
|
|
1479 days = round(hours / 24),
|
|
|
1480 years = round(days / 365),
|
|
|
1481 args = seconds < 45 && ['s', seconds] ||
|
|
|
1482 minutes === 1 && ['m'] ||
|
|
|
1483 minutes < 45 && ['mm', minutes] ||
|
|
|
1484 hours === 1 && ['h'] ||
|
|
|
1485 hours < 22 && ['hh', hours] ||
|
|
|
1486 days === 1 && ['d'] ||
|
|
|
1487 days <= 25 && ['dd', days] ||
|
|
|
1488 days <= 45 && ['M'] ||
|
|
|
1489 days < 345 && ['MM', round(days / 30)] ||
|
|
|
1490 years === 1 && ['y'] || ['yy', years];
|
|
|
1491 args[2] = withoutSuffix;
|
|
|
1492 args[3] = milliseconds > 0;
|
|
|
1493 args[4] = lang;
|
|
|
1494 return substituteTimeAgo.apply({}, args);
|
|
|
1495 }
|
|
|
1496
|
|
|
1497
|
|
|
1498 /************************************
|
|
|
1499 Week of Year
|
|
|
1500 ************************************/
|
|
|
1501
|
|
|
1502
|
|
|
1503 // firstDayOfWeek 0 = sun, 6 = sat
|
|
|
1504 // the day of the week that starts the week
|
|
|
1505 // (usually sunday or monday)
|
|
|
1506 // firstDayOfWeekOfYear 0 = sun, 6 = sat
|
|
|
1507 // the first week is the week that contains the first
|
|
|
1508 // of this day of the week
|
|
|
1509 // (eg. ISO weeks use thursday (4))
|
|
|
1510 function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
|
|
|
1511 var end = firstDayOfWeekOfYear - firstDayOfWeek,
|
|
|
1512 daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
|
|
|
1513 adjustedMoment;
|
|
|
1514
|
|
|
1515
|
|
|
1516 if (daysToDayOfWeek > end) {
|
|
|
1517 daysToDayOfWeek -= 7;
|
|
|
1518 }
|
|
|
1519
|
|
|
1520 if (daysToDayOfWeek < end - 7) {
|
|
|
1521 daysToDayOfWeek += 7;
|
|
|
1522 }
|
|
|
1523
|
|
|
1524 adjustedMoment = moment(mom).add('d', daysToDayOfWeek);
|
|
|
1525 return {
|
|
|
1526 week: Math.ceil(adjustedMoment.dayOfYear() / 7),
|
|
|
1527 year: adjustedMoment.year()
|
|
|
1528 };
|
|
|
1529 }
|
|
|
1530
|
|
|
1531 //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
|
|
|
1532 function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
|
|
|
1533 var d = makeUTCDate(year, 0, 1).getUTCDay(), daysToAdd, dayOfYear;
|
|
|
1534
|
|
|
1535 weekday = weekday != null ? weekday : firstDayOfWeek;
|
|
|
1536 daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
|
|
|
1537 dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;
|
|
|
1538
|
|
|
1539 return {
|
|
|
1540 year: dayOfYear > 0 ? year : year - 1,
|
|
|
1541 dayOfYear: dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
|
|
|
1542 };
|
|
|
1543 }
|
|
|
1544
|
|
|
1545 /************************************
|
|
|
1546 Top Level Functions
|
|
|
1547 ************************************/
|
|
|
1548
|
|
|
1549 function makeMoment(config) {
|
|
|
1550 var input = config._i,
|
|
|
1551 format = config._f;
|
|
|
1552
|
|
|
1553 if (input === null) {
|
|
|
1554 return moment.invalid({nullInput: true});
|
|
|
1555 }
|
|
|
1556
|
|
|
1557 if (typeof input === 'string') {
|
|
|
1558 config._i = input = getLangDefinition().preparse(input);
|
|
|
1559 }
|
|
|
1560
|
|
|
1561 if (moment.isMoment(input)) {
|
|
|
1562 config = cloneMoment(input);
|
|
|
1563
|
|
|
1564 config._d = new Date(+input._d);
|
|
|
1565 } else if (format) {
|
|
|
1566 if (isArray(format)) {
|
|
|
1567 makeDateFromStringAndArray(config);
|
|
|
1568 } else {
|
|
|
1569 makeDateFromStringAndFormat(config);
|
|
|
1570 }
|
|
|
1571 } else {
|
|
|
1572 makeDateFromInput(config);
|
|
|
1573 }
|
|
|
1574
|
|
|
1575 return new Moment(config);
|
|
|
1576 }
|
|
|
1577
|
|
|
1578 moment = function (input, format, lang, strict) {
|
|
|
1579 var c;
|
|
|
1580
|
|
|
1581 if (typeof(lang) === "boolean") {
|
|
|
1582 strict = lang;
|
|
|
1583 lang = undefined;
|
|
|
1584 }
|
|
|
1585 // object construction must be done this way.
|
|
|
1586 // https://github.com/moment/moment/issues/1423
|
|
|
1587 c = {};
|
|
|
1588 c._isAMomentObject = true;
|
|
|
1589 c._i = input;
|
|
|
1590 c._f = format;
|
|
|
1591 c._l = lang;
|
|
|
1592 c._strict = strict;
|
|
|
1593 c._isUTC = false;
|
|
|
1594 c._pf = defaultParsingFlags();
|
|
|
1595
|
|
|
1596 return makeMoment(c);
|
|
|
1597 };
|
|
|
1598
|
|
|
1599 // creating with utc
|
|
|
1600 moment.utc = function (input, format, lang, strict) {
|
|
|
1601 var c;
|
|
|
1602
|
|
|
1603 if (typeof(lang) === "boolean") {
|
|
|
1604 strict = lang;
|
|
|
1605 lang = undefined;
|
|
|
1606 }
|
|
|
1607 // object construction must be done this way.
|
|
|
1608 // https://github.com/moment/moment/issues/1423
|
|
|
1609 c = {};
|
|
|
1610 c._isAMomentObject = true;
|
|
|
1611 c._useUTC = true;
|
|
|
1612 c._isUTC = true;
|
|
|
1613 c._l = lang;
|
|
|
1614 c._i = input;
|
|
|
1615 c._f = format;
|
|
|
1616 c._strict = strict;
|
|
|
1617 c._pf = defaultParsingFlags();
|
|
|
1618
|
|
|
1619 return makeMoment(c).utc();
|
|
|
1620 };
|
|
|
1621
|
|
|
1622 // creating with unix timestamp (in seconds)
|
|
|
1623 moment.unix = function (input) {
|
|
|
1624 return moment(input * 1000);
|
|
|
1625 };
|
|
|
1626
|
|
|
1627 // duration
|
|
|
1628 moment.duration = function (input, key) {
|
|
|
1629 var duration = input,
|
|
|
1630 // matching against regexp is expensive, do it on demand
|
|
|
1631 match = null,
|
|
|
1632 sign,
|
|
|
1633 ret,
|
|
|
1634 parseIso;
|
|
|
1635
|
|
|
1636 if (moment.isDuration(input)) {
|
|
|
1637 duration = {
|
|
|
1638 ms: input._milliseconds,
|
|
|
1639 d: input._days,
|
|
|
1640 M: input._months
|
|
|
1641 };
|
|
|
1642 } else if (typeof input === 'number') {
|
|
|
1643 duration = {};
|
|
|
1644 if (key) {
|
|
|
1645 duration[key] = input;
|
|
|
1646 } else {
|
|
|
1647 duration.milliseconds = input;
|
|
|
1648 }
|
|
|
1649 } else if (!!(match = aspNetTimeSpanJsonRegex.exec(input))) {
|
|
|
1650 sign = (match[1] === "-") ? -1 : 1;
|
|
|
1651 duration = {
|
|
|
1652 y: 0,
|
|
|
1653 d: toInt(match[DATE]) * sign,
|
|
|
1654 h: toInt(match[HOUR]) * sign,
|
|
|
1655 m: toInt(match[MINUTE]) * sign,
|
|
|
1656 s: toInt(match[SECOND]) * sign,
|
|
|
1657 ms: toInt(match[MILLISECOND]) * sign
|
|
|
1658 };
|
|
|
1659 } else if (!!(match = isoDurationRegex.exec(input))) {
|
|
|
1660 sign = (match[1] === "-") ? -1 : 1;
|
|
|
1661 parseIso = function (inp) {
|
|
|
1662 // We'd normally use ~~inp for this, but unfortunately it also
|
|
|
1663 // converts floats to ints.
|
|
|
1664 // inp may be undefined, so careful calling replace on it.
|
|
|
1665 var res = inp && parseFloat(inp.replace(',', '.'));
|
|
|
1666 // apply sign while we're at it
|
|
|
1667 return (isNaN(res) ? 0 : res) * sign;
|
|
|
1668 };
|
|
|
1669 duration = {
|
|
|
1670 y: parseIso(match[2]),
|
|
|
1671 M: parseIso(match[3]),
|
|
|
1672 d: parseIso(match[4]),
|
|
|
1673 h: parseIso(match[5]),
|
|
|
1674 m: parseIso(match[6]),
|
|
|
1675 s: parseIso(match[7]),
|
|
|
1676 w: parseIso(match[8])
|
|
|
1677 };
|
|
|
1678 }
|
|
|
1679
|
|
|
1680 ret = new Duration(duration);
|
|
|
1681
|
|
|
1682 if (moment.isDuration(input) && input.hasOwnProperty('_lang')) {
|
|
|
1683 ret._lang = input._lang;
|
|
|
1684 }
|
|
|
1685
|
|
|
1686 return ret;
|
|
|
1687 };
|
|
|
1688
|
|
|
1689 // version number
|
|
|
1690 moment.version = VERSION;
|
|
|
1691
|
|
|
1692 // default format
|
|
|
1693 moment.defaultFormat = isoFormat;
|
|
|
1694
|
|
|
1695 // This function will be called whenever a moment is mutated.
|
|
|
1696 // It is intended to keep the offset in sync with the timezone.
|
|
|
1697 moment.updateOffset = function () {};
|
|
|
1698
|
|
|
1699 // This function will load languages and then set the global language. If
|
|
|
1700 // no arguments are passed in, it will simply return the current global
|
|
|
1701 // language key.
|
|
|
1702 moment.lang = function (key, values) {
|
|
|
1703 var r;
|
|
|
1704 if (!key) {
|
|
|
1705 return moment.fn._lang._abbr;
|
|
|
1706 }
|
|
|
1707 if (values) {
|
|
|
1708 loadLang(normalizeLanguage(key), values);
|
|
|
1709 } else if (values === null) {
|
|
|
1710 unloadLang(key);
|
|
|
1711 key = 'en';
|
|
|
1712 } else if (!languages[key]) {
|
|
|
1713 getLangDefinition(key);
|
|
|
1714 }
|
|
|
1715 r = moment.duration.fn._lang = moment.fn._lang = getLangDefinition(key);
|
|
|
1716 return r._abbr;
|
|
|
1717 };
|
|
|
1718
|
|
|
1719 // returns language data
|
|
|
1720 moment.langData = function (key) {
|
|
|
1721 if (key && key._lang && key._lang._abbr) {
|
|
|
1722 key = key._lang._abbr;
|
|
|
1723 }
|
|
|
1724 return getLangDefinition(key);
|
|
|
1725 };
|
|
|
1726
|
|
|
1727 // compare moment object
|
|
|
1728 moment.isMoment = function (obj) {
|
|
|
1729 return obj instanceof Moment ||
|
|
|
1730 (obj != null && obj.hasOwnProperty('_isAMomentObject'));
|
|
|
1731 };
|
|
|
1732
|
|
|
1733 // for typechecking Duration objects
|
|
|
1734 moment.isDuration = function (obj) {
|
|
|
1735 return obj instanceof Duration;
|
|
|
1736 };
|
|
|
1737
|
|
|
1738 for (i = lists.length - 1; i >= 0; --i) {
|
|
|
1739 makeList(lists[i]);
|
|
|
1740 }
|
|
|
1741
|
|
|
1742 moment.normalizeUnits = function (units) {
|
|
|
1743 return normalizeUnits(units);
|
|
|
1744 };
|
|
|
1745
|
|
|
1746 moment.invalid = function (flags) {
|
|
|
1747 var m = moment.utc(NaN);
|
|
|
1748 if (flags != null) {
|
|
|
1749 extend(m._pf, flags);
|
|
|
1750 }
|
|
|
1751 else {
|
|
|
1752 m._pf.userInvalidated = true;
|
|
|
1753 }
|
|
|
1754
|
|
|
1755 return m;
|
|
|
1756 };
|
|
|
1757
|
|
|
1758 moment.parseZone = function (input) {
|
|
|
1759 return moment(input).parseZone();
|
|
|
1760 };
|
|
|
1761
|
|
|
1762 /************************************
|
|
|
1763 Moment Prototype
|
|
|
1764 ************************************/
|
|
|
1765
|
|
|
1766
|
|
|
1767 extend(moment.fn = Moment.prototype, {
|
|
|
1768
|
|
|
1769 clone : function () {
|
|
|
1770 return moment(this);
|
|
|
1771 },
|
|
|
1772
|
|
|
1773 valueOf : function () {
|
|
|
1774 return +this._d + ((this._offset || 0) * 60000);
|
|
|
1775 },
|
|
|
1776
|
|
|
1777 unix : function () {
|
|
|
1778 return Math.floor(+this / 1000);
|
|
|
1779 },
|
|
|
1780
|
|
|
1781 toString : function () {
|
|
|
1782 return this.clone().lang('en').format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
|
|
|
1783 },
|
|
|
1784
|
|
|
1785 toDate : function () {
|
|
|
1786 return this._offset ? new Date(+this) : this._d;
|
|
|
1787 },
|
|
|
1788
|
|
|
1789 toISOString : function () {
|
|
|
1790 var m = moment(this).utc();
|
|
|
1791 if (0 < m.year() && m.year() <= 9999) {
|
|
|
1792 return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
|
|
|
1793 } else {
|
|
|
1794 return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
|
|
|
1795 }
|
|
|
1796 },
|
|
|
1797
|
|
|
1798 toArray : function () {
|
|
|
1799 var m = this;
|
|
|
1800 return [
|
|
|
1801 m.year(),
|
|
|
1802 m.month(),
|
|
|
1803 m.date(),
|
|
|
1804 m.hours(),
|
|
|
1805 m.minutes(),
|
|
|
1806 m.seconds(),
|
|
|
1807 m.milliseconds()
|
|
|
1808 ];
|
|
|
1809 },
|
|
|
1810
|
|
|
1811 isValid : function () {
|
|
|
1812 return isValid(this);
|
|
|
1813 },
|
|
|
1814
|
|
|
1815 isDSTShifted : function () {
|
|
|
1816
|
|
|
1817 if (this._a) {
|
|
|
1818 return this.isValid() && compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray()) > 0;
|
|
|
1819 }
|
|
|
1820
|
|
|
1821 return false;
|
|
|
1822 },
|
|
|
1823
|
|
|
1824 parsingFlags : function () {
|
|
|
1825 return extend({}, this._pf);
|
|
|
1826 },
|
|
|
1827
|
|
|
1828 invalidAt: function () {
|
|
|
1829 return this._pf.overflow;
|
|
|
1830 },
|
|
|
1831
|
|
|
1832 utc : function () {
|
|
|
1833 return this.zone(0);
|
|
|
1834 },
|
|
|
1835
|
|
|
1836 local : function () {
|
|
|
1837 this.zone(0);
|
|
|
1838 this._isUTC = false;
|
|
|
1839 return this;
|
|
|
1840 },
|
|
|
1841
|
|
|
1842 format : function (inputString) {
|
|
|
1843 var output = formatMoment(this, inputString || moment.defaultFormat);
|
|
|
1844 return this.lang().postformat(output);
|
|
|
1845 },
|
|
|
1846
|
|
|
1847 add : function (input, val) {
|
|
|
1848 var dur;
|
|
|
1849 // switch args to support add('s', 1) and add(1, 's')
|
|
|
1850 if (typeof input === 'string') {
|
|
|
1851 dur = moment.duration(+val, input);
|
|
|
1852 } else {
|
|
|
1853 dur = moment.duration(input, val);
|
|
|
1854 }
|
|
|
1855 addOrSubtractDurationFromMoment(this, dur, 1);
|
|
|
1856 return this;
|
|
|
1857 },
|
|
|
1858
|
|
|
1859 subtract : function (input, val) {
|
|
|
1860 var dur;
|
|
|
1861 // switch args to support subtract('s', 1) and subtract(1, 's')
|
|
|
1862 if (typeof input === 'string') {
|
|
|
1863 dur = moment.duration(+val, input);
|
|
|
1864 } else {
|
|
|
1865 dur = moment.duration(input, val);
|
|
|
1866 }
|
|
|
1867 addOrSubtractDurationFromMoment(this, dur, -1);
|
|
|
1868 return this;
|
|
|
1869 },
|
|
|
1870
|
|
|
1871 diff : function (input, units, asFloat) {
|
|
|
1872 var that = makeAs(input, this),
|
|
|
1873 zoneDiff = (this.zone() - that.zone()) * 6e4,
|
|
|
1874 diff, output;
|
|
|
1875
|
|
|
1876 units = normalizeUnits(units);
|
|
|
1877
|
|
|
1878 if (units === 'year' || units === 'month') {
|
|
|
1879 // average number of days in the months in the given dates
|
|
|
1880 diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2
|
|
|
1881 // difference in months
|
|
|
1882 output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
|
|
|
1883 // adjust by taking difference in days, average number of days
|
|
|
1884 // and dst in the given months.
|
|
|
1885 output += ((this - moment(this).startOf('month')) -
|
|
|
1886 (that - moment(that).startOf('month'))) / diff;
|
|
|
1887 // same as above but with zones, to negate all dst
|
|
|
1888 output -= ((this.zone() - moment(this).startOf('month').zone()) -
|
|
|
1889 (that.zone() - moment(that).startOf('month').zone())) * 6e4 / diff;
|
|
|
1890 if (units === 'year') {
|
|
|
1891 output = output / 12;
|
|
|
1892 }
|
|
|
1893 } else {
|
|
|
1894 diff = (this - that);
|
|
|
1895 output = units === 'second' ? diff / 1e3 : // 1000
|
|
|
1896 units === 'minute' ? diff / 6e4 : // 1000 * 60
|
|
|
1897 units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60
|
|
|
1898 units === 'day' ? (diff - zoneDiff) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
|
|
|
1899 units === 'week' ? (diff - zoneDiff) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
|
|
|
1900 diff;
|
|
|
1901 }
|
|
|
1902 return asFloat ? output : absRound(output);
|
|
|
1903 },
|
|
|
1904
|
|
|
1905 from : function (time, withoutSuffix) {
|
|
|
1906 return moment.duration(this.diff(time)).lang(this.lang()._abbr).humanize(!withoutSuffix);
|
|
|
1907 },
|
|
|
1908
|
|
|
1909 fromNow : function (withoutSuffix) {
|
|
|
1910 return this.from(moment(), withoutSuffix);
|
|
|
1911 },
|
|
|
1912
|
|
|
1913 calendar : function () {
|
|
|
1914 // We want to compare the start of today, vs this.
|
|
|
1915 // Getting start-of-today depends on whether we're zone'd or not.
|
|
|
1916 var sod = makeAs(moment(), this).startOf('day'),
|
|
|
1917 diff = this.diff(sod, 'days', true),
|
|
|
1918 format = diff < -6 ? 'sameElse' :
|
|
|
1919 diff < -1 ? 'lastWeek' :
|
|
|
1920 diff < 0 ? 'lastDay' :
|
|
|
1921 diff < 1 ? 'sameDay' :
|
|
|
1922 diff < 2 ? 'nextDay' :
|
|
|
1923 diff < 7 ? 'nextWeek' : 'sameElse';
|
|
|
1924 return this.format(this.lang().calendar(format, this));
|
|
|
1925 },
|
|
|
1926
|
|
|
1927 isLeapYear : function () {
|
|
|
1928 return isLeapYear(this.year());
|
|
|
1929 },
|
|
|
1930
|
|
|
1931 isDST : function () {
|
|
|
1932 return (this.zone() < this.clone().month(0).zone() ||
|
|
|
1933 this.zone() < this.clone().month(5).zone());
|
|
|
1934 },
|
|
|
1935
|
|
|
1936 day : function (input) {
|
|
|
1937 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
|
|
|
1938 if (input != null) {
|
|
|
1939 input = parseWeekday(input, this.lang());
|
|
|
1940 return this.add({ d : input - day });
|
|
|
1941 } else {
|
|
|
1942 return day;
|
|
|
1943 }
|
|
|
1944 },
|
|
|
1945
|
|
|
1946 month : function (input) {
|
|
|
1947 var utc = this._isUTC ? 'UTC' : '',
|
|
|
1948 dayOfMonth;
|
|
|
1949
|
|
|
1950 if (input != null) {
|
|
|
1951 if (typeof input === 'string') {
|
|
|
1952 input = this.lang().monthsParse(input);
|
|
|
1953 if (typeof input !== 'number') {
|
|
|
1954 return this;
|
|
|
1955 }
|
|
|
1956 }
|
|
|
1957
|
|
|
1958 dayOfMonth = this.date();
|
|
|
1959 this.date(1);
|
|
|
1960 this._d['set' + utc + 'Month'](input);
|
|
|
1961 this.date(Math.min(dayOfMonth, this.daysInMonth()));
|
|
|
1962
|
|
|
1963 moment.updateOffset(this);
|
|
|
1964 return this;
|
|
|
1965 } else {
|
|
|
1966 return this._d['get' + utc + 'Month']();
|
|
|
1967 }
|
|
|
1968 },
|
|
|
1969
|
|
|
1970 startOf: function (units) {
|
|
|
1971 units = normalizeUnits(units);
|
|
|
1972 // the following switch intentionally omits break keywords
|
|
|
1973 // to utilize falling through the cases.
|
|
|
1974 switch (units) {
|
|
|
1975 case 'year':
|
|
|
1976 this.month(0);
|
|
|
1977 /* falls through */
|
|
|
1978 case 'month':
|
|
|
1979 this.date(1);
|
|
|
1980 /* falls through */
|
|
|
1981 case 'week':
|
|
|
1982 case 'isoWeek':
|
|
|
1983 case 'day':
|
|
|
1984 this.hours(0);
|
|
|
1985 /* falls through */
|
|
|
1986 case 'hour':
|
|
|
1987 this.minutes(0);
|
|
|
1988 /* falls through */
|
|
|
1989 case 'minute':
|
|
|
1990 this.seconds(0);
|
|
|
1991 /* falls through */
|
|
|
1992 case 'second':
|
|
|
1993 this.milliseconds(0);
|
|
|
1994 /* falls through */
|
|
|
1995 }
|
|
|
1996
|
|
|
1997 // weeks are a special case
|
|
|
1998 if (units === 'week') {
|
|
|
1999 this.weekday(0);
|
|
|
2000 } else if (units === 'isoWeek') {
|
|
|
2001 this.isoWeekday(1);
|
|
|
2002 }
|
|
|
2003
|
|
|
2004 return this;
|
|
|
2005 },
|
|
|
2006
|
|
|
2007 endOf: function (units) {
|
|
|
2008 units = normalizeUnits(units);
|
|
|
2009 return this.startOf(units).add((units === 'isoWeek' ? 'week' : units), 1).subtract('ms', 1);
|
|
|
2010 },
|
|
|
2011
|
|
|
2012 isAfter: function (input, units) {
|
|
|
2013 units = typeof units !== 'undefined' ? units : 'millisecond';
|
|
|
2014 return +this.clone().startOf(units) > +moment(input).startOf(units);
|
|
|
2015 },
|
|
|
2016
|
|
|
2017 isBefore: function (input, units) {
|
|
|
2018 units = typeof units !== 'undefined' ? units : 'millisecond';
|
|
|
2019 return +this.clone().startOf(units) < +moment(input).startOf(units);
|
|
|
2020 },
|
|
|
2021
|
|
|
2022 isSame: function (input, units) {
|
|
|
2023 units = units || 'ms';
|
|
|
2024 return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
|
|
|
2025 },
|
|
|
2026
|
|
|
2027 min: function (other) {
|
|
|
2028 other = moment.apply(null, arguments);
|
|
|
2029 return other < this ? this : other;
|
|
|
2030 },
|
|
|
2031
|
|
|
2032 max: function (other) {
|
|
|
2033 other = moment.apply(null, arguments);
|
|
|
2034 return other > this ? this : other;
|
|
|
2035 },
|
|
|
2036
|
|
|
2037 zone : function (input) {
|
|
|
2038 var offset = this._offset || 0;
|
|
|
2039 if (input != null) {
|
|
|
2040 if (typeof input === "string") {
|
|
|
2041 input = timezoneMinutesFromString(input);
|
|
|
2042 }
|
|
|
2043 if (Math.abs(input) < 16) {
|
|
|
2044 input = input * 60;
|
|
|
2045 }
|
|
|
2046 this._offset = input;
|
|
|
2047 this._isUTC = true;
|
|
|
2048 if (offset !== input) {
|
|
|
2049 addOrSubtractDurationFromMoment(this, moment.duration(offset - input, 'm'), 1, true);
|
|
|
2050 }
|
|
|
2051 } else {
|
|
|
2052 return this._isUTC ? offset : this._d.getTimezoneOffset();
|
|
|
2053 }
|
|
|
2054 return this;
|
|
|
2055 },
|
|
|
2056
|
|
|
2057 zoneAbbr : function () {
|
|
|
2058 return this._isUTC ? "UTC" : "";
|
|
|
2059 },
|
|
|
2060
|
|
|
2061 zoneName : function () {
|
|
|
2062 return this._isUTC ? "Coordinated Universal Time" : "";
|
|
|
2063 },
|
|
|
2064
|
|
|
2065 parseZone : function () {
|
|
|
2066 if (this._tzm) {
|
|
|
2067 this.zone(this._tzm);
|
|
|
2068 } else if (typeof this._i === 'string') {
|
|
|
2069 this.zone(this._i);
|
|
|
2070 }
|
|
|
2071 return this;
|
|
|
2072 },
|
|
|
2073
|
|
|
2074 hasAlignedHourOffset : function (input) {
|
|
|
2075 if (!input) {
|
|
|
2076 input = 0;
|
|
|
2077 }
|
|
|
2078 else {
|
|
|
2079 input = moment(input).zone();
|
|
|
2080 }
|
|
|
2081
|
|
|
2082 return (this.zone() - input) % 60 === 0;
|
|
|
2083 },
|
|
|
2084
|
|
|
2085 daysInMonth : function () {
|
|
|
2086 return daysInMonth(this.year(), this.month());
|
|
|
2087 },
|
|
|
2088
|
|
|
2089 dayOfYear : function (input) {
|
|
|
2090 var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;
|
|
|
2091 return input == null ? dayOfYear : this.add("d", (input - dayOfYear));
|
|
|
2092 },
|
|
|
2093
|
|
|
2094 quarter : function () {
|
|
|
2095 return Math.ceil((this.month() + 1.0) / 3.0);
|
|
|
2096 },
|
|
|
2097
|
|
|
2098 weekYear : function (input) {
|
|
|
2099 var year = weekOfYear(this, this.lang()._week.dow, this.lang()._week.doy).year;
|
|
|
2100 return input == null ? year : this.add("y", (input - year));
|
|
|
2101 },
|
|
|
2102
|
|
|
2103 isoWeekYear : function (input) {
|
|
|
2104 var year = weekOfYear(this, 1, 4).year;
|
|
|
2105 return input == null ? year : this.add("y", (input - year));
|
|
|
2106 },
|
|
|
2107
|
|
|
2108 week : function (input) {
|
|
|
2109 var week = this.lang().week(this);
|
|
|
2110 return input == null ? week : this.add("d", (input - week) * 7);
|
|
|
2111 },
|
|
|
2112
|
|
|
2113 isoWeek : function (input) {
|
|
|
2114 var week = weekOfYear(this, 1, 4).week;
|
|
|
2115 return input == null ? week : this.add("d", (input - week) * 7);
|
|
|
2116 },
|
|
|
2117
|
|
|
2118 weekday : function (input) {
|
|
|
2119 var weekday = (this.day() + 7 - this.lang()._week.dow) % 7;
|
|
|
2120 return input == null ? weekday : this.add("d", input - weekday);
|
|
|
2121 },
|
|
|
2122
|
|
|
2123 isoWeekday : function (input) {
|
|
|
2124 // behaves the same as moment#day except
|
|
|
2125 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
|
|
|
2126 // as a setter, sunday should belong to the previous week.
|
|
|
2127 return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
|
|
|
2128 },
|
|
|
2129
|
|
|
2130 get : function (units) {
|
|
|
2131 units = normalizeUnits(units);
|
|
|
2132 return this[units]();
|
|
|
2133 },
|
|
|
2134
|
|
|
2135 set : function (units, value) {
|
|
|
2136 units = normalizeUnits(units);
|
|
|
2137 if (typeof this[units] === 'function') {
|
|
|
2138 this[units](value);
|
|
|
2139 }
|
|
|
2140 return this;
|
|
|
2141 },
|
|
|
2142
|
|
|
2143 // If passed a language key, it will set the language for this
|
|
|
2144 // instance. Otherwise, it will return the language configuration
|
|
|
2145 // variables for this instance.
|
|
|
2146 lang : function (key) {
|
|
|
2147 if (key === undefined) {
|
|
|
2148 return this._lang;
|
|
|
2149 } else {
|
|
|
2150 this._lang = getLangDefinition(key);
|
|
|
2151 return this;
|
|
|
2152 }
|
|
|
2153 }
|
|
|
2154 });
|
|
|
2155
|
|
|
2156 // helper for adding shortcuts
|
|
|
2157 function makeGetterAndSetter(name, key) {
|
|
|
2158 moment.fn[name] = moment.fn[name + 's'] = function (input) {
|
|
|
2159 var utc = this._isUTC ? 'UTC' : '';
|
|
|
2160 if (input != null) {
|
|
|
2161 this._d['set' + utc + key](input);
|
|
|
2162 moment.updateOffset(this);
|
|
|
2163 return this;
|
|
|
2164 } else {
|
|
|
2165 return this._d['get' + utc + key]();
|
|
|
2166 }
|
|
|
2167 };
|
|
|
2168 }
|
|
|
2169
|
|
|
2170 // loop through and add shortcuts (Month, Date, Hours, Minutes, Seconds, Milliseconds)
|
|
|
2171 for (i = 0; i < proxyGettersAndSetters.length; i ++) {
|
|
|
2172 makeGetterAndSetter(proxyGettersAndSetters[i].toLowerCase().replace(/s$/, ''), proxyGettersAndSetters[i]);
|
|
|
2173 }
|
|
|
2174
|
|
|
2175 // add shortcut for year (uses different syntax than the getter/setter 'year' == 'FullYear')
|
|
|
2176 makeGetterAndSetter('year', 'FullYear');
|
|
|
2177
|
|
|
2178 // add plural methods
|
|
|
2179 moment.fn.days = moment.fn.day;
|
|
|
2180 moment.fn.months = moment.fn.month;
|
|
|
2181 moment.fn.weeks = moment.fn.week;
|
|
|
2182 moment.fn.isoWeeks = moment.fn.isoWeek;
|
|
|
2183
|
|
|
2184 // add aliased format methods
|
|
|
2185 moment.fn.toJSON = moment.fn.toISOString;
|
|
|
2186
|
|
|
2187 /************************************
|
|
|
2188 Duration Prototype
|
|
|
2189 ************************************/
|
|
|
2190
|
|
|
2191
|
|
|
2192 extend(moment.duration.fn = Duration.prototype, {
|
|
|
2193
|
|
|
2194 _bubble : function () {
|
|
|
2195 var milliseconds = this._milliseconds,
|
|
|
2196 days = this._days,
|
|
|
2197 months = this._months,
|
|
|
2198 data = this._data,
|
|
|
2199 seconds, minutes, hours, years;
|
|
|
2200
|
|
|
2201 // The following code bubbles up values, see the tests for
|
|
|
2202 // examples of what that means.
|
|
|
2203 data.milliseconds = milliseconds % 1000;
|
|
|
2204
|
|
|
2205 seconds = absRound(milliseconds / 1000);
|
|
|
2206 data.seconds = seconds % 60;
|
|
|
2207
|
|
|
2208 minutes = absRound(seconds / 60);
|
|
|
2209 data.minutes = minutes % 60;
|
|
|
2210
|
|
|
2211 hours = absRound(minutes / 60);
|
|
|
2212 data.hours = hours % 24;
|
|
|
2213
|
|
|
2214 days += absRound(hours / 24);
|
|
|
2215 data.days = days % 30;
|
|
|
2216
|
|
|
2217 months += absRound(days / 30);
|
|
|
2218 data.months = months % 12;
|
|
|
2219
|
|
|
2220 years = absRound(months / 12);
|
|
|
2221 data.years = years;
|
|
|
2222 },
|
|
|
2223
|
|
|
2224 weeks : function () {
|
|
|
2225 return absRound(this.days() / 7);
|
|
|
2226 },
|
|
|
2227
|
|
|
2228 valueOf : function () {
|
|
|
2229 return this._milliseconds +
|
|
|
2230 this._days * 864e5 +
|
|
|
2231 (this._months % 12) * 2592e6 +
|
|
|
2232 toInt(this._months / 12) * 31536e6;
|
|
|
2233 },
|
|
|
2234
|
|
|
2235 humanize : function (withSuffix) {
|
|
|
2236 var difference = +this,
|
|
|
2237 output = relativeTime(difference, !withSuffix, this.lang());
|
|
|
2238
|
|
|
2239 if (withSuffix) {
|
|
|
2240 output = this.lang().pastFuture(difference, output);
|
|
|
2241 }
|
|
|
2242
|
|
|
2243 return this.lang().postformat(output);
|
|
|
2244 },
|
|
|
2245
|
|
|
2246 add : function (input, val) {
|
|
|
2247 // supports only 2.0-style add(1, 's') or add(moment)
|
|
|
2248 var dur = moment.duration(input, val);
|
|
|
2249
|
|
|
2250 this._milliseconds += dur._milliseconds;
|
|
|
2251 this._days += dur._days;
|
|
|
2252 this._months += dur._months;
|
|
|
2253
|
|
|
2254 this._bubble();
|
|
|
2255
|
|
|
2256 return this;
|
|
|
2257 },
|
|
|
2258
|
|
|
2259 subtract : function (input, val) {
|
|
|
2260 var dur = moment.duration(input, val);
|
|
|
2261
|
|
|
2262 this._milliseconds -= dur._milliseconds;
|
|
|
2263 this._days -= dur._days;
|
|
|
2264 this._months -= dur._months;
|
|
|
2265
|
|
|
2266 this._bubble();
|
|
|
2267
|
|
|
2268 return this;
|
|
|
2269 },
|
|
|
2270
|
|
|
2271 get : function (units) {
|
|
|
2272 units = normalizeUnits(units);
|
|
|
2273 return this[units.toLowerCase() + 's']();
|
|
|
2274 },
|
|
|
2275
|
|
|
2276 as : function (units) {
|
|
|
2277 units = normalizeUnits(units);
|
|
|
2278 return this['as' + units.charAt(0).toUpperCase() + units.slice(1) + 's']();
|
|
|
2279 },
|
|
|
2280
|
|
|
2281 lang : moment.fn.lang,
|
|
|
2282
|
|
|
2283 toIsoString : function () {
|
|
|
2284 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
|
|
|
2285 var years = Math.abs(this.years()),
|
|
|
2286 months = Math.abs(this.months()),
|
|
|
2287 days = Math.abs(this.days()),
|
|
|
2288 hours = Math.abs(this.hours()),
|
|
|
2289 minutes = Math.abs(this.minutes()),
|
|
|
2290 seconds = Math.abs(this.seconds() + this.milliseconds() / 1000);
|
|
|
2291
|
|
|
2292 if (!this.asSeconds()) {
|
|
|
2293 // this is the same as C#'s (Noda) and python (isodate)...
|
|
|
2294 // but not other JS (goog.date)
|
|
|
2295 return 'P0D';
|
|
|
2296 }
|
|
|
2297
|
|
|
2298 return (this.asSeconds() < 0 ? '-' : '') +
|
|
|
2299 'P' +
|
|
|
2300 (years ? years + 'Y' : '') +
|
|
|
2301 (months ? months + 'M' : '') +
|
|
|
2302 (days ? days + 'D' : '') +
|
|
|
2303 ((hours || minutes || seconds) ? 'T' : '') +
|
|
|
2304 (hours ? hours + 'H' : '') +
|
|
|
2305 (minutes ? minutes + 'M' : '') +
|
|
|
2306 (seconds ? seconds + 'S' : '');
|
|
|
2307 }
|
|
|
2308 });
|
|
|
2309
|
|
|
2310 function makeDurationGetter(name) {
|
|
|
2311 moment.duration.fn[name] = function () {
|
|
|
2312 return this._data[name];
|
|
|
2313 };
|
|
|
2314 }
|
|
|
2315
|
|
|
2316 function makeDurationAsGetter(name, factor) {
|
|
|
2317 moment.duration.fn['as' + name] = function () {
|
|
|
2318 return +this / factor;
|
|
|
2319 };
|
|
|
2320 }
|
|
|
2321
|
|
|
2322 for (i in unitMillisecondFactors) {
|
|
|
2323 if (unitMillisecondFactors.hasOwnProperty(i)) {
|
|
|
2324 makeDurationAsGetter(i, unitMillisecondFactors[i]);
|
|
|
2325 makeDurationGetter(i.toLowerCase());
|
|
|
2326 }
|
|
|
2327 }
|
|
|
2328
|
|
|
2329 makeDurationAsGetter('Weeks', 6048e5);
|
|
|
2330 moment.duration.fn.asMonths = function () {
|
|
|
2331 return (+this - this.years() * 31536e6) / 2592e6 + this.years() * 12;
|
|
|
2332 };
|
|
|
2333
|
|
|
2334
|
|
|
2335 /************************************
|
|
|
2336 Default Lang
|
|
|
2337 ************************************/
|
|
|
2338
|
|
|
2339
|
|
|
2340 // Set default language, other languages will inherit from English.
|
|
|
2341 moment.lang('en', {
|
|
|
2342 ordinal : function (number) {
|
|
|
2343 var b = number % 10,
|
|
|
2344 output = (toInt(number % 100 / 10) === 1) ? 'th' :
|
|
|
2345 (b === 1) ? 'st' :
|
|
|
2346 (b === 2) ? 'nd' :
|
|
|
2347 (b === 3) ? 'rd' : 'th';
|
|
|
2348 return number + output;
|
|
|
2349 }
|
|
|
2350 });
|
|
|
2351
|
|
|
2352 /* EMBED_LANGUAGES */
|
|
|
2353
|
|
|
2354 /************************************
|
|
|
2355 Exposing Moment
|
|
|
2356 ************************************/
|
|
|
2357
|
|
|
2358 function makeGlobal(deprecate) {
|
|
|
2359 var warned = false, local_moment = moment;
|
|
|
2360 /*global ender:false */
|
|
|
2361 if (typeof ender !== 'undefined') {
|
|
|
2362 return;
|
|
|
2363 }
|
|
|
2364 // here, `this` means `window` in the browser, or `global` on the server
|
|
|
2365 // add `moment` as a global object via a string identifier,
|
|
|
2366 // for Closure Compiler "advanced" mode
|
|
|
2367 if (deprecate) {
|
|
|
2368 global.moment = function () {
|
|
|
2369 if (!warned && console && console.warn) {
|
|
|
2370 warned = true;
|
|
|
2371 console.warn(
|
|
|
2372 "Accessing Moment through the global scope is " +
|
|
|
2373 "deprecated, and will be removed in an upcoming " +
|
|
|
2374 "release.");
|
|
|
2375 }
|
|
|
2376 return local_moment.apply(null, arguments);
|
|
|
2377 };
|
|
|
2378 extend(global.moment, local_moment);
|
|
|
2379 } else {
|
|
|
2380 global['moment'] = moment;
|
|
|
2381 }
|
|
|
2382 }
|
|
|
2383
|
|
|
2384 // CommonJS module is defined
|
|
|
2385 if (hasModule) {
|
|
|
2386 module.exports = moment;
|
|
|
2387 makeGlobal(true);
|
|
|
2388 } else if (typeof define === "function" && define.amd) {
|
|
|
2389 define("moment", function (require, exports, module) {
|
|
|
2390 if (module.config && module.config() && module.config().noGlobal !== true) {
|
|
|
2391 // If user provided noGlobal, he is aware of global
|
|
|
2392 makeGlobal(module.config().noGlobal === undefined);
|
|
|
2393 }
|
|
|
2394
|
|
|
2395 return moment;
|
|
|
2396 });
|
|
|
2397 } else {
|
|
|
2398 makeGlobal();
|
|
|
2399 }
|
|
|
2400 }).call(this);
|
