@uipath/api-workflow-tool 1.203.0-preview.180 → 1.203.0-preview.203

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -8034,7 +8034,7 @@ var require_workflow_extensions = __commonJS(function(exports) {
8034
8034
  // ../../node_modules/moment/moment.js
8035
8035
  var require_moment = __commonJS(function(exports, module) {
8036
8036
  //! moment.js
8037
- //! version : 2.30.1
8037
+ //! version : 2.31.0
8038
8038
  //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
8039
8039
  //! license : MIT
8040
8040
  //! momentjs.com
@@ -8113,6 +8113,7 @@ var require_moment = __commonJS(function(exports, module) {
8113
8113
  nullInput: false,
8114
8114
  invalidEra: null,
8115
8115
  invalidMonth: null,
8116
+ invalidOffset: null,
8116
8117
  invalidFormat: false,
8117
8118
  userInvalidated: false,
8118
8119
  iso: false,
@@ -8143,14 +8144,14 @@ var require_moment = __commonJS(function(exports, module) {
8143
8144
  return false;
8144
8145
  };
8145
8146
  }
8146
- function isValid(m) {
8147
+ function isValid$2(m) {
8147
8148
  var flags = null, parsedParts = false, isNowValid = m._d && !isNaN(m._d.getTime());
8148
8149
  if (isNowValid) {
8149
8150
  flags = getParsingFlags(m);
8150
8151
  parsedParts = some.call(flags.parsedDateParts, function(i) {
8151
8152
  return i != null;
8152
8153
  });
8153
- isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
8154
+ isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidOffset && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
8154
8155
  if (m._strict) {
8155
8156
  isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === undefined;
8156
8157
  }
@@ -8162,7 +8163,7 @@ var require_moment = __commonJS(function(exports, module) {
8162
8163
  }
8163
8164
  return m._isValid;
8164
8165
  }
8165
- function createInvalid(flags) {
8166
+ function createInvalid$1(flags) {
8166
8167
  var m = createUTC(NaN);
8167
8168
  if (flags != null) {
8168
8169
  extend(getParsingFlags(m), flags);
@@ -8273,7 +8274,8 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8273
8274
  hooks.deprecationHandler(name, msg);
8274
8275
  }
8275
8276
  if (!deprecations[name]) {
8276
- warn(msg);
8277
+ warn(msg + `
8278
+ ` + new Error().stack);
8277
8279
  deprecations[name] = true;
8278
8280
  }
8279
8281
  }
@@ -8282,199 +8284,6 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8282
8284
  function isFunction(input) {
8283
8285
  return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
8284
8286
  }
8285
- function set(config) {
8286
- var prop, i;
8287
- for (i in config) {
8288
- if (hasOwnProp(config, i)) {
8289
- prop = config[i];
8290
- if (isFunction(prop)) {
8291
- this[i] = prop;
8292
- } else {
8293
- this["_" + i] = prop;
8294
- }
8295
- }
8296
- }
8297
- this._config = config;
8298
- this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source);
8299
- }
8300
- function mergeConfigs(parentConfig, childConfig) {
8301
- var res = extend({}, parentConfig), prop;
8302
- for (prop in childConfig) {
8303
- if (hasOwnProp(childConfig, prop)) {
8304
- if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
8305
- res[prop] = {};
8306
- extend(res[prop], parentConfig[prop]);
8307
- extend(res[prop], childConfig[prop]);
8308
- } else if (childConfig[prop] != null) {
8309
- res[prop] = childConfig[prop];
8310
- } else {
8311
- delete res[prop];
8312
- }
8313
- }
8314
- }
8315
- for (prop in parentConfig) {
8316
- if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
8317
- res[prop] = extend({}, res[prop]);
8318
- }
8319
- }
8320
- return res;
8321
- }
8322
- function Locale(config) {
8323
- if (config != null) {
8324
- this.set(config);
8325
- }
8326
- }
8327
- var keys;
8328
- if (Object.keys) {
8329
- keys = Object.keys;
8330
- } else {
8331
- keys = function(obj) {
8332
- var i, res = [];
8333
- for (i in obj) {
8334
- if (hasOwnProp(obj, i)) {
8335
- res.push(i);
8336
- }
8337
- }
8338
- return res;
8339
- };
8340
- }
8341
- var defaultCalendar = {
8342
- sameDay: "[Today at] LT",
8343
- nextDay: "[Tomorrow at] LT",
8344
- nextWeek: "dddd [at] LT",
8345
- lastDay: "[Yesterday at] LT",
8346
- lastWeek: "[Last] dddd [at] LT",
8347
- sameElse: "L"
8348
- };
8349
- function calendar(key, mom, now2) {
8350
- var output = this._calendar[key] || this._calendar["sameElse"];
8351
- return isFunction(output) ? output.call(mom, now2) : output;
8352
- }
8353
- function zeroFill(number, targetLength, forceSign) {
8354
- var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0;
8355
- return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
8356
- }
8357
- var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
8358
- function addFormatToken(token2, padded, ordinal2, callback) {
8359
- var func = callback;
8360
- if (typeof callback === "string") {
8361
- func = function() {
8362
- return this[callback]();
8363
- };
8364
- }
8365
- if (token2) {
8366
- formatTokenFunctions[token2] = func;
8367
- }
8368
- if (padded) {
8369
- formatTokenFunctions[padded[0]] = function() {
8370
- return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
8371
- };
8372
- }
8373
- if (ordinal2) {
8374
- formatTokenFunctions[ordinal2] = function() {
8375
- return this.localeData().ordinal(func.apply(this, arguments), token2);
8376
- };
8377
- }
8378
- }
8379
- function removeFormattingTokens(input) {
8380
- if (input.match(/\[[\s\S]/)) {
8381
- return input.replace(/^\[|\]$/g, "");
8382
- }
8383
- return input.replace(/\\/g, "");
8384
- }
8385
- function makeFormatFunction(format2) {
8386
- var array = format2.match(formattingTokens), i, length;
8387
- for (i = 0, length = array.length;i < length; i++) {
8388
- if (formatTokenFunctions[array[i]]) {
8389
- array[i] = formatTokenFunctions[array[i]];
8390
- } else {
8391
- array[i] = removeFormattingTokens(array[i]);
8392
- }
8393
- }
8394
- return function(mom) {
8395
- var output = "", i2;
8396
- for (i2 = 0;i2 < length; i2++) {
8397
- output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2];
8398
- }
8399
- return output;
8400
- };
8401
- }
8402
- function formatMoment(m, format2) {
8403
- if (!m.isValid()) {
8404
- return m.localeData().invalidDate();
8405
- }
8406
- format2 = expandFormat(format2, m.localeData());
8407
- formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
8408
- return formatFunctions[format2](m);
8409
- }
8410
- function expandFormat(format2, locale2) {
8411
- var i = 5;
8412
- function replaceLongDateFormatTokens(input) {
8413
- return locale2.longDateFormat(input) || input;
8414
- }
8415
- localFormattingTokens.lastIndex = 0;
8416
- while (i >= 0 && localFormattingTokens.test(format2)) {
8417
- format2 = format2.replace(localFormattingTokens, replaceLongDateFormatTokens);
8418
- localFormattingTokens.lastIndex = 0;
8419
- i -= 1;
8420
- }
8421
- return format2;
8422
- }
8423
- var defaultLongDateFormat = {
8424
- LTS: "h:mm:ss A",
8425
- LT: "h:mm A",
8426
- L: "MM/DD/YYYY",
8427
- LL: "MMMM D, YYYY",
8428
- LLL: "MMMM D, YYYY h:mm A",
8429
- LLLL: "dddd, MMMM D, YYYY h:mm A"
8430
- };
8431
- function longDateFormat(key) {
8432
- var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
8433
- if (format2 || !formatUpper) {
8434
- return format2;
8435
- }
8436
- this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
8437
- if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
8438
- return tok.slice(1);
8439
- }
8440
- return tok;
8441
- }).join("");
8442
- return this._longDateFormat[key];
8443
- }
8444
- var defaultInvalidDate = "Invalid date";
8445
- function invalidDate() {
8446
- return this._invalidDate;
8447
- }
8448
- var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
8449
- function ordinal(number) {
8450
- return this._ordinal.replace("%d", number);
8451
- }
8452
- var defaultRelativeTime = {
8453
- future: "in %s",
8454
- past: "%s ago",
8455
- s: "a few seconds",
8456
- ss: "%d seconds",
8457
- m: "a minute",
8458
- mm: "%d minutes",
8459
- h: "an hour",
8460
- hh: "%d hours",
8461
- d: "a day",
8462
- dd: "%d days",
8463
- w: "a week",
8464
- ww: "%d weeks",
8465
- M: "a month",
8466
- MM: "%d months",
8467
- y: "a year",
8468
- yy: "%d years"
8469
- };
8470
- function relativeTime(number, withoutSuffix, string, isFuture) {
8471
- var output = this._relativeTime[string];
8472
- return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
8473
- }
8474
- function pastFuture(diff2, output) {
8475
- var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
8476
- return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
8477
- }
8478
8287
  var aliases = {
8479
8288
  D: "date",
8480
8289
  dates: "date",
@@ -8570,6 +8379,79 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8570
8379
  });
8571
8380
  return units;
8572
8381
  }
8382
+ function zeroFill(number, targetLength, forceSign) {
8383
+ var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0;
8384
+ return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
8385
+ }
8386
+ var formattingTokens = /(\[[^\[]*\])|(\\e)|(\\)?(eHHmm|[Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
8387
+ function addFormatToken(token2, padded, ordinal2, callback) {
8388
+ var func = callback;
8389
+ if (typeof callback === "string") {
8390
+ func = function() {
8391
+ return this[callback]();
8392
+ };
8393
+ }
8394
+ if (token2) {
8395
+ formatTokenFunctions[token2] = func;
8396
+ }
8397
+ if (padded) {
8398
+ formatTokenFunctions[padded[0]] = function() {
8399
+ return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
8400
+ };
8401
+ }
8402
+ if (ordinal2) {
8403
+ formatTokenFunctions[ordinal2] = function() {
8404
+ return this.localeData().ordinal(func.apply(this, arguments), token2);
8405
+ };
8406
+ }
8407
+ }
8408
+ function removeFormattingTokens(input) {
8409
+ if (input.match(/\[[\s\S]/)) {
8410
+ return input.replace(/^\[|\]$/g, "");
8411
+ }
8412
+ return input.replace(/\\/g, "");
8413
+ }
8414
+ function makeFormatFunction(format2) {
8415
+ var array = format2.match(formattingTokens), i, length;
8416
+ for (i = 0, length = array.length;i < length; i++) {
8417
+ if (formatTokenFunctions[array[i]]) {
8418
+ array[i] = formatTokenFunctions[array[i]];
8419
+ } else {
8420
+ array[i] = removeFormattingTokens(array[i]);
8421
+ }
8422
+ }
8423
+ return function(mom) {
8424
+ var output = "", i2;
8425
+ for (i2 = 0;i2 < length; i2++) {
8426
+ output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2];
8427
+ }
8428
+ return output;
8429
+ };
8430
+ }
8431
+ function formatMoment(m, format2) {
8432
+ if (!m.isValid()) {
8433
+ return m.localeData().invalidDate();
8434
+ }
8435
+ format2 = expandFormat(format2, m.localeData());
8436
+ var cacheKey = "$" + format2;
8437
+ if (!hasOwnProp(formatFunctions, cacheKey)) {
8438
+ formatFunctions[cacheKey] = makeFormatFunction(format2);
8439
+ }
8440
+ return formatFunctions[cacheKey](m);
8441
+ }
8442
+ function expandFormat(format2, locale2) {
8443
+ var i = 5;
8444
+ function replaceLongDateFormatTokens(input) {
8445
+ return locale2.longDateFormat(input) || input;
8446
+ }
8447
+ localFormattingTokens.lastIndex = 0;
8448
+ while (i >= 0 && localFormattingTokens.test(format2)) {
8449
+ format2 = format2.replace(localFormattingTokens, replaceLongDateFormatTokens);
8450
+ localFormattingTokens.lastIndex = 0;
8451
+ i -= 1;
8452
+ }
8453
+ return format2;
8454
+ }
8573
8455
  var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes;
8574
8456
  regexes = {};
8575
8457
  function addRegexToken(token2, regex, strictRegex) {
@@ -8678,11 +8560,11 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8678
8560
  hooks.updateOffset(this, keepTime);
8679
8561
  return this;
8680
8562
  } else {
8681
- return get(this, unit);
8563
+ return get$2(this, unit);
8682
8564
  }
8683
8565
  };
8684
8566
  }
8685
- function get(mom, unit) {
8567
+ function get$2(mom, unit) {
8686
8568
  if (!mom.isValid()) {
8687
8569
  return NaN;
8688
8570
  }
@@ -8759,7 +8641,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8759
8641
  }
8760
8642
  return this;
8761
8643
  }
8762
- function mod(n, x) {
8644
+ function mod$1(n, x) {
8763
8645
  return (n % x + x) % x;
8764
8646
  }
8765
8647
  var indexOf;
@@ -8780,7 +8662,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8780
8662
  if (isNaN(year) || isNaN(month)) {
8781
8663
  return NaN;
8782
8664
  }
8783
- var modMonth = mod(month, 12);
8665
+ var modMonth = mod$1(month, 12);
8784
8666
  year += (month - modMonth) / 12;
8785
8667
  return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
8786
8668
  }
@@ -8812,9 +8694,26 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8812
8694
  getParsingFlags(config).invalidMonth = input;
8813
8695
  }
8814
8696
  });
8815
- var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
8816
- function localeMonths(m, format2) {
8817
- if (!m) {
8697
+ var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord, monthsParseProperties = [
8698
+ "monthsParse",
8699
+ "longMonthsParse",
8700
+ "shortMonthsParse",
8701
+ "monthsRegex",
8702
+ "monthsShortRegex",
8703
+ "monthsStrictRegex",
8704
+ "monthsShortStrictRegex"
8705
+ ];
8706
+ function clearMonthsParseCache(locale2, config) {
8707
+ var i, prop;
8708
+ for (i = 0;i < monthsParseProperties.length; i++) {
8709
+ prop = monthsParseProperties[i];
8710
+ if (!hasOwnProp(config, prop)) {
8711
+ delete locale2["_" + prop];
8712
+ }
8713
+ }
8714
+ }
8715
+ function localeMonths(m, format2) {
8716
+ if (!m) {
8818
8717
  return isArray(this._months) ? this._months : this._months["standalone"];
8819
8718
  }
8820
8719
  return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m.month()];
@@ -8825,7 +8724,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8825
8724
  }
8826
8725
  return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m.month()];
8827
8726
  }
8828
- function handleStrictParse(monthName, format2, strict) {
8727
+ function handleStrictParse$1(monthName, format2, strict) {
8829
8728
  var i, ii, mom, llc = monthName.toLocaleLowerCase();
8830
8729
  if (!this._monthsParse) {
8831
8730
  this._monthsParse = [];
@@ -8866,7 +8765,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8866
8765
  function localeMonthsParse(monthName, format2, strict) {
8867
8766
  var i, mom, regex;
8868
8767
  if (this._monthsParseExact) {
8869
- return handleStrictParse.call(this, monthName, format2, strict);
8768
+ return handleStrictParse$1.call(this, monthName, format2, strict);
8870
8769
  }
8871
8770
  if (!this._monthsParse) {
8872
8771
  this._monthsParse = [];
@@ -8917,7 +8816,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8917
8816
  hooks.updateOffset(this, true);
8918
8817
  return this;
8919
8818
  } else {
8920
- return get(this, "Month");
8819
+ return get$2(this, "Month");
8921
8820
  }
8922
8821
  }
8923
8822
  function getDaysInMonth() {
@@ -8979,104 +8878,6 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
8979
8878
  this._monthsStrictRegex = new RegExp("^(" + longPieces.join("|") + ")", "i");
8980
8879
  this._monthsShortStrictRegex = new RegExp("^(" + shortPieces.join("|") + ")", "i");
8981
8880
  }
8982
- function createDate(y, m, d, h, M, s, ms) {
8983
- var date;
8984
- if (y < 100 && y >= 0) {
8985
- date = new Date(y + 400, m, d, h, M, s, ms);
8986
- if (isFinite(date.getFullYear())) {
8987
- date.setFullYear(y);
8988
- }
8989
- } else {
8990
- date = new Date(y, m, d, h, M, s, ms);
8991
- }
8992
- return date;
8993
- }
8994
- function createUTCDate(y) {
8995
- var date, args;
8996
- if (y < 100 && y >= 0) {
8997
- args = Array.prototype.slice.call(arguments);
8998
- args[0] = y + 400;
8999
- date = new Date(Date.UTC.apply(null, args));
9000
- if (isFinite(date.getUTCFullYear())) {
9001
- date.setUTCFullYear(y);
9002
- }
9003
- } else {
9004
- date = new Date(Date.UTC.apply(null, arguments));
9005
- }
9006
- return date;
9007
- }
9008
- function firstWeekOffset(year, dow, doy) {
9009
- var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
9010
- return -fwdlw + fwd - 1;
9011
- }
9012
- function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
9013
- var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
9014
- if (dayOfYear <= 0) {
9015
- resYear = year - 1;
9016
- resDayOfYear = daysInYear(resYear) + dayOfYear;
9017
- } else if (dayOfYear > daysInYear(year)) {
9018
- resYear = year + 1;
9019
- resDayOfYear = dayOfYear - daysInYear(year);
9020
- } else {
9021
- resYear = year;
9022
- resDayOfYear = dayOfYear;
9023
- }
9024
- return {
9025
- year: resYear,
9026
- dayOfYear: resDayOfYear
9027
- };
9028
- }
9029
- function weekOfYear(mom, dow, doy) {
9030
- var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
9031
- if (week < 1) {
9032
- resYear = mom.year() - 1;
9033
- resWeek = week + weeksInYear(resYear, dow, doy);
9034
- } else if (week > weeksInYear(mom.year(), dow, doy)) {
9035
- resWeek = week - weeksInYear(mom.year(), dow, doy);
9036
- resYear = mom.year() + 1;
9037
- } else {
9038
- resYear = mom.year();
9039
- resWeek = week;
9040
- }
9041
- return {
9042
- week: resWeek,
9043
- year: resYear
9044
- };
9045
- }
9046
- function weeksInYear(year, dow, doy) {
9047
- var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
9048
- return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
9049
- }
9050
- addFormatToken("w", ["ww", 2], "wo", "week");
9051
- addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
9052
- addRegexToken("w", match1to2, match1to2NoLeadingZero);
9053
- addRegexToken("ww", match1to2, match2);
9054
- addRegexToken("W", match1to2, match1to2NoLeadingZero);
9055
- addRegexToken("WW", match1to2, match2);
9056
- addWeekParseToken(["w", "ww", "W", "WW"], function(input, week, config, token2) {
9057
- week[token2.substr(0, 1)] = toInt(input);
9058
- });
9059
- function localeWeek(mom) {
9060
- return weekOfYear(mom, this._week.dow, this._week.doy).week;
9061
- }
9062
- var defaultLocaleWeek = {
9063
- dow: 0,
9064
- doy: 6
9065
- };
9066
- function localeFirstDayOfWeek() {
9067
- return this._week.dow;
9068
- }
9069
- function localeFirstDayOfYear() {
9070
- return this._week.doy;
9071
- }
9072
- function getSetWeek(input) {
9073
- var week = this.localeData().week(this);
9074
- return input == null ? week : this.add((input - week) * 7, "d");
9075
- }
9076
- function getSetISOWeek(input) {
9077
- var week = weekOfYear(this, 1, 4).week;
9078
- return input == null ? week : this.add((input - week) * 7, "d");
9079
- }
9080
8881
  addFormatToken("d", 0, "do", "day");
9081
8882
  addFormatToken("dd", 0, 0, function(format2) {
9082
8883
  return this.localeData().weekdaysMin(this, format2);
@@ -9089,9 +8890,13 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9089
8890
  });
9090
8891
  addFormatToken("e", 0, 0, "weekday");
9091
8892
  addFormatToken("E", 0, 0, "isoWeekday");
8893
+ addFormatToken("eHHmm", 0, 0, function() {
8894
+ return "" + this.weekday() + zeroFill(this.hours(), 2) + zeroFill(this.minutes(), 2);
8895
+ });
9092
8896
  addRegexToken("d", match1to2);
9093
8897
  addRegexToken("e", match1to2);
9094
8898
  addRegexToken("E", match1to2);
8899
+ addRegexToken("eHHmm", match5to6);
9095
8900
  addRegexToken("dd", function(isStrict, locale2) {
9096
8901
  return locale2.weekdaysMinRegex(isStrict);
9097
8902
  });
@@ -9112,6 +8917,12 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9112
8917
  addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) {
9113
8918
  week[token2] = toInt(input);
9114
8919
  });
8920
+ addWeekParseToken("eHHmm", function(input, week, config) {
8921
+ var weekdayEnd = input.length - 4;
8922
+ week.e = toInt(input.substr(0, weekdayEnd));
8923
+ config._a[HOUR] = toInt(input.substr(weekdayEnd, 2));
8924
+ config._a[MINUTE] = toInt(input.substr(weekdayEnd + 2));
8925
+ });
9115
8926
  function parseWeekday(input, locale2) {
9116
8927
  if (typeof input !== "string") {
9117
8928
  return input;
@@ -9134,7 +8945,27 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9134
8945
  function shiftWeekdays(ws, n) {
9135
8946
  return ws.slice(n, 7).concat(ws.slice(0, n));
9136
8947
  }
9137
- var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
8948
+ var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord, weekdaysParseProperties = [
8949
+ "weekdaysParse",
8950
+ "fullWeekdaysParse",
8951
+ "shortWeekdaysParse",
8952
+ "minWeekdaysParse",
8953
+ "weekdaysRegex",
8954
+ "weekdaysShortRegex",
8955
+ "weekdaysMinRegex",
8956
+ "weekdaysStrictRegex",
8957
+ "weekdaysShortStrictRegex",
8958
+ "weekdaysMinStrictRegex"
8959
+ ];
8960
+ function clearWeekdaysParseCache(locale2, config) {
8961
+ var i, prop;
8962
+ for (i = 0;i < weekdaysParseProperties.length; i++) {
8963
+ prop = weekdaysParseProperties[i];
8964
+ if (!hasOwnProp(config, prop)) {
8965
+ delete locale2["_" + prop];
8966
+ }
8967
+ }
8968
+ }
9138
8969
  function localeWeekdays(m, format2) {
9139
8970
  var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
9140
8971
  return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;
@@ -9145,7 +8976,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9145
8976
  function localeWeekdaysMin(m) {
9146
8977
  return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin;
9147
8978
  }
9148
- function handleStrictParse$1(weekdayName, format2, strict) {
8979
+ function handleStrictParse(weekdayName, format2, strict) {
9149
8980
  var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
9150
8981
  if (!this._weekdaysParse) {
9151
8982
  this._weekdaysParse = [];
@@ -9209,7 +9040,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9209
9040
  function localeWeekdaysParse(weekdayName, format2, strict) {
9210
9041
  var i, mom, regex;
9211
9042
  if (this._weekdaysParseExact) {
9212
- return handleStrictParse$1.call(this, weekdayName, format2, strict);
9043
+ return handleStrictParse.call(this, weekdayName, format2, strict);
9213
9044
  }
9214
9045
  if (!this._weekdaysParse) {
9215
9046
  this._weekdaysParse = [];
@@ -9239,114 +9070,360 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9239
9070
  }
9240
9071
  }
9241
9072
  }
9242
- function getSetDayOfWeek(input) {
9243
- if (!this.isValid()) {
9244
- return input != null ? this : NaN;
9245
- }
9246
- var day = get(this, "Day");
9247
- if (input != null) {
9248
- input = parseWeekday(input, this.localeData());
9249
- return this.add(input - day, "d");
9250
- } else {
9251
- return day;
9252
- }
9073
+ function getSetDayOfWeek(input) {
9074
+ if (!this.isValid()) {
9075
+ return input != null ? this : NaN;
9076
+ }
9077
+ var day = get$2(this, "Day");
9078
+ if (input != null) {
9079
+ input = parseWeekday(input, this.localeData());
9080
+ return this.add(input - day, "d");
9081
+ } else {
9082
+ return day;
9083
+ }
9084
+ }
9085
+ function getSetLocaleDayOfWeek(input) {
9086
+ if (!this.isValid()) {
9087
+ return input != null ? this : NaN;
9088
+ }
9089
+ var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
9090
+ return input == null ? weekday : this.add(input - weekday, "d");
9091
+ }
9092
+ function getSetISODayOfWeek(input) {
9093
+ if (!this.isValid()) {
9094
+ return input != null ? this : NaN;
9095
+ }
9096
+ if (input != null) {
9097
+ var weekday = parseIsoWeekday(input, this.localeData());
9098
+ return this.day(this.day() % 7 ? weekday : weekday - 7);
9099
+ } else {
9100
+ return this.day() || 7;
9101
+ }
9102
+ }
9103
+ function weekdaysRegex(isStrict) {
9104
+ if (this._weekdaysParseExact) {
9105
+ if (!hasOwnProp(this, "_weekdaysRegex")) {
9106
+ computeWeekdaysParse.call(this);
9107
+ }
9108
+ if (isStrict) {
9109
+ return this._weekdaysStrictRegex;
9110
+ } else {
9111
+ return this._weekdaysRegex;
9112
+ }
9113
+ } else {
9114
+ if (!hasOwnProp(this, "_weekdaysRegex")) {
9115
+ this._weekdaysRegex = defaultWeekdaysRegex;
9116
+ }
9117
+ return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
9118
+ }
9119
+ }
9120
+ function weekdaysShortRegex(isStrict) {
9121
+ if (this._weekdaysParseExact) {
9122
+ if (!hasOwnProp(this, "_weekdaysRegex")) {
9123
+ computeWeekdaysParse.call(this);
9124
+ }
9125
+ if (isStrict) {
9126
+ return this._weekdaysShortStrictRegex;
9127
+ } else {
9128
+ return this._weekdaysShortRegex;
9129
+ }
9130
+ } else {
9131
+ if (!hasOwnProp(this, "_weekdaysShortRegex")) {
9132
+ this._weekdaysShortRegex = defaultWeekdaysShortRegex;
9133
+ }
9134
+ return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
9135
+ }
9136
+ }
9137
+ function weekdaysMinRegex(isStrict) {
9138
+ if (this._weekdaysParseExact) {
9139
+ if (!hasOwnProp(this, "_weekdaysRegex")) {
9140
+ computeWeekdaysParse.call(this);
9141
+ }
9142
+ if (isStrict) {
9143
+ return this._weekdaysMinStrictRegex;
9144
+ } else {
9145
+ return this._weekdaysMinRegex;
9146
+ }
9147
+ } else {
9148
+ if (!hasOwnProp(this, "_weekdaysMinRegex")) {
9149
+ this._weekdaysMinRegex = defaultWeekdaysMinRegex;
9150
+ }
9151
+ return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
9152
+ }
9153
+ }
9154
+ function computeWeekdaysParse() {
9155
+ function cmpLenRev(a, b) {
9156
+ return b.length - a.length;
9157
+ }
9158
+ var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp;
9159
+ for (i = 0;i < 7; i++) {
9160
+ mom = createUTC([2000, 1]).day(i);
9161
+ minp = regexEscape(this.weekdaysMin(mom, ""));
9162
+ shortp = regexEscape(this.weekdaysShort(mom, ""));
9163
+ longp = regexEscape(this.weekdays(mom, ""));
9164
+ minPieces.push(minp);
9165
+ shortPieces.push(shortp);
9166
+ longPieces.push(longp);
9167
+ mixedPieces.push(minp);
9168
+ mixedPieces.push(shortp);
9169
+ mixedPieces.push(longp);
9170
+ }
9171
+ minPieces.sort(cmpLenRev);
9172
+ shortPieces.sort(cmpLenRev);
9173
+ longPieces.sort(cmpLenRev);
9174
+ mixedPieces.sort(cmpLenRev);
9175
+ this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
9176
+ this._weekdaysShortRegex = this._weekdaysRegex;
9177
+ this._weekdaysMinRegex = this._weekdaysRegex;
9178
+ this._weekdaysStrictRegex = new RegExp("^(" + longPieces.join("|") + ")", "i");
9179
+ this._weekdaysShortStrictRegex = new RegExp("^(" + shortPieces.join("|") + ")", "i");
9180
+ this._weekdaysMinStrictRegex = new RegExp("^(" + minPieces.join("|") + ")", "i");
9181
+ }
9182
+ function set(config) {
9183
+ var prop, i;
9184
+ clearMonthsParseCache(this, config);
9185
+ clearWeekdaysParseCache(this, config);
9186
+ for (i in config) {
9187
+ if (hasOwnProp(config, i)) {
9188
+ prop = config[i];
9189
+ if (isFunction(prop)) {
9190
+ this[i] = prop;
9191
+ } else {
9192
+ this["_" + i] = prop;
9193
+ }
9194
+ }
9195
+ }
9196
+ this._config = config;
9197
+ this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source);
9198
+ }
9199
+ function mergeConfigs(parentConfig, childConfig) {
9200
+ var res = extend({}, parentConfig), prop;
9201
+ for (prop in childConfig) {
9202
+ if (hasOwnProp(childConfig, prop)) {
9203
+ if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
9204
+ res[prop] = {};
9205
+ extend(res[prop], parentConfig[prop]);
9206
+ extend(res[prop], childConfig[prop]);
9207
+ } else if (childConfig[prop] != null) {
9208
+ res[prop] = childConfig[prop];
9209
+ } else {
9210
+ delete res[prop];
9211
+ }
9212
+ }
9213
+ }
9214
+ for (prop in parentConfig) {
9215
+ if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
9216
+ res[prop] = extend({}, res[prop]);
9217
+ }
9218
+ }
9219
+ return res;
9220
+ }
9221
+ function Locale(config) {
9222
+ if (config != null) {
9223
+ this.set(config);
9224
+ }
9225
+ }
9226
+ var keys;
9227
+ if (Object.keys) {
9228
+ keys = Object.keys;
9229
+ } else {
9230
+ keys = function(obj) {
9231
+ var i, res = [];
9232
+ for (i in obj) {
9233
+ if (hasOwnProp(obj, i)) {
9234
+ res.push(i);
9235
+ }
9236
+ }
9237
+ return res;
9238
+ };
9239
+ }
9240
+ var defaultCalendar = {
9241
+ sameDay: "[Today at] LT",
9242
+ nextDay: "[Tomorrow at] LT",
9243
+ nextWeek: "dddd [at] LT",
9244
+ lastDay: "[Yesterday at] LT",
9245
+ lastWeek: "[Last] dddd [at] LT",
9246
+ sameElse: "L"
9247
+ };
9248
+ function calendar$1(key, mom, now2) {
9249
+ var output = this._calendar[key] || this._calendar["sameElse"];
9250
+ return isFunction(output) ? output.call(mom, now2) : output;
9251
+ }
9252
+ var defaultLongDateFormat = {
9253
+ LTS: "h:mm:ss A",
9254
+ LT: "h:mm A",
9255
+ L: "MM/DD/YYYY",
9256
+ LL: "MMMM D, YYYY",
9257
+ LLL: "MMMM D, YYYY h:mm A",
9258
+ LLLL: "dddd, MMMM D, YYYY h:mm A"
9259
+ };
9260
+ function longDateFormat(key) {
9261
+ var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()], formatCache = this._longDateFormatCache;
9262
+ if (format2 || !formatUpper) {
9263
+ return format2;
9264
+ }
9265
+ if (formatCache && formatCache[key] && formatCache[key].formatUpper === formatUpper) {
9266
+ return formatCache[key].format;
9267
+ }
9268
+ format2 = formatUpper.match(formattingTokens).map(function(tok) {
9269
+ if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
9270
+ return tok.slice(1);
9271
+ }
9272
+ return tok;
9273
+ }).join("");
9274
+ if (!formatCache) {
9275
+ formatCache = this._longDateFormatCache = {};
9276
+ }
9277
+ formatCache[key] = {
9278
+ formatUpper,
9279
+ format: format2
9280
+ };
9281
+ return format2;
9282
+ }
9283
+ var defaultInvalidDate = "Invalid date";
9284
+ function invalidDate() {
9285
+ return this._invalidDate;
9286
+ }
9287
+ var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
9288
+ function ordinal(number) {
9289
+ return this._ordinal.replace("%d", number);
9290
+ }
9291
+ var defaultRelativeTime = {
9292
+ future: "in %s",
9293
+ past: "%s ago",
9294
+ s: "a few seconds",
9295
+ ss: "%d seconds",
9296
+ m: "a minute",
9297
+ mm: "%d minutes",
9298
+ h: "an hour",
9299
+ hh: "%d hours",
9300
+ d: "a day",
9301
+ dd: "%d days",
9302
+ w: "a week",
9303
+ ww: "%d weeks",
9304
+ M: "a month",
9305
+ MM: "%d months",
9306
+ y: "a year",
9307
+ yy: "%d years"
9308
+ };
9309
+ function relativeTimeWithoutPostformat(number, withoutSuffix, string, isFuture) {
9310
+ var output = this._relativeTime[string];
9311
+ return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
9312
+ }
9313
+ function relativeTime$1(number, withoutSuffix, string, isFuture) {
9314
+ return this.postformat(relativeTimeWithoutPostformat.call(this, number, withoutSuffix, string, isFuture));
9253
9315
  }
9254
- function getSetLocaleDayOfWeek(input) {
9255
- if (!this.isValid()) {
9256
- return input != null ? this : NaN;
9257
- }
9258
- var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
9259
- return input == null ? weekday : this.add(input - weekday, "d");
9316
+ function pastFutureWithoutPostformat(diff2, output) {
9317
+ var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
9318
+ return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
9260
9319
  }
9261
- function getSetISODayOfWeek(input) {
9262
- if (!this.isValid()) {
9263
- return input != null ? this : NaN;
9264
- }
9265
- if (input != null) {
9266
- var weekday = parseIsoWeekday(input, this.localeData());
9267
- return this.day(this.day() % 7 ? weekday : weekday - 7);
9268
- } else {
9269
- return this.day() || 7;
9270
- }
9320
+ function pastFuture(diff2, output) {
9321
+ return this.postformat(pastFutureWithoutPostformat.call(this, diff2, output));
9271
9322
  }
9272
- function weekdaysRegex(isStrict) {
9273
- if (this._weekdaysParseExact) {
9274
- if (!hasOwnProp(this, "_weekdaysRegex")) {
9275
- computeWeekdaysParse.call(this);
9276
- }
9277
- if (isStrict) {
9278
- return this._weekdaysStrictRegex;
9279
- } else {
9280
- return this._weekdaysRegex;
9323
+ function createDate(y, m, d, h, M, s, ms) {
9324
+ var date;
9325
+ if (y < 100 && y >= 0) {
9326
+ date = new Date(y + 400, m, d, h, M, s, ms);
9327
+ if (isFinite(date.getFullYear())) {
9328
+ date.setFullYear(y);
9281
9329
  }
9282
9330
  } else {
9283
- if (!hasOwnProp(this, "_weekdaysRegex")) {
9284
- this._weekdaysRegex = defaultWeekdaysRegex;
9285
- }
9286
- return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
9331
+ date = new Date(y, m, d, h, M, s, ms);
9287
9332
  }
9333
+ return date;
9288
9334
  }
9289
- function weekdaysShortRegex(isStrict) {
9290
- if (this._weekdaysParseExact) {
9291
- if (!hasOwnProp(this, "_weekdaysRegex")) {
9292
- computeWeekdaysParse.call(this);
9293
- }
9294
- if (isStrict) {
9295
- return this._weekdaysShortStrictRegex;
9296
- } else {
9297
- return this._weekdaysShortRegex;
9335
+ function createUTCDate(y) {
9336
+ var date, args;
9337
+ if (y < 100 && y >= 0) {
9338
+ args = Array.prototype.slice.call(arguments);
9339
+ args[0] = y + 400;
9340
+ date = new Date(Date.UTC.apply(null, args));
9341
+ if (isFinite(date.getUTCFullYear())) {
9342
+ date.setUTCFullYear(y);
9298
9343
  }
9299
9344
  } else {
9300
- if (!hasOwnProp(this, "_weekdaysShortRegex")) {
9301
- this._weekdaysShortRegex = defaultWeekdaysShortRegex;
9302
- }
9303
- return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
9345
+ date = new Date(Date.UTC.apply(null, arguments));
9304
9346
  }
9347
+ return date;
9305
9348
  }
9306
- function weekdaysMinRegex(isStrict) {
9307
- if (this._weekdaysParseExact) {
9308
- if (!hasOwnProp(this, "_weekdaysRegex")) {
9309
- computeWeekdaysParse.call(this);
9310
- }
9311
- if (isStrict) {
9312
- return this._weekdaysMinStrictRegex;
9313
- } else {
9314
- return this._weekdaysMinRegex;
9315
- }
9349
+ function firstWeekOffset(year, dow, doy) {
9350
+ var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
9351
+ return -fwdlw + fwd - 1;
9352
+ }
9353
+ function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
9354
+ var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
9355
+ if (dayOfYear <= 0) {
9356
+ resYear = year - 1;
9357
+ resDayOfYear = daysInYear(resYear) + dayOfYear;
9358
+ } else if (dayOfYear > daysInYear(year)) {
9359
+ resYear = year + 1;
9360
+ resDayOfYear = dayOfYear - daysInYear(year);
9316
9361
  } else {
9317
- if (!hasOwnProp(this, "_weekdaysMinRegex")) {
9318
- this._weekdaysMinRegex = defaultWeekdaysMinRegex;
9319
- }
9320
- return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
9362
+ resYear = year;
9363
+ resDayOfYear = dayOfYear;
9321
9364
  }
9365
+ return {
9366
+ year: resYear,
9367
+ dayOfYear: resDayOfYear
9368
+ };
9322
9369
  }
9323
- function computeWeekdaysParse() {
9324
- function cmpLenRev(a, b) {
9325
- return b.length - a.length;
9326
- }
9327
- var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp;
9328
- for (i = 0;i < 7; i++) {
9329
- mom = createUTC([2000, 1]).day(i);
9330
- minp = regexEscape(this.weekdaysMin(mom, ""));
9331
- shortp = regexEscape(this.weekdaysShort(mom, ""));
9332
- longp = regexEscape(this.weekdays(mom, ""));
9333
- minPieces.push(minp);
9334
- shortPieces.push(shortp);
9335
- longPieces.push(longp);
9336
- mixedPieces.push(minp);
9337
- mixedPieces.push(shortp);
9338
- mixedPieces.push(longp);
9370
+ function weekOfYearFromDayOfYear(year, dayOfYear, dow, doy) {
9371
+ var weekOffset = firstWeekOffset(year, dow, doy), week = Math.floor((dayOfYear - weekOffset - 1) / 7) + 1, resWeek, resYear;
9372
+ if (week < 1) {
9373
+ resYear = year - 1;
9374
+ resWeek = week + weeksInYear(resYear, dow, doy);
9375
+ } else if (week > weeksInYear(year, dow, doy)) {
9376
+ resWeek = week - weeksInYear(year, dow, doy);
9377
+ resYear = year + 1;
9378
+ } else {
9379
+ resYear = year;
9380
+ resWeek = week;
9339
9381
  }
9340
- minPieces.sort(cmpLenRev);
9341
- shortPieces.sort(cmpLenRev);
9342
- longPieces.sort(cmpLenRev);
9343
- mixedPieces.sort(cmpLenRev);
9344
- this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
9345
- this._weekdaysShortRegex = this._weekdaysRegex;
9346
- this._weekdaysMinRegex = this._weekdaysRegex;
9347
- this._weekdaysStrictRegex = new RegExp("^(" + longPieces.join("|") + ")", "i");
9348
- this._weekdaysShortStrictRegex = new RegExp("^(" + shortPieces.join("|") + ")", "i");
9349
- this._weekdaysMinStrictRegex = new RegExp("^(" + minPieces.join("|") + ")", "i");
9382
+ return {
9383
+ week: resWeek,
9384
+ year: resYear
9385
+ };
9386
+ }
9387
+ function weekOfYear(mom, dow, doy) {
9388
+ return weekOfYearFromDayOfYear(mom.year(), mom.dayOfYear(), dow, doy);
9389
+ }
9390
+ function weekOfYearFromDate(year, month, date, dow, doy) {
9391
+ var dayOfYear = Math.round((createUTCDate(year, month, date) - createUTCDate(year, 0, 1)) / 86400000) + 1;
9392
+ return weekOfYearFromDayOfYear(year, dayOfYear, dow, doy);
9393
+ }
9394
+ function weeksInYear(year, dow, doy) {
9395
+ var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
9396
+ return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
9397
+ }
9398
+ addFormatToken("w", ["ww", 2], "wo", "week");
9399
+ addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
9400
+ addRegexToken("w", match1to2, match1to2NoLeadingZero);
9401
+ addRegexToken("ww", match1to2, match2);
9402
+ addRegexToken("W", match1to2, match1to2NoLeadingZero);
9403
+ addRegexToken("WW", match1to2, match2);
9404
+ addWeekParseToken(["w", "ww", "W", "WW"], function(input, week, config, token2) {
9405
+ week[token2.substr(0, 1)] = toInt(input);
9406
+ });
9407
+ function localeWeek(mom) {
9408
+ return weekOfYear(mom, this._week.dow, this._week.doy).week;
9409
+ }
9410
+ var defaultLocaleWeek = {
9411
+ dow: 0,
9412
+ doy: 6
9413
+ };
9414
+ function localeFirstDayOfWeek() {
9415
+ return this._week.dow;
9416
+ }
9417
+ function localeFirstDayOfYear() {
9418
+ return this._week.doy;
9419
+ }
9420
+ function getSetWeek(input) {
9421
+ var week = this.localeData().week(this);
9422
+ return input == null ? week : this.add((input - week) * 7, "d");
9423
+ }
9424
+ function getSetISOWeek(input) {
9425
+ var week = weekOfYear(this, 1, 4).week;
9426
+ return input == null ? week : this.add((input - week) * 7, "d");
9350
9427
  }
9351
9428
  function hFormat() {
9352
9429
  return this.hours() % 12 || 12;
@@ -9489,21 +9566,30 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9489
9566
  return globalLocale;
9490
9567
  }
9491
9568
  function isLocaleNameSane(name) {
9492
- return !!(name && name.match("^[^/\\\\]*$"));
9569
+ return typeof name === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
9493
9570
  }
9494
9571
  function loadLocale(name) {
9495
- var oldLocale = null, aliasedRequire;
9496
- if (locales[name] === undefined && typeof module !== "undefined" && module && module.exports && isLocaleNameSane(name)) {
9572
+ var oldLocale = null, aliasedRequire, normalizedName;
9573
+ if (hasOwnProp(locales, name)) {
9574
+ return locales[name];
9575
+ }
9576
+ normalizedName = normalizeLocale(name);
9577
+ if (hasOwnProp(locales, normalizedName)) {
9578
+ return locales[normalizedName];
9579
+ }
9580
+ if (typeof module !== "undefined" && module && module.exports && isLocaleNameSane(normalizedName)) {
9497
9581
  try {
9498
9582
  oldLocale = globalLocale._abbr;
9499
9583
  aliasedRequire = __require;
9500
- aliasedRequire("./locale/" + name);
9584
+ aliasedRequire("./locale/" + normalizedName);
9501
9585
  getSetGlobalLocale(oldLocale);
9502
9586
  } catch (e) {
9503
- locales[name] = null;
9587
+ locales[normalizedName] = null;
9504
9588
  }
9505
9589
  }
9506
- return locales[name];
9590
+ if (hasOwnProp(locales, normalizedName)) {
9591
+ return locales[normalizedName];
9592
+ }
9507
9593
  }
9508
9594
  function getSetGlobalLocale(key, values) {
9509
9595
  var data;
@@ -9563,12 +9649,14 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9563
9649
  }
9564
9650
  }
9565
9651
  function updateLocale(name, config) {
9652
+ var locale2, tmpLocale = loadLocale(name), parentConfig = baseConfig;
9653
+ if (tmpLocale != null) {
9654
+ name = tmpLocale._abbr;
9655
+ }
9566
9656
  if (config != null) {
9567
- var locale2, tmpLocale, parentConfig = baseConfig;
9568
9657
  if (locales[name] != null && locales[name].parentLocale != null) {
9569
9658
  locales[name].set(mergeConfigs(locales[name]._config, config));
9570
9659
  } else {
9571
- tmpLocale = loadLocale(name);
9572
9660
  if (tmpLocale != null) {
9573
9661
  parentConfig = tmpLocale._config;
9574
9662
  }
@@ -9811,8 +9899,35 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9811
9899
  }
9812
9900
  return c;
9813
9901
  }
9814
- function currentDateArray(config) {
9815
- var nowValue = new Date(hooks.now());
9902
+ function currentDateArray(config, now2, forWeek) {
9903
+ var hadWeekContext = Object.prototype.hasOwnProperty.call(config, "_isDefaultDatePartsForWeek"), weekContext = config._isDefaultDatePartsForWeek;
9904
+ config._isDefaultDatePartsForWeek = !!forWeek;
9905
+ try {
9906
+ return hooks._getDefaultDateParts(config, now2, forWeek);
9907
+ } finally {
9908
+ if (hadWeekContext) {
9909
+ config._isDefaultDatePartsForWeek = weekContext;
9910
+ } else {
9911
+ delete config._isDefaultDatePartsForWeek;
9912
+ }
9913
+ }
9914
+ }
9915
+ function currentDateNow(config) {
9916
+ var now2 = config._defaultDatePartsNow;
9917
+ if (!now2) {
9918
+ return hooks.now();
9919
+ }
9920
+ if (!now2.hasValue) {
9921
+ now2.value = hooks.now();
9922
+ now2.hasValue = true;
9923
+ }
9924
+ return now2.value;
9925
+ }
9926
+ function getDefaultDateParts(config, now2, forWeek) {
9927
+ var useWeekDefaults = forWeek || config._isDefaultDatePartsForWeek, nowValue = useWeekDefaults ? createLocal(now2) : new Date(now2);
9928
+ if (useWeekDefaults) {
9929
+ return [nowValue.year(), nowValue.month(), nowValue.date()];
9930
+ }
9816
9931
  if (config._useUTC) {
9817
9932
  return [
9818
9933
  nowValue.getUTCFullYear(),
@@ -9822,17 +9937,21 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9822
9937
  }
9823
9938
  return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
9824
9939
  }
9940
+ hooks._getDefaultDateParts = getDefaultDateParts;
9825
9941
  function configFromArray(config) {
9826
- var i, date, input = [], currentDate, expectedWeekday, yearToUse;
9942
+ var i, date, input = [], now2, currentDate, expectedWeekday, yearToUse, dateIsDefaulted;
9827
9943
  if (config._d) {
9828
9944
  return;
9829
9945
  }
9830
- currentDate = currentDateArray(config);
9946
+ if (config._a[YEAR] == null || config._a[MONTH] == null || config._a[DATE] == null) {
9947
+ now2 = currentDateNow(config);
9948
+ currentDate = currentDateArray(config, now2);
9949
+ }
9831
9950
  if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
9832
- dayOfYearFromWeekInfo(config);
9951
+ dayOfYearFromWeekInfo(config, currentDateArray(config, now2, true));
9833
9952
  }
9834
9953
  if (config._dayOfYear != null) {
9835
- yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
9954
+ yearToUse = config._a[YEAR] != null ? config._a[YEAR] : currentDate[YEAR];
9836
9955
  if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
9837
9956
  getParsingFlags(config)._overflowDayOfYear = true;
9838
9957
  }
@@ -9840,6 +9959,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9840
9959
  config._a[MONTH] = date.getUTCMonth();
9841
9960
  config._a[DATE] = date.getUTCDate();
9842
9961
  }
9962
+ dateIsDefaulted = config._a[YEAR] == null || config._a[MONTH] == null || config._a[DATE] == null;
9843
9963
  for (i = 0;i < 3 && config._a[i] == null; ++i) {
9844
9964
  config._a[i] = input[i] = currentDate[i];
9845
9965
  }
@@ -9858,17 +9978,17 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9858
9978
  if (config._nextDay) {
9859
9979
  config._a[HOUR] = 24;
9860
9980
  }
9861
- if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) {
9981
+ if (config._w && typeof config._w.d !== "undefined" && !dateIsDefaulted && config._w.d !== expectedWeekday) {
9862
9982
  getParsingFlags(config).weekdayMismatch = true;
9863
9983
  }
9864
9984
  }
9865
- function dayOfYearFromWeekInfo(config) {
9985
+ function dayOfYearFromWeekInfo(config, currentDate) {
9866
9986
  var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
9867
9987
  w = config._w;
9868
9988
  if (w.GG != null || w.W != null || w.E != null) {
9869
9989
  dow = 1;
9870
9990
  doy = 4;
9871
- weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
9991
+ weekYear = defaults(w.GG, config._a[YEAR], weekOfYearFromDate(currentDate[YEAR], currentDate[MONTH], currentDate[DATE], 1, 4).year);
9872
9992
  week = defaults(w.W, 1);
9873
9993
  weekday = defaults(w.E, 1);
9874
9994
  if (weekday < 1 || weekday > 7) {
@@ -9877,7 +9997,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9877
9997
  } else {
9878
9998
  dow = config._locale._week.dow;
9879
9999
  doy = config._locale._week.doy;
9880
- curWeek = weekOfYear(createLocal(), dow, doy);
10000
+ curWeek = weekOfYearFromDate(currentDate[YEAR], currentDate[MONTH], currentDate[DATE], dow, doy);
9881
10001
  weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
9882
10002
  week = defaults(w.w, curWeek.week);
9883
10003
  if (w.d != null) {
@@ -9980,7 +10100,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9980
10100
  }
9981
10101
  }
9982
10102
  function configFromStringAndArray(config) {
9983
- var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
10103
+ var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, defaultDatePartsNow = {}, configfLen = config._f.length;
9984
10104
  if (configfLen === 0) {
9985
10105
  getParsingFlags(config).invalidFormat = true;
9986
10106
  config._d = new Date(NaN);
@@ -9993,9 +10113,10 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
9993
10113
  if (config._useUTC != null) {
9994
10114
  tempConfig._useUTC = config._useUTC;
9995
10115
  }
10116
+ tempConfig._defaultDatePartsNow = defaultDatePartsNow;
9996
10117
  tempConfig._f = config._f[i];
9997
10118
  configFromStringAndFormat(tempConfig);
9998
- if (isValid(tempConfig)) {
10119
+ if (isValid$2(tempConfig)) {
9999
10120
  validFormatFound = true;
10000
10121
  }
10001
10122
  currentScore += getParsingFlags(tempConfig).charsLeftOver;
@@ -10040,7 +10161,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10040
10161
  var { _i: input, _f: format2 } = config;
10041
10162
  config._locale = config._locale || getLocale(config._l);
10042
10163
  if (input === null || format2 === undefined && input === "") {
10043
- return createInvalid({ nullInput: true });
10164
+ return createInvalid$1({ nullInput: true });
10044
10165
  }
10045
10166
  if (typeof input === "string") {
10046
10167
  config._i = input = config._locale.preparse(input);
@@ -10056,7 +10177,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10056
10177
  } else {
10057
10178
  configFromInput(config);
10058
10179
  }
10059
- if (!isValid(config)) {
10180
+ if (!isValid$2(config)) {
10060
10181
  config._d = null;
10061
10182
  }
10062
10183
  return config;
@@ -10111,14 +10232,14 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10111
10232
  if (this.isValid() && other.isValid()) {
10112
10233
  return other < this ? this : other;
10113
10234
  } else {
10114
- return createInvalid();
10235
+ return createInvalid$1();
10115
10236
  }
10116
10237
  }), prototypeMax = deprecate("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/", function() {
10117
10238
  var other = createLocal.apply(null, arguments);
10118
10239
  if (this.isValid() && other.isValid()) {
10119
10240
  return other > this ? this : other;
10120
10241
  } else {
10121
- return createInvalid();
10242
+ return createInvalid$1();
10122
10243
  }
10123
10244
  });
10124
10245
  function pickBy(fn, moments) {
@@ -10129,9 +10250,17 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10129
10250
  if (!moments.length) {
10130
10251
  return createLocal();
10131
10252
  }
10132
- res = moments[0];
10133
- for (i = 1;i < moments.length; ++i) {
10134
- if (!moments[i].isValid() || moments[i][fn](res)) {
10253
+ for (i = 0;i < moments.length; ++i) {
10254
+ if (isMoment(moments[i])) {
10255
+ res = moments[i];
10256
+ break;
10257
+ }
10258
+ }
10259
+ if (!res) {
10260
+ return createInvalid$1();
10261
+ }
10262
+ for (++i;i < moments.length; ++i) {
10263
+ if (isMoment(moments[i]) && (!moments[i].isValid() || moments[i][fn](res))) {
10135
10264
  res = moments[i];
10136
10265
  }
10137
10266
  }
@@ -10181,7 +10310,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10181
10310
  function isValid$1() {
10182
10311
  return this._isValid;
10183
10312
  }
10184
- function createInvalid$1() {
10313
+ function createInvalid() {
10185
10314
  return createDuration(NaN);
10186
10315
  }
10187
10316
  function Duration(duration) {
@@ -10207,7 +10336,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10207
10336
  function compareArrays(array1, array2, dontConvert) {
10208
10337
  var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i;
10209
10338
  for (i = 0;i < len; i++) {
10210
- if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) {
10339
+ if (toInt(array1[i]) !== toInt(array2[i])) {
10211
10340
  diffs++;
10212
10341
  }
10213
10342
  }
@@ -10228,8 +10357,12 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10228
10357
  addRegexToken("Z", matchShortOffset);
10229
10358
  addRegexToken("ZZ", matchShortOffset);
10230
10359
  addParseToken(["Z", "ZZ"], function(input, array, config) {
10360
+ var offset2 = offsetFromString(matchShortOffset, input);
10231
10361
  config._useUTC = true;
10232
- config._tzm = offsetFromString(matchShortOffset, input);
10362
+ config._tzm = offset2;
10363
+ if (offset2 === null) {
10364
+ getParsingFlags(config).invalidOffset = input;
10365
+ }
10233
10366
  });
10234
10367
  var chunkOffset = /([\+\-]|\d\d)/gi;
10235
10368
  function offsetFromString(matcher, string) {
@@ -10240,6 +10373,9 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10240
10373
  chunk = matches[matches.length - 1] || [];
10241
10374
  parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
10242
10375
  minutes2 = +(parts[1] * 60) + toInt(parts[2]);
10376
+ if (toInt(parts[2]) > 59 || (parts[0] === "+" ? minutes2 > 14 * 60 : minutes2 > 12 * 60)) {
10377
+ return null;
10378
+ }
10243
10379
  return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
10244
10380
  }
10245
10381
  function cloneWithOffset(input, model) {
@@ -10282,7 +10418,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10282
10418
  }
10283
10419
  if (offset2 !== input) {
10284
10420
  if (!keepLocalTime || this._changeInProgress) {
10285
- addSubtract(this, createDuration(input - offset2, "m"), 1, false);
10421
+ addSubtract$1(this, createDuration(input - offset2, "m"), 1, false);
10286
10422
  } else if (!this._changeInProgress) {
10287
10423
  this._changeInProgress = true;
10288
10424
  hooks.updateOffset(this, true);
@@ -10420,7 +10556,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10420
10556
  return ret;
10421
10557
  }
10422
10558
  createDuration.fn = Duration.prototype;
10423
- createDuration.invalid = createInvalid$1;
10559
+ createDuration.invalid = createInvalid;
10424
10560
  function parseIso(inp, sign2) {
10425
10561
  var res = inp && parseFloat(inp.replace(",", "."));
10426
10562
  return (isNaN(res) ? 0 : res) * sign2;
@@ -10459,21 +10595,21 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10459
10595
  period = tmp;
10460
10596
  }
10461
10597
  dur = createDuration(val, period);
10462
- addSubtract(this, dur, direction);
10598
+ addSubtract$1(this, dur, direction);
10463
10599
  return this;
10464
10600
  };
10465
10601
  }
10466
- function addSubtract(mom, duration, isAdding, updateOffset) {
10602
+ function addSubtract$1(mom, duration, isAdding, updateOffset) {
10467
10603
  var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
10468
10604
  if (!mom.isValid()) {
10469
10605
  return;
10470
10606
  }
10471
10607
  updateOffset = updateOffset == null ? true : updateOffset;
10472
10608
  if (months2) {
10473
- setMonth(mom, get(mom, "Month") + months2 * isAdding);
10609
+ setMonth(mom, get$2(mom, "Month") + months2 * isAdding);
10474
10610
  }
10475
10611
  if (days2) {
10476
- set$1(mom, "Date", get(mom, "Date") + days2 * isAdding);
10612
+ set$1(mom, "Date", get$2(mom, "Date") + days2 * isAdding);
10477
10613
  }
10478
10614
  if (milliseconds2) {
10479
10615
  mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
@@ -10482,7 +10618,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10482
10618
  hooks.updateOffset(mom, days2 || months2);
10483
10619
  }
10484
10620
  }
10485
- var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
10621
+ var add$1 = createAdder(1, "add"), subtract$1 = createAdder(-1, "subtract");
10486
10622
  function isString(input) {
10487
10623
  return typeof input === "string" || input instanceof String;
10488
10624
  }
@@ -10550,7 +10686,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10550
10686
  var diff2 = myMoment.diff(now2, "days", true);
10551
10687
  return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
10552
10688
  }
10553
- function calendar$1(time, formats) {
10689
+ function calendar(time, formats) {
10554
10690
  if (arguments.length === 1) {
10555
10691
  if (!arguments[0]) {
10556
10692
  time = undefined;
@@ -10566,7 +10702,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10566
10702
  var now2 = time || createLocal(), sod = cloneWithOffset(now2, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now2) : formats[format2]);
10567
10703
  return this.format(output || this.localeData().calendar(format2, this, createLocal(now2)));
10568
10704
  }
10569
- function clone() {
10705
+ function clone$1() {
10570
10706
  return new Moment(this);
10571
10707
  }
10572
10708
  function isAfter(input, units) {
@@ -10680,7 +10816,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10680
10816
  function toString() {
10681
10817
  return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
10682
10818
  }
10683
- function toISOString(keepOffset) {
10819
+ function toISOString$1(keepOffset) {
10684
10820
  if (!this.isValid()) {
10685
10821
  return null;
10686
10822
  }
@@ -10762,7 +10898,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10762
10898
  return this._locale;
10763
10899
  }
10764
10900
  var MS_PER_SECOND = 1000, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
10765
- function mod$1(dividend, divisor) {
10901
+ function mod(dividend, divisor) {
10766
10902
  return (dividend % divisor + divisor) % divisor;
10767
10903
  }
10768
10904
  function localStartOfDate(y, m, d) {
@@ -10808,15 +10944,15 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10808
10944
  break;
10809
10945
  case "hour":
10810
10946
  time = this._d.valueOf();
10811
- time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
10947
+ time -= mod(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
10812
10948
  break;
10813
10949
  case "minute":
10814
10950
  time = this._d.valueOf();
10815
- time -= mod$1(time, MS_PER_MINUTE);
10951
+ time -= mod(time, MS_PER_MINUTE);
10816
10952
  break;
10817
10953
  case "second":
10818
10954
  time = this._d.valueOf();
10819
- time -= mod$1(time, MS_PER_SECOND);
10955
+ time -= mod(time, MS_PER_SECOND);
10820
10956
  break;
10821
10957
  }
10822
10958
  this._d.setTime(time);
@@ -10852,22 +10988,22 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10852
10988
  break;
10853
10989
  case "hour":
10854
10990
  time = this._d.valueOf();
10855
- time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;
10991
+ time += MS_PER_HOUR - mod(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;
10856
10992
  break;
10857
10993
  case "minute":
10858
10994
  time = this._d.valueOf();
10859
- time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
10995
+ time += MS_PER_MINUTE - mod(time, MS_PER_MINUTE) - 1;
10860
10996
  break;
10861
10997
  case "second":
10862
10998
  time = this._d.valueOf();
10863
- time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
10999
+ time += MS_PER_SECOND - mod(time, MS_PER_SECOND) - 1;
10864
11000
  break;
10865
11001
  }
10866
11002
  this._d.setTime(time);
10867
11003
  hooks.updateOffset(this, true);
10868
11004
  return this;
10869
11005
  }
10870
- function valueOf() {
11006
+ function valueOf$1() {
10871
11007
  return this._d.valueOf() - (this._offset || 0) * 60000;
10872
11008
  }
10873
11009
  function unix() {
@@ -10903,8 +11039,8 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
10903
11039
  function toJSON() {
10904
11040
  return this.isValid() ? this.toISOString() : null;
10905
11041
  }
10906
- function isValid$2() {
10907
- return isValid(this);
11042
+ function isValid() {
11043
+ return isValid$2(this);
10908
11044
  }
10909
11045
  function parsingFlags() {
10910
11046
  return extend({}, getParsingFlags(this));
@@ -11271,93 +11407,93 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11271
11407
  function getZoneName() {
11272
11408
  return this._isUTC ? "Coordinated Universal Time" : "";
11273
11409
  }
11274
- var proto = Moment.prototype;
11275
- proto.add = add;
11276
- proto.calendar = calendar$1;
11277
- proto.clone = clone;
11278
- proto.diff = diff;
11279
- proto.endOf = endOf;
11280
- proto.format = format;
11281
- proto.from = from;
11282
- proto.fromNow = fromNow;
11283
- proto.to = to;
11284
- proto.toNow = toNow;
11285
- proto.get = stringGet;
11286
- proto.invalidAt = invalidAt;
11287
- proto.isAfter = isAfter;
11288
- proto.isBefore = isBefore;
11289
- proto.isBetween = isBetween;
11290
- proto.isSame = isSame;
11291
- proto.isSameOrAfter = isSameOrAfter;
11292
- proto.isSameOrBefore = isSameOrBefore;
11293
- proto.isValid = isValid$2;
11294
- proto.lang = lang;
11295
- proto.locale = locale;
11296
- proto.localeData = localeData;
11297
- proto.max = prototypeMax;
11298
- proto.min = prototypeMin;
11299
- proto.parsingFlags = parsingFlags;
11300
- proto.set = stringSet;
11301
- proto.startOf = startOf;
11302
- proto.subtract = subtract;
11303
- proto.toArray = toArray;
11304
- proto.toObject = toObject;
11305
- proto.toDate = toDate;
11306
- proto.toISOString = toISOString;
11307
- proto.inspect = inspect;
11410
+ var proto$2 = Moment.prototype;
11411
+ proto$2.add = add$1;
11412
+ proto$2.calendar = calendar;
11413
+ proto$2.clone = clone$1;
11414
+ proto$2.diff = diff;
11415
+ proto$2.endOf = endOf;
11416
+ proto$2.format = format;
11417
+ proto$2.from = from;
11418
+ proto$2.fromNow = fromNow;
11419
+ proto$2.to = to;
11420
+ proto$2.toNow = toNow;
11421
+ proto$2.get = stringGet;
11422
+ proto$2.invalidAt = invalidAt;
11423
+ proto$2.isAfter = isAfter;
11424
+ proto$2.isBefore = isBefore;
11425
+ proto$2.isBetween = isBetween;
11426
+ proto$2.isSame = isSame;
11427
+ proto$2.isSameOrAfter = isSameOrAfter;
11428
+ proto$2.isSameOrBefore = isSameOrBefore;
11429
+ proto$2.isValid = isValid;
11430
+ proto$2.lang = lang;
11431
+ proto$2.locale = locale;
11432
+ proto$2.localeData = localeData;
11433
+ proto$2.max = prototypeMax;
11434
+ proto$2.min = prototypeMin;
11435
+ proto$2.parsingFlags = parsingFlags;
11436
+ proto$2.set = stringSet;
11437
+ proto$2.startOf = startOf;
11438
+ proto$2.subtract = subtract$1;
11439
+ proto$2.toArray = toArray;
11440
+ proto$2.toObject = toObject;
11441
+ proto$2.toDate = toDate;
11442
+ proto$2.toISOString = toISOString$1;
11443
+ proto$2.inspect = inspect;
11308
11444
  if (typeof Symbol !== "undefined" && Symbol.for != null) {
11309
- proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
11445
+ proto$2[Symbol.for("nodejs.util.inspect.custom")] = function() {
11310
11446
  return "Moment<" + this.format() + ">";
11311
11447
  };
11312
11448
  }
11313
- proto.toJSON = toJSON;
11314
- proto.toString = toString;
11315
- proto.unix = unix;
11316
- proto.valueOf = valueOf;
11317
- proto.creationData = creationData;
11318
- proto.eraName = getEraName;
11319
- proto.eraNarrow = getEraNarrow;
11320
- proto.eraAbbr = getEraAbbr;
11321
- proto.eraYear = getEraYear;
11322
- proto.year = getSetYear;
11323
- proto.isLeapYear = getIsLeapYear;
11324
- proto.weekYear = getSetWeekYear;
11325
- proto.isoWeekYear = getSetISOWeekYear;
11326
- proto.quarter = proto.quarters = getSetQuarter;
11327
- proto.month = getSetMonth;
11328
- proto.daysInMonth = getDaysInMonth;
11329
- proto.week = proto.weeks = getSetWeek;
11330
- proto.isoWeek = proto.isoWeeks = getSetISOWeek;
11331
- proto.weeksInYear = getWeeksInYear;
11332
- proto.weeksInWeekYear = getWeeksInWeekYear;
11333
- proto.isoWeeksInYear = getISOWeeksInYear;
11334
- proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
11335
- proto.date = getSetDayOfMonth;
11336
- proto.day = proto.days = getSetDayOfWeek;
11337
- proto.weekday = getSetLocaleDayOfWeek;
11338
- proto.isoWeekday = getSetISODayOfWeek;
11339
- proto.dayOfYear = getSetDayOfYear;
11340
- proto.hour = proto.hours = getSetHour;
11341
- proto.minute = proto.minutes = getSetMinute;
11342
- proto.second = proto.seconds = getSetSecond;
11343
- proto.millisecond = proto.milliseconds = getSetMillisecond;
11344
- proto.utcOffset = getSetOffset;
11345
- proto.utc = setOffsetToUTC;
11346
- proto.local = setOffsetToLocal;
11347
- proto.parseZone = setOffsetToParsedOffset;
11348
- proto.hasAlignedHourOffset = hasAlignedHourOffset;
11349
- proto.isDST = isDaylightSavingTime;
11350
- proto.isLocal = isLocal;
11351
- proto.isUtcOffset = isUtcOffset;
11352
- proto.isUtc = isUtc;
11353
- proto.isUTC = isUtc;
11354
- proto.zoneAbbr = getZoneAbbr;
11355
- proto.zoneName = getZoneName;
11356
- proto.dates = deprecate("dates accessor is deprecated. Use date instead.", getSetDayOfMonth);
11357
- proto.months = deprecate("months accessor is deprecated. Use month instead", getSetMonth);
11358
- proto.years = deprecate("years accessor is deprecated. Use year instead", getSetYear);
11359
- proto.zone = deprecate("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/", getSetZone);
11360
- proto.isDSTShifted = deprecate("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information", isDaylightSavingTimeShifted);
11449
+ proto$2.toJSON = toJSON;
11450
+ proto$2.toString = toString;
11451
+ proto$2.unix = unix;
11452
+ proto$2.valueOf = valueOf$1;
11453
+ proto$2.creationData = creationData;
11454
+ proto$2.eraName = getEraName;
11455
+ proto$2.eraNarrow = getEraNarrow;
11456
+ proto$2.eraAbbr = getEraAbbr;
11457
+ proto$2.eraYear = getEraYear;
11458
+ proto$2.year = getSetYear;
11459
+ proto$2.isLeapYear = getIsLeapYear;
11460
+ proto$2.weekYear = getSetWeekYear;
11461
+ proto$2.isoWeekYear = getSetISOWeekYear;
11462
+ proto$2.quarter = proto$2.quarters = getSetQuarter;
11463
+ proto$2.month = getSetMonth;
11464
+ proto$2.daysInMonth = getDaysInMonth;
11465
+ proto$2.week = proto$2.weeks = getSetWeek;
11466
+ proto$2.isoWeek = proto$2.isoWeeks = getSetISOWeek;
11467
+ proto$2.weeksInYear = getWeeksInYear;
11468
+ proto$2.weeksInWeekYear = getWeeksInWeekYear;
11469
+ proto$2.isoWeeksInYear = getISOWeeksInYear;
11470
+ proto$2.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
11471
+ proto$2.date = getSetDayOfMonth;
11472
+ proto$2.day = proto$2.days = getSetDayOfWeek;
11473
+ proto$2.weekday = getSetLocaleDayOfWeek;
11474
+ proto$2.isoWeekday = getSetISODayOfWeek;
11475
+ proto$2.dayOfYear = getSetDayOfYear;
11476
+ proto$2.hour = proto$2.hours = getSetHour;
11477
+ proto$2.minute = proto$2.minutes = getSetMinute;
11478
+ proto$2.second = proto$2.seconds = getSetSecond;
11479
+ proto$2.millisecond = proto$2.milliseconds = getSetMillisecond;
11480
+ proto$2.utcOffset = getSetOffset;
11481
+ proto$2.utc = setOffsetToUTC;
11482
+ proto$2.local = setOffsetToLocal;
11483
+ proto$2.parseZone = setOffsetToParsedOffset;
11484
+ proto$2.hasAlignedHourOffset = hasAlignedHourOffset;
11485
+ proto$2.isDST = isDaylightSavingTime;
11486
+ proto$2.isLocal = isLocal;
11487
+ proto$2.isUtcOffset = isUtcOffset;
11488
+ proto$2.isUtc = isUtc;
11489
+ proto$2.isUTC = isUtc;
11490
+ proto$2.zoneAbbr = getZoneAbbr;
11491
+ proto$2.zoneName = getZoneName;
11492
+ proto$2.dates = deprecate("dates accessor is deprecated. Use date instead.", getSetDayOfMonth);
11493
+ proto$2.months = deprecate("months accessor is deprecated. Use month instead", getSetMonth);
11494
+ proto$2.years = deprecate("years accessor is deprecated. Use year instead", getSetYear);
11495
+ proto$2.zone = deprecate("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/", getSetZone);
11496
+ proto$2.isDSTShifted = deprecate("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information", isDaylightSavingTimeShifted);
11361
11497
  function createUnix(input) {
11362
11498
  return createLocal(input * 1000);
11363
11499
  }
@@ -11368,13 +11504,13 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11368
11504
  return string;
11369
11505
  }
11370
11506
  var proto$1 = Locale.prototype;
11371
- proto$1.calendar = calendar;
11507
+ proto$1.calendar = calendar$1;
11372
11508
  proto$1.longDateFormat = longDateFormat;
11373
11509
  proto$1.invalidDate = invalidDate;
11374
11510
  proto$1.ordinal = ordinal;
11375
11511
  proto$1.preparse = preParsePostFormat;
11376
11512
  proto$1.postformat = preParsePostFormat;
11377
- proto$1.relativeTime = relativeTime;
11513
+ proto$1.relativeTime = relativeTime$1;
11378
11514
  proto$1.pastFuture = pastFuture;
11379
11515
  proto$1.set = set;
11380
11516
  proto$1.eras = localeEras;
@@ -11488,7 +11624,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11488
11624
  hooks.lang = deprecate("moment.lang is deprecated. Use moment.locale instead.", getSetGlobalLocale);
11489
11625
  hooks.langData = deprecate("moment.langData is deprecated. Use moment.localeData instead.", getLocale);
11490
11626
  var mathAbs = Math.abs;
11491
- function abs() {
11627
+ function abs$1() {
11492
11628
  var data = this._data;
11493
11629
  this._milliseconds = mathAbs(this._milliseconds);
11494
11630
  this._days = mathAbs(this._days);
@@ -11501,18 +11637,18 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11501
11637
  data.years = mathAbs(data.years);
11502
11638
  return this;
11503
11639
  }
11504
- function addSubtract$1(duration, input, value, direction) {
11640
+ function addSubtract(duration, input, value, direction) {
11505
11641
  var other = createDuration(input, value);
11506
11642
  duration._milliseconds += direction * other._milliseconds;
11507
11643
  duration._days += direction * other._days;
11508
11644
  duration._months += direction * other._months;
11509
11645
  return duration._bubble();
11510
11646
  }
11511
- function add$1(input, value) {
11512
- return addSubtract$1(this, input, value, 1);
11647
+ function add(input, value) {
11648
+ return addSubtract(this, input, value, 1);
11513
11649
  }
11514
- function subtract$1(input, value) {
11515
- return addSubtract$1(this, input, value, -1);
11650
+ function subtract(input, value) {
11651
+ return addSubtract(this, input, value, -1);
11516
11652
  }
11517
11653
  function absCeil(number) {
11518
11654
  if (number < 0) {
@@ -11594,11 +11730,11 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11594
11730
  return this.as(alias);
11595
11731
  };
11596
11732
  }
11597
- var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds;
11598
- function clone$1() {
11733
+ var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf = asMilliseconds;
11734
+ function clone() {
11599
11735
  return createDuration(this);
11600
11736
  }
11601
- function get$2(units) {
11737
+ function get(units) {
11602
11738
  units = normalizeUnits(units);
11603
11739
  return this.isValid() ? this[units + "s"]() : NaN;
11604
11740
  }
@@ -11621,9 +11757,9 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11621
11757
  M: 11
11622
11758
  };
11623
11759
  function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) {
11624
- return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
11760
+ return relativeTimeWithoutPostformat.call(locale2, number || 1, !!withoutSuffix, string, isFuture);
11625
11761
  }
11626
- function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
11762
+ function relativeTime(posNegDuration, withoutSuffix, thresholds2, locale2) {
11627
11763
  var duration = createDuration(posNegDuration).abs(), seconds2 = round(duration.as("s")), minutes2 = round(duration.as("m")), hours2 = round(duration.as("h")), days2 = round(duration.as("d")), months2 = round(duration.as("M")), weeks2 = round(duration.as("w")), years2 = round(duration.as("y")), a = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
11628
11764
  if (thresholds2.w != null) {
11629
11765
  a = a || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
@@ -11670,27 +11806,27 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11670
11806
  withSuffix = argWithSuffix;
11671
11807
  }
11672
11808
  if (typeof argThresholds === "object") {
11673
- th = Object.assign({}, thresholds, argThresholds);
11809
+ th = extend(extend({}, thresholds), argThresholds || {});
11674
11810
  if (argThresholds.s != null && argThresholds.ss == null) {
11675
11811
  th.ss = argThresholds.s - 1;
11676
11812
  }
11677
11813
  }
11678
11814
  locale2 = this.localeData();
11679
- output = relativeTime$1(this, !withSuffix, th, locale2);
11815
+ output = relativeTime(this, !withSuffix, th, locale2);
11680
11816
  if (withSuffix) {
11681
- output = locale2.pastFuture(+this, output);
11817
+ output = pastFutureWithoutPostformat.call(locale2, +this, output);
11682
11818
  }
11683
11819
  return locale2.postformat(output);
11684
11820
  }
11685
- var abs$1 = Math.abs;
11821
+ var abs = Math.abs;
11686
11822
  function sign(x) {
11687
11823
  return (x > 0) - (x < 0) || +x;
11688
11824
  }
11689
- function toISOString$1() {
11825
+ function toISOString() {
11690
11826
  if (!this.isValid()) {
11691
11827
  return this.localeData().invalidDate();
11692
11828
  }
11693
- var seconds2 = abs$1(this._milliseconds) / 1000, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
11829
+ var seconds2 = abs(this._milliseconds) / 1000, days2 = abs(this._days), months2 = abs(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
11694
11830
  if (!total) {
11695
11831
  return "P0D";
11696
11832
  }
@@ -11707,41 +11843,41 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11707
11843
  hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : "";
11708
11844
  return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s + "S" : "");
11709
11845
  }
11710
- var proto$2 = Duration.prototype;
11711
- proto$2.isValid = isValid$1;
11712
- proto$2.abs = abs;
11713
- proto$2.add = add$1;
11714
- proto$2.subtract = subtract$1;
11715
- proto$2.as = as;
11716
- proto$2.asMilliseconds = asMilliseconds;
11717
- proto$2.asSeconds = asSeconds;
11718
- proto$2.asMinutes = asMinutes;
11719
- proto$2.asHours = asHours;
11720
- proto$2.asDays = asDays;
11721
- proto$2.asWeeks = asWeeks;
11722
- proto$2.asMonths = asMonths;
11723
- proto$2.asQuarters = asQuarters;
11724
- proto$2.asYears = asYears;
11725
- proto$2.valueOf = valueOf$1;
11726
- proto$2._bubble = bubble;
11727
- proto$2.clone = clone$1;
11728
- proto$2.get = get$2;
11729
- proto$2.milliseconds = milliseconds;
11730
- proto$2.seconds = seconds;
11731
- proto$2.minutes = minutes;
11732
- proto$2.hours = hours;
11733
- proto$2.days = days;
11734
- proto$2.weeks = weeks;
11735
- proto$2.months = months;
11736
- proto$2.years = years;
11737
- proto$2.humanize = humanize;
11738
- proto$2.toISOString = toISOString$1;
11739
- proto$2.toString = toISOString$1;
11740
- proto$2.toJSON = toISOString$1;
11741
- proto$2.locale = locale;
11742
- proto$2.localeData = localeData;
11743
- proto$2.toIsoString = deprecate("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", toISOString$1);
11744
- proto$2.lang = lang;
11846
+ var proto = Duration.prototype;
11847
+ proto.isValid = isValid$1;
11848
+ proto.abs = abs$1;
11849
+ proto.add = add;
11850
+ proto.subtract = subtract;
11851
+ proto.as = as;
11852
+ proto.asMilliseconds = asMilliseconds;
11853
+ proto.asSeconds = asSeconds;
11854
+ proto.asMinutes = asMinutes;
11855
+ proto.asHours = asHours;
11856
+ proto.asDays = asDays;
11857
+ proto.asWeeks = asWeeks;
11858
+ proto.asMonths = asMonths;
11859
+ proto.asQuarters = asQuarters;
11860
+ proto.asYears = asYears;
11861
+ proto.valueOf = valueOf;
11862
+ proto._bubble = bubble;
11863
+ proto.clone = clone;
11864
+ proto.get = get;
11865
+ proto.milliseconds = milliseconds;
11866
+ proto.seconds = seconds;
11867
+ proto.minutes = minutes;
11868
+ proto.hours = hours;
11869
+ proto.days = days;
11870
+ proto.weeks = weeks;
11871
+ proto.months = months;
11872
+ proto.years = years;
11873
+ proto.humanize = humanize;
11874
+ proto.toISOString = toISOString;
11875
+ proto.toString = toISOString;
11876
+ proto.toJSON = toISOString;
11877
+ proto.locale = locale;
11878
+ proto.localeData = localeData;
11879
+ proto.toIsoString = deprecate("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", toISOString);
11880
+ proto.lang = lang;
11745
11881
  addFormatToken("X", 0, 0, "unix");
11746
11882
  addFormatToken("x", 0, 0, "valueOf");
11747
11883
  addRegexToken("x", matchSigned);
@@ -11753,9 +11889,9 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11753
11889
  config._d = new Date(toInt(input));
11754
11890
  });
11755
11891
  //! moment.js
11756
- hooks.version = "2.30.1";
11892
+ hooks.version = "2.31.0";
11757
11893
  setHookCallback(createLocal);
11758
- hooks.fn = proto;
11894
+ hooks.fn = proto$2;
11759
11895
  hooks.min = min;
11760
11896
  hooks.max = max;
11761
11897
  hooks.now = now;
@@ -11764,7 +11900,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11764
11900
  hooks.months = listMonths;
11765
11901
  hooks.isDate = isDate;
11766
11902
  hooks.locale = getSetGlobalLocale;
11767
- hooks.invalid = createInvalid;
11903
+ hooks.invalid = createInvalid$1;
11768
11904
  hooks.duration = createDuration;
11769
11905
  hooks.isMoment = isMoment;
11770
11906
  hooks.weekdays = listWeekdays;
@@ -11781,7 +11917,7 @@ Arguments: ` + Array.prototype.slice.call(args).join("") + `
11781
11917
  hooks.relativeTimeRounding = getSetRelativeTimeRounding;
11782
11918
  hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
11783
11919
  hooks.calendarFormat = getCalendarFormat;
11784
- hooks.prototype = proto;
11920
+ hooks.prototype = proto$2;
11785
11921
  hooks.HTML5_FMT = {
11786
11922
  DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
11787
11923
  DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
@@ -33019,4 +33155,4 @@ Running workflow: ${fs2.path.basename(resolvedPath)}`);
33019
33155
 
33020
33156
  export { getFileSystem, catchError, logger, RESULTS, SuccessOutput, FailureOutput, OutputFormatter, Command, processContext, registerPackageMetadataOptions, mapPackageMetadataOptions, getSdkUserAgentToken, addSdkUserAgentHeader, installSdkUserAgentHeader, unsupportedSolutionProjectType, getLoginStatusAsync, getAuthContext, WorkflowRunService };
33021
33157
 
33022
- //# debugId=755819A287F9A86164756E2164756E21
33158
+ //# debugId=714B0CA10CA03ECC64756E2164756E21