vendor: 130,196 bytes, lines 1-4514
1//! moment.js 2//! version : 2.19.1 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 13var hookCallback; 14 15function 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. 21function setHookCallback (callback) { 22 hookCallback = callback; 23} 24 25function isArray(input) { 26 return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'; 27} 28 29function isObject(input) { 30 // IE8 will treat undefined and null as object if it wasn't for 31 // input != null 32 return input != null && Object.prototype.toString.call(input) === '[object Object]'; 33} 34 35function isObjectEmpty(obj) { 36 if (Object.getOwnPropertyNames) { 37 return (Object.getOwnPropertyNames(obj).length === 0); 38 } else { 39 var k; 40 for (k in obj) { 41 if (obj.hasOwnProperty(k)) { 42 return false; 43 } 44 } 45 return true; 46 } 47} 48 49function isUndefined(input) { 50 return input === void 0; 51} 52 53function isNumber(input) { 54 return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]'; 55} 56 57function isDate(input) { 58 return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; 59} 60 61function map(arr, fn) { 62 var res = [], i; 63 for (i = 0; i < arr.length; ++i) { 64 res.push(fn(arr[i], i)); 65 } 66 return res; 67} 68 69function hasOwnProp(a, b) { 70 return Object.prototype.hasOwnProperty.call(a, b); 71} 72 73function extend(a, b) { 74 for (var i in b) { 75 if (hasOwnProp(b, i)) { 76 a[i] = b[i]; 77 } 78 } 79 80 if (hasOwnProp(b, 'toString')) { 81 a.toString = b.toString; 82 } 83 84 if (hasOwnProp(b, 'valueOf')) { 85 a.valueOf = b.valueOf; 86 } 87 88 return a; 89} 90 91function createUTC (input, format, locale, strict) { 92 return createLocalOrUTC(input, format, locale, strict, true).utc(); 93} 94 95function defaultParsingFlags() { 96 // We need to deep clone this object. 97 return { 98 empty : false, 99 unusedTokens : [], 100 unusedInput : [], 101 overflow : -2, 102 charsLeftOver : 0, 103 nullInput : false, 104 invalidMonth : null, 105 invalidFormat : false, 106 userInvalidated : false, 107 iso : false, 108 parsedDateParts : [], 109 meridiem : null, 110 rfc2822 : false, 111 weekdayMismatch : false 112 }; 113} 114 115function getParsingFlags(m) { 116 if (m._pf == null) { 117 m._pf = defaultParsingFlags(); 118 } 119 return m._pf; 120} 121 122var some; 123if (Array.prototype.some) { 124 some = Array.prototype.some; 125} else { 126 some = function (fun) { 127 var t = Object(this); 128 var len = t.length >>> 0; 129 130 for (var i = 0; i < len; i++) { 131 if (i in t && fun.call(this, t[i], i, t)) { 132 return true; 133 } 134 } 135 136 return false; 137 }; 138} 139 140function isValid(m) { 141 if (m._isValid == null) { 142 var flags = getParsingFlags(m); 143 var parsedParts = some.call(flags.parsedDateParts, function (i) { 144 return i != null; 145 }); 146 var isNowValid = !isNaN(m._d.getTime()) && 147 flags.overflow < 0 && 148 !flags.empty && 149 !flags.invalidMonth && 150 !flags.invalidWeekday && 151 !flags.weekdayMismatch && 152 !flags.nullInput && 153 !flags.invalidFormat && 154 !flags.userInvalidated && 155 (!flags.meridiem || (flags.meridiem && parsedParts)); 156 157 if (m._strict) { 158 isNowValid = isNowValid && 159 flags.charsLeftOver === 0 && 160 flags.unusedTokens.length === 0 && 161 flags.bigHour === undefined; 162 } 163 164 if (Object.isFrozen == null || !Object.isFrozen(m)) { 165 m._isValid = isNowValid; 166 } 167 else { 168 return isNowValid; 169 } 170 } 171 return m._isValid; 172} 173 174function createInvalid (flags) { 175 var m = createUTC(NaN); 176 if (flags != null) { 177 extend(getParsingFlags(m), flags); 178 } 179 else { 180 getParsingFlags(m).userInvalidated = true; 181 } 182 183 return m; 184} 185 186// Plugins that add properties should also add the key here (null value), 187// so we can properly clone ourselves. 188var momentProperties = hooks.momentProperties = []; 189 190function copyConfig(to, from) { 191 var i, prop, val; 192 193 if (!isUndefined(from._isAMomentObject)) { 194 to._isAMomentObject = from._isAMomentObject; 195 } 196 if (!isUndefined(from._i)) { 197 to._i = from._i; 198 } 199 if (!isUndefined(from._f)) { 200 to._f = from._f; 201 } 202 if (!isUndefined(from._l)) { 203 to._l = from._l; 204 } 205 if (!isUndefined(from._strict)) { 206 to._strict = from._strict; 207 } 208 if (!isUndefined(from._tzm)) { 209 to._tzm = from._tzm; 210 } 211 if (!isUndefined(from._isUTC)) { 212 to._isUTC = from._isUTC; 213 } 214 if (!isUndefined(from._offset)) { 215 to._offset = from._offset; 216 } 217 if (!isUndefined(from._pf)) { 218 to._pf = getParsingFlags(from); 219 } 220 if (!isUndefined(from._locale)) { 221 to._locale = from._locale; 222 } 223 224 if (momentProperties.length > 0) { 225 for (i = 0; i < momentProperties.length; i++) { 226 prop = momentProperties[i]; 227 val = from[prop]; 228 if (!isUndefined(val)) { 229 to[prop] = val; 230 } 231 } 232 } 233 234 return to; 235} 236 237var updateInProgress = false; 238 239// Moment prototype object 240function Moment(config) { 241 copyConfig(this, config); 242 this._d = new Date(config._d != null ? config._d.getTime() : NaN); 243 if (!this.isValid()) { 244 this._d = new Date(NaN); 245 } 246 // Prevent infinite loop in case updateOffset creates new moment 247 // objects. 248 if (updateInProgress === false) { 249 updateInProgress = true; 250 hooks.updateOffset(this); 251 updateInProgress = false; 252 } 253} 254 255function isMoment (obj) { 256 return obj instanceof Moment || (obj != null && obj._isAMomentObject != null); 257} 258 259function absFloor (number) { 260 if (number < 0) { 261 // -0 -> 0 262 return Math.ceil(number) || 0; 263 } else { 264 return Math.floor(number); 265 } 266} 267 268function toInt(argumentForCoercion) { 269 var coercedNumber = +argumentForCoercion, 270 value = 0; 271 272 if (coercedNumber !== 0 && isFinite(coercedNumber)) { 273 value = absFloor(coercedNumber); 274 } 275 276 return value; 277} 278 279// compare two arrays, return the number of differences 280function compareArrays(array1, array2, dontConvert) { 281 var len = Math.min(array1.length, array2.length), 282 lengthDiff = Math.abs(array1.length - array2.length), 283 diffs = 0, 284 i; 285 for (i = 0; i < len; i++) { 286 if ((dontConvert && array1[i] !== array2[i]) || 287 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) { 288 diffs++; 289 } 290 } 291 return diffs + lengthDiff; 292} 293 294function warn(msg) { 295 if (hooks.suppressDeprecationWarnings === false && 296 (typeof console !== 'undefined') && console.warn) { 297 console.warn('Deprecation warning: ' + msg); 298 } 299} 300 301function deprecate(msg, fn) { 302 var firstTime = true; 303 304 return extend(function () { 305 if (hooks.deprecationHandler != null) { 306 hooks.deprecationHandler(null, msg); 307 } 308 if (firstTime) { 309 var args = []; 310 var arg; 311 for (var i = 0; i < arguments.length; i++) { 312 arg = ''; 313 if (typeof arguments[i] === 'object') { 314 arg += '\n[' + i + '] '; 315 for (var key in arguments[0]) { 316 arg += key + ': ' + arguments[0][key] + ', '; 317 } 318 arg = arg.slice(0, -2); // Remove trailing comma and space 319 } else { 320 arg = arguments[i]; 321 } 322 args.push(arg); 323 } 324 warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack); 325 firstTime = false; 326 } 327 return fn.apply(this, arguments); 328 }, fn); 329} 330 331var deprecations = {}; 332 333function deprecateSimple(name, msg) { 334 if (hooks.deprecationHandler != null) { 335 hooks.deprecationHandler(name, msg); 336 } 337 if (!deprecations[name]) { 338 warn(msg); 339 deprecations[name] = true; 340 } 341} 342 343hooks.suppressDeprecationWarnings = false; 344hooks.deprecationHandler = null; 345 346function isFunction(input) { 347 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'; 348} 349 350function set (config) { 351 var prop, i; 352 for (i in config) { 353 prop = config[i]; 354 if (isFunction(prop)) { 355 this[i] = prop; 356 } else { 357 this['_' + i] = prop; 358 } 359 } 360 this._config = config; 361 // Lenient ordinal parsing accepts just a number in addition to 362 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. 363 // TODO: Remove "ordinalParse" fallback in next major release. 364 this._dayOfMonthOrdinalParseLenient = new RegExp( 365 (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + 366 '|' + (/\d{1,2}/).source); 367} 368 369function mergeConfigs(parentConfig, childConfig) { 370 var res = extend({}, parentConfig), prop; 371 for (prop in childConfig) { 372 if (hasOwnProp(childConfig, prop)) { 373 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { 374 res[prop] = {}; 375 extend(res[prop], parentConfig[prop]); 376 extend(res[prop], childConfig[prop]); 377 } else if (childConfig[prop] != null) { 378 res[prop] = childConfig[prop]; 379 } else { 380 delete res[prop]; 381 } 382 } 383 } 384 for (prop in parentConfig) { 385 if (hasOwnProp(parentConfig, prop) && 386 !hasOwnProp(childConfig, prop) && 387 isObject(parentConfig[prop])) { 388 // make sure changes to properties don't modify parent config 389 res[prop] = extend({}, res[prop]); 390 } 391 } 392 return res; 393} 394 395function Locale(config) { 396 if (config != null) { 397 this.set(config); 398 } 399} 400 401var keys; 402 403if (Object.keys) { 404 keys = Object.keys; 405} else { 406 keys = function (obj) { 407 var i, res = []; 408 for (i in obj) { 409 if (hasOwnProp(obj, i)) { 410 res.push(i); 411 } 412 } 413 return res; 414 }; 415} 416 417var defaultCalendar = { 418 sameDay : '[Today at] LT', 419 nextDay : '[Tomorrow at] LT', 420 nextWeek : 'dddd [at] LT', 421 lastDay : '[Yesterday at] LT', 422 lastWeek : '[Last] dddd [at] LT', 423 sameElse : 'L' 424}; 425 426function calendar (key, mom, now) { 427 var output = this._calendar[key] || this._calendar['sameElse']; 428 return isFunction(output) ? output.call(mom, now) : output; 429} 430 431var defaultLongDateFormat = { 432 LTS : 'h:mm:ss A', 433 LT : 'h:mm A', 434 L : 'MM/DD/YYYY', 435 LL : 'MMMM D, YYYY', 436 LLL : 'MMMM D, YYYY h:mm A', 437 LLLL : 'dddd, MMMM D, YYYY h:mm A' 438}; 439 440function longDateFormat (key) { 441 var format = this._longDateFormat[key], 442 formatUpper = this._longDateFormat[key.toUpperCase()]; 443 444 if (format || !formatUpper) { 445 return format; 446 } 447 448 this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) { 449 return val.slice(1); 450 }); 451 452 return this._longDateFormat[key]; 453} 454 455var defaultInvalidDate = 'Invalid date'; 456 457function invalidDate () { 458 return this._invalidDate; 459} 460 461var defaultOrdinal = '%d'; 462var defaultDayOfMonthOrdinalParse = /\d{1,2}/; 463 464function ordinal (number) { 465 return this._ordinal.replace('%d', number); 466} 467 468var defaultRelativeTime = { 469 future : 'in %s', 470 past : '%s ago', 471 s : 'a few seconds', 472 ss : '%d seconds', 473 m : 'a minute', 474 mm : '%d minutes', 475 h : 'an hour', 476 hh : '%d hours', 477 d : 'a day', 478 dd : '%d days', 479 M : 'a month', 480 MM : '%d months', 481 y : 'a year', 482 yy : '%d years' 483}; 484 485function relativeTime (number, withoutSuffix, string, isFuture) { 486 var output = this._relativeTime[string]; 487 return (isFunction(output)) ? 488 output(number, withoutSuffix, string, isFuture) : 489 output.replace(/%d/i, number); 490} 491 492function pastFuture (diff, output) { 493 var format = this._relativeTime[diff > 0 ? 'future' : 'past']; 494 return isFunction(format) ? format(output) : format.replace(/%s/i, output); 495} 496 497var aliases = {}; 498 499function addUnitAlias (unit, shorthand) { 500 var lowerCase = unit.toLowerCase(); 501 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; 502} 503 504function normalizeUnits(units) { 505 return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined; 506} 507 508function normalizeObjectUnits(inputObject) { 509 var normalizedInput = {}, 510 normalizedProp, 511 prop; 512 513 for (prop in inputObject) { 514 if (hasOwnProp(inputObject, prop)) { 515 normalizedProp = normalizeUnits(prop); 516 if (normalizedProp) { 517 normalizedInput[normalizedProp] = inputObject[prop]; 518 } 519 } 520 } 521 522 return normalizedInput; 523} 524 525var priorities = {}; 526 527function addUnitPriority(unit, priority) { 528 priorities[unit] = priority; 529} 530 531function getPrioritizedUnits(unitsObj) { 532 var units = []; 533 for (var u in unitsObj) { 534 units.push({unit: u, priority: priorities[u]}); 535 } 536 units.sort(function (a, b) { 537 return a.priority - b.priority; 538 }); 539 return units; 540} 541 542function zeroFill(number, targetLength, forceSign) { 543 var absNumber = '' + Math.abs(number), 544 zerosToFill = targetLength - absNumber.length, 545 sign = number >= 0; 546 return (sign ? (forceSign ? '+' : '') : '-') + 547 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; 548} 549 550var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g; 551 552var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g; 553 554var formatFunctions = {}; 555 556var formatTokenFunctions = {}; 557 558// token: 'M' 559// padded: ['MM', 2] 560// ordinal: 'Mo' 561// callback: function () { this.month() + 1 } 562function addFormatToken (token, padded, ordinal, callback) { 563 var func = callback; 564 if (typeof callback === 'string') { 565 func = function () { 566 return this[callback](); 567 }; 568 } 569 if (token) { 570 formatTokenFunctions[token] = func; 571 } 572 if (padded) { 573 formatTokenFunctions[padded[0]] = function () { 574 return zeroFill(func.apply(this, arguments), padded[1], padded[2]); 575 }; 576 } 577 if (ordinal) { 578 formatTokenFunctions[ordinal] = function () { 579 return this.localeData().ordinal(func.apply(this, arguments), token); 580 }; 581 } 582} 583 584function removeFormattingTokens(input) { 585 if (input.match(/\[[\s\S]/)) { 586 return input.replace(/^\[|\]$/g, ''); 587 } 588 return input.replace(/\\/g, ''); 589} 590 591function makeFormatFunction(format) { 592 var array = format.match(formattingTokens), i, length; 593 594 for (i = 0, length = array.length; i < length; i++) { 595 if (formatTokenFunctions[array[i]]) { 596 array[i] = formatTokenFunctions[array[i]]; 597 } else { 598 array[i] = removeFormattingTokens(array[i]); 599 } 600 } 601 602 return function (mom) { 603 var output = '', i; 604 for (i = 0; i < length; i++) { 605 output += isFunction(array[i]) ? array[i].call(mom, format) : array[i]; 606 } 607 return output; 608 }; 609} 610 611// format date using native date object 612function formatMoment(m, format) { 613 if (!m.isValid()) { 614 return m.localeData().invalidDate(); 615 } 616 617 format = expandFormat(format, m.localeData()); 618 formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format); 619 620 return formatFunctions[format](m); 621} 622 623function expandFormat(format, locale) { 624 var i = 5; 625 626 function replaceLongDateFormatTokens(input) { 627 return locale.longDateFormat(input) || input; 628 } 629 630 localFormattingTokens.lastIndex = 0; 631 while (i >= 0 && localFormattingTokens.test(format)) { 632 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens); 633 localFormattingTokens.lastIndex = 0; 634 i -= 1; 635 } 636 637 return format; 638} 639 640var match1 = /\d/; // 0 - 9 641var match2 = /\d\d/; // 00 - 99 642var match3 = /\d{3}/; // 000 - 999 643var match4 = /\d{4}/; // 0000 - 9999 644var match6 = /[+-]?\d{6}/; // -999999 - 999999 645var match1to2 = /\d\d?/; // 0 - 99 646var match3to4 = /\d\d\d\d?/; // 999 - 9999 647var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999 648var match1to3 = /\d{1,3}/; // 0 - 999 649var match1to4 = /\d{1,4}/; // 0 - 9999 650var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999 651 652var matchUnsigned = /\d+/; // 0 - inf 653var matchSigned = /[+-]?\d+/; // -inf - inf 654 655var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z 656var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z 657 658var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123 659 660// any word (or two) characters or numbers including two/three word month in arabic. 661// includes scottish gaelic two word and hyphenated months 662var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i; 663 664 665var regexes = {}; 666 667function addRegexToken (token, regex, strictRegex) { 668 regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) { 669 return (isStrict && strictRegex) ? strictRegex : regex; 670 }; 671} 672 673function getParseRegexForToken (token, config) { 674 if (!hasOwnProp(regexes, token)) { 675 return new RegExp(unescapeFormat(token)); 676 } 677 678 return regexes[token](config._strict, config._locale); 679} 680 681// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript 682function unescapeFormat(s) { 683 return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { 684 return p1 || p2 || p3 || p4; 685 })); 686} 687 688function regexEscape(s) { 689 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); 690} 691 692var tokens = {}; 693 694function addParseToken (token, callback) { 695 var i, func = callback; 696 if (typeof token === 'string') { 697 token = [token]; 698 } 699 if (isNumber(callback)) { 700 func = function (input, array) { 701 array[callback] = toInt(input); 702 }; 703 } 704 for (i = 0; i < token.length; i++) { 705 tokens[token[i]] = func; 706 } 707} 708 709function addWeekParseToken (token, callback) { 710 addParseToken(token, function (input, array, config, token) { 711 config._w = config._w || {}; 712 callback(input, config._w, config, token); 713 }); 714} 715 716function addTimeToArrayFromToken(token, input, config) { 717 if (input != null && hasOwnProp(tokens, token)) { 718 tokens[token](input, config._a, config, token); 719 } 720} 721 722var YEAR = 0; 723var MONTH = 1; 724var DATE = 2; 725var HOUR = 3; 726var MINUTE = 4; 727var SECOND = 5; 728var MILLISECOND = 6; 729var WEEK = 7; 730var WEEKDAY = 8; 731 732// FORMATTING 733 734addFormatToken('Y', 0, 0, function () { 735 var y = this.year(); 736 return y <= 9999 ? '' + y : '+' + y; 737}); 738 739addFormatToken(0, ['YY', 2], 0, function () { 740 return this.year() % 100; 741}); 742 743addFormatToken(0, ['YYYY', 4], 0, 'year'); 744addFormatToken(0, ['YYYYY', 5], 0, 'year'); 745addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); 746 747// ALIASES 748 749addUnitAlias('year', 'y'); 750 751// PRIORITIES 752 753addUnitPriority('year', 1); 754 755// PARSING 756 757addRegexToken('Y', matchSigned); 758addRegexToken('YY', match1to2, match2); 759addRegexToken('YYYY', match1to4, match4); 760addRegexToken('YYYYY', match1to6, match6); 761addRegexToken('YYYYYY', match1to6, match6); 762 763addParseToken(['YYYYY', 'YYYYYY'], YEAR); 764addParseToken('YYYY', function (input, array) { 765 array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); 766}); 767addParseToken('YY', function (input, array) { 768 array[YEAR] = hooks.parseTwoDigitYear(input); 769}); 770addParseToken('Y', function (input, array) { 771 array[YEAR] = parseInt(input, 10); 772}); 773 774// HELPERS 775 776function daysInYear(year) { 777 return isLeapYear(year) ? 366 : 365; 778} 779 780function isLeapYear(year) { 781 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; 782} 783 784// HOOKS 785 786hooks.parseTwoDigitYear = function (input) { 787 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); 788}; 789 790// MOMENTS 791 792var getSetYear = makeGetSet('FullYear', true); 793 794function getIsLeapYear () { 795 return isLeapYear(this.year()); 796} 797 798function makeGetSet (unit, keepTime) { 799 return function (value) { 800 if (value != null) { 801 set$1(this, unit, value); 802 hooks.updateOffset(this, keepTime); 803 return this; 804 } else { 805 return get(this, unit); 806 } 807 }; 808} 809 810function get (mom, unit) { 811 return mom.isValid() ? 812 mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN; 813} 814 815function set$1 (mom, unit, value) { 816 if (mom.isValid() && !isNaN(value)) { 817 if (unit === 'FullYear' && isLeapYear(mom.year())) { 818 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month())); 819 } 820 else { 821 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); 822 } 823 } 824} 825 826// MOMENTS 827 828function stringGet (units) { 829 units = normalizeUnits(units); 830 if (isFunction(this[units])) { 831 return this[units](); 832 } 833 return this; 834} 835 836 837function stringSet (units, value) { 838 if (typeof units === 'object') { 839 units = normalizeObjectUnits(units); 840 var prioritized = getPrioritizedUnits(units); 841 for (var i = 0; i < prioritized.length; i++) { 842 this[prioritized[i].unit](units[prioritized[i].unit]); 843 } 844 } else { 845 units = normalizeUnits(units); 846 if (isFunction(this[units])) { 847 return this[units](value); 848 } 849 } 850 return this; 851} 852 853function mod(n, x) { 854 return ((n % x) + x) % x; 855} 856 857var indexOf; 858 859if (Array.prototype.indexOf) { 860 indexOf = Array.prototype.indexOf; 861} else { 862 indexOf = function (o) { 863 // I know 864 var i; 865 for (i = 0; i < this.length; ++i) { 866 if (this[i] === o) { 867 return i; 868 } 869 } 870 return -1; 871 }; 872} 873 874function daysInMonth(year, month) { 875 if (isNaN(year) || isNaN(month)) { 876 return NaN; 877 } 878 var modMonth = mod(month, 12); 879 year += (month - modMonth) / 12; 880 return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2); 881} 882 883// FORMATTING 884 885addFormatToken('M', ['MM', 2], 'Mo', function () { 886 return this.month() + 1; 887}); 888 889addFormatToken('MMM', 0, 0, function (format) { 890 return this.localeData().monthsShort(this, format); 891}); 892 893addFormatToken('MMMM', 0, 0, function (format) { 894 return this.localeData().months(this, format); 895}); 896 897// ALIASES 898 899addUnitAlias('month', 'M'); 900 901// PRIORITY 902 903addUnitPriority('month', 8); 904 905// PARSING 906 907addRegexToken('M', match1to2); 908addRegexToken('MM', match1to2, match2); 909addRegexToken('MMM', function (isStrict, locale) { 910 return locale.monthsShortRegex(isStrict); 911}); 912addRegexToken('MMMM', function (isStrict, locale) { 913 return locale.monthsRegex(isStrict); 914}); 915 916addParseToken(['M', 'MM'], function (input, array) { 917 array[MONTH] = toInt(input) - 1; 918}); 919 920addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { 921 var month = config._locale.monthsParse(input, token, config._strict); 922 // if we didn't find a month name, mark the date as invalid. 923 if (month != null) { 924 array[MONTH] = month; 925 } else { 926 getParsingFlags(config).invalidMonth = input; 927 } 928}); 929 930// LOCALES 931 932var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/; 933var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); 934function localeMonths (m, format) { 935 if (!m) { 936 return isArray(this._months) ? this._months : 937 this._months['standalone']; 938 } 939 return isArray(this._months) ? this._months[m.month()] : 940 this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()]; 941} 942 943var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); 944function localeMonthsShort (m, format) { 945 if (!m) { 946 return isArray(this._monthsShort) ? this._monthsShort : 947 this._monthsShort['standalone']; 948 } 949 return isArray(this._monthsShort) ? this._monthsShort[m.month()] : 950 this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]; 951} 952 953function handleStrictParse(monthName, format, strict) { 954 var i, ii, mom, llc = monthName.toLocaleLowerCase(); 955 if (!this._monthsParse) { 956 // this is not used 957 this._monthsParse = []; 958 this._longMonthsParse = []; 959 this._shortMonthsParse = []; 960 for (i = 0; i < 12; ++i) { 961 mom = createUTC([2000, i]); 962 this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase(); 963 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); 964 } 965 } 966 967 if (strict) { 968 if (format === 'MMM') { 969 ii = indexOf.call(this._shortMonthsParse, llc); 970 return ii !== -1 ? ii : null; 971 } else { 972 ii = indexOf.call(this._longMonthsParse, llc); 973 return ii !== -1 ? ii : null; 974 } 975 } else { 976 if (format === 'MMM') { 977 ii = indexOf.call(this._shortMonthsParse, llc); 978 if (ii !== -1) { 979 return ii; 980 } 981 ii = indexOf.call(this._longMonthsParse, llc); 982 return ii !== -1 ? ii : null; 983 } else { 984 ii = indexOf.call(this._longMonthsParse, llc); 985 if (ii !== -1) { 986 return ii; 987 } 988 ii = indexOf.call(this._shortMonthsParse, llc); 989 return ii !== -1 ? ii : null; 990 } 991 } 992} 993 994function localeMonthsParse (monthName, format, strict) { 995 var i, mom, regex; 996 997 if (this._monthsParseExact) { 998 return handleStrictParse.call(this, monthName, format, strict); 999 } 1000 1001 if (!this._monthsParse) { 1002 this._monthsParse = []; 1003 this._longMonthsParse = []; 1004 this._shortMonthsParse = []; 1005 } 1006 1007 // TODO: add sorting 1008 // Sorting makes sure if one month (or abbr) is a prefix of another 1009 // see sorting in computeMonthsParse 1010 for (i = 0; i < 12; i++) { 1011 // make the regex if we don't have it already 1012 mom = createUTC([2000, i]); 1013 if (strict && !this._longMonthsParse[i]) { 1014 this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i'); 1015 this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i'); 1016 } 1017 if (!strict && !this._monthsParse[i]) { 1018 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); 1019 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1020 } 1021 // test the regex 1022 if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) { 1023 return i; 1024 } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) { 1025 return i; 1026 } else if (!strict && this._monthsParse[i].test(monthName)) { 1027 return i; 1028 } 1029 } 1030} 1031 1032// MOMENTS 1033 1034function setMonth (mom, value) { 1035 var dayOfMonth; 1036 1037 if (!mom.isValid()) { 1038 // No op 1039 return mom; 1040 } 1041 1042 if (typeof value === 'string') { 1043 if (/^\d+$/.test(value)) { 1044 value = toInt(value); 1045 } else { 1046 value = mom.localeData().monthsParse(value); 1047 // TODO: Another silent failure? 1048 if (!isNumber(value)) { 1049 return mom; 1050 } 1051 } 1052 } 1053 1054 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); 1055 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); 1056 return mom; 1057} 1058 1059function getSetMonth (value) { 1060 if (value != null) { 1061 setMonth(this, value); 1062 hooks.updateOffset(this, true); 1063 return this; 1064 } else { 1065 return get(this, 'Month'); 1066 } 1067} 1068 1069function getDaysInMonth () { 1070 return daysInMonth(this.year(), this.month()); 1071} 1072 1073var defaultMonthsShortRegex = matchWord; 1074function monthsShortRegex (isStrict) { 1075 if (this._monthsParseExact) { 1076 if (!hasOwnProp(this, '_monthsRegex')) { 1077 computeMonthsParse.call(this); 1078 } 1079 if (isStrict) { 1080 return this._monthsShortStrictRegex; 1081 } else { 1082 return this._monthsShortRegex; 1083 } 1084 } else { 1085 if (!hasOwnProp(this, '_monthsShortRegex')) { 1086 this._monthsShortRegex = defaultMonthsShortRegex; 1087 } 1088 return this._monthsShortStrictRegex && isStrict ? 1089 this._monthsShortStrictRegex : this._monthsShortRegex; 1090 } 1091} 1092 1093var defaultMonthsRegex = matchWord; 1094function monthsRegex (isStrict) { 1095 if (this._monthsParseExact) { 1096 if (!hasOwnProp(this, '_monthsRegex')) { 1097 computeMonthsParse.call(this); 1098 } 1099 if (isStrict) { 1100 return this._monthsStrictRegex; 1101 } else { 1102 return this._monthsRegex; 1103 } 1104 } else { 1105 if (!hasOwnProp(this, '_monthsRegex')) { 1106 this._monthsRegex = defaultMonthsRegex; 1107 } 1108 return this._monthsStrictRegex && isStrict ? 1109 this._monthsStrictRegex : this._monthsRegex; 1110 } 1111} 1112 1113function computeMonthsParse () { 1114 function cmpLenRev(a, b) { 1115 return b.length - a.length; 1116 } 1117 1118 var shortPieces = [], longPieces = [], mixedPieces = [], 1119 i, mom; 1120 for (i = 0; i < 12; i++) { 1121 // make the regex if we don't have it already 1122 mom = createUTC([2000, i]); 1123 shortPieces.push(this.monthsShort(mom, '')); 1124 longPieces.push(this.months(mom, '')); 1125 mixedPieces.push(this.months(mom, '')); 1126 mixedPieces.push(this.monthsShort(mom, '')); 1127 } 1128 // Sorting makes sure if one month (or abbr) is a prefix of another it 1129 // will match the longer piece. 1130 shortPieces.sort(cmpLenRev); 1131 longPieces.sort(cmpLenRev); 1132 mixedPieces.sort(cmpLenRev); 1133 for (i = 0; i < 12; i++) { 1134 shortPieces[i] = regexEscape(shortPieces[i]); 1135 longPieces[i] = regexEscape(longPieces[i]); 1136 } 1137 for (i = 0; i < 24; i++) { 1138 mixedPieces[i] = regexEscape(mixedPieces[i]); 1139 } 1140 1141 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1142 this._monthsShortRegex = this._monthsRegex; 1143 this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); 1144 this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); 1145} 1146 1147function createDate (y, m, d, h, M, s, ms) { 1148 // can't just apply() to create a date: 1149 // https://stackoverflow.com/q/181348 1150 var date = new Date(y, m, d, h, M, s, ms); 1151 1152 // the date constructor remaps years 0-99 to 1900-1999 1153 if (y < 100 && y >= 0 && isFinite(date.getFullYear())) { 1154 date.setFullYear(y); 1155 } 1156 return date; 1157} 1158 1159function createUTCDate (y) { 1160 var date = new Date(Date.UTC.apply(null, arguments)); 1161 1162 // the Date.UTC function remaps years 0-99 to 1900-1999 1163 if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) { 1164 date.setUTCFullYear(y); 1165 } 1166 return date; 1167} 1168 1169// start-of-first-week - start-of-year 1170function firstWeekOffset(year, dow, doy) { 1171 var // first-week day -- which january is always in the first week (4 for iso, 1 for other) 1172 fwd = 7 + dow - doy, 1173 // first-week day local weekday -- which local weekday is fwd 1174 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; 1175 1176 return -fwdlw + fwd - 1; 1177} 1178 1179// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday 1180function dayOfYearFromWeeks(year, week, weekday, dow, doy) { 1181 var localWeekday = (7 + weekday - dow) % 7, 1182 weekOffset = firstWeekOffset(year, dow, doy), 1183 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, 1184 resYear, resDayOfYear; 1185 1186 if (dayOfYear <= 0) { 1187 resYear = year - 1; 1188 resDayOfYear = daysInYear(resYear) + dayOfYear; 1189 } else if (dayOfYear > daysInYear(year)) { 1190 resYear = year + 1; 1191 resDayOfYear = dayOfYear - daysInYear(year); 1192 } else { 1193 resYear = year; 1194 resDayOfYear = dayOfYear; 1195 } 1196 1197 return { 1198 year: resYear, 1199 dayOfYear: resDayOfYear 1200 }; 1201} 1202 1203function weekOfYear(mom, dow, doy) { 1204 var weekOffset = firstWeekOffset(mom.year(), dow, doy), 1205 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, 1206 resWeek, resYear; 1207 1208 if (week < 1) { 1209 resYear = mom.year() - 1; 1210 resWeek = week + weeksInYear(resYear, dow, doy); 1211 } else if (week > weeksInYear(mom.year(), dow, doy)) { 1212 resWeek = week - weeksInYear(mom.year(), dow, doy); 1213 resYear = mom.year() + 1; 1214 } else { 1215 resYear = mom.year(); 1216 resWeek = week; 1217 } 1218 1219 return { 1220 week: resWeek, 1221 year: resYear 1222 }; 1223} 1224 1225function weeksInYear(year, dow, doy) { 1226 var weekOffset = firstWeekOffset(year, dow, doy), 1227 weekOffsetNext = firstWeekOffset(year + 1, dow, doy); 1228 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; 1229} 1230 1231// FORMATTING 1232 1233addFormatToken('w', ['ww', 2], 'wo', 'week'); 1234addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); 1235 1236// ALIASES 1237 1238addUnitAlias('week', 'w'); 1239addUnitAlias('isoWeek', 'W'); 1240 1241// PRIORITIES 1242 1243addUnitPriority('week', 5); 1244addUnitPriority('isoWeek', 5); 1245 1246// PARSING 1247 1248addRegexToken('w', match1to2); 1249addRegexToken('ww', match1to2, match2); 1250addRegexToken('W', match1to2); 1251addRegexToken('WW', match1to2, match2); 1252 1253addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) { 1254 week[token.substr(0, 1)] = toInt(input); 1255}); 1256 1257// HELPERS 1258 1259// LOCALES 1260 1261function localeWeek (mom) { 1262 return weekOfYear(mom, this._week.dow, this._week.doy).week; 1263} 1264 1265var defaultLocaleWeek = { 1266 dow : 0, // Sunday is the first day of the week. 1267 doy : 6 // The week that contains Jan 1st is the first week of the year. 1268}; 1269 1270function localeFirstDayOfWeek () { 1271 return this._week.dow; 1272} 1273 1274function localeFirstDayOfYear () { 1275 return this._week.doy; 1276} 1277 1278// MOMENTS 1279 1280function getSetWeek (input) { 1281 var week = this.localeData().week(this); 1282 return input == null ? week : this.add((input - week) * 7, 'd'); 1283} 1284 1285function getSetISOWeek (input) { 1286 var week = weekOfYear(this, 1, 4).week; 1287 return input == null ? week : this.add((input - week) * 7, 'd'); 1288} 1289 1290// FORMATTING 1291 1292addFormatToken('d', 0, 'do', 'day'); 1293 1294addFormatToken('dd', 0, 0, function (format) { 1295 return this.localeData().weekdaysMin(this, format); 1296}); 1297 1298addFormatToken('ddd', 0, 0, function (format) { 1299 return this.localeData().weekdaysShort(this, format); 1300}); 1301 1302addFormatToken('dddd', 0, 0, function (format) { 1303 return this.localeData().weekdays(this, format); 1304}); 1305 1306addFormatToken('e', 0, 0, 'weekday'); 1307addFormatToken('E', 0, 0, 'isoWeekday'); 1308 1309// ALIASES 1310 1311addUnitAlias('day', 'd'); 1312addUnitAlias('weekday', 'e'); 1313addUnitAlias('isoWeekday', 'E'); 1314 1315// PRIORITY 1316addUnitPriority('day', 11); 1317addUnitPriority('weekday', 11); 1318addUnitPriority('isoWeekday', 11); 1319 1320// PARSING 1321 1322addRegexToken('d', match1to2); 1323addRegexToken('e', match1to2); 1324addRegexToken('E', match1to2); 1325addRegexToken('dd', function (isStrict, locale) { 1326 return locale.weekdaysMinRegex(isStrict); 1327}); 1328addRegexToken('ddd', function (isStrict, locale) { 1329 return locale.weekdaysShortRegex(isStrict); 1330}); 1331addRegexToken('dddd', function (isStrict, locale) { 1332 return locale.weekdaysRegex(isStrict); 1333}); 1334 1335addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { 1336 var weekday = config._locale.weekdaysParse(input, token, config._strict); 1337 // if we didn't get a weekday name, mark the date as invalid 1338 if (weekday != null) { 1339 week.d = weekday; 1340 } else { 1341 getParsingFlags(config).invalidWeekday = input; 1342 } 1343}); 1344 1345addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { 1346 week[token] = toInt(input); 1347}); 1348 1349// HELPERS 1350 1351function parseWeekday(input, locale) { 1352 if (typeof input !== 'string') { 1353 return input; 1354 } 1355 1356 if (!isNaN(input)) { 1357 return parseInt(input, 10); 1358 } 1359 1360 input = locale.weekdaysParse(input); 1361 if (typeof input === 'number') { 1362 return input; 1363 } 1364 1365 return null; 1366} 1367 1368function parseIsoWeekday(input, locale) { 1369 if (typeof input === 'string') { 1370 return locale.weekdaysParse(input) % 7 || 7; 1371 } 1372 return isNaN(input) ? null : input; 1373} 1374 1375// LOCALES 1376 1377var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); 1378function localeWeekdays (m, format) { 1379 if (!m) { 1380 return isArray(this._weekdays) ? this._weekdays : 1381 this._weekdays['standalone']; 1382 } 1383 return isArray(this._weekdays) ? this._weekdays[m.day()] : 1384 this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()]; 1385} 1386 1387var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); 1388function localeWeekdaysShort (m) { 1389 return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort; 1390} 1391 1392var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); 1393function localeWeekdaysMin (m) { 1394 return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin; 1395} 1396 1397function handleStrictParse$1(weekdayName, format, strict) { 1398 var i, ii, mom, llc = weekdayName.toLocaleLowerCase(); 1399 if (!this._weekdaysParse) { 1400 this._weekdaysParse = []; 1401 this._shortWeekdaysParse = []; 1402 this._minWeekdaysParse = []; 1403 1404 for (i = 0; i < 7; ++i) { 1405 mom = createUTC([2000, 1]).day(i); 1406 this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase(); 1407 this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase(); 1408 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); 1409 } 1410 } 1411 1412 if (strict) { 1413 if (format === 'dddd') { 1414 ii = indexOf.call(this._weekdaysParse, llc); 1415 return ii !== -1 ? ii : null; 1416 } else if (format === 'ddd') { 1417 ii = indexOf.call(this._shortWeekdaysParse, llc); 1418 return ii !== -1 ? ii : null; 1419 } else { 1420 ii = indexOf.call(this._minWeekdaysParse, llc); 1421 return ii !== -1 ? ii : null; 1422 } 1423 } else { 1424 if (format === 'dddd') { 1425 ii = indexOf.call(this._weekdaysParse, llc); 1426 if (ii !== -1) { 1427 return ii; 1428 } 1429 ii = indexOf.call(this._shortWeekdaysParse, llc); 1430 if (ii !== -1) { 1431 return ii; 1432 } 1433 ii = indexOf.call(this._minWeekdaysParse, llc); 1434 return ii !== -1 ? ii : null; 1435 } else if (format === 'ddd') { 1436 ii = indexOf.call(this._shortWeekdaysParse, llc); 1437 if (ii !== -1) { 1438 return ii; 1439 } 1440 ii = indexOf.call(this._weekdaysParse, llc); 1441 if (ii !== -1) { 1442 return ii; 1443 } 1444 ii = indexOf.call(this._minWeekdaysParse, llc); 1445 return ii !== -1 ? ii : null; 1446 } else { 1447 ii = indexOf.call(this._minWeekdaysParse, llc); 1448 if (ii !== -1) { 1449 return ii; 1450 } 1451 ii = indexOf.call(this._weekdaysParse, llc); 1452 if (ii !== -1) { 1453 return ii; 1454 } 1455 ii = indexOf.call(this._shortWeekdaysParse, llc); 1456 return ii !== -1 ? ii : null; 1457 } 1458 } 1459} 1460 1461function localeWeekdaysParse (weekdayName, format, strict) { 1462 var i, mom, regex; 1463 1464 if (this._weekdaysParseExact) { 1465 return handleStrictParse$1.call(this, weekdayName, format, strict); 1466 } 1467 1468 if (!this._weekdaysParse) { 1469 this._weekdaysParse = []; 1470 this._minWeekdaysParse = []; 1471 this._shortWeekdaysParse = []; 1472 this._fullWeekdaysParse = []; 1473 } 1474 1475 for (i = 0; i < 7; i++) { 1476 // make the regex if we don't have it already 1477 1478 mom = createUTC([2000, 1]).day(i); 1479 if (strict && !this._fullWeekdaysParse[i]) { 1480 this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i'); 1481 this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i'); 1482 this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i'); 1483 } 1484 if (!this._weekdaysParse[i]) { 1485 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, ''); 1486 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1487 } 1488 // test the regex 1489 if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) { 1490 return i; 1491 } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) { 1492 return i; 1493 } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) { 1494 return i; 1495 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { 1496 return i; 1497 } 1498 } 1499} 1500 1501// MOMENTS 1502 1503function getSetDayOfWeek (input) { 1504 if (!this.isValid()) { 1505 return input != null ? this : NaN; 1506 } 1507 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); 1508 if (input != null) { 1509 input = parseWeekday(input, this.localeData()); 1510 return this.add(input - day, 'd'); 1511 } else { 1512 return day; 1513 } 1514} 1515 1516function getSetLocaleDayOfWeek (input) { 1517 if (!this.isValid()) { 1518 return input != null ? this : NaN; 1519 } 1520 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; 1521 return input == null ? weekday : this.add(input - weekday, 'd'); 1522} 1523 1524function getSetISODayOfWeek (input) { 1525 if (!this.isValid()) { 1526 return input != null ? this : NaN; 1527 } 1528 1529 // behaves the same as moment#day except 1530 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) 1531 // as a setter, sunday should belong to the previous week. 1532 1533 if (input != null) { 1534 var weekday = parseIsoWeekday(input, this.localeData()); 1535 return this.day(this.day() % 7 ? weekday : weekday - 7); 1536 } else { 1537 return this.day() || 7; 1538 } 1539} 1540 1541var defaultWeekdaysRegex = matchWord; 1542function weekdaysRegex (isStrict) { 1543 if (this._weekdaysParseExact) { 1544 if (!hasOwnProp(this, '_weekdaysRegex')) { 1545 computeWeekdaysParse.call(this); 1546 } 1547 if (isStrict) { 1548 return this._weekdaysStrictRegex; 1549 } else { 1550 return this._weekdaysRegex; 1551 } 1552 } else { 1553 if (!hasOwnProp(this, '_weekdaysRegex')) { 1554 this._weekdaysRegex = defaultWeekdaysRegex; 1555 } 1556 return this._weekdaysStrictRegex && isStrict ? 1557 this._weekdaysStrictRegex : this._weekdaysRegex; 1558 } 1559} 1560 1561var defaultWeekdaysShortRegex = matchWord; 1562function weekdaysShortRegex (isStrict) { 1563 if (this._weekdaysParseExact) { 1564 if (!hasOwnProp(this, '_weekdaysRegex')) { 1565 computeWeekdaysParse.call(this); 1566 } 1567 if (isStrict) { 1568 return this._weekdaysShortStrictRegex; 1569 } else { 1570 return this._weekdaysShortRegex; 1571 } 1572 } else { 1573 if (!hasOwnProp(this, '_weekdaysShortRegex')) { 1574 this._weekdaysShortRegex = defaultWeekdaysShortRegex; 1575 } 1576 return this._weekdaysShortStrictRegex && isStrict ? 1577 this._weekdaysShortStrictRegex : this._weekdaysShortRegex; 1578 } 1579} 1580 1581var defaultWeekdaysMinRegex = matchWord; 1582function weekdaysMinRegex (isStrict) { 1583 if (this._weekdaysParseExact) { 1584 if (!hasOwnProp(this, '_weekdaysRegex')) { 1585 computeWeekdaysParse.call(this); 1586 } 1587 if (isStrict) { 1588 return this._weekdaysMinStrictRegex; 1589 } else { 1590 return this._weekdaysMinRegex; 1591 } 1592 } else { 1593 if (!hasOwnProp(this, '_weekdaysMinRegex')) { 1594 this._weekdaysMinRegex = defaultWeekdaysMinRegex; 1595 } 1596 return this._weekdaysMinStrictRegex && isStrict ? 1597 this._weekdaysMinStrictRegex : this._weekdaysMinRegex; 1598 } 1599} 1600 1601 1602function computeWeekdaysParse () { 1603 function cmpLenRev(a, b) { 1604 return b.length - a.length; 1605 } 1606 1607 var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], 1608 i, mom, minp, shortp, longp; 1609 for (i = 0; i < 7; i++) { 1610 // make the regex if we don't have it already 1611 mom = createUTC([2000, 1]).day(i); 1612 minp = this.weekdaysMin(mom, ''); 1613 shortp = this.weekdaysShort(mom, ''); 1614 longp = this.weekdays(mom, ''); 1615 minPieces.push(minp); 1616 shortPieces.push(shortp); 1617 longPieces.push(longp); 1618 mixedPieces.push(minp); 1619 mixedPieces.push(shortp); 1620 mixedPieces.push(longp); 1621 } 1622 // Sorting makes sure if one weekday (or abbr) is a prefix of another it 1623 // will match the longer piece. 1624 minPieces.sort(cmpLenRev); 1625 shortPieces.sort(cmpLenRev); 1626 longPieces.sort(cmpLenRev); 1627 mixedPieces.sort(cmpLenRev); 1628 for (i = 0; i < 7; i++) { 1629 shortPieces[i] = regexEscape(shortPieces[i]); 1630 longPieces[i] = regexEscape(longPieces[i]); 1631 mixedPieces[i] = regexEscape(mixedPieces[i]); 1632 } 1633 1634 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1635 this._weekdaysShortRegex = this._weekdaysRegex; 1636 this._weekdaysMinRegex = this._weekdaysRegex; 1637 1638 this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); 1639 this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); 1640 this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i'); 1641} 1642 1643// FORMATTING 1644 1645function hFormat() { 1646 return this.hours() % 12 || 12; 1647} 1648 1649function kFormat() { 1650 return this.hours() || 24; 1651} 1652 1653addFormatToken('H', ['HH', 2], 0, 'hour'); 1654addFormatToken('h', ['hh', 2], 0, hFormat); 1655addFormatToken('k', ['kk', 2], 0, kFormat); 1656 1657addFormatToken('hmm', 0, 0, function () { 1658 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); 1659}); 1660 1661addFormatToken('hmmss', 0, 0, function () { 1662 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + 1663 zeroFill(this.seconds(), 2); 1664}); 1665 1666addFormatToken('Hmm', 0, 0, function () { 1667 return '' + this.hours() + zeroFill(this.minutes(), 2); 1668}); 1669 1670addFormatToken('Hmmss', 0, 0, function () { 1671 return '' + this.hours() + zeroFill(this.minutes(), 2) + 1672 zeroFill(this.seconds(), 2); 1673}); 1674 1675function meridiem (token, lowercase) { 1676 addFormatToken(token, 0, 0, function () { 1677 return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); 1678 }); 1679} 1680 1681meridiem('a', true); 1682meridiem('A', false); 1683 1684// ALIASES 1685 1686addUnitAlias('hour', 'h'); 1687 1688// PRIORITY 1689addUnitPriority('hour', 13); 1690 1691// PARSING 1692 1693function matchMeridiem (isStrict, locale) { 1694 return locale._meridiemParse; 1695} 1696 1697addRegexToken('a', matchMeridiem); 1698addRegexToken('A', matchMeridiem); 1699addRegexToken('H', match1to2); 1700addRegexToken('h', match1to2); 1701addRegexToken('k', match1to2); 1702addRegexToken('HH', match1to2, match2); 1703addRegexToken('hh', match1to2, match2); 1704addRegexToken('kk', match1to2, match2); 1705 1706addRegexToken('hmm', match3to4); 1707addRegexToken('hmmss', match5to6); 1708addRegexToken('Hmm', match3to4); 1709addRegexToken('Hmmss', match5to6); 1710 1711addParseToken(['H', 'HH'], HOUR); 1712addParseToken(['k', 'kk'], function (input, array, config) { 1713 var kInput = toInt(input); 1714 array[HOUR] = kInput === 24 ? 0 : kInput; 1715}); 1716addParseToken(['a', 'A'], function (input, array, config) { 1717 config._isPm = config._locale.isPM(input); 1718 config._meridiem = input; 1719}); 1720addParseToken(['h', 'hh'], function (input, array, config) { 1721 array[HOUR] = toInt(input); 1722 getParsingFlags(config).bigHour = true; 1723}); 1724addParseToken('hmm', function (input, array, config) { 1725 var pos = input.length - 2; 1726 array[HOUR] = toInt(input.substr(0, pos)); 1727 array[MINUTE] = toInt(input.substr(pos)); 1728 getParsingFlags(config).bigHour = true; 1729}); 1730addParseToken('hmmss', function (input, array, config) { 1731 var pos1 = input.length - 4; 1732 var pos2 = input.length - 2; 1733 array[HOUR] = toInt(input.substr(0, pos1)); 1734 array[MINUTE] = toInt(input.substr(pos1, 2)); 1735 array[SECOND] = toInt(input.substr(pos2)); 1736 getParsingFlags(config).bigHour = true; 1737}); 1738addParseToken('Hmm', function (input, array, config) { 1739 var pos = input.length - 2; 1740 array[HOUR] = toInt(input.substr(0, pos)); 1741 array[MINUTE] = toInt(input.substr(pos)); 1742}); 1743addParseToken('Hmmss', function (input, array, config) { 1744 var pos1 = input.length - 4; 1745 var pos2 = input.length - 2; 1746 array[HOUR] = toInt(input.substr(0, pos1)); 1747 array[MINUTE] = toInt(input.substr(pos1, 2)); 1748 array[SECOND] = toInt(input.substr(pos2)); 1749}); 1750 1751// LOCALES 1752 1753function localeIsPM (input) { 1754 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays 1755 // Using charAt should be more compatible. 1756 return ((input + '').toLowerCase().charAt(0) === 'p'); 1757} 1758 1759var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i; 1760function localeMeridiem (hours, minutes, isLower) { 1761 if (hours > 11) { 1762 return isLower ? 'pm' : 'PM'; 1763 } else { 1764 return isLower ? 'am' : 'AM'; 1765 } 1766} 1767 1768 1769// MOMENTS 1770 1771// Setting the hour should keep the time, because the user explicitly 1772// specified which hour he wants. So trying to maintain the same hour (in 1773// a new timezone) makes sense. Adding/subtracting hours does not follow 1774// this rule. 1775var getSetHour = makeGetSet('Hours', true); 1776 1777// months 1778// week 1779// weekdays 1780// meridiem 1781var baseConfig = { 1782 calendar: defaultCalendar, 1783 longDateFormat: defaultLongDateFormat, 1784 invalidDate: defaultInvalidDate, 1785 ordinal: defaultOrdinal, 1786 dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, 1787 relativeTime: defaultRelativeTime, 1788 1789 months: defaultLocaleMonths, 1790 monthsShort: defaultLocaleMonthsShort, 1791 1792 week: defaultLocaleWeek, 1793 1794 weekdays: defaultLocaleWeekdays, 1795 weekdaysMin: defaultLocaleWeekdaysMin, 1796 weekdaysShort: defaultLocaleWeekdaysShort, 1797 1798 meridiemParse: defaultLocaleMeridiemParse 1799}; 1800 1801// internal storage for locale config files 1802var locales = {}; 1803var localeFamilies = {}; 1804var globalLocale; 1805 1806function normalizeLocale(key) { 1807 return key ? key.toLowerCase().replace('_', '-') : key; 1808} 1809 1810// pick the locale from the array 1811// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each 1812// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root 1813function chooseLocale(names) { 1814 var i = 0, j, next, locale, split; 1815 1816 while (i < names.length) { 1817 split = normalizeLocale(names[i]).split('-'); 1818 j = split.length; 1819 next = normalizeLocale(names[i + 1]); 1820 next = next ? next.split('-') : null; 1821 while (j > 0) { 1822 locale = loadLocale(split.slice(0, j).join('-')); 1823 if (locale) { 1824 return locale; 1825 } 1826 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) { 1827 //the next array item is better than a shallower substring of this one 1828 break; 1829 } 1830 j--; 1831 } 1832 i++; 1833 } 1834 return null; 1835} 1836 1837function loadLocale(name) { 1838 var oldLocale = null; 1839 // TODO: Find a better way to register and load all the locales in Node 1840 if (!locales[name] && (typeof module !== 'undefined') && 1841 module && module.exports) { 1842 try { 1843 oldLocale = globalLocale._abbr; 1844 var aliasedRequire = require; 1845 aliasedRequire('./locale/' + name); 1846 getSetGlobalLocale(oldLocale); 1847 } catch (e) {} 1848 } 1849 return locales[name]; 1850} 1851 1852// This function will load locale and then set the global locale. If 1853// no arguments are passed in, it will simply return the current global 1854// locale key. 1855function getSetGlobalLocale (key, values) { 1856 var data; 1857 if (key) { 1858 if (isUndefined(values)) { 1859 data = getLocale(key); 1860 } 1861 else { 1862 data = defineLocale(key, values); 1863 } 1864 1865 if (data) { 1866 // moment.duration._locale = moment._locale = data; 1867 globalLocale = data; 1868 } 1869 } 1870 1871 return globalLocale._abbr; 1872} 1873 1874function defineLocale (name, config) { 1875 if (config !== null) { 1876 var parentConfig = baseConfig; 1877 config.abbr = name; 1878 if (locales[name] != null) { 1879 deprecateSimple('defineLocaleOverride', 1880 'use moment.updateLocale(localeName, config) to change ' + 1881 'an existing locale. moment.defineLocale(localeName, ' + 1882 'config) should only be used for creating a new locale ' + 1883 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'); 1884 parentConfig = locales[name]._config; 1885 } else if (config.parentLocale != null) { 1886 if (locales[config.parentLocale] != null) { 1887 parentConfig = locales[config.parentLocale]._config; 1888 } else { 1889 if (!localeFamilies[config.parentLocale]) { 1890 localeFamilies[config.parentLocale] = []; 1891 } 1892 localeFamilies[config.parentLocale].push({ 1893 name: name, 1894 config: config 1895 }); 1896 return null; 1897 } 1898 } 1899 locales[name] = new Locale(mergeConfigs(parentConfig, config)); 1900 1901 if (localeFamilies[name]) { 1902 localeFamilies[name].forEach(function (x) { 1903 defineLocale(x.name, x.config); 1904 }); 1905 } 1906 1907 // backwards compat for now: also set the locale 1908 // make sure we set the locale AFTER all child locales have been 1909 // created, so we won't end up with the child locale set. 1910 getSetGlobalLocale(name); 1911 1912 1913 return locales[name]; 1914 } else { 1915 // useful for testing 1916 delete locales[name]; 1917 return null; 1918 } 1919} 1920 1921function updateLocale(name, config) { 1922 if (config != null) { 1923 var locale, parentConfig = baseConfig; 1924 // MERGE 1925 if (locales[name] != null) { 1926 parentConfig = locales[name]._config; 1927 } 1928 config = mergeConfigs(parentConfig, config); 1929 locale = new Locale(config); 1930 locale.parentLocale = locales[name]; 1931 locales[name] = locale; 1932 1933 // backwards compat for now: also set the locale 1934 getSetGlobalLocale(name); 1935 } else { 1936 // pass null for config to unupdate, useful for tests 1937 if (locales[name] != null) { 1938 if (locales[name].parentLocale != null) { 1939 locales[name] = locales[name].parentLocale; 1940 } else if (locales[name] != null) { 1941 delete locales[name]; 1942 } 1943 } 1944 } 1945 return locales[name]; 1946} 1947 1948// returns locale data 1949function getLocale (key) { 1950 var locale; 1951 1952 if (key && key._locale && key._locale._abbr) { 1953 key = key._locale._abbr; 1954 } 1955 1956 if (!key) { 1957 return globalLocale; 1958 } 1959 1960 if (!isArray(key)) { 1961 //short-circuit everything else 1962 locale = loadLocale(key); 1963 if (locale) { 1964 return locale; 1965 } 1966 key = [key]; 1967 } 1968 1969 return chooseLocale(key); 1970} 1971 1972function listLocales() { 1973 return keys(locales); 1974} 1975 1976function checkOverflow (m) { 1977 var overflow; 1978 var a = m._a; 1979 1980 if (a && getParsingFlags(m).overflow === -2) { 1981 overflow = 1982 a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : 1983 a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : 1984 a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR : 1985 a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : 1986 a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : 1987 a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : 1988 -1; 1989 1990 if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { 1991 overflow = DATE; 1992 } 1993 if (getParsingFlags(m)._overflowWeeks && overflow === -1) { 1994 overflow = WEEK; 1995 } 1996 if (getParsingFlags(m)._overflowWeekday && overflow === -1) { 1997 overflow = WEEKDAY; 1998 } 1999 2000 getParsingFlags(m).overflow = overflow; 2001 } 2002 2003 return m; 2004} 2005 2006// Pick the first defined of two or three arguments. 2007function defaults(a, b, c) { 2008 if (a != null) { 2009 return a; 2010 } 2011 if (b != null) { 2012 return b; 2013 } 2014 return c; 2015} 2016 2017function currentDateArray(config) { 2018 // hooks is actually the exported moment object 2019 var nowValue = new Date(hooks.now()); 2020 if (config._useUTC) { 2021 return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()]; 2022 } 2023 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; 2024} 2025 2026// convert an array to a date. 2027// the array should mirror the parameters below 2028// note: all values past the year are optional and will default to the lowest possible value. 2029// [year, month, day , hour, minute, second, millisecond] 2030function configFromArray (config) { 2031 var i, date, input = [], currentDate, yearToUse; 2032 2033 if (config._d) { 2034 return; 2035 } 2036 2037 currentDate = currentDateArray(config); 2038 2039 //compute day of the year from weeks and weekdays 2040 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { 2041 dayOfYearFromWeekInfo(config); 2042 } 2043 2044 //if the day of the year is set, figure out what it is 2045 if (config._dayOfYear != null) { 2046 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); 2047 2048 if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) { 2049 getParsingFlags(config)._overflowDayOfYear = true; 2050 } 2051 2052 date = createUTCDate(yearToUse, 0, config._dayOfYear); 2053 config._a[MONTH] = date.getUTCMonth(); 2054 config._a[DATE] = date.getUTCDate(); 2055 } 2056 2057 // Default to current date. 2058 // * if no year, month, day of month are given, default to today 2059 // * if day of month is given, default month and year 2060 // * if month is given, default only year 2061 // * if year is given, don't default anything 2062 for (i = 0; i < 3 && config._a[i] == null; ++i) { 2063 config._a[i] = input[i] = currentDate[i]; 2064 } 2065 2066 // Zero out whatever was not defaulted, including time 2067 for (; i < 7; i++) { 2068 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i]; 2069 } 2070 2071 // Check for 24:00:00.000 2072 if (config._a[HOUR] === 24 && 2073 config._a[MINUTE] === 0 && 2074 config._a[SECOND] === 0 && 2075 config._a[MILLISECOND] === 0) { 2076 config._nextDay = true; 2077 config._a[HOUR] = 0; 2078 } 2079 2080 config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); 2081 // Apply timezone offset from input. The actual utcOffset can be changed 2082 // with parseZone. 2083 if (config._tzm != null) { 2084 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2085 } 2086 2087 if (config._nextDay) { 2088 config._a[HOUR] = 24; 2089 } 2090 2091 // check for mismatching day of week 2092 if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== config._d.getDay()) { 2093 getParsingFlags(config).weekdayMismatch = true; 2094 } 2095} 2096 2097function dayOfYearFromWeekInfo(config) { 2098 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow; 2099 2100 w = config._w; 2101 if (w.GG != null || w.W != null || w.E != null) { 2102 dow = 1; 2103 doy = 4; 2104 2105 // TODO: We need to take the current isoWeekYear, but that depends on 2106 // how we interpret now (local, utc, fixed offset). So create 2107 // a now version of current config (take local/utc/offset flags, and 2108 // create now). 2109 weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year); 2110 week = defaults(w.W, 1); 2111 weekday = defaults(w.E, 1); 2112 if (weekday < 1 || weekday > 7) { 2113 weekdayOverflow = true; 2114 } 2115 } else { 2116 dow = config._locale._week.dow; 2117 doy = config._locale._week.doy; 2118 2119 var curWeek = weekOfYear(createLocal(), dow, doy); 2120 2121 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); 2122 2123 // Default to current week. 2124 week = defaults(w.w, curWeek.week); 2125 2126 if (w.d != null) { 2127 // weekday -- low day numbers are considered next week 2128 weekday = w.d; 2129 if (weekday < 0 || weekday > 6) { 2130 weekdayOverflow = true; 2131 } 2132 } else if (w.e != null) { 2133 // local weekday -- counting starts from begining of week 2134 weekday = w.e + dow; 2135 if (w.e < 0 || w.e > 6) { 2136 weekdayOverflow = true; 2137 } 2138 } else { 2139 // default to begining of week 2140 weekday = dow; 2141 } 2142 } 2143 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { 2144 getParsingFlags(config)._overflowWeeks = true; 2145 } else if (weekdayOverflow != null) { 2146 getParsingFlags(config)._overflowWeekday = true; 2147 } else { 2148 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); 2149 config._a[YEAR] = temp.year; 2150 config._dayOfYear = temp.dayOfYear; 2151 } 2152} 2153 2154// iso 8601 regex 2155// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00) 2156var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; 2157var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; 2158 2159var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/; 2160 2161var isoDates = [ 2162 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], 2163 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], 2164 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], 2165 ['GGGG-[W]WW', /\d{4}-W\d\d/, false], 2166 ['YYYY-DDD', /\d{4}-\d{3}/], 2167 ['YYYY-MM', /\d{4}-\d\d/, false], 2168 ['YYYYYYMMDD', /[+-]\d{10}/], 2169 ['YYYYMMDD', /\d{8}/], 2170 // YYYYMM is NOT allowed by the standard 2171 ['GGGG[W]WWE', /\d{4}W\d{3}/], 2172 ['GGGG[W]WW', /\d{4}W\d{2}/, false], 2173 ['YYYYDDD', /\d{7}/] 2174]; 2175 2176// iso time formats and regexes 2177var isoTimes = [ 2178 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], 2179 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], 2180 ['HH:mm:ss', /\d\d:\d\d:\d\d/], 2181 ['HH:mm', /\d\d:\d\d/], 2182 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], 2183 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], 2184 ['HHmmss', /\d\d\d\d\d\d/], 2185 ['HHmm', /\d\d\d\d/], 2186 ['HH', /\d\d/] 2187]; 2188 2189var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i; 2190 2191// date from iso format 2192function configFromISO(config) { 2193 var i, l, 2194 string = config._i, 2195 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), 2196 allowTime, dateFormat, timeFormat, tzFormat; 2197 2198 if (match) { 2199 getParsingFlags(config).iso = true; 2200 2201 for (i = 0, l = isoDates.length; i < l; i++) { 2202 if (isoDates[i][1].exec(match[1])) { 2203 dateFormat = isoDates[i][0]; 2204 allowTime = isoDates[i][2] !== false; 2205 break; 2206 } 2207 } 2208 if (dateFormat == null) { 2209 config._isValid = false; 2210 return; 2211 } 2212 if (match[3]) { 2213 for (i = 0, l = isoTimes.length; i < l; i++) { 2214 if (isoTimes[i][1].exec(match[3])) { 2215 // match[2] should be 'T' or space 2216 timeFormat = (match[2] || ' ') + isoTimes[i][0]; 2217 break; 2218 } 2219 } 2220 if (timeFormat == null) { 2221 config._isValid = false; 2222 return; 2223 } 2224 } 2225 if (!allowTime && timeFormat != null) { 2226 config._isValid = false; 2227 return; 2228 } 2229 if (match[4]) { 2230 if (tzRegex.exec(match[4])) { 2231 tzFormat = 'Z'; 2232 } else { 2233 config._isValid = false; 2234 return; 2235 } 2236 } 2237 config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); 2238 configFromStringAndFormat(config); 2239 } else { 2240 config._isValid = false; 2241 } 2242} 2243 2244// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 2245var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/; 2246 2247function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { 2248 var result = [ 2249 untruncateYear(yearStr), 2250 defaultLocaleMonthsShort.indexOf(monthStr), 2251 parseInt(dayStr, 10), 2252 parseInt(hourStr, 10), 2253 parseInt(minuteStr, 10) 2254 ]; 2255 2256 if (secondStr) { 2257 result.push(parseInt(secondStr, 10)); 2258 } 2259 2260 return result; 2261} 2262 2263function untruncateYear(yearStr) { 2264 var year = parseInt(yearStr, 10); 2265 if (year <= 49) { 2266 return 2000 + year; 2267 } else if (year <= 999) { 2268 return 1900 + year; 2269 } 2270 return year; 2271} 2272 2273function preprocessRFC2822(s) { 2274 // Remove comments and folding whitespace and replace multiple-spaces with a single space 2275 return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').trim(); 2276} 2277 2278function checkWeekday(weekdayStr, parsedInput, config) { 2279 if (weekdayStr) { 2280 // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check. 2281 var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), 2282 weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay(); 2283 if (weekdayProvided !== weekdayActual) { 2284 getParsingFlags(config).weekdayMismatch = true; 2285 config._isValid = false; 2286 return false; 2287 } 2288 } 2289 return true; 2290} 2291 2292var obsOffsets = { 2293 UT: 0, 2294 GMT: 0, 2295 EDT: -4 * 60, 2296 EST: -5 * 60, 2297 CDT: -5 * 60, 2298 CST: -6 * 60, 2299 MDT: -6 * 60, 2300 MST: -7 * 60, 2301 PDT: -7 * 60, 2302 PST: -8 * 60 2303}; 2304 2305function calculateOffset(obsOffset, militaryOffset, numOffset) { 2306 if (obsOffset) { 2307 return obsOffsets[obsOffset]; 2308 } else if (militaryOffset) { 2309 // the only allowed military tz is Z 2310 return 0; 2311 } else { 2312 var hm = parseInt(numOffset, 10); 2313 var m = hm % 100, h = (hm - m) / 100; 2314 return h * 60 + m; 2315 } 2316} 2317 2318// date and time from ref 2822 format 2319function configFromRFC2822(config) { 2320 var match = rfc2822.exec(preprocessRFC2822(config._i)); 2321 if (match) { 2322 var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]); 2323 if (!checkWeekday(match[1], parsedArray, config)) { 2324 return; 2325 } 2326 2327 config._a = parsedArray; 2328 config._tzm = calculateOffset(match[8], match[9], match[10]); 2329 2330 config._d = createUTCDate.apply(null, config._a); 2331 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2332 2333 getParsingFlags(config).rfc2822 = true; 2334 } else { 2335 config._isValid = false; 2336 } 2337} 2338 2339// date from iso format or fallback 2340function configFromString(config) { 2341 var matched = aspNetJsonRegex.exec(config._i); 2342 2343 if (matched !== null) { 2344 config._d = new Date(+matched[1]); 2345 return; 2346 } 2347 2348 configFromISO(config); 2349 if (config._isValid === false) { 2350 delete config._isValid; 2351 } else { 2352 return; 2353 } 2354 2355 configFromRFC2822(config); 2356 if (config._isValid === false) { 2357 delete config._isValid; 2358 } else { 2359 return; 2360 } 2361 2362 // Final attempt, use Input Fallback 2363 hooks.createFromInputFallback(config); 2364} 2365 2366hooks.createFromInputFallback = deprecate( 2367 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 2368 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 2369 'discouraged and will be removed in an upcoming major release. Please refer to ' + 2370 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', 2371 function (config) { 2372 config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); 2373 } 2374); 2375 2376// constant that refers to the ISO standard 2377hooks.ISO_8601 = function () {}; 2378 2379// constant that refers to the RFC 2822 form 2380hooks.RFC_2822 = function () {}; 2381 2382// date from string and format string 2383function configFromStringAndFormat(config) { 2384 // TODO: Move this to another part of the creation flow to prevent circular deps 2385 if (config._f === hooks.ISO_8601) { 2386 configFromISO(config); 2387 return; 2388 } 2389 if (config._f === hooks.RFC_2822) { 2390 configFromRFC2822(config); 2391 return; 2392 } 2393 config._a = []; 2394 getParsingFlags(config).empty = true; 2395 2396 // This array is used to make a Date, either with `new Date` or `Date.UTC` 2397 var string = '' + config._i, 2398 i, parsedInput, tokens, token, skipped, 2399 stringLength = string.length, 2400 totalParsedInputLength = 0; 2401 2402 tokens = expandFormat(config._f, config._locale).match(formattingTokens) || []; 2403 2404 for (i = 0; i < tokens.length; i++) { 2405 token = tokens[i]; 2406 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0]; 2407 // console.log('token', token, 'parsedInput', parsedInput, 2408 // 'regex', getParseRegexForToken(token, config)); 2409 if (parsedInput) { 2410 skipped = string.substr(0, string.indexOf(parsedInput)); 2411 if (skipped.length > 0) { 2412 getParsingFlags(config).unusedInput.push(skipped); 2413 } 2414 string = string.slice(string.indexOf(parsedInput) + parsedInput.length); 2415 totalParsedInputLength += parsedInput.length; 2416 } 2417 // don't parse if it's not a known token 2418 if (formatTokenFunctions[token]) { 2419 if (parsedInput) { 2420 getParsingFlags(config).empty = false; 2421 } 2422 else { 2423 getParsingFlags(config).unusedTokens.push(token); 2424 } 2425 addTimeToArrayFromToken(token, parsedInput, config); 2426 } 2427 else if (config._strict && !parsedInput) { 2428 getParsingFlags(config).unusedTokens.push(token); 2429 } 2430 } 2431 2432 // add remaining unparsed input length to the string 2433 getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; 2434 if (string.length > 0) { 2435 getParsingFlags(config).unusedInput.push(string); 2436 } 2437 2438 // clear _12h flag if hour is <= 12 2439 if (config._a[HOUR] <= 12 && 2440 getParsingFlags(config).bigHour === true && 2441 config._a[HOUR] > 0) { 2442 getParsingFlags(config).bigHour = undefined; 2443 } 2444 2445 getParsingFlags(config).parsedDateParts = config._a.slice(0); 2446 getParsingFlags(config).meridiem = config._meridiem; 2447 // handle meridiem 2448 config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); 2449 2450 configFromArray(config); 2451 checkOverflow(config); 2452} 2453 2454 2455function meridiemFixWrap (locale, hour, meridiem) { 2456 var isPm; 2457 2458 if (meridiem == null) { 2459 // nothing to do 2460 return hour; 2461 } 2462 if (locale.meridiemHour != null) { 2463 return locale.meridiemHour(hour, meridiem); 2464 } else if (locale.isPM != null) { 2465 // Fallback 2466 isPm = locale.isPM(meridiem); 2467 if (isPm && hour < 12) { 2468 hour += 12; 2469 } 2470 if (!isPm && hour === 12) { 2471 hour = 0; 2472 } 2473 return hour; 2474 } else { 2475 // this is not supposed to happen 2476 return hour; 2477 } 2478} 2479 2480// date from string and array of format strings 2481function configFromStringAndArray(config) { 2482 var tempConfig, 2483 bestMoment, 2484 2485 scoreToBeat, 2486 i, 2487 currentScore; 2488 2489 if (config._f.length === 0) { 2490 getParsingFlags(config).invalidFormat = true; 2491 config._d = new Date(NaN); 2492 return; 2493 } 2494 2495 for (i = 0; i < config._f.length; i++) { 2496 currentScore = 0; 2497 tempConfig = copyConfig({}, config); 2498 if (config._useUTC != null) { 2499 tempConfig._useUTC = config._useUTC; 2500 } 2501 tempConfig._f = config._f[i]; 2502 configFromStringAndFormat(tempConfig); 2503 2504 if (!isValid(tempConfig)) { 2505 continue; 2506 } 2507 2508 // if there is any input that was not parsed add a penalty for that format 2509 currentScore += getParsingFlags(tempConfig).charsLeftOver; 2510 2511 //or tokens 2512 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; 2513 2514 getParsingFlags(tempConfig).score = currentScore; 2515 2516 if (scoreToBeat == null || currentScore < scoreToBeat) { 2517 scoreToBeat = currentScore; 2518 bestMoment = tempConfig; 2519 } 2520 } 2521 2522 extend(config, bestMoment || tempConfig); 2523} 2524 2525function configFromObject(config) { 2526 if (config._d) { 2527 return; 2528 } 2529 2530 var i = normalizeObjectUnits(config._i); 2531 config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) { 2532 return obj && parseInt(obj, 10); 2533 }); 2534 2535 configFromArray(config); 2536} 2537 2538function createFromConfig (config) { 2539 var res = new Moment(checkOverflow(prepareConfig(config))); 2540 if (res._nextDay) { 2541 // Adding is smart enough around DST 2542 res.add(1, 'd'); 2543 res._nextDay = undefined; 2544 } 2545 2546 return res; 2547} 2548 2549function prepareConfig (config) { 2550 var input = config._i, 2551 format = config._f; 2552 2553 config._locale = config._locale || getLocale(config._l); 2554 2555 if (input === null || (format === undefined && input === '')) { 2556 return createInvalid({nullInput: true}); 2557 } 2558 2559 if (typeof input === 'string') { 2560 config._i = input = config._locale.preparse(input); 2561 } 2562 2563 if (isMoment(input)) { 2564 return new Moment(checkOverflow(input)); 2565 } else if (isDate(input)) { 2566 config._d = input; 2567 } else if (isArray(format)) { 2568 configFromStringAndArray(config); 2569 } else if (format) { 2570 configFromStringAndFormat(config); 2571 } else { 2572 configFromInput(config); 2573 } 2574 2575 if (!isValid(config)) { 2576 config._d = null; 2577 } 2578 2579 return config; 2580} 2581 2582function configFromInput(config) { 2583 var input = config._i; 2584 if (isUndefined(input)) { 2585 config._d = new Date(hooks.now()); 2586 } else if (isDate(input)) { 2587 config._d = new Date(input.valueOf()); 2588 } else if (typeof input === 'string') { 2589 configFromString(config); 2590 } else if (isArray(input)) { 2591 config._a = map(input.slice(0), function (obj) { 2592 return parseInt(obj, 10); 2593 }); 2594 configFromArray(config); 2595 } else if (isObject(input)) { 2596 configFromObject(config); 2597 } else if (isNumber(input)) { 2598 // from milliseconds 2599 config._d = new Date(input); 2600 } else { 2601 hooks.createFromInputFallback(config); 2602 } 2603} 2604 2605function createLocalOrUTC (input, format, locale, strict, isUTC) { 2606 var c = {}; 2607 2608 if (locale === true || locale === false) { 2609 strict = locale; 2610 locale = undefined; 2611 } 2612 2613 if ((isObject(input) && isObjectEmpty(input)) || 2614 (isArray(input) && input.length === 0)) { 2615 input = undefined; 2616 } 2617 // object construction must be done this way. 2618 // https://github.com/moment/moment/issues/1423 2619 c._isAMomentObject = true; 2620 c._useUTC = c._isUTC = isUTC; 2621 c._l = locale; 2622 c._i = input; 2623 c._f = format; 2624 c._strict = strict; 2625 2626 return createFromConfig(c); 2627} 2628 2629function createLocal (input, format, locale, strict) { 2630 return createLocalOrUTC(input, format, locale, strict, false); 2631} 2632 2633var prototypeMin = deprecate( 2634 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', 2635 function () { 2636 var other = createLocal.apply(null, arguments); 2637 if (this.isValid() && other.isValid()) { 2638 return other < this ? this : other; 2639 } else { 2640 return createInvalid(); 2641 } 2642 } 2643); 2644 2645var prototypeMax = deprecate( 2646 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', 2647 function () { 2648 var other = createLocal.apply(null, arguments); 2649 if (this.isValid() && other.isValid()) { 2650 return other > this ? this : other; 2651 } else { 2652 return createInvalid(); 2653 } 2654 } 2655); 2656 2657// Pick a moment m from moments so that m[fn](other) is true for all 2658// other. This relies on the function fn to be transitive. 2659// 2660// moments should either be an array of moment objects or an array, whose 2661// first element is an array of moment objects. 2662function pickBy(fn, moments) { 2663 var res, i; 2664 if (moments.length === 1 && isArray(moments[0])) { 2665 moments = moments[0]; 2666 } 2667 if (!moments.length) { 2668 return createLocal(); 2669 } 2670 res = moments[0]; 2671 for (i = 1; i < moments.length; ++i) { 2672 if (!moments[i].isValid() || moments[i][fn](res)) { 2673 res = moments[i]; 2674 } 2675 } 2676 return res; 2677} 2678 2679// TODO: Use [].sort instead? 2680function min () { 2681 var args = [].slice.call(arguments, 0); 2682 2683 return pickBy('isBefore', args); 2684} 2685 2686function max () { 2687 var args = [].slice.call(arguments, 0); 2688 2689 return pickBy('isAfter', args); 2690} 2691 2692var now = function () { 2693 return Date.now ? Date.now() : +(new Date()); 2694}; 2695 2696var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond']; 2697 2698function isDurationValid(m) { 2699 for (var key in m) { 2700 if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) { 2701 return false; 2702 } 2703 } 2704 2705 var unitHasDecimal = false; 2706 for (var i = 0; i < ordering.length; ++i) { 2707 if (m[ordering[i]]) { 2708 if (unitHasDecimal) { 2709 return false; // only allow non-integers for smallest unit 2710 } 2711 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { 2712 unitHasDecimal = true; 2713 } 2714 } 2715 } 2716 2717 return true; 2718} 2719 2720function isValid$1() { 2721 return this._isValid; 2722} 2723 2724function createInvalid$1() { 2725 return createDuration(NaN); 2726} 2727 2728function Duration (duration) { 2729 var normalizedInput = normalizeObjectUnits(duration), 2730 years = normalizedInput.year || 0, 2731 quarters = normalizedInput.quarter || 0, 2732 months = normalizedInput.month || 0, 2733 weeks = normalizedInput.week || 0, 2734 days = normalizedInput.day || 0, 2735 hours = normalizedInput.hour || 0, 2736 minutes = normalizedInput.minute || 0, 2737 seconds = normalizedInput.second || 0, 2738 milliseconds = normalizedInput.millisecond || 0; 2739 2740 this._isValid = isDurationValid(normalizedInput); 2741 2742 // representation for dateAddRemove 2743 this._milliseconds = +milliseconds + 2744 seconds * 1e3 + // 1000 2745 minutes * 6e4 + // 1000 * 60 2746 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 2747 // Because of dateAddRemove treats 24 hours as different from a 2748 // day when working around DST, we need to store them separately 2749 this._days = +days + 2750 weeks * 7; 2751 // It is impossible to translate months into days without knowing 2752 // which months you are are talking about, so we have to store 2753 // it separately. 2754 this._months = +months + 2755 quarters * 3 + 2756 years * 12; 2757 2758 this._data = {}; 2759 2760 this._locale = getLocale(); 2761 2762 this._bubble(); 2763} 2764 2765function isDuration (obj) { 2766 return obj instanceof Duration; 2767} 2768 2769function absRound (number) { 2770 if (number < 0) { 2771 return Math.round(-1 * number) * -1; 2772 } else { 2773 return Math.round(number); 2774 } 2775} 2776 2777// FORMATTING 2778 2779function offset (token, separator) { 2780 addFormatToken(token, 0, 0, function () { 2781 var offset = this.utcOffset(); 2782 var sign = '+'; 2783 if (offset < 0) { 2784 offset = -offset; 2785 sign = '-'; 2786 } 2787 return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2); 2788 }); 2789} 2790 2791offset('Z', ':'); 2792offset('ZZ', ''); 2793 2794// PARSING 2795 2796addRegexToken('Z', matchShortOffset); 2797addRegexToken('ZZ', matchShortOffset); 2798addParseToken(['Z', 'ZZ'], function (input, array, config) { 2799 config._useUTC = true; 2800 config._tzm = offsetFromString(matchShortOffset, input); 2801}); 2802 2803// HELPERS 2804 2805// timezone chunker 2806// '+10:00' > ['10', '00'] 2807// '-1530' > ['-15', '30'] 2808var chunkOffset = /([\+\-]|\d\d)/gi; 2809 2810function offsetFromString(matcher, string) { 2811 var matches = (string || '').match(matcher); 2812 2813 if (matches === null) { 2814 return null; 2815 } 2816 2817 var chunk = matches[matches.length - 1] || []; 2818 var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; 2819 var minutes = +(parts[1] * 60) + toInt(parts[2]); 2820 2821 return minutes === 0 ? 2822 0 : 2823 parts[0] === '+' ? minutes : -minutes; 2824} 2825 2826// Return a moment from input, that is local/utc/zone equivalent to model. 2827function cloneWithOffset(input, model) { 2828 var res, diff; 2829 if (model._isUTC) { 2830 res = model.clone(); 2831 diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf(); 2832 // Use low-level api, because this fn is low-level api. 2833 res._d.setTime(res._d.valueOf() + diff); 2834 hooks.updateOffset(res, false); 2835 return res; 2836 } else { 2837 return createLocal(input).local(); 2838 } 2839} 2840 2841function getDateOffset (m) { 2842 // On Firefox.24 Date#getTimezoneOffset returns a floating point. 2843 // https://github.com/moment/moment/pull/1871 2844 return -Math.round(m._d.getTimezoneOffset() / 15) * 15; 2845} 2846 2847// HOOKS 2848 2849// This function will be called whenever a moment is mutated. 2850// It is intended to keep the offset in sync with the timezone. 2851hooks.updateOffset = function () {}; 2852 2853// MOMENTS 2854 2855// keepLocalTime = true means only change the timezone, without 2856// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> 2857// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset 2858// +0200, so we adjust the time as needed, to be valid. 2859// 2860// Keeping the time actually adds/subtracts (one hour) 2861// from the actual represented time. That is why we call updateOffset 2862// a second time. In case it wants us to change the offset again 2863// _changeInProgress == true case, then we have to adjust, because 2864// there is no such time in the given timezone. 2865function getSetOffset (input, keepLocalTime, keepMinutes) { 2866 var offset = this._offset || 0, 2867 localAdjust; 2868 if (!this.isValid()) { 2869 return input != null ? this : NaN; 2870 } 2871 if (input != null) { 2872 if (typeof input === 'string') { 2873 input = offsetFromString(matchShortOffset, input); 2874 if (input === null) { 2875 return this; 2876 } 2877 } else if (Math.abs(input) < 16 && !keepMinutes) { 2878 input = input * 60; 2879 } 2880 if (!this._isUTC && keepLocalTime) { 2881 localAdjust = getDateOffset(this); 2882 } 2883 this._offset = input; 2884 this._isUTC = true; 2885 if (localAdjust != null) { 2886 this.add(localAdjust, 'm'); 2887 } 2888 if (offset !== input) { 2889 if (!keepLocalTime || this._changeInProgress) { 2890 addSubtract(this, createDuration(input - offset, 'm'), 1, false); 2891 } else if (!this._changeInProgress) { 2892 this._changeInProgress = true; 2893 hooks.updateOffset(this, true); 2894 this._changeInProgress = null; 2895 } 2896 } 2897 return this; 2898 } else { 2899 return this._isUTC ? offset : getDateOffset(this); 2900 } 2901} 2902 2903function getSetZone (input, keepLocalTime) { 2904 if (input != null) { 2905 if (typeof input !== 'string') { 2906 input = -input; 2907 } 2908 2909 this.utcOffset(input, keepLocalTime); 2910 2911 return this; 2912 } else { 2913 return -this.utcOffset(); 2914 } 2915} 2916 2917function setOffsetToUTC (keepLocalTime) { 2918 return this.utcOffset(0, keepLocalTime); 2919} 2920 2921function setOffsetToLocal (keepLocalTime) { 2922 if (this._isUTC) { 2923 this.utcOffset(0, keepLocalTime); 2924 this._isUTC = false; 2925 2926 if (keepLocalTime) { 2927 this.subtract(getDateOffset(this), 'm'); 2928 } 2929 } 2930 return this; 2931} 2932 2933function setOffsetToParsedOffset () { 2934 if (this._tzm != null) { 2935 this.utcOffset(this._tzm, false, true); 2936 } else if (typeof this._i === 'string') { 2937 var tZone = offsetFromString(matchOffset, this._i); 2938 if (tZone != null) { 2939 this.utcOffset(tZone); 2940 } 2941 else { 2942 this.utcOffset(0, true); 2943 } 2944 } 2945 return this; 2946} 2947 2948function hasAlignedHourOffset (input) { 2949 if (!this.isValid()) { 2950 return false; 2951 } 2952 input = input ? createLocal(input).utcOffset() : 0; 2953 2954 return (this.utcOffset() - input) % 60 === 0; 2955} 2956 2957function isDaylightSavingTime () { 2958 return ( 2959 this.utcOffset() > this.clone().month(0).utcOffset() || 2960 this.utcOffset() > this.clone().month(5).utcOffset() 2961 ); 2962} 2963 2964function isDaylightSavingTimeShifted () { 2965 if (!isUndefined(this._isDSTShifted)) { 2966 return this._isDSTShifted; 2967 } 2968 2969 var c = {}; 2970 2971 copyConfig(c, this); 2972 c = prepareConfig(c); 2973 2974 if (c._a) { 2975 var other = c._isUTC ? createUTC(c._a) : createLocal(c._a); 2976 this._isDSTShifted = this.isValid() && 2977 compareArrays(c._a, other.toArray()) > 0; 2978 } else { 2979 this._isDSTShifted = false; 2980 } 2981 2982 return this._isDSTShifted; 2983} 2984 2985function isLocal () { 2986 return this.isValid() ? !this._isUTC : false; 2987} 2988 2989function isUtcOffset () { 2990 return this.isValid() ? this._isUTC : false; 2991} 2992 2993function isUtc () { 2994 return this.isValid() ? this._isUTC && this._offset === 0 : false; 2995} 2996 2997// ASP.NET json date format regex 2998var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/; 2999 3000// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html 3001// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere 3002// and further modified to allow for strings containing both week and day 3003var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; 3004 3005function createDuration (input, key) { 3006 var duration = input, 3007 // matching against regexp is expensive, do it on demand 3008 match = null, 3009 sign, 3010 ret, 3011 diffRes; 3012 3013 if (isDuration(input)) { 3014 duration = { 3015 ms : input._milliseconds, 3016 d : input._days, 3017 M : input._months 3018 }; 3019 } else if (isNumber(input)) { 3020 duration = {}; 3021 if (key) { 3022 duration[key] = input; 3023 } else { 3024 duration.milliseconds = input; 3025 } 3026 } else if (!!(match = aspNetRegex.exec(input))) { 3027 sign = (match[1] === '-') ? -1 : 1; 3028 duration = { 3029 y : 0, 3030 d : toInt(match[DATE]) * sign, 3031 h : toInt(match[HOUR]) * sign, 3032 m : toInt(match[MINUTE]) * sign, 3033 s : toInt(match[SECOND]) * sign, 3034 ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match 3035 }; 3036 } else if (!!(match = isoRegex.exec(input))) { 3037 sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1; 3038 duration = { 3039 y : parseIso(match[2], sign), 3040 M : parseIso(match[3], sign), 3041 w : parseIso(match[4], sign), 3042 d : parseIso(match[5], sign), 3043 h : parseIso(match[6], sign), 3044 m : parseIso(match[7], sign), 3045 s : parseIso(match[8], sign) 3046 }; 3047 } else if (duration == null) {// checks for null or undefined 3048 duration = {}; 3049 } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) { 3050 diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to)); 3051 3052 duration = {}; 3053 duration.ms = diffRes.milliseconds; 3054 duration.M = diffRes.months; 3055 } 3056 3057 ret = new Duration(duration); 3058 3059 if (isDuration(input) && hasOwnProp(input, '_locale')) { 3060 ret._locale = input._locale; 3061 } 3062 3063 return ret; 3064} 3065 3066createDuration.fn = Duration.prototype; 3067createDuration.invalid = createInvalid$1; 3068 3069function parseIso (inp, sign) { 3070 // We'd normally use ~~inp for this, but unfortunately it also 3071 // converts floats to ints. 3072 // inp may be undefined, so careful calling replace on it. 3073 var res = inp && parseFloat(inp.replace(',', '.')); 3074 // apply sign while we're at it 3075 return (isNaN(res) ? 0 : res) * sign; 3076} 3077 3078function positiveMomentsDifference(base, other) { 3079 var res = {milliseconds: 0, months: 0}; 3080 3081 res.months = other.month() - base.month() + 3082 (other.year() - base.year()) * 12; 3083 if (base.clone().add(res.months, 'M').isAfter(other)) { 3084 --res.months; 3085 } 3086 3087 res.milliseconds = +other - +(base.clone().add(res.months, 'M')); 3088 3089 return res; 3090} 3091 3092function momentsDifference(base, other) { 3093 var res; 3094 if (!(base.isValid() && other.isValid())) { 3095 return {milliseconds: 0, months: 0}; 3096 } 3097 3098 other = cloneWithOffset(other, base); 3099 if (base.isBefore(other)) { 3100 res = positiveMomentsDifference(base, other); 3101 } else { 3102 res = positiveMomentsDifference(other, base); 3103 res.milliseconds = -res.milliseconds; 3104 res.months = -res.months; 3105 } 3106 3107 return res; 3108} 3109 3110// TODO: remove 'name' arg after deprecation is removed 3111function createAdder(direction, name) { 3112 return function (val, period) { 3113 var dur, tmp; 3114 //invert the arguments, but complain about it 3115 if (period !== null && !isNaN(+period)) { 3116 deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + 3117 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'); 3118 tmp = val; val = period; period = tmp; 3119 } 3120 3121 val = typeof val === 'string' ? +val : val; 3122 dur = createDuration(val, period); 3123 addSubtract(this, dur, direction); 3124 return this; 3125 }; 3126} 3127 3128function addSubtract (mom, duration, isAdding, updateOffset) { 3129 var milliseconds = duration._milliseconds, 3130 days = absRound(duration._days), 3131 months = absRound(duration._months); 3132 3133 if (!mom.isValid()) { 3134 // No op 3135 return; 3136 } 3137 3138 updateOffset = updateOffset == null ? true : updateOffset; 3139 3140 if (months) { 3141 setMonth(mom, get(mom, 'Month') + months * isAdding); 3142 } 3143 if (days) { 3144 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); 3145 } 3146 if (milliseconds) { 3147 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); 3148 } 3149 if (updateOffset) { 3150 hooks.updateOffset(mom, days || months); 3151 } 3152} 3153 3154var add = createAdder(1, 'add'); 3155var subtract = createAdder(-1, 'subtract'); 3156 3157function getCalendarFormat(myMoment, now) { 3158 var diff = myMoment.diff(now, 'days', true); 3159 return diff < -6 ? 'sameElse' : 3160 diff < -1 ? 'lastWeek' : 3161 diff < 0 ? 'lastDay' : 3162 diff < 1 ? 'sameDay' : 3163 diff < 2 ? 'nextDay' : 3164 diff < 7 ? 'nextWeek' : 'sameElse'; 3165} 3166 3167function calendar$1 (time, formats) { 3168 // We want to compare the start of today, vs this. 3169 // Getting start-of-today depends on whether we're local/utc/offset or not. 3170 var now = time || createLocal(), 3171 sod = cloneWithOffset(now, this).startOf('day'), 3172 format = hooks.calendarFormat(this, sod) || 'sameElse'; 3173 3174 var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]); 3175 3176 return this.format(output || this.localeData().calendar(format, this, createLocal(now))); 3177} 3178 3179function clone () { 3180 return new Moment(this); 3181} 3182 3183function isAfter (input, units) { 3184 var localInput = isMoment(input) ? input : createLocal(input); 3185 if (!(this.isValid() && localInput.isValid())) { 3186 return false; 3187 } 3188 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); 3189 if (units === 'millisecond') { 3190 return this.valueOf() > localInput.valueOf(); 3191 } else { 3192 return localInput.valueOf() < this.clone().startOf(units).valueOf(); 3193 } 3194} 3195 3196function isBefore (input, units) { 3197 var localInput = isMoment(input) ? input : createLocal(input); 3198 if (!(this.isValid() && localInput.isValid())) { 3199 return false; 3200 } 3201 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); 3202 if (units === 'millisecond') { 3203 return this.valueOf() < localInput.valueOf(); 3204 } else { 3205 return this.clone().endOf(units).valueOf() < localInput.valueOf(); 3206 } 3207} 3208 3209function isBetween (from, to, units, inclusivity) { 3210 inclusivity = inclusivity || '()'; 3211 return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) && 3212 (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units)); 3213} 3214 3215function isSame (input, units) { 3216 var localInput = isMoment(input) ? input : createLocal(input), 3217 inputMs; 3218 if (!(this.isValid() && localInput.isValid())) { 3219 return false; 3220 } 3221 units = normalizeUnits(units || 'millisecond'); 3222 if (units === 'millisecond') { 3223 return this.valueOf() === localInput.valueOf(); 3224 } else { 3225 inputMs = localInput.valueOf(); 3226 return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf(); 3227 } 3228} 3229 3230function isSameOrAfter (input, units) { 3231 return this.isSame(input, units) || this.isAfter(input,units); 3232} 3233 3234function isSameOrBefore (input, units) { 3235 return this.isSame(input, units) || this.isBefore(input,units); 3236} 3237 3238function diff (input, units, asFloat) { 3239 var that, 3240 zoneDelta, 3241 delta, output; 3242 3243 if (!this.isValid()) { 3244 return NaN; 3245 } 3246 3247 that = cloneWithOffset(input, this); 3248 3249 if (!that.isValid()) { 3250 return NaN; 3251 } 3252 3253 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; 3254 3255 units = normalizeUnits(units); 3256 3257 switch (units) { 3258 case 'year': output = monthDiff(this, that) / 12; break; 3259 case 'month': output = monthDiff(this, that); break; 3260 case 'quarter': output = monthDiff(this, that) / 3; break; 3261 case 'second': output = (this - that) / 1e3; break; // 1000 3262 case 'minute': output = (this - that) / 6e4; break; // 1000 * 60 3263 case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60 3264 case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst 3265 case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst 3266 default: output = this - that; 3267 } 3268 3269 return asFloat ? output : absFloor(output); 3270} 3271 3272function monthDiff (a, b) { 3273 // difference in months 3274 var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()), 3275 // b is in (anchor - 1 month, anchor + 1 month) 3276 anchor = a.clone().add(wholeMonthDiff, 'months'), 3277 anchor2, adjust; 3278 3279 if (b - anchor < 0) { 3280 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); 3281 // linear across the month 3282 adjust = (b - anchor) / (anchor - anchor2); 3283 } else { 3284 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); 3285 // linear across the month 3286 adjust = (b - anchor) / (anchor2 - anchor); 3287 } 3288 3289 //check for negative zero, return zero if negative zero 3290 return -(wholeMonthDiff + adjust) || 0; 3291} 3292 3293hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; 3294hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; 3295 3296function toString () { 3297 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); 3298} 3299 3300function toISOString() { 3301 if (!this.isValid()) { 3302 return null; 3303 } 3304 var m = this.clone().utc(); 3305 if (m.year() < 0 || m.year() > 9999) { 3306 return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); 3307 } 3308 if (isFunction(Date.prototype.toISOString)) { 3309 // native implementation is ~50x faster, use it when we can 3310 return this.toDate().toISOString(); 3311 } 3312 return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]'); 3313} 3314 3315/** 3316 * Return a human readable representation of a moment that can 3317 * also be evaluated to get a new moment which is the same 3318 * 3319 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects 3320 */ 3321function inspect () { 3322 if (!this.isValid()) { 3323 return 'moment.invalid(/* ' + this._i + ' */)'; 3324 } 3325 var func = 'moment'; 3326 var zone = ''; 3327 if (!this.isLocal()) { 3328 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; 3329 zone = 'Z'; 3330 } 3331 var prefix = '[' + func + '("]'; 3332 var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY'; 3333 var datetime = '-MM-DD[T]HH:mm:ss.SSS'; 3334 var suffix = zone + '[")]'; 3335 3336 return this.format(prefix + year + datetime + suffix); 3337} 3338 3339function format (inputString) { 3340 if (!inputString) { 3341 inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat; 3342 } 3343 var output = formatMoment(this, inputString); 3344 return this.localeData().postformat(output); 3345} 3346 3347function from (time, withoutSuffix) { 3348 if (this.isValid() && 3349 ((isMoment(time) && time.isValid()) || 3350 createLocal(time).isValid())) { 3351 return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix); 3352 } else { 3353 return this.localeData().invalidDate(); 3354 } 3355} 3356 3357function fromNow (withoutSuffix) { 3358 return this.from(createLocal(), withoutSuffix); 3359} 3360 3361function to (time, withoutSuffix) { 3362 if (this.isValid() && 3363 ((isMoment(time) && time.isValid()) || 3364 createLocal(time).isValid())) { 3365 return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix); 3366 } else { 3367 return this.localeData().invalidDate(); 3368 } 3369} 3370 3371function toNow (withoutSuffix) { 3372 return this.to(createLocal(), withoutSuffix); 3373} 3374 3375// If passed a locale key, it will set the locale for this 3376// instance. Otherwise, it will return the locale configuration 3377// variables for this instance. 3378function locale (key) { 3379 var newLocaleData; 3380 3381 if (key === undefined) { 3382 return this._locale._abbr; 3383 } else { 3384 newLocaleData = getLocale(key); 3385 if (newLocaleData != null) { 3386 this._locale = newLocaleData; 3387 } 3388 return this; 3389 } 3390} 3391 3392var lang = deprecate( 3393 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', 3394 function (key) { 3395 if (key === undefined) { 3396 return this.localeData(); 3397 } else { 3398 return this.locale(key); 3399 } 3400 } 3401); 3402 3403function localeData () { 3404 return this._locale; 3405} 3406 3407function startOf (units) { 3408 units = normalizeUnits(units); 3409 // the following switch intentionally omits break keywords 3410 // to utilize falling through the cases. 3411 switch (units) { 3412 case 'year': 3413 this.month(0); 3414 /* falls through */ 3415 case 'quarter': 3416 case 'month': 3417 this.date(1); 3418 /* falls through */ 3419 case 'week': 3420 case 'isoWeek': 3421 case 'day': 3422 case 'date': 3423 this.hours(0); 3424 /* falls through */ 3425 case 'hour': 3426 this.minutes(0); 3427 /* falls through */ 3428 case 'minute': 3429 this.seconds(0); 3430 /* falls through */ 3431 case 'second': 3432 this.milliseconds(0); 3433 } 3434 3435 // weeks are a special case 3436 if (units === 'week') { 3437 this.weekday(0); 3438 } 3439 if (units === 'isoWeek') { 3440 this.isoWeekday(1); 3441 } 3442 3443 // quarters are also special 3444 if (units === 'quarter') { 3445 this.month(Math.floor(this.month() / 3) * 3); 3446 } 3447 3448 return this; 3449} 3450 3451function endOf (units) { 3452 units = normalizeUnits(units); 3453 if (units === undefined || units === 'millisecond') { 3454 return this; 3455 } 3456 3457 // 'date' is an alias for 'day', so it should be considered as such. 3458 if (units === 'date') { 3459 units = 'day'; 3460 } 3461 3462 return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms'); 3463} 3464 3465function valueOf () { 3466 return this._d.valueOf() - ((this._offset || 0) * 60000); 3467} 3468 3469function unix () { 3470 return Math.floor(this.valueOf() / 1000); 3471} 3472 3473function toDate () { 3474 return new Date(this.valueOf()); 3475} 3476 3477function toArray () { 3478 var m = this; 3479 return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()]; 3480} 3481 3482function toObject () { 3483 var m = this; 3484 return { 3485 years: m.year(), 3486 months: m.month(), 3487 date: m.date(), 3488 hours: m.hours(), 3489 minutes: m.minutes(), 3490 seconds: m.seconds(), 3491 milliseconds: m.milliseconds() 3492 }; 3493} 3494 3495function toJSON () { 3496 // new Date(NaN).toJSON() === null 3497 return this.isValid() ? this.toISOString() : null; 3498} 3499 3500function isValid$2 () { 3501 return isValid(this); 3502} 3503 3504function parsingFlags () { 3505 return extend({}, getParsingFlags(this)); 3506} 3507 3508function invalidAt () { 3509 return getParsingFlags(this).overflow; 3510} 3511 3512function creationData() { 3513 return { 3514 input: this._i, 3515 format: this._f, 3516 locale: this._locale, 3517 isUTC: this._isUTC, 3518 strict: this._strict 3519 }; 3520} 3521 3522// FORMATTING 3523 3524addFormatToken(0, ['gg', 2], 0, function () { 3525 return this.weekYear() % 100; 3526}); 3527 3528addFormatToken(0, ['GG', 2], 0, function () { 3529 return this.isoWeekYear() % 100; 3530}); 3531 3532function addWeekYearFormatToken (token, getter) { 3533 addFormatToken(0, [token, token.length], 0, getter); 3534} 3535 3536addWeekYearFormatToken('gggg', 'weekYear'); 3537addWeekYearFormatToken('ggggg', 'weekYear'); 3538addWeekYearFormatToken('GGGG', 'isoWeekYear'); 3539addWeekYearFormatToken('GGGGG', 'isoWeekYear'); 3540 3541// ALIASES 3542 3543addUnitAlias('weekYear', 'gg'); 3544addUnitAlias('isoWeekYear', 'GG'); 3545 3546// PRIORITY 3547 3548addUnitPriority('weekYear', 1); 3549addUnitPriority('isoWeekYear', 1); 3550 3551 3552// PARSING 3553 3554addRegexToken('G', matchSigned); 3555addRegexToken('g', matchSigned); 3556addRegexToken('GG', match1to2, match2); 3557addRegexToken('gg', match1to2, match2); 3558addRegexToken('GGGG', match1to4, match4); 3559addRegexToken('gggg', match1to4, match4); 3560addRegexToken('GGGGG', match1to6, match6); 3561addRegexToken('ggggg', match1to6, match6); 3562 3563addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) { 3564 week[token.substr(0, 2)] = toInt(input); 3565}); 3566 3567addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { 3568 week[token] = hooks.parseTwoDigitYear(input); 3569}); 3570 3571// MOMENTS 3572 3573function getSetWeekYear (input) { 3574 return getSetWeekYearHelper.call(this, 3575 input, 3576 this.week(), 3577 this.weekday(), 3578 this.localeData()._week.dow, 3579 this.localeData()._week.doy); 3580} 3581 3582function getSetISOWeekYear (input) { 3583 return getSetWeekYearHelper.call(this, 3584 input, this.isoWeek(), this.isoWeekday(), 1, 4); 3585} 3586 3587function getISOWeeksInYear () { 3588 return weeksInYear(this.year(), 1, 4); 3589} 3590 3591function getWeeksInYear () { 3592 var weekInfo = this.localeData()._week; 3593 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); 3594} 3595 3596function getSetWeekYearHelper(input, week, weekday, dow, doy) { 3597 var weeksTarget; 3598 if (input == null) { 3599 return weekOfYear(this, dow, doy).year; 3600 } else { 3601 weeksTarget = weeksInYear(input, dow, doy); 3602 if (week > weeksTarget) { 3603 week = weeksTarget; 3604 } 3605 return setWeekAll.call(this, input, week, weekday, dow, doy); 3606 } 3607} 3608 3609function setWeekAll(weekYear, week, weekday, dow, doy) { 3610 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), 3611 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); 3612 3613 this.year(date.getUTCFullYear()); 3614 this.month(date.getUTCMonth()); 3615 this.date(date.getUTCDate()); 3616 return this; 3617} 3618 3619// FORMATTING 3620 3621addFormatToken('Q', 0, 'Qo', 'quarter'); 3622 3623// ALIASES 3624 3625addUnitAlias('quarter', 'Q'); 3626 3627// PRIORITY 3628 3629addUnitPriority('quarter', 7); 3630 3631// PARSING 3632 3633addRegexToken('Q', match1); 3634addParseToken('Q', function (input, array) { 3635 array[MONTH] = (toInt(input) - 1) * 3; 3636}); 3637 3638// MOMENTS 3639 3640function getSetQuarter (input) { 3641 return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); 3642} 3643 3644// FORMATTING 3645 3646addFormatToken('D', ['DD', 2], 'Do', 'date'); 3647 3648// ALIASES 3649 3650addUnitAlias('date', 'D'); 3651 3652// PRIOROITY 3653addUnitPriority('date', 9); 3654 3655// PARSING 3656 3657addRegexToken('D', match1to2); 3658addRegexToken('DD', match1to2, match2); 3659addRegexToken('Do', function (isStrict, locale) { 3660 // TODO: Remove "ordinalParse" fallback in next major release. 3661 return isStrict ? 3662 (locale._dayOfMonthOrdinalParse || locale._ordinalParse) : 3663 locale._dayOfMonthOrdinalParseLenient; 3664}); 3665 3666addParseToken(['D', 'DD'], DATE); 3667addParseToken('Do', function (input, array) { 3668 array[DATE] = toInt(input.match(match1to2)[0], 10); 3669}); 3670 3671// MOMENTS 3672 3673var getSetDayOfMonth = makeGetSet('Date', true); 3674 3675// FORMATTING 3676 3677addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); 3678 3679// ALIASES 3680 3681addUnitAlias('dayOfYear', 'DDD'); 3682 3683// PRIORITY 3684addUnitPriority('dayOfYear', 4); 3685 3686// PARSING 3687 3688addRegexToken('DDD', match1to3); 3689addRegexToken('DDDD', match3); 3690addParseToken(['DDD', 'DDDD'], function (input, array, config) { 3691 config._dayOfYear = toInt(input); 3692}); 3693 3694// HELPERS 3695 3696// MOMENTS 3697 3698function getSetDayOfYear (input) { 3699 var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1; 3700 return input == null ? dayOfYear : this.add((input - dayOfYear), 'd'); 3701} 3702 3703// FORMATTING 3704 3705addFormatToken('m', ['mm', 2], 0, 'minute'); 3706 3707// ALIASES 3708 3709addUnitAlias('minute', 'm'); 3710 3711// PRIORITY 3712 3713addUnitPriority('minute', 14); 3714 3715// PARSING 3716 3717addRegexToken('m', match1to2); 3718addRegexToken('mm', match1to2, match2); 3719addParseToken(['m', 'mm'], MINUTE); 3720 3721// MOMENTS 3722 3723var getSetMinute = makeGetSet('Minutes', false); 3724 3725// FORMATTING 3726 3727addFormatToken('s', ['ss', 2], 0, 'second'); 3728 3729// ALIASES 3730 3731addUnitAlias('second', 's'); 3732 3733// PRIORITY 3734 3735addUnitPriority('second', 15); 3736 3737// PARSING 3738 3739addRegexToken('s', match1to2); 3740addRegexToken('ss', match1to2, match2); 3741addParseToken(['s', 'ss'], SECOND); 3742 3743// MOMENTS 3744 3745var getSetSecond = makeGetSet('Seconds', false); 3746 3747// FORMATTING 3748 3749addFormatToken('S', 0, 0, function () { 3750 return ~~(this.millisecond() / 100); 3751}); 3752 3753addFormatToken(0, ['SS', 2], 0, function () { 3754 return ~~(this.millisecond() / 10); 3755}); 3756 3757addFormatToken(0, ['SSS', 3], 0, 'millisecond'); 3758addFormatToken(0, ['SSSS', 4], 0, function () { 3759 return this.millisecond() * 10; 3760}); 3761addFormatToken(0, ['SSSSS', 5], 0, function () { 3762 return this.millisecond() * 100; 3763}); 3764addFormatToken(0, ['SSSSSS', 6], 0, function () { 3765 return this.millisecond() * 1000; 3766}); 3767addFormatToken(0, ['SSSSSSS', 7], 0, function () { 3768 return this.millisecond() * 10000; 3769}); 3770addFormatToken(0, ['SSSSSSSS', 8], 0, function () { 3771 return this.millisecond() * 100000; 3772}); 3773addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { 3774 return this.millisecond() * 1000000; 3775}); 3776 3777 3778// ALIASES 3779 3780addUnitAlias('millisecond', 'ms'); 3781 3782// PRIORITY 3783 3784addUnitPriority('millisecond', 16); 3785 3786// PARSING 3787 3788addRegexToken('S', match1to3, match1); 3789addRegexToken('SS', match1to3, match2); 3790addRegexToken('SSS', match1to3, match3); 3791 3792var token; 3793for (token = 'SSSS'; token.length <= 9; token += 'S') { 3794 addRegexToken(token, matchUnsigned); 3795} 3796 3797function parseMs(input, array) { 3798 array[MILLISECOND] = toInt(('0.' + input) * 1000); 3799} 3800 3801for (token = 'S'; token.length <= 9; token += 'S') { 3802 addParseToken(token, parseMs); 3803} 3804// MOMENTS 3805 3806var getSetMillisecond = makeGetSet('Milliseconds', false); 3807 3808// FORMATTING 3809 3810addFormatToken('z', 0, 0, 'zoneAbbr'); 3811addFormatToken('zz', 0, 0, 'zoneName'); 3812 3813// MOMENTS 3814 3815function getZoneAbbr () { 3816 return this._isUTC ? 'UTC' : ''; 3817} 3818 3819function getZoneName () { 3820 return this._isUTC ? 'Coordinated Universal Time' : ''; 3821} 3822 3823var proto = Moment.prototype; 3824 3825proto.add = add; 3826proto.calendar = calendar$1; 3827proto.clone = clone; 3828proto.diff = diff; 3829proto.endOf = endOf; 3830proto.format = format; 3831proto.from = from; 3832proto.fromNow = fromNow; 3833proto.to = to; 3834proto.toNow = toNow; 3835proto.get = stringGet; 3836proto.invalidAt = invalidAt; 3837proto.isAfter = isAfter; 3838proto.isBefore = isBefore; 3839proto.isBetween = isBetween; 3840proto.isSame = isSame; 3841proto.isSameOrAfter = isSameOrAfter; 3842proto.isSameOrBefore = isSameOrBefore; 3843proto.isValid = isValid$2; 3844proto.lang = lang; 3845proto.locale = locale; 3846proto.localeData = localeData; 3847proto.max = prototypeMax; 3848proto.min = prototypeMin; 3849proto.parsingFlags = parsingFlags; 3850proto.set = stringSet; 3851proto.startOf = startOf; 3852proto.subtract = subtract; 3853proto.toArray = toArray; 3854proto.toObject = toObject; 3855proto.toDate = toDate; 3856proto.toISOString = toISOString; 3857proto.inspect = inspect; 3858proto.toJSON = toJSON; 3859proto.toString = toString; 3860proto.unix = unix; 3861proto.valueOf = valueOf; 3862proto.creationData = creationData; 3863 3864// Year 3865proto.year = getSetYear; 3866proto.isLeapYear = getIsLeapYear; 3867 3868// Week Year 3869proto.weekYear = getSetWeekYear; 3870proto.isoWeekYear = getSetISOWeekYear; 3871 3872// Quarter 3873proto.quarter = proto.quarters = getSetQuarter; 3874 3875// Month 3876proto.month = getSetMonth; 3877proto.daysInMonth = getDaysInMonth; 3878 3879// Week 3880proto.week = proto.weeks = getSetWeek; 3881proto.isoWeek = proto.isoWeeks = getSetISOWeek; 3882proto.weeksInYear = getWeeksInYear; 3883proto.isoWeeksInYear = getISOWeeksInYear; 3884 3885// Day 3886proto.date = getSetDayOfMonth; 3887proto.day = proto.days = getSetDayOfWeek; 3888proto.weekday = getSetLocaleDayOfWeek; 3889proto.isoWeekday = getSetISODayOfWeek; 3890proto.dayOfYear = getSetDayOfYear; 3891 3892// Hour 3893proto.hour = proto.hours = getSetHour; 3894 3895// Minute 3896proto.minute = proto.minutes = getSetMinute; 3897 3898// Second 3899proto.second = proto.seconds = getSetSecond; 3900 3901// Millisecond 3902proto.millisecond = proto.milliseconds = getSetMillisecond; 3903 3904// Offset 3905proto.utcOffset = getSetOffset; 3906proto.utc = setOffsetToUTC; 3907proto.local = setOffsetToLocal; 3908proto.parseZone = setOffsetToParsedOffset; 3909proto.hasAlignedHourOffset = hasAlignedHourOffset; 3910proto.isDST = isDaylightSavingTime; 3911proto.isLocal = isLocal; 3912proto.isUtcOffset = isUtcOffset; 3913proto.isUtc = isUtc; 3914proto.isUTC = isUtc; 3915 3916// Timezone 3917proto.zoneAbbr = getZoneAbbr; 3918proto.zoneName = getZoneName; 3919 3920// Deprecations 3921proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); 3922proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); 3923proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); 3924proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone); 3925proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted); 3926 3927function createUnix (input) { 3928 return createLocal(input * 1000); 3929} 3930 3931function createInZone () { 3932 return createLocal.apply(null, arguments).parseZone(); 3933} 3934 3935function preParsePostFormat (string) { 3936 return string; 3937} 3938 3939var proto$1 = Locale.prototype; 3940 3941proto$1.calendar = calendar; 3942proto$1.longDateFormat = longDateFormat; 3943proto$1.invalidDate = invalidDate; 3944proto$1.ordinal = ordinal; 3945proto$1.preparse = preParsePostFormat; 3946proto$1.postformat = preParsePostFormat; 3947proto$1.relativeTime = relativeTime; 3948proto$1.pastFuture = pastFuture; 3949proto$1.set = set; 3950 3951// Month 3952proto$1.months = localeMonths; 3953proto$1.monthsShort = localeMonthsShort; 3954proto$1.monthsParse = localeMonthsParse; 3955proto$1.monthsRegex = monthsRegex; 3956proto$1.monthsShortRegex = monthsShortRegex; 3957 3958// Week 3959proto$1.week = localeWeek; 3960proto$1.firstDayOfYear = localeFirstDayOfYear; 3961proto$1.firstDayOfWeek = localeFirstDayOfWeek; 3962 3963// Day of Week 3964proto$1.weekdays = localeWeekdays; 3965proto$1.weekdaysMin = localeWeekdaysMin; 3966proto$1.weekdaysShort = localeWeekdaysShort; 3967proto$1.weekdaysParse = localeWeekdaysParse; 3968 3969proto$1.weekdaysRegex = weekdaysRegex; 3970proto$1.weekdaysShortRegex = weekdaysShortRegex; 3971proto$1.weekdaysMinRegex = weekdaysMinRegex; 3972 3973// Hours 3974proto$1.isPM = localeIsPM; 3975proto$1.meridiem = localeMeridiem; 3976 3977function get$1 (format, index, field, setter) { 3978 var locale = getLocale(); 3979 var utc = createUTC().set(setter, index); 3980 return locale[field](utc, format); 3981} 3982 3983function listMonthsImpl (format, index, field) { 3984 if (isNumber(format)) { 3985 index = format; 3986 format = undefined; 3987 } 3988 3989 format = format || ''; 3990 3991 if (index != null) { 3992 return get$1(format, index, field, 'month'); 3993 } 3994 3995 var i; 3996 var out = []; 3997 for (i = 0; i < 12; i++) { 3998 out[i] = get$1(format, i, field, 'month'); 3999 } 4000 return out; 4001} 4002 4003// () 4004// (5) 4005// (fmt, 5) 4006// (fmt) 4007// (true) 4008// (true, 5) 4009// (true, fmt, 5) 4010// (true, fmt) 4011function listWeekdaysImpl (localeSorted, format, index, field) { 4012 if (typeof localeSorted === 'boolean') { 4013 if (isNumber(format)) { 4014 index = format; 4015 format = undefined; 4016 } 4017 4018 format = format || ''; 4019 } else { 4020 format = localeSorted; 4021 index = format; 4022 localeSorted = false; 4023 4024 if (isNumber(format)) { 4025 index = format; 4026 format = undefined; 4027 } 4028 4029 format = format || ''; 4030 } 4031 4032 var locale = getLocale(), 4033 shift = localeSorted ? locale._week.dow : 0; 4034 4035 if (index != null) { 4036 return get$1(format, (index + shift) % 7, field, 'day'); 4037 } 4038 4039 var i; 4040 var out = []; 4041 for (i = 0; i < 7; i++) { 4042 out[i] = get$1(format, (i + shift) % 7, field, 'day'); 4043 } 4044 return out; 4045} 4046 4047function listMonths (format, index) { 4048 return listMonthsImpl(format, index, 'months'); 4049} 4050 4051function listMonthsShort (format, index) { 4052 return listMonthsImpl(format, index, 'monthsShort'); 4053} 4054 4055function listWeekdays (localeSorted, format, index) { 4056 return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); 4057} 4058 4059function listWeekdaysShort (localeSorted, format, index) { 4060 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); 4061} 4062 4063function listWeekdaysMin (localeSorted, format, index) { 4064 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); 4065} 4066 4067getSetGlobalLocale('en', { 4068 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 4069 ordinal : function (number) { 4070 var b = number % 10, 4071 output = (toInt(number % 100 / 10) === 1) ? 'th' : 4072 (b === 1) ? 'st' : 4073 (b === 2) ? 'nd' : 4074 (b === 3) ? 'rd' : 'th'; 4075 return number + output; 4076 } 4077}); 4078 4079// Side effect imports 4080hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale); 4081hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale); 4082 4083var mathAbs = Math.abs; 4084 4085function abs () { 4086 var data = this._data; 4087 4088 this._milliseconds = mathAbs(this._milliseconds); 4089 this._days = mathAbs(this._days); 4090 this._months = mathAbs(this._months); 4091 4092 data.milliseconds = mathAbs(data.milliseconds); 4093 data.seconds = mathAbs(data.seconds); 4094 data.minutes = mathAbs(data.minutes); 4095 data.hours = mathAbs(data.hours); 4096 data.months = mathAbs(data.months); 4097 data.years = mathAbs(data.years); 4098 4099 return this; 4100} 4101 4102function addSubtract$1 (duration, input, value, direction) { 4103 var other = createDuration(input, value); 4104 4105 duration._milliseconds += direction * other._milliseconds; 4106 duration._days += direction * other._days; 4107 duration._months += direction * other._months; 4108 4109 return duration._bubble(); 4110} 4111 4112// supports only 2.0-style add(1, 's') or add(duration) 4113function add$1 (input, value) { 4114 return addSubtract$1(this, input, value, 1); 4115} 4116 4117// supports only 2.0-style subtract(1, 's') or subtract(duration) 4118function subtract$1 (input, value) { 4119 return addSubtract$1(this, input, value, -1); 4120} 4121 4122function absCeil (number) { 4123 if (number < 0) { 4124 return Math.floor(number); 4125 } else { 4126 return Math.ceil(number); 4127 } 4128} 4129 4130function bubble () { 4131 var milliseconds = this._milliseconds; 4132 var days = this._days; 4133 var months = this._months; 4134 var data = this._data; 4135 var seconds, minutes, hours, years, monthsFromDays; 4136 4137 // if we have a mix of positive and negative values, bubble down first 4138 // check: https://github.com/moment/moment/issues/2166 4139 if (!((milliseconds >= 0 && days >= 0 && months >= 0) || 4140 (milliseconds <= 0 && days <= 0 && months <= 0))) { 4141 milliseconds += absCeil(monthsToDays(months) + days) * 864e5; 4142 days = 0; 4143 months = 0; 4144 } 4145 4146 // The following code bubbles up values, see the tests for 4147 // examples of what that means. 4148 data.milliseconds = milliseconds % 1000; 4149 4150 seconds = absFloor(milliseconds / 1000); 4151 data.seconds = seconds % 60; 4152 4153 minutes = absFloor(seconds / 60); 4154 data.minutes = minutes % 60; 4155 4156 hours = absFloor(minutes / 60); 4157 data.hours = hours % 24; 4158 4159 days += absFloor(hours / 24); 4160 4161 // convert days to months 4162 monthsFromDays = absFloor(daysToMonths(days)); 4163 months += monthsFromDays; 4164 days -= absCeil(monthsToDays(monthsFromDays)); 4165 4166 // 12 months -> 1 year 4167 years = absFloor(months / 12); 4168 months %= 12; 4169 4170 data.days = days; 4171 data.months = months; 4172 data.years = years; 4173 4174 return this; 4175} 4176 4177function daysToMonths (days) { 4178 // 400 years have 146097 days (taking into account leap year rules) 4179 // 400 years have 12 months === 4800 4180 return days * 4800 / 146097; 4181} 4182 4183function monthsToDays (months) { 4184 // the reverse of daysToMonths 4185 return months * 146097 / 4800; 4186} 4187 4188function as (units) { 4189 if (!this.isValid()) { 4190 return NaN; 4191 } 4192 var days; 4193 var months; 4194 var milliseconds = this._milliseconds; 4195 4196 units = normalizeUnits(units); 4197 4198 if (units === 'month' || units === 'year') { 4199 days = this._days + milliseconds / 864e5; 4200 months = this._months + daysToMonths(days); 4201 return units === 'month' ? months : months / 12; 4202 } else { 4203 // handle milliseconds separately because of floating point math errors (issue #1867) 4204 days = this._days + Math.round(monthsToDays(this._months)); 4205 switch (units) { 4206 case 'week' : return days / 7 + milliseconds / 6048e5; 4207 case 'day' : return days + milliseconds / 864e5; 4208 case 'hour' : return days * 24 + milliseconds / 36e5; 4209 case 'minute' : return days * 1440 + milliseconds / 6e4; 4210 case 'second' : return days * 86400 + milliseconds / 1000; 4211 // Math.floor prevents floating point math errors here 4212 case 'millisecond': return Math.floor(days * 864e5) + milliseconds; 4213 default: throw new Error('Unknown unit ' + units); 4214 } 4215 } 4216} 4217 4218// TODO: Use this.as('ms')? 4219function valueOf$1 () { 4220 if (!this.isValid()) { 4221 return NaN; 4222 } 4223 return ( 4224 this._milliseconds + 4225 this._days * 864e5 + 4226 (this._months % 12) * 2592e6 + 4227 toInt(this._months / 12) * 31536e6 4228 ); 4229} 4230 4231function makeAs (alias) { 4232 return function () { 4233 return this.as(alias); 4234 }; 4235} 4236 4237var asMilliseconds = makeAs('ms'); 4238var asSeconds = makeAs('s'); 4239var asMinutes = makeAs('m'); 4240var asHours = makeAs('h'); 4241var asDays = makeAs('d'); 4242var asWeeks = makeAs('w'); 4243var asMonths = makeAs('M'); 4244var asYears = makeAs('y'); 4245 4246function clone$1 () { 4247 return createDuration(this); 4248} 4249 4250function get$2 (units) { 4251 units = normalizeUnits(units); 4252 return this.isValid() ? this[units + 's']() : NaN; 4253} 4254 4255function makeGetter(name) { 4256 return function () { 4257 return this.isValid() ? this._data[name] : NaN; 4258 }; 4259} 4260 4261var milliseconds = makeGetter('milliseconds'); 4262var seconds = makeGetter('seconds'); 4263var minutes = makeGetter('minutes'); 4264var hours = makeGetter('hours'); 4265var days = makeGetter('days'); 4266var months = makeGetter('months'); 4267var years = makeGetter('years'); 4268 4269function weeks () { 4270 return absFloor(this.days() / 7); 4271} 4272 4273var round = Math.round; 4274var thresholds = { 4275 ss: 44, // a few seconds to seconds 4276 s : 45, // seconds to minute 4277 m : 45, // minutes to hour 4278 h : 22, // hours to day 4279 d : 26, // days to month 4280 M : 11 // months to year 4281}; 4282 4283// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize 4284function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { 4285 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); 4286} 4287 4288function relativeTime$1 (posNegDuration, withoutSuffix, locale) { 4289 var duration = createDuration(posNegDuration).abs(); 4290 var seconds = round(duration.as('s')); 4291 var minutes = round(duration.as('m')); 4292 var hours = round(duration.as('h')); 4293 var days = round(duration.as('d')); 4294 var months = round(duration.as('M')); 4295 var years = round(duration.as('y')); 4296 4297 var a = seconds <= thresholds.ss && ['s', seconds] || 4298 seconds < thresholds.s && ['ss', seconds] || 4299 minutes <= 1 && ['m'] || 4300 minutes < thresholds.m && ['mm', minutes] || 4301 hours <= 1 && ['h'] || 4302 hours < thresholds.h && ['hh', hours] || 4303 days <= 1 && ['d'] || 4304 days < thresholds.d && ['dd', days] || 4305 months <= 1 && ['M'] || 4306 months < thresholds.M && ['MM', months] || 4307 years <= 1 && ['y'] || ['yy', years]; 4308 4309 a[2] = withoutSuffix; 4310 a[3] = +posNegDuration > 0; 4311 a[4] = locale; 4312 return substituteTimeAgo.apply(null, a); 4313} 4314 4315// This function allows you to set the rounding function for relative time strings 4316function getSetRelativeTimeRounding (roundingFunction) { 4317 if (roundingFunction === undefined) { 4318 return round; 4319 } 4320 if (typeof(roundingFunction) === 'function') { 4321 round = roundingFunction; 4322 return true; 4323 } 4324 return false; 4325} 4326 4327// This function allows you to set a threshold for relative time strings 4328function getSetRelativeTimeThreshold (threshold, limit) { 4329 if (thresholds[threshold] === undefined) { 4330 return false; 4331 } 4332 if (limit === undefined) { 4333 return thresholds[threshold]; 4334 } 4335 thresholds[threshold] = limit; 4336 if (threshold === 's') { 4337 thresholds.ss = limit - 1; 4338 } 4339 return true; 4340} 4341 4342function humanize (withSuffix) { 4343 if (!this.isValid()) { 4344 return this.localeData().invalidDate(); 4345 } 4346 4347 var locale = this.localeData(); 4348 var output = relativeTime$1(this, !withSuffix, locale); 4349 4350 if (withSuffix) { 4351 output = locale.pastFuture(+this, output); 4352 } 4353 4354 return locale.postformat(output); 4355} 4356 4357var abs$1 = Math.abs; 4358 4359function sign(x) { 4360 return ((x > 0) - (x < 0)) || +x; 4361} 4362 4363function toISOString$1() { 4364 // for ISO strings we do not use the normal bubbling rules: 4365 // * milliseconds bubble up until they become hours 4366 // * days do not bubble at all 4367 // * months bubble up until they become years 4368 // This is because there is no context-free conversion between hours and days 4369 // (think of clock changes) 4370 // and also not between days and months (28-31 days per month) 4371 if (!this.isValid()) { 4372 return this.localeData().invalidDate(); 4373 } 4374 4375 var seconds = abs$1(this._milliseconds) / 1000; 4376 var days = abs$1(this._days); 4377 var months = abs$1(this._months); 4378 var minutes, hours, years; 4379 4380 // 3600 seconds -> 60 minutes -> 1 hour 4381 minutes = absFloor(seconds / 60); 4382 hours = absFloor(minutes / 60); 4383 seconds %= 60; 4384 minutes %= 60; 4385 4386 // 12 months -> 1 year 4387 years = absFloor(months / 12); 4388 months %= 12; 4389 4390 4391 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js 4392 var Y = years; 4393 var M = months; 4394 var D = days; 4395 var h = hours; 4396 var m = minutes; 4397 var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; 4398 var total = this.asSeconds(); 4399 4400 if (!total) { 4401 // this is the same as C#'s (Noda) and python (isodate)... 4402 // but not other JS (goog.date) 4403 return 'P0D'; 4404 } 4405 4406 var totalSign = total < 0 ? '-' : ''; 4407 var ymSign = sign(this._months) !== sign(total) ? '-' : ''; 4408 var daysSign = sign(this._days) !== sign(total) ? '-' : ''; 4409 var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; 4410 4411 return totalSign + 'P' + 4412 (Y ? ymSign + Y + 'Y' : '') + 4413 (M ? ymSign + M + 'M' : '') + 4414 (D ? daysSign + D + 'D' : '') + 4415 ((h || m || s) ? 'T' : '') + 4416 (h ? hmsSign + h + 'H' : '') + 4417 (m ? hmsSign + m + 'M' : '') + 4418 (s ? hmsSign + s + 'S' : ''); 4419} 4420 4421var proto$2 = Duration.prototype; 4422 4423proto$2.isValid = isValid$1; 4424proto$2.abs = abs; 4425proto$2.add = add$1; 4426proto$2.subtract = subtract$1; 4427proto$2.as = as; 4428proto$2.asMilliseconds = asMilliseconds; 4429proto$2.asSeconds = asSeconds; 4430proto$2.asMinutes = asMinutes; 4431proto$2.asHours = asHours; 4432proto$2.asDays = asDays; 4433proto$2.asWeeks = asWeeks; 4434proto$2.asMonths = asMonths; 4435proto$2.asYears = asYears; 4436proto$2.valueOf = valueOf$1; 4437proto$2._bubble = bubble; 4438proto$2.clone = clone$1; 4439proto$2.get = get$2; 4440proto$2.milliseconds = milliseconds; 4441proto$2.seconds = seconds; 4442proto$2.minutes = minutes; 4443proto$2.hours = hours; 4444proto$2.days = days; 4445proto$2.weeks = weeks; 4446proto$2.months = months; 4447proto$2.years = years; 4448proto$2.humanize = humanize; 4449proto$2.toISOString = toISOString$1; 4450proto$2.toString = toISOString$1; 4451proto$2.toJSON = toISOString$1; 4452proto$2.locale = locale; 4453proto$2.localeData = localeData; 4454 4455// Deprecations 4456proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1); 4457proto$2.lang = lang; 4458 4459// Side effect imports 4460 4461// FORMATTING 4462 4463addFormatToken('X', 0, 0, 'unix'); 4464addFormatToken('x', 0, 0, 'valueOf'); 4465 4466// PARSING 4467 4468addRegexToken('x', matchSigned); 4469addRegexToken('X', matchTimestamp); 4470addParseToken('X', function (input, array, config) { 4471 config._d = new Date(parseFloat(input, 10) * 1000); 4472}); 4473addParseToken('x', function (input, array, config) { 4474 config._d = new Date(toInt(input)); 4475}); 4476 4477// Side effect imports 4478 4479 4480hooks.version = '2.19.1'; 4481 4482setHookCallback(createLocal); 4483 4484hooks.fn = proto; 4485hooks.min = min; 4486hooks.max = max; 4487hooks.now = now; 4488hooks.utc = createUTC; 4489hooks.unix = createUnix; 4490hooks.months = listMonths; 4491hooks.isDate = isDate; 4492hooks.locale = getSetGlobalLocale; 4493hooks.invalid = createInvalid; 4494hooks.duration = createDuration; 4495hooks.isMoment = isMoment; 4496hooks.weekdays = listWeekdays; 4497hooks.parseZone = createInZone; 4498hooks.localeData = getLocale; 4499hooks.isDuration = isDuration; 4500hooks.monthsShort = listMonthsShort; 4501hooks.weekdaysMin = listWeekdaysMin; 4502hooks.defineLocale = defineLocale; 4503hooks.updateLocale = updateLocale; 4504hooks.locales = listLocales; 4505hooks.weekdaysShort = listWeekdaysShort; 4506hooks.normalizeUnits = normalizeUnits; 4507hooks.relativeTimeRounding = getSetRelativeTimeRounding; 4508hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; 4509hooks.calendarFormat = getCalendarFormat; 4510hooks.prototype = proto; 4511 4512return hooks; 4513 4514})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.