提交 | 用户 | 时间
|
58d006
|
1 |
//! moment.js |
A |
2 |
//! version : 2.10.6 |
|
3 |
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors |
|
4 |
//! license : MIT |
|
5 |
//! momentjs.com |
|
6 |
|
|
7 |
(function (global, factory) { |
|
8 |
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : |
|
9 |
typeof define === 'function' && define.amd ? define(factory) : |
|
10 |
global.moment = factory() |
|
11 |
}(this, function () { 'use strict'; |
|
12 |
|
|
13 |
var hookCallback; |
|
14 |
|
|
15 |
function utils_hooks__hooks () { |
|
16 |
return hookCallback.apply(null, arguments); |
|
17 |
} |
|
18 |
|
|
19 |
// This is done to register the method called with moment() |
|
20 |
// without creating circular dependencies. |
|
21 |
function setHookCallback (callback) { |
|
22 |
hookCallback = callback; |
|
23 |
} |
|
24 |
|
|
25 |
function isArray(input) { |
|
26 |
return Object.prototype.toString.call(input) === '[object Array]'; |
|
27 |
} |
|
28 |
|
|
29 |
function isDate(input) { |
|
30 |
return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; |
|
31 |
} |
|
32 |
|
|
33 |
function map(arr, fn) { |
|
34 |
var res = [], i; |
|
35 |
for (i = 0; i < arr.length; ++i) { |
|
36 |
res.push(fn(arr[i], i)); |
|
37 |
} |
|
38 |
return res; |
|
39 |
} |
|
40 |
|
|
41 |
function hasOwnProp(a, b) { |
|
42 |
return Object.prototype.hasOwnProperty.call(a, b); |
|
43 |
} |
|
44 |
|
|
45 |
function extend(a, b) { |
|
46 |
for (var i in b) { |
|
47 |
if (hasOwnProp(b, i)) { |
|
48 |
a[i] = b[i]; |
|
49 |
} |
|
50 |
} |
|
51 |
|
|
52 |
if (hasOwnProp(b, 'toString')) { |
|
53 |
a.toString = b.toString; |
|
54 |
} |
|
55 |
|
|
56 |
if (hasOwnProp(b, 'valueOf')) { |
|
57 |
a.valueOf = b.valueOf; |
|
58 |
} |
|
59 |
|
|
60 |
return a; |
|
61 |
} |
|
62 |
|
|
63 |
function create_utc__createUTC (input, format, locale, strict) { |
|
64 |
return createLocalOrUTC(input, format, locale, strict, true).utc(); |
|
65 |
} |
|
66 |
|
|
67 |
function defaultParsingFlags() { |
|
68 |
// We need to deep clone this object. |
|
69 |
return { |
|
70 |
empty : false, |
|
71 |
unusedTokens : [], |
|
72 |
unusedInput : [], |
|
73 |
overflow : -2, |
|
74 |
charsLeftOver : 0, |
|
75 |
nullInput : false, |
|
76 |
invalidMonth : null, |
|
77 |
invalidFormat : false, |
|
78 |
userInvalidated : false, |
|
79 |
iso : false |
|
80 |
}; |
|
81 |
} |
|
82 |
|
|
83 |
function getParsingFlags(m) { |
|
84 |
if (m._pf == null) { |
|
85 |
m._pf = defaultParsingFlags(); |
|
86 |
} |
|
87 |
return m._pf; |
|
88 |
} |
|
89 |
|
|
90 |
function valid__isValid(m) { |
|
91 |
if (m._isValid == null) { |
|
92 |
var flags = getParsingFlags(m); |
|
93 |
m._isValid = !isNaN(m._d.getTime()) && |
|
94 |
flags.overflow < 0 && |
|
95 |
!flags.empty && |
|
96 |
!flags.invalidMonth && |
|
97 |
!flags.invalidWeekday && |
|
98 |
!flags.nullInput && |
|
99 |
!flags.invalidFormat && |
|
100 |
!flags.userInvalidated; |
|
101 |
|
|
102 |
if (m._strict) { |
|
103 |
m._isValid = m._isValid && |
|
104 |
flags.charsLeftOver === 0 && |
|
105 |
flags.unusedTokens.length === 0 && |
|
106 |
flags.bigHour === undefined; |
|
107 |
} |
|
108 |
} |
|
109 |
return m._isValid; |
|
110 |
} |
|
111 |
|
|
112 |
function valid__createInvalid (flags) { |
|
113 |
var m = create_utc__createUTC(NaN); |
|
114 |
if (flags != null) { |
|
115 |
extend(getParsingFlags(m), flags); |
|
116 |
} |
|
117 |
else { |
|
118 |
getParsingFlags(m).userInvalidated = true; |
|
119 |
} |
|
120 |
|
|
121 |
return m; |
|
122 |
} |
|
123 |
|
|
124 |
var momentProperties = utils_hooks__hooks.momentProperties = []; |
|
125 |
|
|
126 |
function copyConfig(to, from) { |
|
127 |
var i, prop, val; |
|
128 |
|
|
129 |
if (typeof from._isAMomentObject !== 'undefined') { |
|
130 |
to._isAMomentObject = from._isAMomentObject; |
|
131 |
} |
|
132 |
if (typeof from._i !== 'undefined') { |
|
133 |
to._i = from._i; |
|
134 |
} |
|
135 |
if (typeof from._f !== 'undefined') { |
|
136 |
to._f = from._f; |
|
137 |
} |
|
138 |
if (typeof from._l !== 'undefined') { |
|
139 |
to._l = from._l; |
|
140 |
} |
|
141 |
if (typeof from._strict !== 'undefined') { |
|
142 |
to._strict = from._strict; |
|
143 |
} |
|
144 |
if (typeof from._tzm !== 'undefined') { |
|
145 |
to._tzm = from._tzm; |
|
146 |
} |
|
147 |
if (typeof from._isUTC !== 'undefined') { |
|
148 |
to._isUTC = from._isUTC; |
|
149 |
} |
|
150 |
if (typeof from._offset !== 'undefined') { |
|
151 |
to._offset = from._offset; |
|
152 |
} |
|
153 |
if (typeof from._pf !== 'undefined') { |
|
154 |
to._pf = getParsingFlags(from); |
|
155 |
} |
|
156 |
if (typeof from._locale !== 'undefined') { |
|
157 |
to._locale = from._locale; |
|
158 |
} |
|
159 |
|
|
160 |
if (momentProperties.length > 0) { |
|
161 |
for (i in momentProperties) { |
|
162 |
prop = momentProperties[i]; |
|
163 |
val = from[prop]; |
|
164 |
if (typeof val !== 'undefined') { |
|
165 |
to[prop] = val; |
|
166 |
} |
|
167 |
} |
|
168 |
} |
|
169 |
|
|
170 |
return to; |
|
171 |
} |
|
172 |
|
|
173 |
var updateInProgress = false; |
|
174 |
|
|
175 |
// Moment prototype object |
|
176 |
function Moment(config) { |
|
177 |
copyConfig(this, config); |
|
178 |
this._d = new Date(config._d != null ? config._d.getTime() : NaN); |
|
179 |
// Prevent infinite loop in case updateOffset creates new moment |
|
180 |
// objects. |
|
181 |
if (updateInProgress === false) { |
|
182 |
updateInProgress = true; |
|
183 |
utils_hooks__hooks.updateOffset(this); |
|
184 |
updateInProgress = false; |
|
185 |
} |
|
186 |
} |
|
187 |
|
|
188 |
function isMoment (obj) { |
|
189 |
return obj instanceof Moment || (obj != null && obj._isAMomentObject != null); |
|
190 |
} |
|
191 |
|
|
192 |
function absFloor (number) { |
|
193 |
if (number < 0) { |
|
194 |
return Math.ceil(number); |
|
195 |
} else { |
|
196 |
return Math.floor(number); |
|
197 |
} |
|
198 |
} |
|
199 |
|
|
200 |
function toInt(argumentForCoercion) { |
|
201 |
var coercedNumber = +argumentForCoercion, |
|
202 |
value = 0; |
|
203 |
|
|
204 |
if (coercedNumber !== 0 && isFinite(coercedNumber)) { |
|
205 |
value = absFloor(coercedNumber); |
|
206 |
} |
|
207 |
|
|
208 |
return value; |
|
209 |
} |
|
210 |
|
|
211 |
function compareArrays(array1, array2, dontConvert) { |
|
212 |
var len = Math.min(array1.length, array2.length), |
|
213 |
lengthDiff = Math.abs(array1.length - array2.length), |
|
214 |
diffs = 0, |
|
215 |
i; |
|
216 |
for (i = 0; i < len; i++) { |
|
217 |
if ((dontConvert && array1[i] !== array2[i]) || |
|
218 |
(!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) { |
|
219 |
diffs++; |
|
220 |
} |
|
221 |
} |
|
222 |
return diffs + lengthDiff; |
|
223 |
} |
|
224 |
|
|
225 |
function Locale() { |
|
226 |
} |
|
227 |
|
|
228 |
var locales = {}; |
|
229 |
var globalLocale; |
|
230 |
|
|
231 |
function normalizeLocale(key) { |
|
232 |
return key ? key.toLowerCase().replace('_', '-') : key; |
|
233 |
} |
|
234 |
|
|
235 |
// pick the locale from the array |
|
236 |
// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each |
|
237 |
// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root |
|
238 |
function chooseLocale(names) { |
|
239 |
var i = 0, j, next, locale, split; |
|
240 |
|
|
241 |
while (i < names.length) { |
|
242 |
split = normalizeLocale(names[i]).split('-'); |
|
243 |
j = split.length; |
|
244 |
next = normalizeLocale(names[i + 1]); |
|
245 |
next = next ? next.split('-') : null; |
|
246 |
while (j > 0) { |
|
247 |
locale = loadLocale(split.slice(0, j).join('-')); |
|
248 |
if (locale) { |
|
249 |
return locale; |
|
250 |
} |
|
251 |
if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) { |
|
252 |
//the next array item is better than a shallower substring of this one |
|
253 |
break; |
|
254 |
} |
|
255 |
j--; |
|
256 |
} |
|
257 |
i++; |
|
258 |
} |
|
259 |
return null; |
|
260 |
} |
|
261 |
|
|
262 |
function loadLocale(name) { |
|
263 |
var oldLocale = null; |
|
264 |
// TODO: Find a better way to register and load all the locales in Node |
|
265 |
if (!locales[name] && typeof module !== 'undefined' && |
|
266 |
module && module.exports) { |
|
267 |
try { |
|
268 |
oldLocale = globalLocale._abbr; |
|
269 |
require('./locale/' + name); |
|
270 |
// because defineLocale currently also sets the global locale, we |
|
271 |
// want to undo that for lazy loaded locales |
|
272 |
locale_locales__getSetGlobalLocale(oldLocale); |
|
273 |
} catch (e) { } |
|
274 |
} |
|
275 |
return locales[name]; |
|
276 |
} |
|
277 |
|
|
278 |
// This function will load locale and then set the global locale. If |
|
279 |
// no arguments are passed in, it will simply return the current global |
|
280 |
// locale key. |
|
281 |
function locale_locales__getSetGlobalLocale (key, values) { |
|
282 |
var data; |
|
283 |
if (key) { |
|
284 |
if (typeof values === 'undefined') { |
|
285 |
data = locale_locales__getLocale(key); |
|
286 |
} |
|
287 |
else { |
|
288 |
data = defineLocale(key, values); |
|
289 |
} |
|
290 |
|
|
291 |
if (data) { |
|
292 |
// moment.duration._locale = moment._locale = data; |
|
293 |
globalLocale = data; |
|
294 |
} |
|
295 |
} |
|
296 |
|
|
297 |
return globalLocale._abbr; |
|
298 |
} |
|
299 |
|
|
300 |
function defineLocale (name, values) { |
|
301 |
if (values !== null) { |
|
302 |
values.abbr = name; |
|
303 |
locales[name] = locales[name] || new Locale(); |
|
304 |
locales[name].set(values); |
|
305 |
|
|
306 |
// backwards compat for now: also set the locale |
|
307 |
locale_locales__getSetGlobalLocale(name); |
|
308 |
|
|
309 |
return locales[name]; |
|
310 |
} else { |
|
311 |
// useful for testing |
|
312 |
delete locales[name]; |
|
313 |
return null; |
|
314 |
} |
|
315 |
} |
|
316 |
|
|
317 |
// returns locale data |
|
318 |
function locale_locales__getLocale (key) { |
|
319 |
var locale; |
|
320 |
|
|
321 |
if (key && key._locale && key._locale._abbr) { |
|
322 |
key = key._locale._abbr; |
|
323 |
} |
|
324 |
|
|
325 |
if (!key) { |
|
326 |
return globalLocale; |
|
327 |
} |
|
328 |
|
|
329 |
if (!isArray(key)) { |
|
330 |
//short-circuit everything else |
|
331 |
locale = loadLocale(key); |
|
332 |
if (locale) { |
|
333 |
return locale; |
|
334 |
} |
|
335 |
key = [key]; |
|
336 |
} |
|
337 |
|
|
338 |
return chooseLocale(key); |
|
339 |
} |
|
340 |
|
|
341 |
var aliases = {}; |
|
342 |
|
|
343 |
function addUnitAlias (unit, shorthand) { |
|
344 |
var lowerCase = unit.toLowerCase(); |
|
345 |
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; |
|
346 |
} |
|
347 |
|
|
348 |
function normalizeUnits(units) { |
|
349 |
return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined; |
|
350 |
} |
|
351 |
|
|
352 |
function normalizeObjectUnits(inputObject) { |
|
353 |
var normalizedInput = {}, |
|
354 |
normalizedProp, |
|
355 |
prop; |
|
356 |
|
|
357 |
for (prop in inputObject) { |
|
358 |
if (hasOwnProp(inputObject, prop)) { |
|
359 |
normalizedProp = normalizeUnits(prop); |
|
360 |
if (normalizedProp) { |
|
361 |
normalizedInput[normalizedProp] = inputObject[prop]; |
|
362 |
} |
|
363 |
} |
|
364 |
} |
|
365 |
|
|
366 |
return normalizedInput; |
|
367 |
} |
|
368 |
|
|
369 |
function makeGetSet (unit, keepTime) { |
|
370 |
return function (value) { |
|
371 |
if (value != null) { |
|
372 |
get_set__set(this, unit, value); |
|
373 |
utils_hooks__hooks.updateOffset(this, keepTime); |
|
374 |
return this; |
|
375 |
} else { |
|
376 |
return get_set__get(this, unit); |
|
377 |
} |
|
378 |
}; |
|
379 |
} |
|
380 |
|
|
381 |
function get_set__get (mom, unit) { |
|
382 |
return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit](); |
|
383 |
} |
|
384 |
|
|
385 |
function get_set__set (mom, unit, value) { |
|
386 |
return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); |
|
387 |
} |
|
388 |
|
|
389 |
// MOMENTS |
|
390 |
|
|
391 |
function getSet (units, value) { |
|
392 |
var unit; |
|
393 |
if (typeof units === 'object') { |
|
394 |
for (unit in units) { |
|
395 |
this.set(unit, units[unit]); |
|
396 |
} |
|
397 |
} else { |
|
398 |
units = normalizeUnits(units); |
|
399 |
if (typeof this[units] === 'function') { |
|
400 |
return this[units](value); |
|
401 |
} |
|
402 |
} |
|
403 |
return this; |
|
404 |
} |
|
405 |
|
|
406 |
function zeroFill(number, targetLength, forceSign) { |
|
407 |
var absNumber = '' + Math.abs(number), |
|
408 |
zerosToFill = targetLength - absNumber.length, |
|
409 |
sign = number >= 0; |
|
410 |
return (sign ? (forceSign ? '+' : '') : '-') + |
|
411 |
Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; |
|
412 |
} |
|
413 |
|
|
414 |
var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g; |
|
415 |
|
|
416 |
var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g; |
|
417 |
|
|
418 |
var formatFunctions = {}; |
|
419 |
|
|
420 |
var formatTokenFunctions = {}; |
|
421 |
|
|
422 |
// token: 'M' |
|
423 |
// padded: ['MM', 2] |
|
424 |
// ordinal: 'Mo' |
|
425 |
// callback: function () { this.month() + 1 } |
|
426 |
function addFormatToken (token, padded, ordinal, callback) { |
|
427 |
var func = callback; |
|
428 |
if (typeof callback === 'string') { |
|
429 |
func = function () { |
|
430 |
return this[callback](); |
|
431 |
}; |
|
432 |
} |
|
433 |
if (token) { |
|
434 |
formatTokenFunctions[token] = func; |
|
435 |
} |
|
436 |
if (padded) { |
|
437 |
formatTokenFunctions[padded[0]] = function () { |
|
438 |
return zeroFill(func.apply(this, arguments), padded[1], padded[2]); |
|
439 |
}; |
|
440 |
} |
|
441 |
if (ordinal) { |
|
442 |
formatTokenFunctions[ordinal] = function () { |
|
443 |
return this.localeData().ordinal(func.apply(this, arguments), token); |
|
444 |
}; |
|
445 |
} |
|
446 |
} |
|
447 |
|
|
448 |
function removeFormattingTokens(input) { |
|
449 |
if (input.match(/\[[\s\S]/)) { |
|
450 |
return input.replace(/^\[|\]$/g, ''); |
|
451 |
} |
|
452 |
return input.replace(/\\/g, ''); |
|
453 |
} |
|
454 |
|
|
455 |
function makeFormatFunction(format) { |
|
456 |
var array = format.match(formattingTokens), i, length; |
|
457 |
|
|
458 |
for (i = 0, length = array.length; i < length; i++) { |
|
459 |
if (formatTokenFunctions[array[i]]) { |
|
460 |
array[i] = formatTokenFunctions[array[i]]; |
|
461 |
} else { |
|
462 |
array[i] = removeFormattingTokens(array[i]); |
|
463 |
} |
|
464 |
} |
|
465 |
|
|
466 |
return function (mom) { |
|
467 |
var output = ''; |
|
468 |
for (i = 0; i < length; i++) { |
|
469 |
output += array[i] instanceof Function ? array[i].call(mom, format) : array[i]; |
|
470 |
} |
|
471 |
return output; |
|
472 |
}; |
|
473 |
} |
|
474 |
|
|
475 |
// format date using native date object |
|
476 |
function formatMoment(m, format) { |
|
477 |
if (!m.isValid()) { |
|
478 |
return m.localeData().invalidDate(); |
|
479 |
} |
|
480 |
|
|
481 |
format = expandFormat(format, m.localeData()); |
|
482 |
formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format); |
|
483 |
|
|
484 |
return formatFunctions[format](m); |
|
485 |
} |
|
486 |
|
|
487 |
function expandFormat(format, locale) { |
|
488 |
var i = 5; |
|
489 |
|
|
490 |
function replaceLongDateFormatTokens(input) { |
|
491 |
return locale.longDateFormat(input) || input; |
|
492 |
} |
|
493 |
|
|
494 |
localFormattingTokens.lastIndex = 0; |
|
495 |
while (i >= 0 && localFormattingTokens.test(format)) { |
|
496 |
format = format.replace(localFormattingTokens, replaceLongDateFormatTokens); |
|
497 |
localFormattingTokens.lastIndex = 0; |
|
498 |
i -= 1; |
|
499 |
} |
|
500 |
|
|
501 |
return format; |
|
502 |
} |
|
503 |
|
|
504 |
var match1 = /\d/; // 0 - 9 |
|
505 |
var match2 = /\d\d/; // 00 - 99 |
|
506 |
var match3 = /\d{3}/; // 000 - 999 |
|
507 |
var match4 = /\d{4}/; // 0000 - 9999 |
|
508 |
var match6 = /[+-]?\d{6}/; // -999999 - 999999 |
|
509 |
var match1to2 = /\d\d?/; // 0 - 99 |
|
510 |
var match1to3 = /\d{1,3}/; // 0 - 999 |
|
511 |
var match1to4 = /\d{1,4}/; // 0 - 9999 |
|
512 |
var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999 |
|
513 |
|
|
514 |
var matchUnsigned = /\d+/; // 0 - inf |
|
515 |
var matchSigned = /[+-]?\d+/; // -inf - inf |
|
516 |
|
|
517 |
var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z |
|
518 |
|
|
519 |
var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123 |
|
520 |
|
|
521 |
// any word (or two) characters or numbers including two/three word month in arabic. |
|
522 |
var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i; |
|
523 |
|
|
524 |
var regexes = {}; |
|
525 |
|
|
526 |
function isFunction (sth) { |
|
527 |
// https://github.com/moment/moment/issues/2325 |
|
528 |
return typeof sth === 'function' && |
|
529 |
Object.prototype.toString.call(sth) === '[object Function]'; |
|
530 |
} |
|
531 |
|
|
532 |
|
|
533 |
function addRegexToken (token, regex, strictRegex) { |
|
534 |
regexes[token] = isFunction(regex) ? regex : function (isStrict) { |
|
535 |
return (isStrict && strictRegex) ? strictRegex : regex; |
|
536 |
}; |
|
537 |
} |
|
538 |
|
|
539 |
function getParseRegexForToken (token, config) { |
|
540 |
if (!hasOwnProp(regexes, token)) { |
|
541 |
return new RegExp(unescapeFormat(token)); |
|
542 |
} |
|
543 |
|
|
544 |
return regexes[token](config._strict, config._locale); |
|
545 |
} |
|
546 |
|
|
547 |
// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript |
|
548 |
function unescapeFormat(s) { |
|
549 |
return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { |
|
550 |
return p1 || p2 || p3 || p4; |
|
551 |
}).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); |
|
552 |
} |
|
553 |
|
|
554 |
var tokens = {}; |
|
555 |
|
|
556 |
function addParseToken (token, callback) { |
|
557 |
var i, func = callback; |
|
558 |
if (typeof token === 'string') { |
|
559 |
token = [token]; |
|
560 |
} |
|
561 |
if (typeof callback === 'number') { |
|
562 |
func = function (input, array) { |
|
563 |
array[callback] = toInt(input); |
|
564 |
}; |
|
565 |
} |
|
566 |
for (i = 0; i < token.length; i++) { |
|
567 |
tokens[token[i]] = func; |
|
568 |
} |
|
569 |
} |
|
570 |
|
|
571 |
function addWeekParseToken (token, callback) { |
|
572 |
addParseToken(token, function (input, array, config, token) { |
|
573 |
config._w = config._w || {}; |
|
574 |
callback(input, config._w, config, token); |
|
575 |
}); |
|
576 |
} |
|
577 |
|
|
578 |
function addTimeToArrayFromToken(token, input, config) { |
|
579 |
if (input != null && hasOwnProp(tokens, token)) { |
|
580 |
tokens[token](input, config._a, config, token); |
|
581 |
} |
|
582 |
} |
|
583 |
|
|
584 |
var YEAR = 0; |
|
585 |
var MONTH = 1; |
|
586 |
var DATE = 2; |
|
587 |
var HOUR = 3; |
|
588 |
var MINUTE = 4; |
|
589 |
var SECOND = 5; |
|
590 |
var MILLISECOND = 6; |
|
591 |
|
|
592 |
function daysInMonth(year, month) { |
|
593 |
return new Date(Date.UTC(year, month + 1, 0)).getUTCDate(); |
|
594 |
} |
|
595 |
|
|
596 |
// FORMATTING |
|
597 |
|
|
598 |
addFormatToken('M', ['MM', 2], 'Mo', function () { |
|
599 |
return this.month() + 1; |
|
600 |
}); |
|
601 |
|
|
602 |
addFormatToken('MMM', 0, 0, function (format) { |
|
603 |
return this.localeData().monthsShort(this, format); |
|
604 |
}); |
|
605 |
|
|
606 |
addFormatToken('MMMM', 0, 0, function (format) { |
|
607 |
return this.localeData().months(this, format); |
|
608 |
}); |
|
609 |
|
|
610 |
// ALIASES |
|
611 |
|
|
612 |
addUnitAlias('month', 'M'); |
|
613 |
|
|
614 |
// PARSING |
|
615 |
|
|
616 |
addRegexToken('M', match1to2); |
|
617 |
addRegexToken('MM', match1to2, match2); |
|
618 |
addRegexToken('MMM', matchWord); |
|
619 |
addRegexToken('MMMM', matchWord); |
|
620 |
|
|
621 |
addParseToken(['M', 'MM'], function (input, array) { |
|
622 |
array[MONTH] = toInt(input) - 1; |
|
623 |
}); |
|
624 |
|
|
625 |
addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { |
|
626 |
var month = config._locale.monthsParse(input, token, config._strict); |
|
627 |
// if we didn't find a month name, mark the date as invalid. |
|
628 |
if (month != null) { |
|
629 |
array[MONTH] = month; |
|
630 |
} else { |
|
631 |
getParsingFlags(config).invalidMonth = input; |
|
632 |
} |
|
633 |
}); |
|
634 |
|
|
635 |
// LOCALES |
|
636 |
|
|
637 |
var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); |
|
638 |
function localeMonths (m) { |
|
639 |
return this._months[m.month()]; |
|
640 |
} |
|
641 |
|
|
642 |
var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); |
|
643 |
function localeMonthsShort (m) { |
|
644 |
return this._monthsShort[m.month()]; |
|
645 |
} |
|
646 |
|
|
647 |
function localeMonthsParse (monthName, format, strict) { |
|
648 |
var i, mom, regex; |
|
649 |
|
|
650 |
if (!this._monthsParse) { |
|
651 |
this._monthsParse = []; |
|
652 |
this._longMonthsParse = []; |
|
653 |
this._shortMonthsParse = []; |
|
654 |
} |
|
655 |
|
|
656 |
for (i = 0; i < 12; i++) { |
|
657 |
// make the regex if we don't have it already |
|
658 |
mom = create_utc__createUTC([2000, i]); |
|
659 |
if (strict && !this._longMonthsParse[i]) { |
|
660 |
this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i'); |
|
661 |
this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i'); |
|
662 |
} |
|
663 |
if (!strict && !this._monthsParse[i]) { |
|
664 |
regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); |
|
665 |
this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); |
|
666 |
} |
|
667 |
// test the regex |
|
668 |
if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) { |
|
669 |
return i; |
|
670 |
} else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) { |
|
671 |
return i; |
|
672 |
} else if (!strict && this._monthsParse[i].test(monthName)) { |
|
673 |
return i; |
|
674 |
} |
|
675 |
} |
|
676 |
} |
|
677 |
|
|
678 |
// MOMENTS |
|
679 |
|
|
680 |
function setMonth (mom, value) { |
|
681 |
var dayOfMonth; |
|
682 |
|
|
683 |
// TODO: Move this out of here! |
|
684 |
if (typeof value === 'string') { |
|
685 |
value = mom.localeData().monthsParse(value); |
|
686 |
// TODO: Another silent failure? |
|
687 |
if (typeof value !== 'number') { |
|
688 |
return mom; |
|
689 |
} |
|
690 |
} |
|
691 |
|
|
692 |
dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); |
|
693 |
mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); |
|
694 |
return mom; |
|
695 |
} |
|
696 |
|
|
697 |
function getSetMonth (value) { |
|
698 |
if (value != null) { |
|
699 |
setMonth(this, value); |
|
700 |
utils_hooks__hooks.updateOffset(this, true); |
|
701 |
return this; |
|
702 |
} else { |
|
703 |
return get_set__get(this, 'Month'); |
|
704 |
} |
|
705 |
} |
|
706 |
|
|
707 |
function getDaysInMonth () { |
|
708 |
return daysInMonth(this.year(), this.month()); |
|
709 |
} |
|
710 |
|
|
711 |
function checkOverflow (m) { |
|
712 |
var overflow; |
|
713 |
var a = m._a; |
|
714 |
|
|
715 |
if (a && getParsingFlags(m).overflow === -2) { |
|
716 |
overflow = |
|
717 |
a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : |
|
718 |
a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : |
|
719 |
a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR : |
|
720 |
a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : |
|
721 |
a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : |
|
722 |
a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : |
|
723 |
-1; |
|
724 |
|
|
725 |
if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { |
|
726 |
overflow = DATE; |
|
727 |
} |
|
728 |
|
|
729 |
getParsingFlags(m).overflow = overflow; |
|
730 |
} |
|
731 |
|
|
732 |
return m; |
|
733 |
} |
|
734 |
|
|
735 |
function warn(msg) { |
|
736 |
if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) { |
|
737 |
console.warn('Deprecation warning: ' + msg); |
|
738 |
} |
|
739 |
} |
|
740 |
|
|
741 |
function deprecate(msg, fn) { |
|
742 |
var firstTime = true; |
|
743 |
|
|
744 |
return extend(function () { |
|
745 |
if (firstTime) { |
|
746 |
warn(msg + '\n' + (new Error()).stack); |
|
747 |
firstTime = false; |
|
748 |
} |
|
749 |
return fn.apply(this, arguments); |
|
750 |
}, fn); |
|
751 |
} |
|
752 |
|
|
753 |
var deprecations = {}; |
|
754 |
|
|
755 |
function deprecateSimple(name, msg) { |
|
756 |
if (!deprecations[name]) { |
|
757 |
warn(msg); |
|
758 |
deprecations[name] = true; |
|
759 |
} |
|
760 |
} |
|
761 |
|
|
762 |
utils_hooks__hooks.suppressDeprecationWarnings = false; |
|
763 |
|
|
764 |
var from_string__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)?)?$/; |
|
765 |
|
|
766 |
var isoDates = [ |
|
767 |
['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/], |
|
768 |
['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/], |
|
769 |
['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/], |
|
770 |
['GGGG-[W]WW', /\d{4}-W\d{2}/], |
|
771 |
['YYYY-DDD', /\d{4}-\d{3}/] |
|
772 |
]; |
|
773 |
|
|
774 |
// iso time formats and regexes |
|
775 |
var isoTimes = [ |
|
776 |
['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/], |
|
777 |
['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/], |
|
778 |
['HH:mm', /(T| )\d\d:\d\d/], |
|
779 |
['HH', /(T| )\d\d/] |
|
780 |
]; |
|
781 |
|
|
782 |
var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i; |
|
783 |
|
|
784 |
// date from iso format |
|
785 |
function configFromISO(config) { |
|
786 |
var i, l, |
|
787 |
string = config._i, |
|
788 |
match = from_string__isoRegex.exec(string); |
|
789 |
|
|
790 |
if (match) { |
|
791 |
getParsingFlags(config).iso = true; |
|
792 |
for (i = 0, l = isoDates.length; i < l; i++) { |
|
793 |
if (isoDates[i][1].exec(string)) { |
|
794 |
config._f = isoDates[i][0]; |
|
795 |
break; |
|
796 |
} |
|
797 |
} |
|
798 |
for (i = 0, l = isoTimes.length; i < l; i++) { |
|
799 |
if (isoTimes[i][1].exec(string)) { |
|
800 |
// match[6] should be 'T' or space |
|
801 |
config._f += (match[6] || ' ') + isoTimes[i][0]; |
|
802 |
break; |
|
803 |
} |
|
804 |
} |
|
805 |
if (string.match(matchOffset)) { |
|
806 |
config._f += 'Z'; |
|
807 |
} |
|
808 |
configFromStringAndFormat(config); |
|
809 |
} else { |
|
810 |
config._isValid = false; |
|
811 |
} |
|
812 |
} |
|
813 |
|
|
814 |
// date from iso format or fallback |
|
815 |
function configFromString(config) { |
|
816 |
var matched = aspNetJsonRegex.exec(config._i); |
|
817 |
|
|
818 |
if (matched !== null) { |
|
819 |
config._d = new Date(+matched[1]); |
|
820 |
return; |
|
821 |
} |
|
822 |
|
|
823 |
configFromISO(config); |
|
824 |
if (config._isValid === false) { |
|
825 |
delete config._isValid; |
|
826 |
utils_hooks__hooks.createFromInputFallback(config); |
|
827 |
} |
|
828 |
} |
|
829 |
|
|
830 |
utils_hooks__hooks.createFromInputFallback = deprecate( |
|
831 |
'moment construction falls back to js Date. This is ' + |
|
832 |
'discouraged and will be removed in upcoming major ' + |
|
833 |
'release. Please refer to ' + |
|
834 |
'https://github.com/moment/moment/issues/1407 for more info.', |
|
835 |
function (config) { |
|
836 |
config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); |
|
837 |
} |
|
838 |
); |
|
839 |
|
|
840 |
function createDate (y, m, d, h, M, s, ms) { |
|
841 |
//can't just apply() to create a date: |
|
842 |
//http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply |
|
843 |
var date = new Date(y, m, d, h, M, s, ms); |
|
844 |
|
|
845 |
//the date constructor doesn't accept years < 1970 |
|
846 |
if (y < 1970) { |
|
847 |
date.setFullYear(y); |
|
848 |
} |
|
849 |
return date; |
|
850 |
} |
|
851 |
|
|
852 |
function createUTCDate (y) { |
|
853 |
var date = new Date(Date.UTC.apply(null, arguments)); |
|
854 |
if (y < 1970) { |
|
855 |
date.setUTCFullYear(y); |
|
856 |
} |
|
857 |
return date; |
|
858 |
} |
|
859 |
|
|
860 |
addFormatToken(0, ['YY', 2], 0, function () { |
|
861 |
return this.year() % 100; |
|
862 |
}); |
|
863 |
|
|
864 |
addFormatToken(0, ['YYYY', 4], 0, 'year'); |
|
865 |
addFormatToken(0, ['YYYYY', 5], 0, 'year'); |
|
866 |
addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); |
|
867 |
|
|
868 |
// ALIASES |
|
869 |
|
|
870 |
addUnitAlias('year', 'y'); |
|
871 |
|
|
872 |
// PARSING |
|
873 |
|
|
874 |
addRegexToken('Y', matchSigned); |
|
875 |
addRegexToken('YY', match1to2, match2); |
|
876 |
addRegexToken('YYYY', match1to4, match4); |
|
877 |
addRegexToken('YYYYY', match1to6, match6); |
|
878 |
addRegexToken('YYYYYY', match1to6, match6); |
|
879 |
|
|
880 |
addParseToken(['YYYYY', 'YYYYYY'], YEAR); |
|
881 |
addParseToken('YYYY', function (input, array) { |
|
882 |
array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input); |
|
883 |
}); |
|
884 |
addParseToken('YY', function (input, array) { |
|
885 |
array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input); |
|
886 |
}); |
|
887 |
|
|
888 |
// HELPERS |
|
889 |
|
|
890 |
function daysInYear(year) { |
|
891 |
return isLeapYear(year) ? 366 : 365; |
|
892 |
} |
|
893 |
|
|
894 |
function isLeapYear(year) { |
|
895 |
return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; |
|
896 |
} |
|
897 |
|
|
898 |
// HOOKS |
|
899 |
|
|
900 |
utils_hooks__hooks.parseTwoDigitYear = function (input) { |
|
901 |
return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); |
|
902 |
}; |
|
903 |
|
|
904 |
// MOMENTS |
|
905 |
|
|
906 |
var getSetYear = makeGetSet('FullYear', false); |
|
907 |
|
|
908 |
function getIsLeapYear () { |
|
909 |
return isLeapYear(this.year()); |
|
910 |
} |
|
911 |
|
|
912 |
addFormatToken('w', ['ww', 2], 'wo', 'week'); |
|
913 |
addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); |
|
914 |
|
|
915 |
// ALIASES |
|
916 |
|
|
917 |
addUnitAlias('week', 'w'); |
|
918 |
addUnitAlias('isoWeek', 'W'); |
|
919 |
|
|
920 |
// PARSING |
|
921 |
|
|
922 |
addRegexToken('w', match1to2); |
|
923 |
addRegexToken('ww', match1to2, match2); |
|
924 |
addRegexToken('W', match1to2); |
|
925 |
addRegexToken('WW', match1to2, match2); |
|
926 |
|
|
927 |
addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) { |
|
928 |
week[token.substr(0, 1)] = toInt(input); |
|
929 |
}); |
|
930 |
|
|
931 |
// HELPERS |
|
932 |
|
|
933 |
// firstDayOfWeek 0 = sun, 6 = sat |
|
934 |
// the day of the week that starts the week |
|
935 |
// (usually sunday or monday) |
|
936 |
// firstDayOfWeekOfYear 0 = sun, 6 = sat |
|
937 |
// the first week is the week that contains the first |
|
938 |
// of this day of the week |
|
939 |
// (eg. ISO weeks use thursday (4)) |
|
940 |
function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) { |
|
941 |
var end = firstDayOfWeekOfYear - firstDayOfWeek, |
|
942 |
daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(), |
|
943 |
adjustedMoment; |
|
944 |
|
|
945 |
|
|
946 |
if (daysToDayOfWeek > end) { |
|
947 |
daysToDayOfWeek -= 7; |
|
948 |
} |
|
949 |
|
|
950 |
if (daysToDayOfWeek < end - 7) { |
|
951 |
daysToDayOfWeek += 7; |
|
952 |
} |
|
953 |
|
|
954 |
adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek, 'd'); |
|
955 |
return { |
|
956 |
week: Math.ceil(adjustedMoment.dayOfYear() / 7), |
|
957 |
year: adjustedMoment.year() |
|
958 |
}; |
|
959 |
} |
|
960 |
|
|
961 |
// LOCALES |
|
962 |
|
|
963 |
function localeWeek (mom) { |
|
964 |
return weekOfYear(mom, this._week.dow, this._week.doy).week; |
|
965 |
} |
|
966 |
|
|
967 |
var defaultLocaleWeek = { |
|
968 |
dow : 0, // Sunday is the first day of the week. |
|
969 |
doy : 6 // The week that contains Jan 1st is the first week of the year. |
|
970 |
}; |
|
971 |
|
|
972 |
function localeFirstDayOfWeek () { |
|
973 |
return this._week.dow; |
|
974 |
} |
|
975 |
|
|
976 |
function localeFirstDayOfYear () { |
|
977 |
return this._week.doy; |
|
978 |
} |
|
979 |
|
|
980 |
// MOMENTS |
|
981 |
|
|
982 |
function getSetWeek (input) { |
|
983 |
var week = this.localeData().week(this); |
|
984 |
return input == null ? week : this.add((input - week) * 7, 'd'); |
|
985 |
} |
|
986 |
|
|
987 |
function getSetISOWeek (input) { |
|
988 |
var week = weekOfYear(this, 1, 4).week; |
|
989 |
return input == null ? week : this.add((input - week) * 7, 'd'); |
|
990 |
} |
|
991 |
|
|
992 |
addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); |
|
993 |
|
|
994 |
// ALIASES |
|
995 |
|
|
996 |
addUnitAlias('dayOfYear', 'DDD'); |
|
997 |
|
|
998 |
// PARSING |
|
999 |
|
|
1000 |
addRegexToken('DDD', match1to3); |
|
1001 |
addRegexToken('DDDD', match3); |
|
1002 |
addParseToken(['DDD', 'DDDD'], function (input, array, config) { |
|
1003 |
config._dayOfYear = toInt(input); |
|
1004 |
}); |
|
1005 |
|
|
1006 |
// HELPERS |
|
1007 |
|
|
1008 |
//http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday |
|
1009 |
function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) { |
|
1010 |
var week1Jan = 6 + firstDayOfWeek - firstDayOfWeekOfYear, janX = createUTCDate(year, 0, 1 + week1Jan), d = janX.getUTCDay(), dayOfYear; |
|
1011 |
if (d < firstDayOfWeek) { |
|
1012 |
d += 7; |
|
1013 |
} |
|
1014 |
|
|
1015 |
weekday = weekday != null ? 1 * weekday : firstDayOfWeek; |
|
1016 |
|
|
1017 |
dayOfYear = 1 + week1Jan + 7 * (week - 1) - d + weekday; |
|
1018 |
|
|
1019 |
return { |
|
1020 |
year: dayOfYear > 0 ? year : year - 1, |
|
1021 |
dayOfYear: dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear |
|
1022 |
}; |
|
1023 |
} |
|
1024 |
|
|
1025 |
// MOMENTS |
|
1026 |
|
|
1027 |
function getSetDayOfYear (input) { |
|
1028 |
var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1; |
|
1029 |
return input == null ? dayOfYear : this.add((input - dayOfYear), 'd'); |
|
1030 |
} |
|
1031 |
|
|
1032 |
// Pick the first defined of two or three arguments. |
|
1033 |
function defaults(a, b, c) { |
|
1034 |
if (a != null) { |
|
1035 |
return a; |
|
1036 |
} |
|
1037 |
if (b != null) { |
|
1038 |
return b; |
|
1039 |
} |
|
1040 |
return c; |
|
1041 |
} |
|
1042 |
|
|
1043 |
function currentDateArray(config) { |
|
1044 |
var now = new Date(); |
|
1045 |
if (config._useUTC) { |
|
1046 |
return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()]; |
|
1047 |
} |
|
1048 |
return [now.getFullYear(), now.getMonth(), now.getDate()]; |
|
1049 |
} |
|
1050 |
|
|
1051 |
// convert an array to a date. |
|
1052 |
// the array should mirror the parameters below |
|
1053 |
// note: all values past the year are optional and will default to the lowest possible value. |
|
1054 |
// [year, month, day , hour, minute, second, millisecond] |
|
1055 |
function configFromArray (config) { |
|
1056 |
var i, date, input = [], currentDate, yearToUse; |
|
1057 |
|
|
1058 |
if (config._d) { |
|
1059 |
return; |
|
1060 |
} |
|
1061 |
|
|
1062 |
currentDate = currentDateArray(config); |
|
1063 |
|
|
1064 |
//compute day of the year from weeks and weekdays |
|
1065 |
if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { |
|
1066 |
dayOfYearFromWeekInfo(config); |
|
1067 |
} |
|
1068 |
|
|
1069 |
//if the day of the year is set, figure out what it is |
|
1070 |
if (config._dayOfYear) { |
|
1071 |
yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); |
|
1072 |
|
|
1073 |
if (config._dayOfYear > daysInYear(yearToUse)) { |
|
1074 |
getParsingFlags(config)._overflowDayOfYear = true; |
|
1075 |
} |
|
1076 |
|
|
1077 |
date = createUTCDate(yearToUse, 0, config._dayOfYear); |
|
1078 |
config._a[MONTH] = date.getUTCMonth(); |
|
1079 |
config._a[DATE] = date.getUTCDate(); |
|
1080 |
} |
|
1081 |
|
|
1082 |
// Default to current date. |
|
1083 |
// * if no year, month, day of month are given, default to today |
|
1084 |
// * if day of month is given, default month and year |
|
1085 |
// * if month is given, default only year |
|
1086 |
// * if year is given, don't default anything |
|
1087 |
for (i = 0; i < 3 && config._a[i] == null; ++i) { |
|
1088 |
config._a[i] = input[i] = currentDate[i]; |
|
1089 |
} |
|
1090 |
|
|
1091 |
// Zero out whatever was not defaulted, including time |
|
1092 |
for (; i < 7; i++) { |
|
1093 |
config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i]; |
|
1094 |
} |
|
1095 |
|
|
1096 |
// Check for 24:00:00.000 |
|
1097 |
if (config._a[HOUR] === 24 && |
|
1098 |
config._a[MINUTE] === 0 && |
|
1099 |
config._a[SECOND] === 0 && |
|
1100 |
config._a[MILLISECOND] === 0) { |
|
1101 |
config._nextDay = true; |
|
1102 |
config._a[HOUR] = 0; |
|
1103 |
} |
|
1104 |
|
|
1105 |
config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); |
|
1106 |
// Apply timezone offset from input. The actual utcOffset can be changed |
|
1107 |
// with parseZone. |
|
1108 |
if (config._tzm != null) { |
|
1109 |
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); |
|
1110 |
} |
|
1111 |
|
|
1112 |
if (config._nextDay) { |
|
1113 |
config._a[HOUR] = 24; |
|
1114 |
} |
|
1115 |
} |
|
1116 |
|
|
1117 |
function dayOfYearFromWeekInfo(config) { |
|
1118 |
var w, weekYear, week, weekday, dow, doy, temp; |
|
1119 |
|
|
1120 |
w = config._w; |
|
1121 |
if (w.GG != null || w.W != null || w.E != null) { |
|
1122 |
dow = 1; |
|
1123 |
doy = 4; |
|
1124 |
|
|
1125 |
// TODO: We need to take the current isoWeekYear, but that depends on |
|
1126 |
// how we interpret now (local, utc, fixed offset). So create |
|
1127 |
// a now version of current config (take local/utc/offset flags, and |
|
1128 |
// create now). |
|
1129 |
weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year); |
|
1130 |
week = defaults(w.W, 1); |
|
1131 |
weekday = defaults(w.E, 1); |
|
1132 |
} else { |
|
1133 |
dow = config._locale._week.dow; |
|
1134 |
doy = config._locale._week.doy; |
|
1135 |
|
|
1136 |
weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year); |
|
1137 |
week = defaults(w.w, 1); |
|
1138 |
|
|
1139 |
if (w.d != null) { |
|
1140 |
// weekday -- low day numbers are considered next week |
|
1141 |
weekday = w.d; |
|
1142 |
if (weekday < dow) { |
|
1143 |
++week; |
|
1144 |
} |
|
1145 |
} else if (w.e != null) { |
|
1146 |
// local weekday -- counting starts from begining of week |
|
1147 |
weekday = w.e + dow; |
|
1148 |
} else { |
|
1149 |
// default to begining of week |
|
1150 |
weekday = dow; |
|
1151 |
} |
|
1152 |
} |
|
1153 |
temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow); |
|
1154 |
|
|
1155 |
config._a[YEAR] = temp.year; |
|
1156 |
config._dayOfYear = temp.dayOfYear; |
|
1157 |
} |
|
1158 |
|
|
1159 |
utils_hooks__hooks.ISO_8601 = function () {}; |
|
1160 |
|
|
1161 |
// date from string and format string |
|
1162 |
function configFromStringAndFormat(config) { |
|
1163 |
// TODO: Move this to another part of the creation flow to prevent circular deps |
|
1164 |
if (config._f === utils_hooks__hooks.ISO_8601) { |
|
1165 |
configFromISO(config); |
|
1166 |
return; |
|
1167 |
} |
|
1168 |
|
|
1169 |
config._a = []; |
|
1170 |
getParsingFlags(config).empty = true; |
|
1171 |
|
|
1172 |
// This array is used to make a Date, either with `new Date` or `Date.UTC` |
|
1173 |
var string = '' + config._i, |
|
1174 |
i, parsedInput, tokens, token, skipped, |
|
1175 |
stringLength = string.length, |
|
1176 |
totalParsedInputLength = 0; |
|
1177 |
|
|
1178 |
tokens = expandFormat(config._f, config._locale).match(formattingTokens) || []; |
|
1179 |
|
|
1180 |
for (i = 0; i < tokens.length; i++) { |
|
1181 |
token = tokens[i]; |
|
1182 |
parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0]; |
|
1183 |
if (parsedInput) { |
|
1184 |
skipped = string.substr(0, string.indexOf(parsedInput)); |
|
1185 |
if (skipped.length > 0) { |
|
1186 |
getParsingFlags(config).unusedInput.push(skipped); |
|
1187 |
} |
|
1188 |
string = string.slice(string.indexOf(parsedInput) + parsedInput.length); |
|
1189 |
totalParsedInputLength += parsedInput.length; |
|
1190 |
} |
|
1191 |
// don't parse if it's not a known token |
|
1192 |
if (formatTokenFunctions[token]) { |
|
1193 |
if (parsedInput) { |
|
1194 |
getParsingFlags(config).empty = false; |
|
1195 |
} |
|
1196 |
else { |
|
1197 |
getParsingFlags(config).unusedTokens.push(token); |
|
1198 |
} |
|
1199 |
addTimeToArrayFromToken(token, parsedInput, config); |
|
1200 |
} |
|
1201 |
else if (config._strict && !parsedInput) { |
|
1202 |
getParsingFlags(config).unusedTokens.push(token); |
|
1203 |
} |
|
1204 |
} |
|
1205 |
|
|
1206 |
// add remaining unparsed input length to the string |
|
1207 |
getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; |
|
1208 |
if (string.length > 0) { |
|
1209 |
getParsingFlags(config).unusedInput.push(string); |
|
1210 |
} |
|
1211 |
|
|
1212 |
// clear _12h flag if hour is <= 12 |
|
1213 |
if (getParsingFlags(config).bigHour === true && |
|
1214 |
config._a[HOUR] <= 12 && |
|
1215 |
config._a[HOUR] > 0) { |
|
1216 |
getParsingFlags(config).bigHour = undefined; |
|
1217 |
} |
|
1218 |
// handle meridiem |
|
1219 |
config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); |
|
1220 |
|
|
1221 |
configFromArray(config); |
|
1222 |
checkOverflow(config); |
|
1223 |
} |
|
1224 |
|
|
1225 |
|
|
1226 |
function meridiemFixWrap (locale, hour, meridiem) { |
|
1227 |
var isPm; |
|
1228 |
|
|
1229 |
if (meridiem == null) { |
|
1230 |
// nothing to do |
|
1231 |
return hour; |
|
1232 |
} |
|
1233 |
if (locale.meridiemHour != null) { |
|
1234 |
return locale.meridiemHour(hour, meridiem); |
|
1235 |
} else if (locale.isPM != null) { |
|
1236 |
// Fallback |
|
1237 |
isPm = locale.isPM(meridiem); |
|
1238 |
if (isPm && hour < 12) { |
|
1239 |
hour += 12; |
|
1240 |
} |
|
1241 |
if (!isPm && hour === 12) { |
|
1242 |
hour = 0; |
|
1243 |
} |
|
1244 |
return hour; |
|
1245 |
} else { |
|
1246 |
// this is not supposed to happen |
|
1247 |
return hour; |
|
1248 |
} |
|
1249 |
} |
|
1250 |
|
|
1251 |
function configFromStringAndArray(config) { |
|
1252 |
var tempConfig, |
|
1253 |
bestMoment, |
|
1254 |
|
|
1255 |
scoreToBeat, |
|
1256 |
i, |
|
1257 |
currentScore; |
|
1258 |
|
|
1259 |
if (config._f.length === 0) { |
|
1260 |
getParsingFlags(config).invalidFormat = true; |
|
1261 |
config._d = new Date(NaN); |
|
1262 |
return; |
|
1263 |
} |
|
1264 |
|
|
1265 |
for (i = 0; i < config._f.length; i++) { |
|
1266 |
currentScore = 0; |
|
1267 |
tempConfig = copyConfig({}, config); |
|
1268 |
if (config._useUTC != null) { |
|
1269 |
tempConfig._useUTC = config._useUTC; |
|
1270 |
} |
|
1271 |
tempConfig._f = config._f[i]; |
|
1272 |
configFromStringAndFormat(tempConfig); |
|
1273 |
|
|
1274 |
if (!valid__isValid(tempConfig)) { |
|
1275 |
continue; |
|
1276 |
} |
|
1277 |
|
|
1278 |
// if there is any input that was not parsed add a penalty for that format |
|
1279 |
currentScore += getParsingFlags(tempConfig).charsLeftOver; |
|
1280 |
|
|
1281 |
//or tokens |
|
1282 |
currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; |
|
1283 |
|
|
1284 |
getParsingFlags(tempConfig).score = currentScore; |
|
1285 |
|
|
1286 |
if (scoreToBeat == null || currentScore < scoreToBeat) { |
|
1287 |
scoreToBeat = currentScore; |
|
1288 |
bestMoment = tempConfig; |
|
1289 |
} |
|
1290 |
} |
|
1291 |
|
|
1292 |
extend(config, bestMoment || tempConfig); |
|
1293 |
} |
|
1294 |
|
|
1295 |
function configFromObject(config) { |
|
1296 |
if (config._d) { |
|
1297 |
return; |
|
1298 |
} |
|
1299 |
|
|
1300 |
var i = normalizeObjectUnits(config._i); |
|
1301 |
config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond]; |
|
1302 |
|
|
1303 |
configFromArray(config); |
|
1304 |
} |
|
1305 |
|
|
1306 |
function createFromConfig (config) { |
|
1307 |
var res = new Moment(checkOverflow(prepareConfig(config))); |
|
1308 |
if (res._nextDay) { |
|
1309 |
// Adding is smart enough around DST |
|
1310 |
res.add(1, 'd'); |
|
1311 |
res._nextDay = undefined; |
|
1312 |
} |
|
1313 |
|
|
1314 |
return res; |
|
1315 |
} |
|
1316 |
|
|
1317 |
function prepareConfig (config) { |
|
1318 |
var input = config._i, |
|
1319 |
format = config._f; |
|
1320 |
|
|
1321 |
config._locale = config._locale || locale_locales__getLocale(config._l); |
|
1322 |
|
|
1323 |
if (input === null || (format === undefined && input === '')) { |
|
1324 |
return valid__createInvalid({nullInput: true}); |
|
1325 |
} |
|
1326 |
|
|
1327 |
if (typeof input === 'string') { |
|
1328 |
config._i = input = config._locale.preparse(input); |
|
1329 |
} |
|
1330 |
|
|
1331 |
if (isMoment(input)) { |
|
1332 |
return new Moment(checkOverflow(input)); |
|
1333 |
} else if (isArray(format)) { |
|
1334 |
configFromStringAndArray(config); |
|
1335 |
} else if (format) { |
|
1336 |
configFromStringAndFormat(config); |
|
1337 |
} else if (isDate(input)) { |
|
1338 |
config._d = input; |
|
1339 |
} else { |
|
1340 |
configFromInput(config); |
|
1341 |
} |
|
1342 |
|
|
1343 |
return config; |
|
1344 |
} |
|
1345 |
|
|
1346 |
function configFromInput(config) { |
|
1347 |
var input = config._i; |
|
1348 |
if (input === undefined) { |
|
1349 |
config._d = new Date(); |
|
1350 |
} else if (isDate(input)) { |
|
1351 |
config._d = new Date(+input); |
|
1352 |
} else if (typeof input === 'string') { |
|
1353 |
configFromString(config); |
|
1354 |
} else if (isArray(input)) { |
|
1355 |
config._a = map(input.slice(0), function (obj) { |
|
1356 |
return parseInt(obj, 10); |
|
1357 |
}); |
|
1358 |
configFromArray(config); |
|
1359 |
} else if (typeof(input) === 'object') { |
|
1360 |
configFromObject(config); |
|
1361 |
} else if (typeof(input) === 'number') { |
|
1362 |
// from milliseconds |
|
1363 |
config._d = new Date(input); |
|
1364 |
} else { |
|
1365 |
utils_hooks__hooks.createFromInputFallback(config); |
|
1366 |
} |
|
1367 |
} |
|
1368 |
|
|
1369 |
function createLocalOrUTC (input, format, locale, strict, isUTC) { |
|
1370 |
var c = {}; |
|
1371 |
|
|
1372 |
if (typeof(locale) === 'boolean') { |
|
1373 |
strict = locale; |
|
1374 |
locale = undefined; |
|
1375 |
} |
|
1376 |
// object construction must be done this way. |
|
1377 |
// https://github.com/moment/moment/issues/1423 |
|
1378 |
c._isAMomentObject = true; |
|
1379 |
c._useUTC = c._isUTC = isUTC; |
|
1380 |
c._l = locale; |
|
1381 |
c._i = input; |
|
1382 |
c._f = format; |
|
1383 |
c._strict = strict; |
|
1384 |
|
|
1385 |
return createFromConfig(c); |
|
1386 |
} |
|
1387 |
|
|
1388 |
function local__createLocal (input, format, locale, strict) { |
|
1389 |
return createLocalOrUTC(input, format, locale, strict, false); |
|
1390 |
} |
|
1391 |
|
|
1392 |
var prototypeMin = deprecate( |
|
1393 |
'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548', |
|
1394 |
function () { |
|
1395 |
var other = local__createLocal.apply(null, arguments); |
|
1396 |
return other < this ? this : other; |
|
1397 |
} |
|
1398 |
); |
|
1399 |
|
|
1400 |
var prototypeMax = deprecate( |
|
1401 |
'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548', |
|
1402 |
function () { |
|
1403 |
var other = local__createLocal.apply(null, arguments); |
|
1404 |
return other > this ? this : other; |
|
1405 |
} |
|
1406 |
); |
|
1407 |
|
|
1408 |
// Pick a moment m from moments so that m[fn](other) is true for all |
|
1409 |
// other. This relies on the function fn to be transitive. |
|
1410 |
// |
|
1411 |
// moments should either be an array of moment objects or an array, whose |
|
1412 |
// first element is an array of moment objects. |
|
1413 |
function pickBy(fn, moments) { |
|
1414 |
var res, i; |
|
1415 |
if (moments.length === 1 && isArray(moments[0])) { |
|
1416 |
moments = moments[0]; |
|
1417 |
} |
|
1418 |
if (!moments.length) { |
|
1419 |
return local__createLocal(); |
|
1420 |
} |
|
1421 |
res = moments[0]; |
|
1422 |
for (i = 1; i < moments.length; ++i) { |
|
1423 |
if (!moments[i].isValid() || moments[i][fn](res)) { |
|
1424 |
res = moments[i]; |
|
1425 |
} |
|
1426 |
} |
|
1427 |
return res; |
|
1428 |
} |
|
1429 |
|
|
1430 |
// TODO: Use [].sort instead? |
|
1431 |
function min () { |
|
1432 |
var args = [].slice.call(arguments, 0); |
|
1433 |
|
|
1434 |
return pickBy('isBefore', args); |
|
1435 |
} |
|
1436 |
|
|
1437 |
function max () { |
|
1438 |
var args = [].slice.call(arguments, 0); |
|
1439 |
|
|
1440 |
return pickBy('isAfter', args); |
|
1441 |
} |
|
1442 |
|
|
1443 |
function Duration (duration) { |
|
1444 |
var normalizedInput = normalizeObjectUnits(duration), |
|
1445 |
years = normalizedInput.year || 0, |
|
1446 |
quarters = normalizedInput.quarter || 0, |
|
1447 |
months = normalizedInput.month || 0, |
|
1448 |
weeks = normalizedInput.week || 0, |
|
1449 |
days = normalizedInput.day || 0, |
|
1450 |
hours = normalizedInput.hour || 0, |
|
1451 |
minutes = normalizedInput.minute || 0, |
|
1452 |
seconds = normalizedInput.second || 0, |
|
1453 |
milliseconds = normalizedInput.millisecond || 0; |
|
1454 |
|
|
1455 |
// representation for dateAddRemove |
|
1456 |
this._milliseconds = +milliseconds + |
|
1457 |
seconds * 1e3 + // 1000 |
|
1458 |
minutes * 6e4 + // 1000 * 60 |
|
1459 |
hours * 36e5; // 1000 * 60 * 60 |
|
1460 |
// Because of dateAddRemove treats 24 hours as different from a |
|
1461 |
// day when working around DST, we need to store them separately |
|
1462 |
this._days = +days + |
|
1463 |
weeks * 7; |
|
1464 |
// It is impossible translate months into days without knowing |
|
1465 |
// which months you are are talking about, so we have to store |
|
1466 |
// it separately. |
|
1467 |
this._months = +months + |
|
1468 |
quarters * 3 + |
|
1469 |
years * 12; |
|
1470 |
|
|
1471 |
this._data = {}; |
|
1472 |
|
|
1473 |
this._locale = locale_locales__getLocale(); |
|
1474 |
|
|
1475 |
this._bubble(); |
|
1476 |
} |
|
1477 |
|
|
1478 |
function isDuration (obj) { |
|
1479 |
return obj instanceof Duration; |
|
1480 |
} |
|
1481 |
|
|
1482 |
function offset (token, separator) { |
|
1483 |
addFormatToken(token, 0, 0, function () { |
|
1484 |
var offset = this.utcOffset(); |
|
1485 |
var sign = '+'; |
|
1486 |
if (offset < 0) { |
|
1487 |
offset = -offset; |
|
1488 |
sign = '-'; |
|
1489 |
} |
|
1490 |
return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2); |
|
1491 |
}); |
|
1492 |
} |
|
1493 |
|
|
1494 |
offset('Z', ':'); |
|
1495 |
offset('ZZ', ''); |
|
1496 |
|
|
1497 |
// PARSING |
|
1498 |
|
|
1499 |
addRegexToken('Z', matchOffset); |
|
1500 |
addRegexToken('ZZ', matchOffset); |
|
1501 |
addParseToken(['Z', 'ZZ'], function (input, array, config) { |
|
1502 |
config._useUTC = true; |
|
1503 |
config._tzm = offsetFromString(input); |
|
1504 |
}); |
|
1505 |
|
|
1506 |
// HELPERS |
|
1507 |
|
|
1508 |
// timezone chunker |
|
1509 |
// '+10:00' > ['10', '00'] |
|
1510 |
// '-1530' > ['-15', '30'] |
|
1511 |
var chunkOffset = /([\+\-]|\d\d)/gi; |
|
1512 |
|
|
1513 |
function offsetFromString(string) { |
|
1514 |
var matches = ((string || '').match(matchOffset) || []); |
|
1515 |
var chunk = matches[matches.length - 1] || []; |
|
1516 |
var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; |
|
1517 |
var minutes = +(parts[1] * 60) + toInt(parts[2]); |
|
1518 |
|
|
1519 |
return parts[0] === '+' ? minutes : -minutes; |
|
1520 |
} |
|
1521 |
|
|
1522 |
// Return a moment from input, that is local/utc/zone equivalent to model. |
|
1523 |
function cloneWithOffset(input, model) { |
|
1524 |
var res, diff; |
|
1525 |
if (model._isUTC) { |
|
1526 |
res = model.clone(); |
|
1527 |
diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res); |
|
1528 |
// Use low-level api, because this fn is low-level api. |
|
1529 |
res._d.setTime(+res._d + diff); |
|
1530 |
utils_hooks__hooks.updateOffset(res, false); |
|
1531 |
return res; |
|
1532 |
} else { |
|
1533 |
return local__createLocal(input).local(); |
|
1534 |
} |
|
1535 |
} |
|
1536 |
|
|
1537 |
function getDateOffset (m) { |
|
1538 |
// On Firefox.24 Date#getTimezoneOffset returns a floating point. |
|
1539 |
// https://github.com/moment/moment/pull/1871 |
|
1540 |
return -Math.round(m._d.getTimezoneOffset() / 15) * 15; |
|
1541 |
} |
|
1542 |
|
|
1543 |
// HOOKS |
|
1544 |
|
|
1545 |
// This function will be called whenever a moment is mutated. |
|
1546 |
// It is intended to keep the offset in sync with the timezone. |
|
1547 |
utils_hooks__hooks.updateOffset = function () {}; |
|
1548 |
|
|
1549 |
// MOMENTS |
|
1550 |
|
|
1551 |
// keepLocalTime = true means only change the timezone, without |
|
1552 |
// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> |
|
1553 |
// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset |
|
1554 |
// +0200, so we adjust the time as needed, to be valid. |
|
1555 |
// |
|
1556 |
// Keeping the time actually adds/subtracts (one hour) |
|
1557 |
// from the actual represented time. That is why we call updateOffset |
|
1558 |
// a second time. In case it wants us to change the offset again |
|
1559 |
// _changeInProgress == true case, then we have to adjust, because |
|
1560 |
// there is no such time in the given timezone. |
|
1561 |
function getSetOffset (input, keepLocalTime) { |
|
1562 |
var offset = this._offset || 0, |
|
1563 |
localAdjust; |
|
1564 |
if (input != null) { |
|
1565 |
if (typeof input === 'string') { |
|
1566 |
input = offsetFromString(input); |
|
1567 |
} |
|
1568 |
if (Math.abs(input) < 16) { |
|
1569 |
input = input * 60; |
|
1570 |
} |
|
1571 |
if (!this._isUTC && keepLocalTime) { |
|
1572 |
localAdjust = getDateOffset(this); |
|
1573 |
} |
|
1574 |
this._offset = input; |
|
1575 |
this._isUTC = true; |
|
1576 |
if (localAdjust != null) { |
|
1577 |
this.add(localAdjust, 'm'); |
|
1578 |
} |
|
1579 |
if (offset !== input) { |
|
1580 |
if (!keepLocalTime || this._changeInProgress) { |
|
1581 |
add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false); |
|
1582 |
} else if (!this._changeInProgress) { |
|
1583 |
this._changeInProgress = true; |
|
1584 |
utils_hooks__hooks.updateOffset(this, true); |
|
1585 |
this._changeInProgress = null; |
|
1586 |
} |
|
1587 |
} |
|
1588 |
return this; |
|
1589 |
} else { |
|
1590 |
return this._isUTC ? offset : getDateOffset(this); |
|
1591 |
} |
|
1592 |
} |
|
1593 |
|
|
1594 |
function getSetZone (input, keepLocalTime) { |
|
1595 |
if (input != null) { |
|
1596 |
if (typeof input !== 'string') { |
|
1597 |
input = -input; |
|
1598 |
} |
|
1599 |
|
|
1600 |
this.utcOffset(input, keepLocalTime); |
|
1601 |
|
|
1602 |
return this; |
|
1603 |
} else { |
|
1604 |
return -this.utcOffset(); |
|
1605 |
} |
|
1606 |
} |
|
1607 |
|
|
1608 |
function setOffsetToUTC (keepLocalTime) { |
|
1609 |
return this.utcOffset(0, keepLocalTime); |
|
1610 |
} |
|
1611 |
|
|
1612 |
function setOffsetToLocal (keepLocalTime) { |
|
1613 |
if (this._isUTC) { |
|
1614 |
this.utcOffset(0, keepLocalTime); |
|
1615 |
this._isUTC = false; |
|
1616 |
|
|
1617 |
if (keepLocalTime) { |
|
1618 |
this.subtract(getDateOffset(this), 'm'); |
|
1619 |
} |
|
1620 |
} |
|
1621 |
return this; |
|
1622 |
} |
|
1623 |
|
|
1624 |
function setOffsetToParsedOffset () { |
|
1625 |
if (this._tzm) { |
|
1626 |
this.utcOffset(this._tzm); |
|
1627 |
} else if (typeof this._i === 'string') { |
|
1628 |
this.utcOffset(offsetFromString(this._i)); |
|
1629 |
} |
|
1630 |
return this; |
|
1631 |
} |
|
1632 |
|
|
1633 |
function hasAlignedHourOffset (input) { |
|
1634 |
input = input ? local__createLocal(input).utcOffset() : 0; |
|
1635 |
|
|
1636 |
return (this.utcOffset() - input) % 60 === 0; |
|
1637 |
} |
|
1638 |
|
|
1639 |
function isDaylightSavingTime () { |
|
1640 |
return ( |
|
1641 |
this.utcOffset() > this.clone().month(0).utcOffset() || |
|
1642 |
this.utcOffset() > this.clone().month(5).utcOffset() |
|
1643 |
); |
|
1644 |
} |
|
1645 |
|
|
1646 |
function isDaylightSavingTimeShifted () { |
|
1647 |
if (typeof this._isDSTShifted !== 'undefined') { |
|
1648 |
return this._isDSTShifted; |
|
1649 |
} |
|
1650 |
|
|
1651 |
var c = {}; |
|
1652 |
|
|
1653 |
copyConfig(c, this); |
|
1654 |
c = prepareConfig(c); |
|
1655 |
|
|
1656 |
if (c._a) { |
|
1657 |
var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a); |
|
1658 |
this._isDSTShifted = this.isValid() && |
|
1659 |
compareArrays(c._a, other.toArray()) > 0; |
|
1660 |
} else { |
|
1661 |
this._isDSTShifted = false; |
|
1662 |
} |
|
1663 |
|
|
1664 |
return this._isDSTShifted; |
|
1665 |
} |
|
1666 |
|
|
1667 |
function isLocal () { |
|
1668 |
return !this._isUTC; |
|
1669 |
} |
|
1670 |
|
|
1671 |
function isUtcOffset () { |
|
1672 |
return this._isUTC; |
|
1673 |
} |
|
1674 |
|
|
1675 |
function isUtc () { |
|
1676 |
return this._isUTC && this._offset === 0; |
|
1677 |
} |
|
1678 |
|
|
1679 |
var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/; |
|
1680 |
|
|
1681 |
// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html |
|
1682 |
// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere |
|
1683 |
var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/; |
|
1684 |
|
|
1685 |
function create__createDuration (input, key) { |
|
1686 |
var duration = input, |
|
1687 |
// matching against regexp is expensive, do it on demand |
|
1688 |
match = null, |
|
1689 |
sign, |
|
1690 |
ret, |
|
1691 |
diffRes; |
|
1692 |
|
|
1693 |
if (isDuration(input)) { |
|
1694 |
duration = { |
|
1695 |
ms : input._milliseconds, |
|
1696 |
d : input._days, |
|
1697 |
M : input._months |
|
1698 |
}; |
|
1699 |
} else if (typeof input === 'number') { |
|
1700 |
duration = {}; |
|
1701 |
if (key) { |
|
1702 |
duration[key] = input; |
|
1703 |
} else { |
|
1704 |
duration.milliseconds = input; |
|
1705 |
} |
|
1706 |
} else if (!!(match = aspNetRegex.exec(input))) { |
|
1707 |
sign = (match[1] === '-') ? -1 : 1; |
|
1708 |
duration = { |
|
1709 |
y : 0, |
|
1710 |
d : toInt(match[DATE]) * sign, |
|
1711 |
h : toInt(match[HOUR]) * sign, |
|
1712 |
m : toInt(match[MINUTE]) * sign, |
|
1713 |
s : toInt(match[SECOND]) * sign, |
|
1714 |
ms : toInt(match[MILLISECOND]) * sign |
|
1715 |
}; |
|
1716 |
} else if (!!(match = create__isoRegex.exec(input))) { |
|
1717 |
sign = (match[1] === '-') ? -1 : 1; |
|
1718 |
duration = { |
|
1719 |
y : parseIso(match[2], sign), |
|
1720 |
M : parseIso(match[3], sign), |
|
1721 |
d : parseIso(match[4], sign), |
|
1722 |
h : parseIso(match[5], sign), |
|
1723 |
m : parseIso(match[6], sign), |
|
1724 |
s : parseIso(match[7], sign), |
|
1725 |
w : parseIso(match[8], sign) |
|
1726 |
}; |
|
1727 |
} else if (duration == null) {// checks for null or undefined |
|
1728 |
duration = {}; |
|
1729 |
} else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) { |
|
1730 |
diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to)); |
|
1731 |
|
|
1732 |
duration = {}; |
|
1733 |
duration.ms = diffRes.milliseconds; |
|
1734 |
duration.M = diffRes.months; |
|
1735 |
} |
|
1736 |
|
|
1737 |
ret = new Duration(duration); |
|
1738 |
|
|
1739 |
if (isDuration(input) && hasOwnProp(input, '_locale')) { |
|
1740 |
ret._locale = input._locale; |
|
1741 |
} |
|
1742 |
|
|
1743 |
return ret; |
|
1744 |
} |
|
1745 |
|
|
1746 |
create__createDuration.fn = Duration.prototype; |
|
1747 |
|
|
1748 |
function parseIso (inp, sign) { |
|
1749 |
// We'd normally use ~~inp for this, but unfortunately it also |
|
1750 |
// converts floats to ints. |
|
1751 |
// inp may be undefined, so careful calling replace on it. |
|
1752 |
var res = inp && parseFloat(inp.replace(',', '.')); |
|
1753 |
// apply sign while we're at it |
|
1754 |
return (isNaN(res) ? 0 : res) * sign; |
|
1755 |
} |
|
1756 |
|
|
1757 |
function positiveMomentsDifference(base, other) { |
|
1758 |
var res = {milliseconds: 0, months: 0}; |
|
1759 |
|
|
1760 |
res.months = other.month() - base.month() + |
|
1761 |
(other.year() - base.year()) * 12; |
|
1762 |
if (base.clone().add(res.months, 'M').isAfter(other)) { |
|
1763 |
--res.months; |
|
1764 |
} |
|
1765 |
|
|
1766 |
res.milliseconds = +other - +(base.clone().add(res.months, 'M')); |
|
1767 |
|
|
1768 |
return res; |
|
1769 |
} |
|
1770 |
|
|
1771 |
function momentsDifference(base, other) { |
|
1772 |
var res; |
|
1773 |
other = cloneWithOffset(other, base); |
|
1774 |
if (base.isBefore(other)) { |
|
1775 |
res = positiveMomentsDifference(base, other); |
|
1776 |
} else { |
|
1777 |
res = positiveMomentsDifference(other, base); |
|
1778 |
res.milliseconds = -res.milliseconds; |
|
1779 |
res.months = -res.months; |
|
1780 |
} |
|
1781 |
|
|
1782 |
return res; |
|
1783 |
} |
|
1784 |
|
|
1785 |
function createAdder(direction, name) { |
|
1786 |
return function (val, period) { |
|
1787 |
var dur, tmp; |
|
1788 |
//invert the arguments, but complain about it |
|
1789 |
if (period !== null && !isNaN(+period)) { |
|
1790 |
deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).'); |
|
1791 |
tmp = val; val = period; period = tmp; |
|
1792 |
} |
|
1793 |
|
|
1794 |
val = typeof val === 'string' ? +val : val; |
|
1795 |
dur = create__createDuration(val, period); |
|
1796 |
add_subtract__addSubtract(this, dur, direction); |
|
1797 |
return this; |
|
1798 |
}; |
|
1799 |
} |
|
1800 |
|
|
1801 |
function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) { |
|
1802 |
var milliseconds = duration._milliseconds, |
|
1803 |
days = duration._days, |
|
1804 |
months = duration._months; |
|
1805 |
updateOffset = updateOffset == null ? true : updateOffset; |
|
1806 |
|
|
1807 |
if (milliseconds) { |
|
1808 |
mom._d.setTime(+mom._d + milliseconds * isAdding); |
|
1809 |
} |
|
1810 |
if (days) { |
|
1811 |
get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding); |
|
1812 |
} |
|
1813 |
if (months) { |
|
1814 |
setMonth(mom, get_set__get(mom, 'Month') + months * isAdding); |
|
1815 |
} |
|
1816 |
if (updateOffset) { |
|
1817 |
utils_hooks__hooks.updateOffset(mom, days || months); |
|
1818 |
} |
|
1819 |
} |
|
1820 |
|
|
1821 |
var add_subtract__add = createAdder(1, 'add'); |
|
1822 |
var add_subtract__subtract = createAdder(-1, 'subtract'); |
|
1823 |
|
|
1824 |
function moment_calendar__calendar (time, formats) { |
|
1825 |
// We want to compare the start of today, vs this. |
|
1826 |
// Getting start-of-today depends on whether we're local/utc/offset or not. |
|
1827 |
var now = time || local__createLocal(), |
|
1828 |
sod = cloneWithOffset(now, this).startOf('day'), |
|
1829 |
diff = this.diff(sod, 'days', true), |
|
1830 |
format = diff < -6 ? 'sameElse' : |
|
1831 |
diff < -1 ? 'lastWeek' : |
|
1832 |
diff < 0 ? 'lastDay' : |
|
1833 |
diff < 1 ? 'sameDay' : |
|
1834 |
diff < 2 ? 'nextDay' : |
|
1835 |
diff < 7 ? 'nextWeek' : 'sameElse'; |
|
1836 |
return this.format(formats && formats[format] || this.localeData().calendar(format, this, local__createLocal(now))); |
|
1837 |
} |
|
1838 |
|
|
1839 |
function clone () { |
|
1840 |
return new Moment(this); |
|
1841 |
} |
|
1842 |
|
|
1843 |
function isAfter (input, units) { |
|
1844 |
var inputMs; |
|
1845 |
units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond'); |
|
1846 |
if (units === 'millisecond') { |
|
1847 |
input = isMoment(input) ? input : local__createLocal(input); |
|
1848 |
return +this > +input; |
|
1849 |
} else { |
|
1850 |
inputMs = isMoment(input) ? +input : +local__createLocal(input); |
|
1851 |
return inputMs < +this.clone().startOf(units); |
|
1852 |
} |
|
1853 |
} |
|
1854 |
|
|
1855 |
function isBefore (input, units) { |
|
1856 |
var inputMs; |
|
1857 |
units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond'); |
|
1858 |
if (units === 'millisecond') { |
|
1859 |
input = isMoment(input) ? input : local__createLocal(input); |
|
1860 |
return +this < +input; |
|
1861 |
} else { |
|
1862 |
inputMs = isMoment(input) ? +input : +local__createLocal(input); |
|
1863 |
return +this.clone().endOf(units) < inputMs; |
|
1864 |
} |
|
1865 |
} |
|
1866 |
|
|
1867 |
function isBetween (from, to, units) { |
|
1868 |
return this.isAfter(from, units) && this.isBefore(to, units); |
|
1869 |
} |
|
1870 |
|
|
1871 |
function isSame (input, units) { |
|
1872 |
var inputMs; |
|
1873 |
units = normalizeUnits(units || 'millisecond'); |
|
1874 |
if (units === 'millisecond') { |
|
1875 |
input = isMoment(input) ? input : local__createLocal(input); |
|
1876 |
return +this === +input; |
|
1877 |
} else { |
|
1878 |
inputMs = +local__createLocal(input); |
|
1879 |
return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units)); |
|
1880 |
} |
|
1881 |
} |
|
1882 |
|
|
1883 |
function diff (input, units, asFloat) { |
|
1884 |
var that = cloneWithOffset(input, this), |
|
1885 |
zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4, |
|
1886 |
delta, output; |
|
1887 |
|
|
1888 |
units = normalizeUnits(units); |
|
1889 |
|
|
1890 |
if (units === 'year' || units === 'month' || units === 'quarter') { |
|
1891 |
output = monthDiff(this, that); |
|
1892 |
if (units === 'quarter') { |
|
1893 |
output = output / 3; |
|
1894 |
} else if (units === 'year') { |
|
1895 |
output = output / 12; |
|
1896 |
} |
|
1897 |
} else { |
|
1898 |
delta = this - that; |
|
1899 |
output = units === 'second' ? delta / 1e3 : // 1000 |
|
1900 |
units === 'minute' ? delta / 6e4 : // 1000 * 60 |
|
1901 |
units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60 |
|
1902 |
units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst |
|
1903 |
units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst |
|
1904 |
delta; |
|
1905 |
} |
|
1906 |
return asFloat ? output : absFloor(output); |
|
1907 |
} |
|
1908 |
|
|
1909 |
function monthDiff (a, b) { |
|
1910 |
// difference in months |
|
1911 |
var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()), |
|
1912 |
// b is in (anchor - 1 month, anchor + 1 month) |
|
1913 |
anchor = a.clone().add(wholeMonthDiff, 'months'), |
|
1914 |
anchor2, adjust; |
|
1915 |
|
|
1916 |
if (b - anchor < 0) { |
|
1917 |
anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); |
|
1918 |
// linear across the month |
|
1919 |
adjust = (b - anchor) / (anchor - anchor2); |
|
1920 |
} else { |
|
1921 |
anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); |
|
1922 |
// linear across the month |
|
1923 |
adjust = (b - anchor) / (anchor2 - anchor); |
|
1924 |
} |
|
1925 |
|
|
1926 |
return -(wholeMonthDiff + adjust); |
|
1927 |
} |
|
1928 |
|
|
1929 |
utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; |
|
1930 |
|
|
1931 |
function toString () { |
|
1932 |
return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); |
|
1933 |
} |
|
1934 |
|
|
1935 |
function moment_format__toISOString () { |
|
1936 |
var m = this.clone().utc(); |
|
1937 |
if (0 < m.year() && m.year() <= 9999) { |
|
1938 |
if ('function' === typeof Date.prototype.toISOString) { |
|
1939 |
// native implementation is ~50x faster, use it when we can |
|
1940 |
return this.toDate().toISOString(); |
|
1941 |
} else { |
|
1942 |
return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); |
|
1943 |
} |
|
1944 |
} else { |
|
1945 |
return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); |
|
1946 |
} |
|
1947 |
} |
|
1948 |
|
|
1949 |
function format (inputString) { |
|
1950 |
var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat); |
|
1951 |
return this.localeData().postformat(output); |
|
1952 |
} |
|
1953 |
|
|
1954 |
function from (time, withoutSuffix) { |
|
1955 |
if (!this.isValid()) { |
|
1956 |
return this.localeData().invalidDate(); |
|
1957 |
} |
|
1958 |
return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix); |
|
1959 |
} |
|
1960 |
|
|
1961 |
function fromNow (withoutSuffix) { |
|
1962 |
return this.from(local__createLocal(), withoutSuffix); |
|
1963 |
} |
|
1964 |
|
|
1965 |
function to (time, withoutSuffix) { |
|
1966 |
if (!this.isValid()) { |
|
1967 |
return this.localeData().invalidDate(); |
|
1968 |
} |
|
1969 |
return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix); |
|
1970 |
} |
|
1971 |
|
|
1972 |
function toNow (withoutSuffix) { |
|
1973 |
return this.to(local__createLocal(), withoutSuffix); |
|
1974 |
} |
|
1975 |
|
|
1976 |
function locale (key) { |
|
1977 |
var newLocaleData; |
|
1978 |
|
|
1979 |
if (key === undefined) { |
|
1980 |
return this._locale._abbr; |
|
1981 |
} else { |
|
1982 |
newLocaleData = locale_locales__getLocale(key); |
|
1983 |
if (newLocaleData != null) { |
|
1984 |
this._locale = newLocaleData; |
|
1985 |
} |
|
1986 |
return this; |
|
1987 |
} |
|
1988 |
} |
|
1989 |
|
|
1990 |
var lang = deprecate( |
|
1991 |
'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', |
|
1992 |
function (key) { |
|
1993 |
if (key === undefined) { |
|
1994 |
return this.localeData(); |
|
1995 |
} else { |
|
1996 |
return this.locale(key); |
|
1997 |
} |
|
1998 |
} |
|
1999 |
); |
|
2000 |
|
|
2001 |
function localeData () { |
|
2002 |
return this._locale; |
|
2003 |
} |
|
2004 |
|
|
2005 |
function startOf (units) { |
|
2006 |
units = normalizeUnits(units); |
|
2007 |
// the following switch intentionally omits break keywords |
|
2008 |
// to utilize falling through the cases. |
|
2009 |
switch (units) { |
|
2010 |
case 'year': |
|
2011 |
this.month(0); |
|
2012 |
/* falls through */ |
|
2013 |
case 'quarter': |
|
2014 |
case 'month': |
|
2015 |
this.date(1); |
|
2016 |
/* falls through */ |
|
2017 |
case 'week': |
|
2018 |
case 'isoWeek': |
|
2019 |
case 'day': |
|
2020 |
this.hours(0); |
|
2021 |
/* falls through */ |
|
2022 |
case 'hour': |
|
2023 |
this.minutes(0); |
|
2024 |
/* falls through */ |
|
2025 |
case 'minute': |
|
2026 |
this.seconds(0); |
|
2027 |
/* falls through */ |
|
2028 |
case 'second': |
|
2029 |
this.milliseconds(0); |
|
2030 |
} |
|
2031 |
|
|
2032 |
// weeks are a special case |
|
2033 |
if (units === 'week') { |
|
2034 |
this.weekday(0); |
|
2035 |
} |
|
2036 |
if (units === 'isoWeek') { |
|
2037 |
this.isoWeekday(1); |
|
2038 |
} |
|
2039 |
|
|
2040 |
// quarters are also special |
|
2041 |
if (units === 'quarter') { |
|
2042 |
this.month(Math.floor(this.month() / 3) * 3); |
|
2043 |
} |
|
2044 |
|
|
2045 |
return this; |
|
2046 |
} |
|
2047 |
|
|
2048 |
function endOf (units) { |
|
2049 |
units = normalizeUnits(units); |
|
2050 |
if (units === undefined || units === 'millisecond') { |
|
2051 |
return this; |
|
2052 |
} |
|
2053 |
return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms'); |
|
2054 |
} |
|
2055 |
|
|
2056 |
function to_type__valueOf () { |
|
2057 |
return +this._d - ((this._offset || 0) * 60000); |
|
2058 |
} |
|
2059 |
|
|
2060 |
function unix () { |
|
2061 |
return Math.floor(+this / 1000); |
|
2062 |
} |
|
2063 |
|
|
2064 |
function toDate () { |
|
2065 |
return this._offset ? new Date(+this) : this._d; |
|
2066 |
} |
|
2067 |
|
|
2068 |
function toArray () { |
|
2069 |
var m = this; |
|
2070 |
return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()]; |
|
2071 |
} |
|
2072 |
|
|
2073 |
function toObject () { |
|
2074 |
var m = this; |
|
2075 |
return { |
|
2076 |
years: m.year(), |
|
2077 |
months: m.month(), |
|
2078 |
date: m.date(), |
|
2079 |
hours: m.hours(), |
|
2080 |
minutes: m.minutes(), |
|
2081 |
seconds: m.seconds(), |
|
2082 |
milliseconds: m.milliseconds() |
|
2083 |
}; |
|
2084 |
} |
|
2085 |
|
|
2086 |
function moment_valid__isValid () { |
|
2087 |
return valid__isValid(this); |
|
2088 |
} |
|
2089 |
|
|
2090 |
function parsingFlags () { |
|
2091 |
return extend({}, getParsingFlags(this)); |
|
2092 |
} |
|
2093 |
|
|
2094 |
function invalidAt () { |
|
2095 |
return getParsingFlags(this).overflow; |
|
2096 |
} |
|
2097 |
|
|
2098 |
addFormatToken(0, ['gg', 2], 0, function () { |
|
2099 |
return this.weekYear() % 100; |
|
2100 |
}); |
|
2101 |
|
|
2102 |
addFormatToken(0, ['GG', 2], 0, function () { |
|
2103 |
return this.isoWeekYear() % 100; |
|
2104 |
}); |
|
2105 |
|
|
2106 |
function addWeekYearFormatToken (token, getter) { |
|
2107 |
addFormatToken(0, [token, token.length], 0, getter); |
|
2108 |
} |
|
2109 |
|
|
2110 |
addWeekYearFormatToken('gggg', 'weekYear'); |
|
2111 |
addWeekYearFormatToken('ggggg', 'weekYear'); |
|
2112 |
addWeekYearFormatToken('GGGG', 'isoWeekYear'); |
|
2113 |
addWeekYearFormatToken('GGGGG', 'isoWeekYear'); |
|
2114 |
|
|
2115 |
// ALIASES |
|
2116 |
|
|
2117 |
addUnitAlias('weekYear', 'gg'); |
|
2118 |
addUnitAlias('isoWeekYear', 'GG'); |
|
2119 |
|
|
2120 |
// PARSING |
|
2121 |
|
|
2122 |
addRegexToken('G', matchSigned); |
|
2123 |
addRegexToken('g', matchSigned); |
|
2124 |
addRegexToken('GG', match1to2, match2); |
|
2125 |
addRegexToken('gg', match1to2, match2); |
|
2126 |
addRegexToken('GGGG', match1to4, match4); |
|
2127 |
addRegexToken('gggg', match1to4, match4); |
|
2128 |
addRegexToken('GGGGG', match1to6, match6); |
|
2129 |
addRegexToken('ggggg', match1to6, match6); |
|
2130 |
|
|
2131 |
addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) { |
|
2132 |
week[token.substr(0, 2)] = toInt(input); |
|
2133 |
}); |
|
2134 |
|
|
2135 |
addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { |
|
2136 |
week[token] = utils_hooks__hooks.parseTwoDigitYear(input); |
|
2137 |
}); |
|
2138 |
|
|
2139 |
// HELPERS |
|
2140 |
|
|
2141 |
function weeksInYear(year, dow, doy) { |
|
2142 |
return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week; |
|
2143 |
} |
|
2144 |
|
|
2145 |
// MOMENTS |
|
2146 |
|
|
2147 |
function getSetWeekYear (input) { |
|
2148 |
var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year; |
|
2149 |
return input == null ? year : this.add((input - year), 'y'); |
|
2150 |
} |
|
2151 |
|
|
2152 |
function getSetISOWeekYear (input) { |
|
2153 |
var year = weekOfYear(this, 1, 4).year; |
|
2154 |
return input == null ? year : this.add((input - year), 'y'); |
|
2155 |
} |
|
2156 |
|
|
2157 |
function getISOWeeksInYear () { |
|
2158 |
return weeksInYear(this.year(), 1, 4); |
|
2159 |
} |
|
2160 |
|
|
2161 |
function getWeeksInYear () { |
|
2162 |
var weekInfo = this.localeData()._week; |
|
2163 |
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); |
|
2164 |
} |
|
2165 |
|
|
2166 |
addFormatToken('Q', 0, 0, 'quarter'); |
|
2167 |
|
|
2168 |
// ALIASES |
|
2169 |
|
|
2170 |
addUnitAlias('quarter', 'Q'); |
|
2171 |
|
|
2172 |
// PARSING |
|
2173 |
|
|
2174 |
addRegexToken('Q', match1); |
|
2175 |
addParseToken('Q', function (input, array) { |
|
2176 |
array[MONTH] = (toInt(input) - 1) * 3; |
|
2177 |
}); |
|
2178 |
|
|
2179 |
// MOMENTS |
|
2180 |
|
|
2181 |
function getSetQuarter (input) { |
|
2182 |
return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); |
|
2183 |
} |
|
2184 |
|
|
2185 |
addFormatToken('D', ['DD', 2], 'Do', 'date'); |
|
2186 |
|
|
2187 |
// ALIASES |
|
2188 |
|
|
2189 |
addUnitAlias('date', 'D'); |
|
2190 |
|
|
2191 |
// PARSING |
|
2192 |
|
|
2193 |
addRegexToken('D', match1to2); |
|
2194 |
addRegexToken('DD', match1to2, match2); |
|
2195 |
addRegexToken('Do', function (isStrict, locale) { |
|
2196 |
return isStrict ? locale._ordinalParse : locale._ordinalParseLenient; |
|
2197 |
}); |
|
2198 |
|
|
2199 |
addParseToken(['D', 'DD'], DATE); |
|
2200 |
addParseToken('Do', function (input, array) { |
|
2201 |
array[DATE] = toInt(input.match(match1to2)[0], 10); |
|
2202 |
}); |
|
2203 |
|
|
2204 |
// MOMENTS |
|
2205 |
|
|
2206 |
var getSetDayOfMonth = makeGetSet('Date', true); |
|
2207 |
|
|
2208 |
addFormatToken('d', 0, 'do', 'day'); |
|
2209 |
|
|
2210 |
addFormatToken('dd', 0, 0, function (format) { |
|
2211 |
return this.localeData().weekdaysMin(this, format); |
|
2212 |
}); |
|
2213 |
|
|
2214 |
addFormatToken('ddd', 0, 0, function (format) { |
|
2215 |
return this.localeData().weekdaysShort(this, format); |
|
2216 |
}); |
|
2217 |
|
|
2218 |
addFormatToken('dddd', 0, 0, function (format) { |
|
2219 |
return this.localeData().weekdays(this, format); |
|
2220 |
}); |
|
2221 |
|
|
2222 |
addFormatToken('e', 0, 0, 'weekday'); |
|
2223 |
addFormatToken('E', 0, 0, 'isoWeekday'); |
|
2224 |
|
|
2225 |
// ALIASES |
|
2226 |
|
|
2227 |
addUnitAlias('day', 'd'); |
|
2228 |
addUnitAlias('weekday', 'e'); |
|
2229 |
addUnitAlias('isoWeekday', 'E'); |
|
2230 |
|
|
2231 |
// PARSING |
|
2232 |
|
|
2233 |
addRegexToken('d', match1to2); |
|
2234 |
addRegexToken('e', match1to2); |
|
2235 |
addRegexToken('E', match1to2); |
|
2236 |
addRegexToken('dd', matchWord); |
|
2237 |
addRegexToken('ddd', matchWord); |
|
2238 |
addRegexToken('dddd', matchWord); |
|
2239 |
|
|
2240 |
addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) { |
|
2241 |
var weekday = config._locale.weekdaysParse(input); |
|
2242 |
// if we didn't get a weekday name, mark the date as invalid |
|
2243 |
if (weekday != null) { |
|
2244 |
week.d = weekday; |
|
2245 |
} else { |
|
2246 |
getParsingFlags(config).invalidWeekday = input; |
|
2247 |
} |
|
2248 |
}); |
|
2249 |
|
|
2250 |
addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { |
|
2251 |
week[token] = toInt(input); |
|
2252 |
}); |
|
2253 |
|
|
2254 |
// HELPERS |
|
2255 |
|
|
2256 |
function parseWeekday(input, locale) { |
|
2257 |
if (typeof input !== 'string') { |
|
2258 |
return input; |
|
2259 |
} |
|
2260 |
|
|
2261 |
if (!isNaN(input)) { |
|
2262 |
return parseInt(input, 10); |
|
2263 |
} |
|
2264 |
|
|
2265 |
input = locale.weekdaysParse(input); |
|
2266 |
if (typeof input === 'number') { |
|
2267 |
return input; |
|
2268 |
} |
|
2269 |
|
|
2270 |
return null; |
|
2271 |
} |
|
2272 |
|
|
2273 |
// LOCALES |
|
2274 |
|
|
2275 |
var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); |
|
2276 |
function localeWeekdays (m) { |
|
2277 |
return this._weekdays[m.day()]; |
|
2278 |
} |
|
2279 |
|
|
2280 |
var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); |
|
2281 |
function localeWeekdaysShort (m) { |
|
2282 |
return this._weekdaysShort[m.day()]; |
|
2283 |
} |
|
2284 |
|
|
2285 |
var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); |
|
2286 |
function localeWeekdaysMin (m) { |
|
2287 |
return this._weekdaysMin[m.day()]; |
|
2288 |
} |
|
2289 |
|
|
2290 |
function localeWeekdaysParse (weekdayName) { |
|
2291 |
var i, mom, regex; |
|
2292 |
|
|
2293 |
this._weekdaysParse = this._weekdaysParse || []; |
|
2294 |
|
|
2295 |
for (i = 0; i < 7; i++) { |
|
2296 |
// make the regex if we don't have it already |
|
2297 |
if (!this._weekdaysParse[i]) { |
|
2298 |
mom = local__createLocal([2000, 1]).day(i); |
|
2299 |
regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, ''); |
|
2300 |
this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); |
|
2301 |
} |
|
2302 |
// test the regex |
|
2303 |
if (this._weekdaysParse[i].test(weekdayName)) { |
|
2304 |
return i; |
|
2305 |
} |
|
2306 |
} |
|
2307 |
} |
|
2308 |
|
|
2309 |
// MOMENTS |
|
2310 |
|
|
2311 |
function getSetDayOfWeek (input) { |
|
2312 |
var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); |
|
2313 |
if (input != null) { |
|
2314 |
input = parseWeekday(input, this.localeData()); |
|
2315 |
return this.add(input - day, 'd'); |
|
2316 |
} else { |
|
2317 |
return day; |
|
2318 |
} |
|
2319 |
} |
|
2320 |
|
|
2321 |
function getSetLocaleDayOfWeek (input) { |
|
2322 |
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; |
|
2323 |
return input == null ? weekday : this.add(input - weekday, 'd'); |
|
2324 |
} |
|
2325 |
|
|
2326 |
function getSetISODayOfWeek (input) { |
|
2327 |
// behaves the same as moment#day except |
|
2328 |
// as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) |
|
2329 |
// as a setter, sunday should belong to the previous week. |
|
2330 |
return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7); |
|
2331 |
} |
|
2332 |
|
|
2333 |
addFormatToken('H', ['HH', 2], 0, 'hour'); |
|
2334 |
addFormatToken('h', ['hh', 2], 0, function () { |
|
2335 |
return this.hours() % 12 || 12; |
|
2336 |
}); |
|
2337 |
|
|
2338 |
function meridiem (token, lowercase) { |
|
2339 |
addFormatToken(token, 0, 0, function () { |
|
2340 |
return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); |
|
2341 |
}); |
|
2342 |
} |
|
2343 |
|
|
2344 |
meridiem('a', true); |
|
2345 |
meridiem('A', false); |
|
2346 |
|
|
2347 |
// ALIASES |
|
2348 |
|
|
2349 |
addUnitAlias('hour', 'h'); |
|
2350 |
|
|
2351 |
// PARSING |
|
2352 |
|
|
2353 |
function matchMeridiem (isStrict, locale) { |
|
2354 |
return locale._meridiemParse; |
|
2355 |
} |
|
2356 |
|
|
2357 |
addRegexToken('a', matchMeridiem); |
|
2358 |
addRegexToken('A', matchMeridiem); |
|
2359 |
addRegexToken('H', match1to2); |
|
2360 |
addRegexToken('h', match1to2); |
|
2361 |
addRegexToken('HH', match1to2, match2); |
|
2362 |
addRegexToken('hh', match1to2, match2); |
|
2363 |
|
|
2364 |
addParseToken(['H', 'HH'], HOUR); |
|
2365 |
addParseToken(['a', 'A'], function (input, array, config) { |
|
2366 |
config._isPm = config._locale.isPM(input); |
|
2367 |
config._meridiem = input; |
|
2368 |
}); |
|
2369 |
addParseToken(['h', 'hh'], function (input, array, config) { |
|
2370 |
array[HOUR] = toInt(input); |
|
2371 |
getParsingFlags(config).bigHour = true; |
|
2372 |
}); |
|
2373 |
|
|
2374 |
// LOCALES |
|
2375 |
|
|
2376 |
function localeIsPM (input) { |
|
2377 |
// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays |
|
2378 |
// Using charAt should be more compatible. |
|
2379 |
return ((input + '').toLowerCase().charAt(0) === 'p'); |
|
2380 |
} |
|
2381 |
|
|
2382 |
var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i; |
|
2383 |
function localeMeridiem (hours, minutes, isLower) { |
|
2384 |
if (hours > 11) { |
|
2385 |
return isLower ? 'pm' : 'PM'; |
|
2386 |
} else { |
|
2387 |
return isLower ? 'am' : 'AM'; |
|
2388 |
} |
|
2389 |
} |
|
2390 |
|
|
2391 |
|
|
2392 |
// MOMENTS |
|
2393 |
|
|
2394 |
// Setting the hour should keep the time, because the user explicitly |
|
2395 |
// specified which hour he wants. So trying to maintain the same hour (in |
|
2396 |
// a new timezone) makes sense. Adding/subtracting hours does not follow |
|
2397 |
// this rule. |
|
2398 |
var getSetHour = makeGetSet('Hours', true); |
|
2399 |
|
|
2400 |
addFormatToken('m', ['mm', 2], 0, 'minute'); |
|
2401 |
|
|
2402 |
// ALIASES |
|
2403 |
|
|
2404 |
addUnitAlias('minute', 'm'); |
|
2405 |
|
|
2406 |
// PARSING |
|
2407 |
|
|
2408 |
addRegexToken('m', match1to2); |
|
2409 |
addRegexToken('mm', match1to2, match2); |
|
2410 |
addParseToken(['m', 'mm'], MINUTE); |
|
2411 |
|
|
2412 |
// MOMENTS |
|
2413 |
|
|
2414 |
var getSetMinute = makeGetSet('Minutes', false); |
|
2415 |
|
|
2416 |
addFormatToken('s', ['ss', 2], 0, 'second'); |
|
2417 |
|
|
2418 |
// ALIASES |
|
2419 |
|
|
2420 |
addUnitAlias('second', 's'); |
|
2421 |
|
|
2422 |
// PARSING |
|
2423 |
|
|
2424 |
addRegexToken('s', match1to2); |
|
2425 |
addRegexToken('ss', match1to2, match2); |
|
2426 |
addParseToken(['s', 'ss'], SECOND); |
|
2427 |
|
|
2428 |
// MOMENTS |
|
2429 |
|
|
2430 |
var getSetSecond = makeGetSet('Seconds', false); |
|
2431 |
|
|
2432 |
addFormatToken('S', 0, 0, function () { |
|
2433 |
return ~~(this.millisecond() / 100); |
|
2434 |
}); |
|
2435 |
|
|
2436 |
addFormatToken(0, ['SS', 2], 0, function () { |
|
2437 |
return ~~(this.millisecond() / 10); |
|
2438 |
}); |
|
2439 |
|
|
2440 |
addFormatToken(0, ['SSS', 3], 0, 'millisecond'); |
|
2441 |
addFormatToken(0, ['SSSS', 4], 0, function () { |
|
2442 |
return this.millisecond() * 10; |
|
2443 |
}); |
|
2444 |
addFormatToken(0, ['SSSSS', 5], 0, function () { |
|
2445 |
return this.millisecond() * 100; |
|
2446 |
}); |
|
2447 |
addFormatToken(0, ['SSSSSS', 6], 0, function () { |
|
2448 |
return this.millisecond() * 1000; |
|
2449 |
}); |
|
2450 |
addFormatToken(0, ['SSSSSSS', 7], 0, function () { |
|
2451 |
return this.millisecond() * 10000; |
|
2452 |
}); |
|
2453 |
addFormatToken(0, ['SSSSSSSS', 8], 0, function () { |
|
2454 |
return this.millisecond() * 100000; |
|
2455 |
}); |
|
2456 |
addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { |
|
2457 |
return this.millisecond() * 1000000; |
|
2458 |
}); |
|
2459 |
|
|
2460 |
|
|
2461 |
// ALIASES |
|
2462 |
|
|
2463 |
addUnitAlias('millisecond', 'ms'); |
|
2464 |
|
|
2465 |
// PARSING |
|
2466 |
|
|
2467 |
addRegexToken('S', match1to3, match1); |
|
2468 |
addRegexToken('SS', match1to3, match2); |
|
2469 |
addRegexToken('SSS', match1to3, match3); |
|
2470 |
|
|
2471 |
var token; |
|
2472 |
for (token = 'SSSS'; token.length <= 9; token += 'S') { |
|
2473 |
addRegexToken(token, matchUnsigned); |
|
2474 |
} |
|
2475 |
|
|
2476 |
function parseMs(input, array) { |
|
2477 |
array[MILLISECOND] = toInt(('0.' + input) * 1000); |
|
2478 |
} |
|
2479 |
|
|
2480 |
for (token = 'S'; token.length <= 9; token += 'S') { |
|
2481 |
addParseToken(token, parseMs); |
|
2482 |
} |
|
2483 |
// MOMENTS |
|
2484 |
|
|
2485 |
var getSetMillisecond = makeGetSet('Milliseconds', false); |
|
2486 |
|
|
2487 |
addFormatToken('z', 0, 0, 'zoneAbbr'); |
|
2488 |
addFormatToken('zz', 0, 0, 'zoneName'); |
|
2489 |
|
|
2490 |
// MOMENTS |
|
2491 |
|
|
2492 |
function getZoneAbbr () { |
|
2493 |
return this._isUTC ? 'UTC' : ''; |
|
2494 |
} |
|
2495 |
|
|
2496 |
function getZoneName () { |
|
2497 |
return this._isUTC ? 'Coordinated Universal Time' : ''; |
|
2498 |
} |
|
2499 |
|
|
2500 |
var momentPrototype__proto = Moment.prototype; |
|
2501 |
|
|
2502 |
momentPrototype__proto.add = add_subtract__add; |
|
2503 |
momentPrototype__proto.calendar = moment_calendar__calendar; |
|
2504 |
momentPrototype__proto.clone = clone; |
|
2505 |
momentPrototype__proto.diff = diff; |
|
2506 |
momentPrototype__proto.endOf = endOf; |
|
2507 |
momentPrototype__proto.format = format; |
|
2508 |
momentPrototype__proto.from = from; |
|
2509 |
momentPrototype__proto.fromNow = fromNow; |
|
2510 |
momentPrototype__proto.to = to; |
|
2511 |
momentPrototype__proto.toNow = toNow; |
|
2512 |
momentPrototype__proto.get = getSet; |
|
2513 |
momentPrototype__proto.invalidAt = invalidAt; |
|
2514 |
momentPrototype__proto.isAfter = isAfter; |
|
2515 |
momentPrototype__proto.isBefore = isBefore; |
|
2516 |
momentPrototype__proto.isBetween = isBetween; |
|
2517 |
momentPrototype__proto.isSame = isSame; |
|
2518 |
momentPrototype__proto.isValid = moment_valid__isValid; |
|
2519 |
momentPrototype__proto.lang = lang; |
|
2520 |
momentPrototype__proto.locale = locale; |
|
2521 |
momentPrototype__proto.localeData = localeData; |
|
2522 |
momentPrototype__proto.max = prototypeMax; |
|
2523 |
momentPrototype__proto.min = prototypeMin; |
|
2524 |
momentPrototype__proto.parsingFlags = parsingFlags; |
|
2525 |
momentPrototype__proto.set = getSet; |
|
2526 |
momentPrototype__proto.startOf = startOf; |
|
2527 |
momentPrototype__proto.subtract = add_subtract__subtract; |
|
2528 |
momentPrototype__proto.toArray = toArray; |
|
2529 |
momentPrototype__proto.toObject = toObject; |
|
2530 |
momentPrototype__proto.toDate = toDate; |
|
2531 |
momentPrototype__proto.toISOString = moment_format__toISOString; |
|
2532 |
momentPrototype__proto.toJSON = moment_format__toISOString; |
|
2533 |
momentPrototype__proto.toString = toString; |
|
2534 |
momentPrototype__proto.unix = unix; |
|
2535 |
momentPrototype__proto.valueOf = to_type__valueOf; |
|
2536 |
|
|
2537 |
// Year |
|
2538 |
momentPrototype__proto.year = getSetYear; |
|
2539 |
momentPrototype__proto.isLeapYear = getIsLeapYear; |
|
2540 |
|
|
2541 |
// Week Year |
|
2542 |
momentPrototype__proto.weekYear = getSetWeekYear; |
|
2543 |
momentPrototype__proto.isoWeekYear = getSetISOWeekYear; |
|
2544 |
|
|
2545 |
// Quarter |
|
2546 |
momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter; |
|
2547 |
|
|
2548 |
// Month |
|
2549 |
momentPrototype__proto.month = getSetMonth; |
|
2550 |
momentPrototype__proto.daysInMonth = getDaysInMonth; |
|
2551 |
|
|
2552 |
// Week |
|
2553 |
momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek; |
|
2554 |
momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek; |
|
2555 |
momentPrototype__proto.weeksInYear = getWeeksInYear; |
|
2556 |
momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear; |
|
2557 |
|
|
2558 |
// Day |
|
2559 |
momentPrototype__proto.date = getSetDayOfMonth; |
|
2560 |
momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek; |
|
2561 |
momentPrototype__proto.weekday = getSetLocaleDayOfWeek; |
|
2562 |
momentPrototype__proto.isoWeekday = getSetISODayOfWeek; |
|
2563 |
momentPrototype__proto.dayOfYear = getSetDayOfYear; |
|
2564 |
|
|
2565 |
// Hour |
|
2566 |
momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour; |
|
2567 |
|
|
2568 |
// Minute |
|
2569 |
momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute; |
|
2570 |
|
|
2571 |
// Second |
|
2572 |
momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond; |
|
2573 |
|
|
2574 |
// Millisecond |
|
2575 |
momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond; |
|
2576 |
|
|
2577 |
// Offset |
|
2578 |
momentPrototype__proto.utcOffset = getSetOffset; |
|
2579 |
momentPrototype__proto.utc = setOffsetToUTC; |
|
2580 |
momentPrototype__proto.local = setOffsetToLocal; |
|
2581 |
momentPrototype__proto.parseZone = setOffsetToParsedOffset; |
|
2582 |
momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset; |
|
2583 |
momentPrototype__proto.isDST = isDaylightSavingTime; |
|
2584 |
momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted; |
|
2585 |
momentPrototype__proto.isLocal = isLocal; |
|
2586 |
momentPrototype__proto.isUtcOffset = isUtcOffset; |
|
2587 |
momentPrototype__proto.isUtc = isUtc; |
|
2588 |
momentPrototype__proto.isUTC = isUtc; |
|
2589 |
|
|
2590 |
// Timezone |
|
2591 |
momentPrototype__proto.zoneAbbr = getZoneAbbr; |
|
2592 |
momentPrototype__proto.zoneName = getZoneName; |
|
2593 |
|
|
2594 |
// Deprecations |
|
2595 |
momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); |
|
2596 |
momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); |
|
2597 |
momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); |
|
2598 |
momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone); |
|
2599 |
|
|
2600 |
var momentPrototype = momentPrototype__proto; |
|
2601 |
|
|
2602 |
function moment__createUnix (input) { |
|
2603 |
return local__createLocal(input * 1000); |
|
2604 |
} |
|
2605 |
|
|
2606 |
function moment__createInZone () { |
|
2607 |
return local__createLocal.apply(null, arguments).parseZone(); |
|
2608 |
} |
|
2609 |
|
|
2610 |
var defaultCalendar = { |
|
2611 |
sameDay : '[Today at] LT', |
|
2612 |
nextDay : '[Tomorrow at] LT', |
|
2613 |
nextWeek : 'dddd [at] LT', |
|
2614 |
lastDay : '[Yesterday at] LT', |
|
2615 |
lastWeek : '[Last] dddd [at] LT', |
|
2616 |
sameElse : 'L' |
|
2617 |
}; |
|
2618 |
|
|
2619 |
function locale_calendar__calendar (key, mom, now) { |
|
2620 |
var output = this._calendar[key]; |
|
2621 |
return typeof output === 'function' ? output.call(mom, now) : output; |
|
2622 |
} |
|
2623 |
|
|
2624 |
var defaultLongDateFormat = { |
|
2625 |
LTS : 'h:mm:ss A', |
|
2626 |
LT : 'h:mm A', |
|
2627 |
L : 'MM/DD/YYYY', |
|
2628 |
LL : 'MMMM D, YYYY', |
|
2629 |
LLL : 'MMMM D, YYYY h:mm A', |
|
2630 |
LLLL : 'dddd, MMMM D, YYYY h:mm A' |
|
2631 |
}; |
|
2632 |
|
|
2633 |
function longDateFormat (key) { |
|
2634 |
var format = this._longDateFormat[key], |
|
2635 |
formatUpper = this._longDateFormat[key.toUpperCase()]; |
|
2636 |
|
|
2637 |
if (format || !formatUpper) { |
|
2638 |
return format; |
|
2639 |
} |
|
2640 |
|
|
2641 |
this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) { |
|
2642 |
return val.slice(1); |
|
2643 |
}); |
|
2644 |
|
|
2645 |
return this._longDateFormat[key]; |
|
2646 |
} |
|
2647 |
|
|
2648 |
var defaultInvalidDate = 'Invalid date'; |
|
2649 |
|
|
2650 |
function invalidDate () { |
|
2651 |
return this._invalidDate; |
|
2652 |
} |
|
2653 |
|
|
2654 |
var defaultOrdinal = '%d'; |
|
2655 |
var defaultOrdinalParse = /\d{1,2}/; |
|
2656 |
|
|
2657 |
function ordinal (number) { |
|
2658 |
return this._ordinal.replace('%d', number); |
|
2659 |
} |
|
2660 |
|
|
2661 |
function preParsePostFormat (string) { |
|
2662 |
return string; |
|
2663 |
} |
|
2664 |
|
|
2665 |
var defaultRelativeTime = { |
|
2666 |
future : 'in %s', |
|
2667 |
past : '%s ago', |
|
2668 |
s : 'a few seconds', |
|
2669 |
m : 'a minute', |
|
2670 |
mm : '%d minutes', |
|
2671 |
h : 'an hour', |
|
2672 |
hh : '%d hours', |
|
2673 |
d : 'a day', |
|
2674 |
dd : '%d days', |
|
2675 |
M : 'a month', |
|
2676 |
MM : '%d months', |
|
2677 |
y : 'a year', |
|
2678 |
yy : '%d years' |
|
2679 |
}; |
|
2680 |
|
|
2681 |
function relative__relativeTime (number, withoutSuffix, string, isFuture) { |
|
2682 |
var output = this._relativeTime[string]; |
|
2683 |
return (typeof output === 'function') ? |
|
2684 |
output(number, withoutSuffix, string, isFuture) : |
|
2685 |
output.replace(/%d/i, number); |
|
2686 |
} |
|
2687 |
|
|
2688 |
function pastFuture (diff, output) { |
|
2689 |
var format = this._relativeTime[diff > 0 ? 'future' : 'past']; |
|
2690 |
return typeof format === 'function' ? format(output) : format.replace(/%s/i, output); |
|
2691 |
} |
|
2692 |
|
|
2693 |
function locale_set__set (config) { |
|
2694 |
var prop, i; |
|
2695 |
for (i in config) { |
|
2696 |
prop = config[i]; |
|
2697 |
if (typeof prop === 'function') { |
|
2698 |
this[i] = prop; |
|
2699 |
} else { |
|
2700 |
this['_' + i] = prop; |
|
2701 |
} |
|
2702 |
} |
|
2703 |
// Lenient ordinal parsing accepts just a number in addition to |
|
2704 |
// number + (possibly) stuff coming from _ordinalParseLenient. |
|
2705 |
this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source); |
|
2706 |
} |
|
2707 |
|
|
2708 |
var prototype__proto = Locale.prototype; |
|
2709 |
|
|
2710 |
prototype__proto._calendar = defaultCalendar; |
|
2711 |
prototype__proto.calendar = locale_calendar__calendar; |
|
2712 |
prototype__proto._longDateFormat = defaultLongDateFormat; |
|
2713 |
prototype__proto.longDateFormat = longDateFormat; |
|
2714 |
prototype__proto._invalidDate = defaultInvalidDate; |
|
2715 |
prototype__proto.invalidDate = invalidDate; |
|
2716 |
prototype__proto._ordinal = defaultOrdinal; |
|
2717 |
prototype__proto.ordinal = ordinal; |
|
2718 |
prototype__proto._ordinalParse = defaultOrdinalParse; |
|
2719 |
prototype__proto.preparse = preParsePostFormat; |
|
2720 |
prototype__proto.postformat = preParsePostFormat; |
|
2721 |
prototype__proto._relativeTime = defaultRelativeTime; |
|
2722 |
prototype__proto.relativeTime = relative__relativeTime; |
|
2723 |
prototype__proto.pastFuture = pastFuture; |
|
2724 |
prototype__proto.set = locale_set__set; |
|
2725 |
|
|
2726 |
// Month |
|
2727 |
prototype__proto.months = localeMonths; |
|
2728 |
prototype__proto._months = defaultLocaleMonths; |
|
2729 |
prototype__proto.monthsShort = localeMonthsShort; |
|
2730 |
prototype__proto._monthsShort = defaultLocaleMonthsShort; |
|
2731 |
prototype__proto.monthsParse = localeMonthsParse; |
|
2732 |
|
|
2733 |
// Week |
|
2734 |
prototype__proto.week = localeWeek; |
|
2735 |
prototype__proto._week = defaultLocaleWeek; |
|
2736 |
prototype__proto.firstDayOfYear = localeFirstDayOfYear; |
|
2737 |
prototype__proto.firstDayOfWeek = localeFirstDayOfWeek; |
|
2738 |
|
|
2739 |
// Day of Week |
|
2740 |
prototype__proto.weekdays = localeWeekdays; |
|
2741 |
prototype__proto._weekdays = defaultLocaleWeekdays; |
|
2742 |
prototype__proto.weekdaysMin = localeWeekdaysMin; |
|
2743 |
prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin; |
|
2744 |
prototype__proto.weekdaysShort = localeWeekdaysShort; |
|
2745 |
prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort; |
|
2746 |
prototype__proto.weekdaysParse = localeWeekdaysParse; |
|
2747 |
|
|
2748 |
// Hours |
|
2749 |
prototype__proto.isPM = localeIsPM; |
|
2750 |
prototype__proto._meridiemParse = defaultLocaleMeridiemParse; |
|
2751 |
prototype__proto.meridiem = localeMeridiem; |
|
2752 |
|
|
2753 |
function lists__get (format, index, field, setter) { |
|
2754 |
var locale = locale_locales__getLocale(); |
|
2755 |
var utc = create_utc__createUTC().set(setter, index); |
|
2756 |
return locale[field](utc, format); |
|
2757 |
} |
|
2758 |
|
|
2759 |
function list (format, index, field, count, setter) { |
|
2760 |
if (typeof format === 'number') { |
|
2761 |
index = format; |
|
2762 |
format = undefined; |
|
2763 |
} |
|
2764 |
|
|
2765 |
format = format || ''; |
|
2766 |
|
|
2767 |
if (index != null) { |
|
2768 |
return lists__get(format, index, field, setter); |
|
2769 |
} |
|
2770 |
|
|
2771 |
var i; |
|
2772 |
var out = []; |
|
2773 |
for (i = 0; i < count; i++) { |
|
2774 |
out[i] = lists__get(format, i, field, setter); |
|
2775 |
} |
|
2776 |
return out; |
|
2777 |
} |
|
2778 |
|
|
2779 |
function lists__listMonths (format, index) { |
|
2780 |
return list(format, index, 'months', 12, 'month'); |
|
2781 |
} |
|
2782 |
|
|
2783 |
function lists__listMonthsShort (format, index) { |
|
2784 |
return list(format, index, 'monthsShort', 12, 'month'); |
|
2785 |
} |
|
2786 |
|
|
2787 |
function lists__listWeekdays (format, index) { |
|
2788 |
return list(format, index, 'weekdays', 7, 'day'); |
|
2789 |
} |
|
2790 |
|
|
2791 |
function lists__listWeekdaysShort (format, index) { |
|
2792 |
return list(format, index, 'weekdaysShort', 7, 'day'); |
|
2793 |
} |
|
2794 |
|
|
2795 |
function lists__listWeekdaysMin (format, index) { |
|
2796 |
return list(format, index, 'weekdaysMin', 7, 'day'); |
|
2797 |
} |
|
2798 |
|
|
2799 |
locale_locales__getSetGlobalLocale('en', { |
|
2800 |
ordinalParse: /\d{1,2}(th|st|nd|rd)/, |
|
2801 |
ordinal : function (number) { |
|
2802 |
var b = number % 10, |
|
2803 |
output = (toInt(number % 100 / 10) === 1) ? 'th' : |
|
2804 |
(b === 1) ? 'st' : |
|
2805 |
(b === 2) ? 'nd' : |
|
2806 |
(b === 3) ? 'rd' : 'th'; |
|
2807 |
return number + output; |
|
2808 |
} |
|
2809 |
}); |
|
2810 |
|
|
2811 |
// Side effect imports |
|
2812 |
utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale); |
|
2813 |
utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale); |
|
2814 |
|
|
2815 |
var mathAbs = Math.abs; |
|
2816 |
|
|
2817 |
function duration_abs__abs () { |
|
2818 |
var data = this._data; |
|
2819 |
|
|
2820 |
this._milliseconds = mathAbs(this._milliseconds); |
|
2821 |
this._days = mathAbs(this._days); |
|
2822 |
this._months = mathAbs(this._months); |
|
2823 |
|
|
2824 |
data.milliseconds = mathAbs(data.milliseconds); |
|
2825 |
data.seconds = mathAbs(data.seconds); |
|
2826 |
data.minutes = mathAbs(data.minutes); |
|
2827 |
data.hours = mathAbs(data.hours); |
|
2828 |
data.months = mathAbs(data.months); |
|
2829 |
data.years = mathAbs(data.years); |
|
2830 |
|
|
2831 |
return this; |
|
2832 |
} |
|
2833 |
|
|
2834 |
function duration_add_subtract__addSubtract (duration, input, value, direction) { |
|
2835 |
var other = create__createDuration(input, value); |
|
2836 |
|
|
2837 |
duration._milliseconds += direction * other._milliseconds; |
|
2838 |
duration._days += direction * other._days; |
|
2839 |
duration._months += direction * other._months; |
|
2840 |
|
|
2841 |
return duration._bubble(); |
|
2842 |
} |
|
2843 |
|
|
2844 |
// supports only 2.0-style add(1, 's') or add(duration) |
|
2845 |
function duration_add_subtract__add (input, value) { |
|
2846 |
return duration_add_subtract__addSubtract(this, input, value, 1); |
|
2847 |
} |
|
2848 |
|
|
2849 |
// supports only 2.0-style subtract(1, 's') or subtract(duration) |
|
2850 |
function duration_add_subtract__subtract (input, value) { |
|
2851 |
return duration_add_subtract__addSubtract(this, input, value, -1); |
|
2852 |
} |
|
2853 |
|
|
2854 |
function absCeil (number) { |
|
2855 |
if (number < 0) { |
|
2856 |
return Math.floor(number); |
|
2857 |
} else { |
|
2858 |
return Math.ceil(number); |
|
2859 |
} |
|
2860 |
} |
|
2861 |
|
|
2862 |
function bubble () { |
|
2863 |
var milliseconds = this._milliseconds; |
|
2864 |
var days = this._days; |
|
2865 |
var months = this._months; |
|
2866 |
var data = this._data; |
|
2867 |
var seconds, minutes, hours, years, monthsFromDays; |
|
2868 |
|
|
2869 |
// if we have a mix of positive and negative values, bubble down first |
|
2870 |
// check: https://github.com/moment/moment/issues/2166 |
|
2871 |
if (!((milliseconds >= 0 && days >= 0 && months >= 0) || |
|
2872 |
(milliseconds <= 0 && days <= 0 && months <= 0))) { |
|
2873 |
milliseconds += absCeil(monthsToDays(months) + days) * 864e5; |
|
2874 |
days = 0; |
|
2875 |
months = 0; |
|
2876 |
} |
|
2877 |
|
|
2878 |
// The following code bubbles up values, see the tests for |
|
2879 |
// examples of what that means. |
|
2880 |
data.milliseconds = milliseconds % 1000; |
|
2881 |
|
|
2882 |
seconds = absFloor(milliseconds / 1000); |
|
2883 |
data.seconds = seconds % 60; |
|
2884 |
|
|
2885 |
minutes = absFloor(seconds / 60); |
|
2886 |
data.minutes = minutes % 60; |
|
2887 |
|
|
2888 |
hours = absFloor(minutes / 60); |
|
2889 |
data.hours = hours % 24; |
|
2890 |
|
|
2891 |
days += absFloor(hours / 24); |
|
2892 |
|
|
2893 |
// convert days to months |
|
2894 |
monthsFromDays = absFloor(daysToMonths(days)); |
|
2895 |
months += monthsFromDays; |
|
2896 |
days -= absCeil(monthsToDays(monthsFromDays)); |
|
2897 |
|
|
2898 |
// 12 months -> 1 year |
|
2899 |
years = absFloor(months / 12); |
|
2900 |
months %= 12; |
|
2901 |
|
|
2902 |
data.days = days; |
|
2903 |
data.months = months; |
|
2904 |
data.years = years; |
|
2905 |
|
|
2906 |
return this; |
|
2907 |
} |
|
2908 |
|
|
2909 |
function daysToMonths (days) { |
|
2910 |
// 400 years have 146097 days (taking into account leap year rules) |
|
2911 |
// 400 years have 12 months === 4800 |
|
2912 |
return days * 4800 / 146097; |
|
2913 |
} |
|
2914 |
|
|
2915 |
function monthsToDays (months) { |
|
2916 |
// the reverse of daysToMonths |
|
2917 |
return months * 146097 / 4800; |
|
2918 |
} |
|
2919 |
|
|
2920 |
function as (units) { |
|
2921 |
var days; |
|
2922 |
var months; |
|
2923 |
var milliseconds = this._milliseconds; |
|
2924 |
|
|
2925 |
units = normalizeUnits(units); |
|
2926 |
|
|
2927 |
if (units === 'month' || units === 'year') { |
|
2928 |
days = this._days + milliseconds / 864e5; |
|
2929 |
months = this._months + daysToMonths(days); |
|
2930 |
return units === 'month' ? months : months / 12; |
|
2931 |
} else { |
|
2932 |
// handle milliseconds separately because of floating point math errors (issue #1867) |
|
2933 |
days = this._days + Math.round(monthsToDays(this._months)); |
|
2934 |
switch (units) { |
|
2935 |
case 'week' : return days / 7 + milliseconds / 6048e5; |
|
2936 |
case 'day' : return days + milliseconds / 864e5; |
|
2937 |
case 'hour' : return days * 24 + milliseconds / 36e5; |
|
2938 |
case 'minute' : return days * 1440 + milliseconds / 6e4; |
|
2939 |
case 'second' : return days * 86400 + milliseconds / 1000; |
|
2940 |
// Math.floor prevents floating point math errors here |
|
2941 |
case 'millisecond': return Math.floor(days * 864e5) + milliseconds; |
|
2942 |
default: throw new Error('Unknown unit ' + units); |
|
2943 |
} |
|
2944 |
} |
|
2945 |
} |
|
2946 |
|
|
2947 |
// TODO: Use this.as('ms')? |
|
2948 |
function duration_as__valueOf () { |
|
2949 |
return ( |
|
2950 |
this._milliseconds + |
|
2951 |
this._days * 864e5 + |
|
2952 |
(this._months % 12) * 2592e6 + |
|
2953 |
toInt(this._months / 12) * 31536e6 |
|
2954 |
); |
|
2955 |
} |
|
2956 |
|
|
2957 |
function makeAs (alias) { |
|
2958 |
return function () { |
|
2959 |
return this.as(alias); |
|
2960 |
}; |
|
2961 |
} |
|
2962 |
|
|
2963 |
var asMilliseconds = makeAs('ms'); |
|
2964 |
var asSeconds = makeAs('s'); |
|
2965 |
var asMinutes = makeAs('m'); |
|
2966 |
var asHours = makeAs('h'); |
|
2967 |
var asDays = makeAs('d'); |
|
2968 |
var asWeeks = makeAs('w'); |
|
2969 |
var asMonths = makeAs('M'); |
|
2970 |
var asYears = makeAs('y'); |
|
2971 |
|
|
2972 |
function duration_get__get (units) { |
|
2973 |
units = normalizeUnits(units); |
|
2974 |
return this[units + 's'](); |
|
2975 |
} |
|
2976 |
|
|
2977 |
function makeGetter(name) { |
|
2978 |
return function () { |
|
2979 |
return this._data[name]; |
|
2980 |
}; |
|
2981 |
} |
|
2982 |
|
|
2983 |
var milliseconds = makeGetter('milliseconds'); |
|
2984 |
var seconds = makeGetter('seconds'); |
|
2985 |
var minutes = makeGetter('minutes'); |
|
2986 |
var hours = makeGetter('hours'); |
|
2987 |
var days = makeGetter('days'); |
|
2988 |
var months = makeGetter('months'); |
|
2989 |
var years = makeGetter('years'); |
|
2990 |
|
|
2991 |
function weeks () { |
|
2992 |
return absFloor(this.days() / 7); |
|
2993 |
} |
|
2994 |
|
|
2995 |
var round = Math.round; |
|
2996 |
var thresholds = { |
|
2997 |
s: 45, // seconds to minute |
|
2998 |
m: 45, // minutes to hour |
|
2999 |
h: 22, // hours to day |
|
3000 |
d: 26, // days to month |
|
3001 |
M: 11 // months to year |
|
3002 |
}; |
|
3003 |
|
|
3004 |
// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize |
|
3005 |
function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { |
|
3006 |
return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); |
|
3007 |
} |
|
3008 |
|
|
3009 |
function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) { |
|
3010 |
var duration = create__createDuration(posNegDuration).abs(); |
|
3011 |
var seconds = round(duration.as('s')); |
|
3012 |
var minutes = round(duration.as('m')); |
|
3013 |
var hours = round(duration.as('h')); |
|
3014 |
var days = round(duration.as('d')); |
|
3015 |
var months = round(duration.as('M')); |
|
3016 |
var years = round(duration.as('y')); |
|
3017 |
|
|
3018 |
var a = seconds < thresholds.s && ['s', seconds] || |
|
3019 |
minutes === 1 && ['m'] || |
|
3020 |
minutes < thresholds.m && ['mm', minutes] || |
|
3021 |
hours === 1 && ['h'] || |
|
3022 |
hours < thresholds.h && ['hh', hours] || |
|
3023 |
days === 1 && ['d'] || |
|
3024 |
days < thresholds.d && ['dd', days] || |
|
3025 |
months === 1 && ['M'] || |
|
3026 |
months < thresholds.M && ['MM', months] || |
|
3027 |
years === 1 && ['y'] || ['yy', years]; |
|
3028 |
|
|
3029 |
a[2] = withoutSuffix; |
|
3030 |
a[3] = +posNegDuration > 0; |
|
3031 |
a[4] = locale; |
|
3032 |
return substituteTimeAgo.apply(null, a); |
|
3033 |
} |
|
3034 |
|
|
3035 |
// This function allows you to set a threshold for relative time strings |
|
3036 |
function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) { |
|
3037 |
if (thresholds[threshold] === undefined) { |
|
3038 |
return false; |
|
3039 |
} |
|
3040 |
if (limit === undefined) { |
|
3041 |
return thresholds[threshold]; |
|
3042 |
} |
|
3043 |
thresholds[threshold] = limit; |
|
3044 |
return true; |
|
3045 |
} |
|
3046 |
|
|
3047 |
function humanize (withSuffix) { |
|
3048 |
var locale = this.localeData(); |
|
3049 |
var output = duration_humanize__relativeTime(this, !withSuffix, locale); |
|
3050 |
|
|
3051 |
if (withSuffix) { |
|
3052 |
output = locale.pastFuture(+this, output); |
|
3053 |
} |
|
3054 |
|
|
3055 |
return locale.postformat(output); |
|
3056 |
} |
|
3057 |
|
|
3058 |
var iso_string__abs = Math.abs; |
|
3059 |
|
|
3060 |
function iso_string__toISOString() { |
|
3061 |
// for ISO strings we do not use the normal bubbling rules: |
|
3062 |
// * milliseconds bubble up until they become hours |
|
3063 |
// * days do not bubble at all |
|
3064 |
// * months bubble up until they become years |
|
3065 |
// This is because there is no context-free conversion between hours and days |
|
3066 |
// (think of clock changes) |
|
3067 |
// and also not between days and months (28-31 days per month) |
|
3068 |
var seconds = iso_string__abs(this._milliseconds) / 1000; |
|
3069 |
var days = iso_string__abs(this._days); |
|
3070 |
var months = iso_string__abs(this._months); |
|
3071 |
var minutes, hours, years; |
|
3072 |
|
|
3073 |
// 3600 seconds -> 60 minutes -> 1 hour |
|
3074 |
minutes = absFloor(seconds / 60); |
|
3075 |
hours = absFloor(minutes / 60); |
|
3076 |
seconds %= 60; |
|
3077 |
minutes %= 60; |
|
3078 |
|
|
3079 |
// 12 months -> 1 year |
|
3080 |
years = absFloor(months / 12); |
|
3081 |
months %= 12; |
|
3082 |
|
|
3083 |
|
|
3084 |
// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js |
|
3085 |
var Y = years; |
|
3086 |
var M = months; |
|
3087 |
var D = days; |
|
3088 |
var h = hours; |
|
3089 |
var m = minutes; |
|
3090 |
var s = seconds; |
|
3091 |
var total = this.asSeconds(); |
|
3092 |
|
|
3093 |
if (!total) { |
|
3094 |
// this is the same as C#'s (Noda) and python (isodate)... |
|
3095 |
// but not other JS (goog.date) |
|
3096 |
return 'P0D'; |
|
3097 |
} |
|
3098 |
|
|
3099 |
return (total < 0 ? '-' : '') + |
|
3100 |
'P' + |
|
3101 |
(Y ? Y + 'Y' : '') + |
|
3102 |
(M ? M + 'M' : '') + |
|
3103 |
(D ? D + 'D' : '') + |
|
3104 |
((h || m || s) ? 'T' : '') + |
|
3105 |
(h ? h + 'H' : '') + |
|
3106 |
(m ? m + 'M' : '') + |
|
3107 |
(s ? s + 'S' : ''); |
|
3108 |
} |
|
3109 |
|
|
3110 |
var duration_prototype__proto = Duration.prototype; |
|
3111 |
|
|
3112 |
duration_prototype__proto.abs = duration_abs__abs; |
|
3113 |
duration_prototype__proto.add = duration_add_subtract__add; |
|
3114 |
duration_prototype__proto.subtract = duration_add_subtract__subtract; |
|
3115 |
duration_prototype__proto.as = as; |
|
3116 |
duration_prototype__proto.asMilliseconds = asMilliseconds; |
|
3117 |
duration_prototype__proto.asSeconds = asSeconds; |
|
3118 |
duration_prototype__proto.asMinutes = asMinutes; |
|
3119 |
duration_prototype__proto.asHours = asHours; |
|
3120 |
duration_prototype__proto.asDays = asDays; |
|
3121 |
duration_prototype__proto.asWeeks = asWeeks; |
|
3122 |
duration_prototype__proto.asMonths = asMonths; |
|
3123 |
duration_prototype__proto.asYears = asYears; |
|
3124 |
duration_prototype__proto.valueOf = duration_as__valueOf; |
|
3125 |
duration_prototype__proto._bubble = bubble; |
|
3126 |
duration_prototype__proto.get = duration_get__get; |
|
3127 |
duration_prototype__proto.milliseconds = milliseconds; |
|
3128 |
duration_prototype__proto.seconds = seconds; |
|
3129 |
duration_prototype__proto.minutes = minutes; |
|
3130 |
duration_prototype__proto.hours = hours; |
|
3131 |
duration_prototype__proto.days = days; |
|
3132 |
duration_prototype__proto.weeks = weeks; |
|
3133 |
duration_prototype__proto.months = months; |
|
3134 |
duration_prototype__proto.years = years; |
|
3135 |
duration_prototype__proto.humanize = humanize; |
|
3136 |
duration_prototype__proto.toISOString = iso_string__toISOString; |
|
3137 |
duration_prototype__proto.toString = iso_string__toISOString; |
|
3138 |
duration_prototype__proto.toJSON = iso_string__toISOString; |
|
3139 |
duration_prototype__proto.locale = locale; |
|
3140 |
duration_prototype__proto.localeData = localeData; |
|
3141 |
|
|
3142 |
// Deprecations |
|
3143 |
duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString); |
|
3144 |
duration_prototype__proto.lang = lang; |
|
3145 |
|
|
3146 |
// Side effect imports |
|
3147 |
|
|
3148 |
addFormatToken('X', 0, 0, 'unix'); |
|
3149 |
addFormatToken('x', 0, 0, 'valueOf'); |
|
3150 |
|
|
3151 |
// PARSING |
|
3152 |
|
|
3153 |
addRegexToken('x', matchSigned); |
|
3154 |
addRegexToken('X', matchTimestamp); |
|
3155 |
addParseToken('X', function (input, array, config) { |
|
3156 |
config._d = new Date(parseFloat(input, 10) * 1000); |
|
3157 |
}); |
|
3158 |
addParseToken('x', function (input, array, config) { |
|
3159 |
config._d = new Date(toInt(input)); |
|
3160 |
}); |
|
3161 |
|
|
3162 |
// Side effect imports |
|
3163 |
|
|
3164 |
|
|
3165 |
utils_hooks__hooks.version = '2.10.6'; |
|
3166 |
|
|
3167 |
setHookCallback(local__createLocal); |
|
3168 |
|
|
3169 |
utils_hooks__hooks.fn = momentPrototype; |
|
3170 |
utils_hooks__hooks.min = min; |
|
3171 |
utils_hooks__hooks.max = max; |
|
3172 |
utils_hooks__hooks.utc = create_utc__createUTC; |
|
3173 |
utils_hooks__hooks.unix = moment__createUnix; |
|
3174 |
utils_hooks__hooks.months = lists__listMonths; |
|
3175 |
utils_hooks__hooks.isDate = isDate; |
|
3176 |
utils_hooks__hooks.locale = locale_locales__getSetGlobalLocale; |
|
3177 |
utils_hooks__hooks.invalid = valid__createInvalid; |
|
3178 |
utils_hooks__hooks.duration = create__createDuration; |
|
3179 |
utils_hooks__hooks.isMoment = isMoment; |
|
3180 |
utils_hooks__hooks.weekdays = lists__listWeekdays; |
|
3181 |
utils_hooks__hooks.parseZone = moment__createInZone; |
|
3182 |
utils_hooks__hooks.localeData = locale_locales__getLocale; |
|
3183 |
utils_hooks__hooks.isDuration = isDuration; |
|
3184 |
utils_hooks__hooks.monthsShort = lists__listMonthsShort; |
|
3185 |
utils_hooks__hooks.weekdaysMin = lists__listWeekdaysMin; |
|
3186 |
utils_hooks__hooks.defineLocale = defineLocale; |
|
3187 |
utils_hooks__hooks.weekdaysShort = lists__listWeekdaysShort; |
|
3188 |
utils_hooks__hooks.normalizeUnits = normalizeUnits; |
|
3189 |
utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold; |
|
3190 |
|
|
3191 |
var _moment = utils_hooks__hooks; |
|
3192 |
|
|
3193 |
return _moment; |
|
3194 |
|
|
3195 |
})); |