1(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[5450],{ 2 3/***/ 201640: 4/***/ (function() { 5 6// extracted by mini-css-extract-plugin 7 8/***/ }), 9 10/***/ 693967: 11/***/ (function(module, exports) { 12 13var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 14 Copyright (c) 2018 Jed Watson. 15 Licensed under the MIT License (MIT), see 16 http://jedwatson.github.io/classnames 17*/ 18/* global define */ 19 20(function () { 21 'use strict'; 22 23 var hasOwn = {}.hasOwnProperty; 24 25 function classNames () { 26 var classes = ''; 27 28 for (var i = 0; i < arguments.length; i++) { 29 var arg = arguments[i]; 30 if (arg) { 31 classes = appendClass(classes, parseValue(arg)); 32 } 33 } 34 35 return classes; 36 } 37 38 function parseValue (arg) { 39 if (typeof arg === 'string' || typeof arg === 'number') { 40 return arg; 41 } 42 43 if (typeof arg !== 'object') { 44 return ''; 45 } 46 47 if (Array.isArray(arg)) { 48 return classNames.apply(null, arg); 49 } 50 51 if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) { 52 return arg.toString(); 53 } 54 55 var classes = ''; 56 57 for (var key in arg) { 58 if (hasOwn.call(arg, key) && arg[key]) {
59 classes = appendClass(classes, key); 60 } 61 } 62 63 return classes; 64 } 65 66 function appendClass (value, newClass) { 67 if (!newClass) { 68 return value; 69 } 70 71 if (value) { 72 return value + ' ' + newClass; 73 } 74 75 return value + newClass; 76 } 77 78 if ( true && module.exports) { 79 classNames.default = classNames; 80 module.exports = classNames; 81 } else if (true) { 82 // register as 'classnames', consistent with npm package name 83 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () { 84 return classNames; 85 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 86 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 87 } else {} 88}()); 89 90 91/***/ }), 92 93/***/ 60842: 94/***/ (function(__unused_webpack_module, exports) { 95 96"use strict"; 97 98 99Object.defineProperty(exports, "__esModule", ({ 100 value: true 101})); 102exports["default"] = getCountryFlag; 103 104/** 105 * Creates Unicode flag from a two-letter ISO country code. 106 * https://stackoverflow.com/questions/24050671/how-to-put-japan-flag-character-in-a-string 107 * @param {string} country â A two-letter ISO country code (case-insensitive). 108 * @return {string} 109 */ 110function getCountryFlag(country) { 111 return getRegionalIndicatorSymbol(country[0]) + getRegionalIndicatorSymbol(country[1]); 112} 113/** 114 * Converts a letter to a Regional Indicator Symbol. 115 * @param {string} letter 116 * @return {string} 117 */ 118 119 120function getRegionalIndicatorSymbol(letter) { 121 return String.fromCodePoint(0x1F1E6 - 65 + letter.toUpperCase().charCodeAt(0)); 122} 123//# sourceMappingURL=unicode.js.map 124 125/***/ }), 126 127/***/ 36177: 128/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 129 130module.exports = __webpack_require__(60842) 131 132/***/ }), 133 134/***/ 616660: 135/***/ (function(__unused_webpack_module, exports) { 136 137"use strict"; 138 139exports.addLeadingZeros = addLeadingZeros; 140function addLeadingZeros(number, targetLength) { 141 const sign = number < 0 ? "-" : ""; 142 const output = Math.abs(number).toString().padStart(targetLength, "0"); 143 return sign + output; 144} 145 146 147/***/ }), 148 149/***/ 65099: 150/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 151 152"use strict"; 153 154Object.defineProperty(exports, "defaultLocale", ({ 155 enumerable: true, 156 get: function () { 157 return _index.enUS; 158 }, 159})); 160var _index = __webpack_require__(810824); 161 162 163/***/ }), 164 165/***/ 983074: 166/***/ (function(__unused_webpack_module, exports) { 167 168"use strict"; 169 170exports.getDefaultOptions = getDefaultOptions; 171exports.setDefaultOptions = setDefaultOptions; 172 173let defaultOptions = {}; 174 175function getDefaultOptions() { 176 return defaultOptions; 177} 178 179function setDefaultOptions(newOptions) { 180 defaultOptions = newOptions; 181} 182 183 184/***/ }), 185 186/***/ 882833: 187/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 188 189"use strict"; 190 191exports.formatters = void 0; 192var _index = __webpack_require__(824866); 193var _index2 = __webpack_require__(125691); 194var _index3 = __webpack_require__(196914); 195var _index4 = __webpack_require__(461625); 196var _index5 = __webpack_require__(23928); 197 198var _index6 = __webpack_require__(616660); 199var _index7 = __webpack_require__(387179); 200 201const dayPeriodEnum = { 202 am: "am", 203 pm: "pm", 204 midnight: "midnight", 205 noon: "noon", 206 morning: "morning", 207 afternoon: "afternoon", 208 evening: "evening", 209 night: "night", 210}; 211 212/* 213 * | | Unit | | Unit | 214 * |-----|--------------------------------|-----|--------------------------------| 215 * | a | AM, PM | A* | Milliseconds in day | 216 * | b | AM, PM, noon, midnight | B | Flexible day period | 217 * | c | Stand-alone local day of week | C* | Localized hour w/ day period | 218 * | d | Day of month | D | Day of year | 219 * | e | Local day of week | E | Day of week | 220 * | f | | F* | Day of week in month | 221 * | g* | Modified Julian day | G | Era | 222 * | h | Hour [1-12] | H | Hour [0-23] | 223 * | i! | ISO day of week | I! | ISO week of year | 224 * | j* | Localized hour w/ day period | J* | Localized hour w/o day period | 225 * | k | Hour [1-24] | K | Hour [0-11] | 226 * | l* | (deprecated) | L | Stand-alone month | 227 * | m | Minute | M | Month | 228 * | n | | N | | 229 * | o! | Ordinal number modifier | O | Timezone (GMT) | 230 * | p! | Long localized time | P! | Long localized date | 231 * | q | Stand-alone quarter | Q | Quarter | 232 * | r* | Related Gregorian year | R! | ISO week-numbering year | 233 * | s | Second | S | Fraction of second | 234 * | t! | Seconds timestamp | T! | Milliseconds timestamp | 235 * | u | Extended year | U* | Cyclic year | 236 * | v* | Timezone (generic non-locat.) | V* | Timezone (location) | 237 * | w | Local week of year | W* | Week of month | 238 * | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) | 239 * | y | Year (abs) | Y | Local week-numbering year | 240 * | z | Timezone (specific non-locat.) | Z* | Timezone (aliases) | 241 * 242 * Letters marked by * are not implemented but reserved by Unicode standard. 243 * 244 * Letters marked by ! are non-standard, but implemented by date-fns: 245 * - `o` modifies the previous token to turn it into an ordinal (see `format` docs) 246 * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days, 247 * i.e. 7 for Sunday, 1 for Monday, etc. 248 * - `I` is ISO week of year, as opposed to `w` which is local week of year. 249 * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year. 250 * `R` is supposed to be used in conjunction with `I` and `i` 251 * for universal ISO week-numbering date, whereas 252 * `Y` is supposed to be used in conjunction with `w` and `e` 253 * for week-numbering date specific to the locale. 254 * - `P` is long localized date format 255 * - `p` is long localized time format 256 */ 257 258const formatters = (exports.formatters = { 259 // Era 260 G: function (date, token, localize) { 261 const era = date.getFullYear() > 0 ? 1 : 0; 262 switch (token) { 263 // AD, BC 264 case "G": 265 case "GG": 266 case "GGG": 267 return localize.era(era, { width: "abbreviated" }); 268 // A, B 269 case "GGGGG": 270 return localize.era(era, { width: "narrow" }); 271 // Anno Domini, Before Christ 272 case "GGGG": 273 default: 274 return localize.era(era, { width: "wide" }); 275 } 276 }, 277 278 // Year 279 y: function (date, token, localize) { 280 // Ordinal number 281 if (token === "yo") { 282 const signedYear = date.getFullYear(); 283 // Returns 1 for 1 BC (which is year 0 in JavaScript) 284 const year = signedYear > 0 ? signedYear : 1 - signedYear; 285 return localize.ordinalNumber(year, { unit: "year" }); 286 } 287 288 return _index7.lightFormatters.y(date, token); 289 }, 290 291 // Local week-numbering year 292 Y: function (date, token, localize, options) { 293 const signedWeekYear = (0, _index5.getWeekYear)(date, options); 294 // Returns 1 for 1 BC (which is year 0 in JavaScript) 295 const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear; 296 297 // Two digit year 298 if (token === "YY") { 299 const twoDigitYear = weekYear % 100; 300 return (0, _index6.addLeadingZeros)(twoDigitYear, 2); 301 } 302 303 // Ordinal number 304 if (token === "Yo") { 305 return localize.ordinalNumber(weekYear, { unit: "year" }); 306 } 307 308 // Padding 309 return (0, _index6.addLeadingZeros)(weekYear, token.length); 310 }, 311 312 // ISO week-numbering year 313 R: function (date, token) { 314 const isoWeekYear = (0, _index3.getISOWeekYear)(date); 315 316 // Padding 317 return (0, _index6.addLeadingZeros)(isoWeekYear, token.length); 318 }, 319 320 // Extended year. This is a single number designating the year of this calendar system. 321 // The main difference between `y` and `u` localizers are B.C. years: 322 // | Year | `y` | `u` | 323 // |------|-----|-----| 324 // | AC 1 | 1 | 1 | 325 // | BC 1 | 1 | 0 | 326 // | BC 2 | 2 | -1 | 327 // Also `yy` always returns the last two digits of a year, 328 // while `uu` pads single digit years to 2 characters and returns other years unchanged. 329 u: function (date, token) { 330 const year = date.getFullYear(); 331 return (0, _index6.addLeadingZeros)(year, token.length); 332 }, 333 334 // Quarter 335 Q: function (date, token, localize) {
336 const quarter = Math.ceil((date.getMonth() + 1) / 3); 337 switch (token) { 338 // 1, 2, 3, 4 339 case "Q": 340 return String(quarter); 341 // 01, 02, 03, 04 342 case "QQ": 343 return (0, _index6.addLeadingZeros)(quarter, 2); 344 // 1st, 2nd, 3rd, 4th 345 case "Qo": 346 return localize.ordinalNumber(quarter, { unit: "quarter" }); 347 // Q1, Q2, Q3, Q4 348 case "QQQ": 349 return localize.quarter(quarter, { 350 width: "abbreviated", 351 context: "formatting", 352 }); 353 // 1, 2, 3, 4 (narrow quarter; could be not numerical) 354 case "QQQQQ": 355 return localize.quarter(quarter, { 356 width: "narrow", 357 context: "formatting", 358 }); 359 // 1st quarter, 2nd quarter, ... 360 case "QQQQ": 361 default: 362 return localize.quarter(quarter, { 363 width: "wide", 364 context: "formatting", 365 }); 366 } 367 }, 368 369 // Stand-alone quarter 370 q: function (date, token, localize) { 371 const quarter = Math.ceil((date.getMonth() + 1) / 3); 372 switch (token) { 373 // 1, 2, 3, 4 374 case "q": 375 return String(quarter); 376 // 01, 02, 03, 04 377 case "qq": 378 return (0, _index6.addLeadingZeros)(quarter, 2); 379 // 1st, 2nd, 3rd, 4th 380 case "qo": 381 return localize.ordinalNumber(quarter, { unit: "quarter" }); 382 // Q1, Q2, Q3, Q4 383 case "qqq": 384 return localize.quarter(quarter, { 385 width: "abbreviated", 386 context: "standalone", 387 }); 388 // 1, 2, 3, 4 (narrow quarter; could be not numerical) 389 case "qqqqq": 390 return localize.quarter(quarter, { 391 width: "narrow", 392 context: "standalone", 393 }); 394 // 1st quarter, 2nd quarter, ... 395 case "qqqq": 396 default: 397 return localize.quarter(quarter, { 398 width: "wide", 399 context: "standalone", 400 }); 401 } 402 }, 403 404 // Month 405 M: function (date, token, localize) {
vendor: 38,008 bytes, lines 406-1741
406 const month = date.getMonth(); 407 switch (token) { 408 case "M": 409 case "MM": 410 return _index7.lightFormatters.M(date, token); 411 // 1st, 2nd, ..., 12th 412 case "Mo": 413 return localize.ordinalNumber(month + 1, { unit: "month" }); 414 // Jan, Feb, ..., Dec 415 case "MMM": 416 return localize.month(month, { 417 width: "abbreviated", 418 context: "formatting", 419 }); 420 // J, F, ..., D 421 case "MMMMM": 422 return localize.month(month, { 423 width: "narrow", 424 context: "formatting", 425 }); 426 // January, February, ..., December 427 case "MMMM": 428 default: 429 return localize.month(month, { width: "wide", context: "formatting" }); 430 } 431 }, 432 433 // Stand-alone month 434 L: function (date, token, localize) { 435 const month = date.getMonth(); 436 switch (token) { 437 // 1, 2, ..., 12 438 case "L": 439 return String(month + 1); 440 // 01, 02, ..., 12 441 case "LL": 442 return (0, _index6.addLeadingZeros)(month + 1, 2); 443 // 1st, 2nd, ..., 12th 444 case "Lo": 445 return localize.ordinalNumber(month + 1, { unit: "month" }); 446 // Jan, Feb, ..., Dec 447 case "LLL": 448 return localize.month(month, { 449 width: "abbreviated", 450 context: "standalone", 451 }); 452 // J, F, ..., D 453 case "LLLLL": 454 return localize.month(month, { 455 width: "narrow", 456 context: "standalone", 457 }); 458 // January, February, ..., December 459 case "LLLL": 460 default: 461 return localize.month(month, { width: "wide", context: "standalone" }); 462 } 463 }, 464 465 // Local week of year 466 w: function (date, token, localize, options) { 467 const week = (0, _index4.getWeek)(date, options); 468 469 if (token === "wo") { 470 return localize.ordinalNumber(week, { unit: "week" }); 471 } 472 473 return (0, _index6.addLeadingZeros)(week, token.length); 474 }, 475 476 // ISO week of year 477 I: function (date, token, localize) { 478 const isoWeek = (0, _index2.getISOWeek)(date); 479 480 if (token === "Io") { 481 return localize.ordinalNumber(isoWeek, { unit: "week" }); 482 } 483 484 return (0, _index6.addLeadingZeros)(isoWeek, token.length); 485 }, 486 487 // Day of the month 488 d: function (date, token, localize) { 489 if (token === "do") { 490 return localize.ordinalNumber(date.getDate(), { unit: "date" }); 491 } 492 493 return _index7.lightFormatters.d(date, token); 494 }, 495 496 // Day of year 497 D: function (date, token, localize) { 498 const dayOfYear = (0, _index.getDayOfYear)(date); 499 500 if (token === "Do") { 501 return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" }); 502 } 503 504 return (0, _index6.addLeadingZeros)(dayOfYear, token.length); 505 }, 506 507 // Day of week 508 E: function (date, token, localize) { 509 const dayOfWeek = date.getDay(); 510 switch (token) { 511 // Tue 512 case "E": 513 case "EE": 514 case "EEE": 515 return localize.day(dayOfWeek, { 516 width: "abbreviated", 517 context: "formatting", 518 }); 519 // T 520 case "EEEEE": 521 return localize.day(dayOfWeek, { 522 width: "narrow", 523 context: "formatting", 524 }); 525 // Tu 526 case "EEEEEE": 527 return localize.day(dayOfWeek, { 528 width: "short", 529 context: "formatting", 530 }); 531 // Tuesday 532 case "EEEE": 533 default: 534 return localize.day(dayOfWeek, { 535 width: "wide", 536 context: "formatting", 537 }); 538 } 539 }, 540 541 // Local day of week 542 e: function (date, token, localize, options) { 543 const dayOfWeek = date.getDay(); 544 const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7; 545 switch (token) { 546 // Numerical value (Nth day of week with current locale or weekStartsOn) 547 case "e": 548 return String(localDayOfWeek); 549 // Padded numerical value 550 case "ee": 551 return (0, _index6.addLeadingZeros)(localDayOfWeek, 2); 552 // 1st, 2nd, ..., 7th 553 case "eo": 554 return localize.ordinalNumber(localDayOfWeek, { unit: "day" }); 555 case "eee": 556 return localize.day(dayOfWeek, { 557 width: "abbreviated", 558 context: "formatting", 559 }); 560 // T 561 case "eeeee": 562 return localize.day(dayOfWeek, { 563 width: "narrow", 564 context: "formatting", 565 }); 566 // Tu 567 case "eeeeee": 568 return localize.day(dayOfWeek, { 569 width: "short", 570 context: "formatting", 571 }); 572 // Tuesday 573 case "eeee": 574 default: 575 return localize.day(dayOfWeek, { 576 width: "wide", 577 context: "formatting", 578 }); 579 } 580 }, 581 582 // Stand-alone local day of week 583 c: function (date, token, localize, options) { 584 const dayOfWeek = date.getDay(); 585 const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7; 586 switch (token) { 587 // Numerical value (same as in `e`) 588 case "c": 589 return String(localDayOfWeek); 590 // Padded numerical value 591 case "cc": 592 return (0, _index6.addLeadingZeros)(localDayOfWeek, token.length); 593 // 1st, 2nd, ..., 7th 594 case "co": 595 return localize.ordinalNumber(localDayOfWeek, { unit: "day" }); 596 case "ccc": 597 return localize.day(dayOfWeek, { 598 width: "abbreviated", 599 context: "standalone", 600 }); 601 // T 602 case "ccccc": 603 return localize.day(dayOfWeek, { 604 width: "narrow", 605 context: "standalone", 606 }); 607 // Tu 608 case "cccccc": 609 return localize.day(dayOfWeek, { 610 width: "short", 611 context: "standalone", 612 }); 613 // Tuesday 614 case "cccc": 615 default: 616 return localize.day(dayOfWeek, { 617 width: "wide", 618 context: "standalone", 619 }); 620 } 621 }, 622 623 // ISO day of week 624 i: function (date, token, localize) { 625 const dayOfWeek = date.getDay(); 626 const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek; 627 switch (token) { 628 // 2 629 case "i": 630 return String(isoDayOfWeek); 631 // 02 632 case "ii": 633 return (0, _index6.addLeadingZeros)(isoDayOfWeek, token.length); 634 // 2nd 635 case "io": 636 return localize.ordinalNumber(isoDayOfWeek, { unit: "day" }); 637 // Tue 638 case "iii": 639 return localize.day(dayOfWeek, { 640 width: "abbreviated", 641 context: "formatting", 642 }); 643 // T 644 case "iiiii": 645 return localize.day(dayOfWeek, { 646 width: "narrow", 647 context: "formatting", 648 }); 649 // Tu 650 case "iiiiii": 651 return localize.day(dayOfWeek, { 652 width: "short", 653 context: "formatting", 654 }); 655 // Tuesday 656 case "iiii": 657 default: 658 return localize.day(dayOfWeek, { 659 width: "wide", 660 context: "formatting", 661 }); 662 } 663 }, 664 665 // AM or PM 666 a: function (date, token, localize) { 667 const hours = date.getHours(); 668 const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am"; 669 670 switch (token) { 671 case "a": 672 case "aa": 673 return localize.dayPeriod(dayPeriodEnumValue, { 674 width: "abbreviated", 675 context: "formatting", 676 }); 677 case "aaa": 678 return localize 679 .dayPeriod(dayPeriodEnumValue, { 680 width: "abbreviated", 681 context: "formatting", 682 }) 683 .toLowerCase(); 684 case "aaaaa": 685 return localize.dayPeriod(dayPeriodEnumValue, { 686 width: "narrow", 687 context: "formatting", 688 }); 689 case "aaaa": 690 default: 691 return localize.dayPeriod(dayPeriodEnumValue, { 692 width: "wide", 693 context: "formatting", 694 }); 695 } 696 }, 697 698 // AM, PM, midnight, noon 699 b: function (date, token, localize) { 700 const hours = date.getHours(); 701 let dayPeriodEnumValue; 702 if (hours === 12) { 703 dayPeriodEnumValue = dayPeriodEnum.noon; 704 } else if (hours === 0) { 705 dayPeriodEnumValue = dayPeriodEnum.midnight; 706 } else { 707 dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am"; 708 } 709 710 switch (token) { 711 case "b": 712 case "bb": 713 return localize.dayPeriod(dayPeriodEnumValue, { 714 width: "abbreviated", 715 context: "formatting", 716 }); 717 case "bbb": 718 return localize 719 .dayPeriod(dayPeriodEnumValue, { 720 width: "abbreviated", 721 context: "formatting", 722 }) 723 .toLowerCase(); 724 case "bbbbb": 725 return localize.dayPeriod(dayPeriodEnumValue, { 726 width: "narrow", 727 context: "formatting", 728 }); 729 case "bbbb": 730 default: 731 return localize.dayPeriod(dayPeriodEnumValue, { 732 width: "wide", 733 context: "formatting", 734 }); 735 } 736 }, 737 738 // in the morning, in the afternoon, in the evening, at night 739 B: function (date, token, localize) { 740 const hours = date.getHours(); 741 let dayPeriodEnumValue; 742 if (hours >= 17) { 743 dayPeriodEnumValue = dayPeriodEnum.evening; 744 } else if (hours >= 12) { 745 dayPeriodEnumValue = dayPeriodEnum.afternoon; 746 } else if (hours >= 4) { 747 dayPeriodEnumValue = dayPeriodEnum.morning; 748 } else { 749 dayPeriodEnumValue = dayPeriodEnum.night; 750 } 751 752 switch (token) { 753 case "B": 754 case "BB": 755 case "BBB": 756 return localize.dayPeriod(dayPeriodEnumValue, { 757 width: "abbreviated", 758 context: "formatting", 759 }); 760 case "BBBBB": 761 return localize.dayPeriod(dayPeriodEnumValue, { 762 width: "narrow", 763 context: "formatting", 764 }); 765 case "BBBB": 766 default: 767 return localize.dayPeriod(dayPeriodEnumValue, { 768 width: "wide", 769 context: "formatting", 770 }); 771 } 772 }, 773 774 // Hour [1-12] 775 h: function (date, token, localize) { 776 if (token === "ho") { 777 let hours = date.getHours() % 12; 778 if (hours === 0) hours = 12; 779 return localize.ordinalNumber(hours, { unit: "hour" }); 780 } 781 782 return _index7.lightFormatters.h(date, token); 783 }, 784 785 // Hour [0-23] 786 H: function (date, token, localize) { 787 if (token === "Ho") { 788 return localize.ordinalNumber(date.getHours(), { unit: "hour" }); 789 } 790 791 return _index7.lightFormatters.H(date, token); 792 }, 793 794 // Hour [0-11] 795 K: function (date, token, localize) { 796 const hours = date.getHours() % 12; 797 798 if (token === "Ko") { 799 return localize.ordinalNumber(hours, { unit: "hour" }); 800 } 801 802 return (0, _index6.addLeadingZeros)(hours, token.length); 803 }, 804 805 // Hour [1-24] 806 k: function (date, token, localize) { 807 let hours = date.getHours(); 808 if (hours === 0) hours = 24; 809 810 if (token === "ko") { 811 return localize.ordinalNumber(hours, { unit: "hour" }); 812 } 813 814 return (0, _index6.addLeadingZeros)(hours, token.length); 815 }, 816 817 // Minute 818 m: function (date, token, localize) { 819 if (token === "mo") { 820 return localize.ordinalNumber(date.getMinutes(), { unit: "minute" }); 821 } 822 823 return _index7.lightFormatters.m(date, token); 824 }, 825 826 // Second 827 s: function (date, token, localize) { 828 if (token === "so") { 829 return localize.ordinalNumber(date.getSeconds(), { unit: "second" }); 830 } 831 832 return _index7.lightFormatters.s(date, token); 833 }, 834 835 // Fraction of second 836 S: function (date, token) { 837 return _index7.lightFormatters.S(date, token); 838 }, 839 840 // Timezone (ISO-8601. If offset is 0, output is always `'Z'`) 841 X: function (date, token, _localize) { 842 const timezoneOffset = date.getTimezoneOffset(); 843 844 if (timezoneOffset === 0) { 845 return "Z"; 846 } 847 848 switch (token) { 849 // Hours and optional minutes 850 case "X": 851 return formatTimezoneWithOptionalMinutes(timezoneOffset); 852 853 // Hours, minutes and optional seconds without `:` delimiter 854 // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets 855 // so this token always has the same output as `XX` 856 case "XXXX": 857 case "XX": // Hours and minutes without `:` delimiter 858 return formatTimezone(timezoneOffset); 859 860 // Hours, minutes and optional seconds with `:` delimiter 861 // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets 862 // so this token always has the same output as `XXX` 863 case "XXXXX": 864 case "XXX": // Hours and minutes with `:` delimiter 865 default: 866 return formatTimezone(timezoneOffset, ":"); 867 } 868 }, 869 870 // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent) 871 x: function (date, token, _localize) { 872 const timezoneOffset = date.getTimezoneOffset(); 873 874 switch (token) { 875 // Hours and optional minutes 876 case "x": 877 return formatTimezoneWithOptionalMinutes(timezoneOffset); 878 879 // Hours, minutes and optional seconds without `:` delimiter 880 // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets 881 // so this token always has the same output as `xx` 882 case "xxxx": 883 case "xx": // Hours and minutes without `:` delimiter 884 return formatTimezone(timezoneOffset); 885 886 // Hours, minutes and optional seconds with `:` delimiter 887 // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets 888 // so this token always has the same output as `xxx` 889 case "xxxxx": 890 case "xxx": // Hours and minutes with `:` delimiter 891 default: 892 return formatTimezone(timezoneOffset, ":"); 893 } 894 }, 895 896 // Timezone (GMT) 897 O: function (date, token, _localize) { 898 const timezoneOffset = date.getTimezoneOffset(); 899 900 switch (token) { 901 // Short 902 case "O": 903 case "OO": 904 case "OOO": 905 return "GMT" + formatTimezoneShort(timezoneOffset, ":"); 906 // Long 907 case "OOOO": 908 default: 909 return "GMT" + formatTimezone(timezoneOffset, ":"); 910 } 911 }, 912 913 // Timezone (specific non-location) 914 z: function (date, token, _localize) { 915 const timezoneOffset = date.getTimezoneOffset(); 916 917 switch (token) { 918 // Short 919 case "z": 920 case "zz": 921 case "zzz": 922 return "GMT" + formatTimezoneShort(timezoneOffset, ":"); 923 // Long 924 case "zzzz": 925 default: 926 return "GMT" + formatTimezone(timezoneOffset, ":"); 927 } 928 }, 929 930 // Seconds timestamp 931 t: function (date, token, _localize) { 932 const timestamp = Math.trunc(+date / 1000); 933 return (0, _index6.addLeadingZeros)(timestamp, token.length); 934 }, 935 936 // Milliseconds timestamp 937 T: function (date, token, _localize) { 938 return (0, _index6.addLeadingZeros)(+date, token.length); 939 }, 940}); 941 942function formatTimezoneShort(offset, delimiter = "") { 943 const sign = offset > 0 ? "-" : "+"; 944 const absOffset = Math.abs(offset); 945 const hours = Math.trunc(absOffset / 60); 946 const minutes = absOffset % 60; 947 if (minutes === 0) { 948 return sign + String(hours); 949 } 950 return ( 951 sign + String(hours) + delimiter + (0, _index6.addLeadingZeros)(minutes, 2) 952 ); 953} 954 955function formatTimezoneWithOptionalMinutes(offset, delimiter) { 956 if (offset % 60 === 0) { 957 const sign = offset > 0 ? "-" : "+"; 958 return sign + (0, _index6.addLeadingZeros)(Math.abs(offset) / 60, 2); 959 } 960 return formatTimezone(offset, delimiter); 961} 962 963function formatTimezone(offset, delimiter = "") { 964 const sign = offset > 0 ? "-" : "+"; 965 const absOffset = Math.abs(offset); 966 const hours = (0, _index6.addLeadingZeros)(Math.trunc(absOffset / 60), 2); 967 const minutes = (0, _index6.addLeadingZeros)(absOffset % 60, 2); 968 return sign + hours + delimiter + minutes; 969} 970 971 972/***/ }), 973 974/***/ 387179: 975/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 976 977"use strict"; 978 979exports.lightFormatters = void 0; 980var _index = __webpack_require__(616660); 981 982/* 983 * | | Unit | | Unit | 984 * |-----|--------------------------------|-----|--------------------------------| 985 * | a | AM, PM | A* | | 986 * | d | Day of month | D | | 987 * | h | Hour [1-12] | H | Hour [0-23] | 988 * | m | Minute | M | Month | 989 * | s | Second | S | Fraction of second | 990 * | y | Year (abs) | Y | | 991 * 992 * Letters marked by * are not implemented but reserved by Unicode standard. 993 */ 994 995const lightFormatters = (exports.lightFormatters = { 996 // Year 997 y(date, token) { 998 // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens 999 // | Year | y | yy | yyy | yyyy | yyyyy | 1000 // |----------|-------|----|-------|-------|-------| 1001 // | AD 1 | 1 | 01 | 001 | 0001 | 00001 | 1002 // | AD 12 | 12 | 12 | 012 | 0012 | 00012 | 1003 // | AD 123 | 123 | 23 | 123 | 0123 | 00123 | 1004 // | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 | 1005 // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 | 1006 1007 const signedYear = date.getFullYear(); 1008 // Returns 1 for 1 BC (which is year 0 in JavaScript) 1009 const year = signedYear > 0 ? signedYear : 1 - signedYear; 1010 return (0, _index.addLeadingZeros)( 1011 token === "yy" ? year % 100 : year, 1012 token.length, 1013 ); 1014 }, 1015 1016 // Month 1017 M(date, token) { 1018 const month = date.getMonth(); 1019 return token === "M" 1020 ? String(month + 1) 1021 : (0, _index.addLeadingZeros)(month + 1, 2); 1022 }, 1023 1024 // Day of the month 1025 d(date, token) { 1026 return (0, _index.addLeadingZeros)(date.getDate(), token.length); 1027 }, 1028 1029 // AM or PM 1030 a(date, token) { 1031 const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am"; 1032 1033 switch (token) { 1034 case "a": 1035 case "aa": 1036 return dayPeriodEnumValue.toUpperCase(); 1037 case "aaa": 1038 return dayPeriodEnumValue; 1039 case "aaaaa": 1040 return dayPeriodEnumValue[0]; 1041 case "aaaa": 1042 default: 1043 return dayPeriodEnumValue === "am" ? "a.m." : "p.m."; 1044 } 1045 }, 1046 1047 // Hour [1-12] 1048 h(date, token) { 1049 return (0, _index.addLeadingZeros)( 1050 date.getHours() % 12 || 12, 1051 token.length, 1052 ); 1053 }, 1054 1055 // Hour [0-23] 1056 H(date, token) { 1057 return (0, _index.addLeadingZeros)(date.getHours(), token.length); 1058 }, 1059 1060 // Minute 1061 m(date, token) { 1062 return (0, _index.addLeadingZeros)(date.getMinutes(), token.length); 1063 }, 1064 1065 // Second 1066 s(date, token) { 1067 return (0, _index.addLeadingZeros)(date.getSeconds(), token.length); 1068 }, 1069 1070 // Fraction of second 1071 S(date, token) { 1072 const numberOfDigits = token.length; 1073 const milliseconds = date.getMilliseconds(); 1074 const fractionalSeconds = Math.trunc( 1075 milliseconds * Math.pow(10, numberOfDigits - 3), 1076 ); 1077 return (0, _index.addLeadingZeros)(fractionalSeconds, token.length); 1078 }, 1079}); 1080 1081 1082/***/ }), 1083 1084/***/ 690419: 1085/***/ (function(__unused_webpack_module, exports) { 1086 1087"use strict"; 1088 1089exports.longFormatters = void 0; 1090 1091const dateLongFormatter = (pattern, formatLong) => { 1092 switch (pattern) { 1093 case "P": 1094 return formatLong.date({ width: "short" }); 1095 case "PP": 1096 return formatLong.date({ width: "medium" }); 1097 case "PPP": 1098 return formatLong.date({ width: "long" }); 1099 case "PPPP": 1100 default: 1101 return formatLong.date({ width: "full" }); 1102 } 1103}; 1104 1105const timeLongFormatter = (pattern, formatLong) => { 1106 switch (pattern) { 1107 case "p": 1108 return formatLong.time({ width: "short" }); 1109 case "pp": 1110 return formatLong.time({ width: "medium" }); 1111 case "ppp": 1112 return formatLong.time({ width: "long" }); 1113 case "pppp": 1114 default: 1115 return formatLong.time({ width: "full" }); 1116 } 1117}; 1118 1119const dateTimeLongFormatter = (pattern, formatLong) => { 1120 const matchResult = pattern.match(/(P+)(p+)?/) || []; 1121 const datePattern = matchResult[1]; 1122 const timePattern = matchResult[2]; 1123 1124 if (!timePattern) { 1125 return dateLongFormatter(pattern, formatLong); 1126 } 1127 1128 let dateTimeFormat; 1129 1130 switch (datePattern) { 1131 case "P": 1132 dateTimeFormat = formatLong.dateTime({ width: "short" }); 1133 break; 1134 case "PP": 1135 dateTimeFormat = formatLong.dateTime({ width: "medium" }); 1136 break; 1137 case "PPP": 1138 dateTimeFormat = formatLong.dateTime({ width: "long" }); 1139 break; 1140 case "PPPP": 1141 default: 1142 dateTimeFormat = formatLong.dateTime({ width: "full" }); 1143 break; 1144 } 1145 1146 return dateTimeFormat 1147 .replace("{{date}}", dateLongFormatter(datePattern, formatLong)) 1148 .replace("{{time}}", timeLongFormatter(timePattern, formatLong)); 1149}; 1150 1151const longFormatters = (exports.longFormatters = { 1152 p: timeLongFormatter, 1153 P: dateTimeLongFormatter, 1154}); 1155 1156 1157/***/ }), 1158 1159/***/ 839886: 1160/***/ (function(__unused_webpack_module, exports) { 1161 1162"use strict"; 1163 1164exports.getRoundingMethod = getRoundingMethod; 1165 1166function getRoundingMethod(method) { 1167 return (number) => { 1168 const round = method ? Math[method] : Math.trunc; 1169 const result = round(number); 1170 // Prevent negative zero 1171 return result === 0 ? 0 : result; 1172 }; 1173} 1174 1175 1176/***/ }), 1177 1178/***/ 158228: 1179/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1180 1181"use strict"; 1182 1183exports.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds; 1184var _index = __webpack_require__(807799); 1185 1186/** 1187 * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds. 1188 * They usually appear for dates that denote time before the timezones were introduced 1189 * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891 1190 * and GMT+01:00:00 after that date) 1191 * 1192 * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above, 1193 * which would lead to incorrect calculations. 1194 * 1195 * This function returns the timezone offset in milliseconds that takes seconds in account. 1196 */ 1197function getTimezoneOffsetInMilliseconds(date) { 1198 const _date = (0, _index.toDate)(date); 1199 const utcDate = new Date( 1200 Date.UTC( 1201 _date.getFullYear(), 1202 _date.getMonth(), 1203 _date.getDate(), 1204 _date.getHours(), 1205 _date.getMinutes(), 1206 _date.getSeconds(), 1207 _date.getMilliseconds(), 1208 ), 1209 ); 1210 utcDate.setUTCFullYear(_date.getFullYear()); 1211 return +date - +utcDate; 1212} 1213 1214 1215/***/ }), 1216 1217/***/ 947561: 1218/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1219 1220"use strict"; 1221 1222exports.normalizeDates = normalizeDates; 1223var _index = __webpack_require__(658612); 1224 1225function normalizeDates(context, ...dates) { 1226 const normalize = _index.constructFrom.bind( 1227 null, 1228 context || dates.find((date) => typeof date === "object"), 1229 ); 1230 return dates.map(normalize); 1231} 1232 1233 1234/***/ }), 1235 1236/***/ 525175: 1237/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1238 1239"use strict"; 1240 1241exports.normalizeInterval = normalizeInterval; 1242var _index = __webpack_require__(947561); 1243 1244function normalizeInterval(context, interval) { 1245 const [start, end] = (0, _index.normalizeDates)( 1246 context, 1247 interval.start, 1248 interval.end, 1249 ); 1250 return { start, end }; 1251} 1252 1253 1254/***/ }), 1255 1256/***/ 697569: 1257/***/ (function(__unused_webpack_module, exports) { 1258 1259"use strict"; 1260 1261exports.isProtectedDayOfYearToken = isProtectedDayOfYearToken; 1262exports.isProtectedWeekYearToken = isProtectedWeekYearToken; 1263exports.warnOrThrowProtectedError = warnOrThrowProtectedError; 1264const dayOfYearTokenRE = /^D+$/; 1265const weekYearTokenRE = /^Y+$/; 1266 1267const throwTokens = ["D", "DD", "YY", "YYYY"]; 1268 1269function isProtectedDayOfYearToken(token) { 1270 return dayOfYearTokenRE.test(token); 1271} 1272 1273function isProtectedWeekYearToken(token) { 1274 return weekYearTokenRE.test(token); 1275} 1276 1277function warnOrThrowProtectedError(token, format, input) { 1278 const _message = message(token, format, input); 1279 console.warn(_message); 1280 if (throwTokens.includes(token)) throw new RangeError(_message); 1281} 1282 1283function message(token, format, input) { 1284 const subject = token[0] === "Y" ? "years" : "days of the month"; 1285 return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`; 1286} 1287 1288 1289/***/ }), 1290 1291/***/ 789198: 1292/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1293 1294"use strict"; 1295 1296exports.add = add; 1297var _index = __webpack_require__(519746); 1298var _index2 = __webpack_require__(292361); 1299var _index3 = __webpack_require__(658612); 1300var _index4 = __webpack_require__(807799); 1301 1302/** 1303 * The {@link add} function options. 1304 */ 1305 1306/** 1307 * @name add 1308 * @category Common Helpers 1309 * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date. 1310 * 1311 * @description 1312 * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date. 1313 * 1314 * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc). 1315 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1316 * 1317 * @param date - The date to be changed 1318 * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added. 1319 * @param options - An object with options 1320 * 1321 * @returns The new date with the seconds added 1322 * 1323 * @example 1324 * // Add the following duration to 1 September 2014, 10:19:50 1325 * const result = add(new Date(2014, 8, 1, 10, 19, 50), { 1326 * years: 2, 1327 * months: 9, 1328 * weeks: 1, 1329 * days: 7, 1330 * hours: 5, 1331 * minutes: 9, 1332 * seconds: 30, 1333 * }) 1334 * //=> Thu Jun 15 2017 15:29:20 1335 */ 1336function add(date, duration, options) { 1337 const { 1338 years = 0, 1339 months = 0, 1340 weeks = 0, 1341 days = 0, 1342 hours = 0, 1343 minutes = 0, 1344 seconds = 0, 1345 } = duration; 1346 1347 // Add years and months 1348 const _date = (0, _index4.toDate)(date, options?.in); 1349 const dateWithMonths = 1350 months || years 1351 ? (0, _index2.addMonths)(_date, months + years * 12) 1352 : _date; 1353 1354 // Add weeks and days 1355 const dateWithDays = 1356 days || weeks 1357 ? (0, _index.addDays)(dateWithMonths, days + weeks * 7) 1358 : dateWithMonths; 1359 1360 // Add days, hours, minutes, and seconds 1361 const minutesToAdd = minutes + hours * 60; 1362 const secondsToAdd = seconds + minutesToAdd * 60; 1363 const msToAdd = secondsToAdd * 1000; 1364 1365 return (0, _index3.constructFrom)( 1366 options?.in || date, 1367 +dateWithDays + msToAdd, 1368 ); 1369} 1370 1371 1372/***/ }), 1373 1374/***/ 835168: 1375/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1376 1377"use strict"; 1378 1379exports.addBusinessDays = addBusinessDays; 1380var _index = __webpack_require__(658612); 1381var _index2 = __webpack_require__(852642); 1382var _index3 = __webpack_require__(843239); 1383var _index4 = __webpack_require__(356804); 1384var _index5 = __webpack_require__(807799); 1385 1386/** 1387 * The {@link addBusinessDays} function options. 1388 */ 1389 1390/** 1391 * @name addBusinessDays 1392 * @category Day Helpers 1393 * @summary Add the specified number of business days (mon - fri) to the given date. 1394 * 1395 * @description 1396 * Add the specified number of business days (mon - fri) to the given date, ignoring weekends. 1397 * 1398 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1399 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1400 * 1401 * @param date - The date to be changed 1402 * @param amount - The amount of business days to be added. 1403 * @param options - An object with options 1404 * 1405 * @returns The new date with the business days added 1406 * 1407 * @example 1408 * // Add 10 business days to 1 September 2014: 1409 * const result = addBusinessDays(new Date(2014, 8, 1), 10) 1410 * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days) 1411 */ 1412function addBusinessDays(date, amount, options) { 1413 const _date = (0, _index5.toDate)(date, options?.in); 1414 const startedOnWeekend = (0, _index4.isWeekend)(_date, options); 1415 1416 if (isNaN(amount)) return (0, _index.constructFrom)(options?.in, NaN); 1417 1418 const hours = _date.getHours(); 1419 const sign = amount < 0 ? -1 : 1; 1420 const fullWeeks = Math.trunc(amount / 5); 1421 1422 _date.setDate(_date.getDate() + fullWeeks * 7); 1423 1424 // Get remaining days not part of a full week 1425 let restDays = Math.abs(amount % 5); 1426 1427 // Loops over remaining days 1428 while (restDays > 0) { 1429 _date.setDate(_date.getDate() + sign); 1430 if (!(0, _index4.isWeekend)(_date, options)) restDays -= 1; 1431 } 1432 1433 // If the date is a weekend day and we reduce a dividable of 1434 // 5 from it, we land on a weekend date. 1435 // To counter this, we add days accordingly to land on the next business day 1436 if ( 1437 startedOnWeekend && 1438 (0, _index4.isWeekend)(_date, options) && 1439 amount !== 0 1440 ) { 1441 // If we're reducing days, we want to add days until we land on a weekday 1442 // If we're adding days we want to reduce days until we land on a weekday 1443 if ((0, _index2.isSaturday)(_date, options)) 1444 _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1)); 1445 if ((0, _index3.isSunday)(_date, options)) 1446 _date.setDate(_date.getDate() + (sign < 0 ? 1 : -2)); 1447 } 1448 1449 // Restore hours to avoid DST lag 1450 _date.setHours(hours); 1451 1452 return _date; 1453} 1454 1455 1456/***/ }), 1457 1458/***/ 519746: 1459/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1460 1461"use strict"; 1462 1463exports.addDays = addDays; 1464var _index = __webpack_require__(658612); 1465var _index2 = __webpack_require__(807799); 1466 1467/** 1468 * The {@link addDays} function options. 1469 */ 1470 1471/** 1472 * @name addDays 1473 * @category Day Helpers 1474 * @summary Add the specified number of days to the given date. 1475 * 1476 * @description 1477 * Add the specified number of days to the given date. 1478 * 1479 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1480 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1481 * 1482 * @param date - The date to be changed 1483 * @param amount - The amount of days to be added. 1484 * @param options - An object with options 1485 * 1486 * @returns The new date with the days added 1487 * 1488 * @example 1489 * // Add 10 days to 1 September 2014: 1490 * const result = addDays(new Date(2014, 8, 1), 10) 1491 * //=> Thu Sep 11 2014 00:00:00 1492 */ 1493function addDays(date, amount, options) { 1494 const _date = (0, _index2.toDate)(date, options?.in); 1495 if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN); 1496 1497 // If 0 days, no-op to avoid changing times in the hour before end of DST 1498 if (!amount) return _date; 1499 1500 _date.setDate(_date.getDate() + amount); 1501 return _date; 1502} 1503 1504 1505/***/ }), 1506 1507/***/ 935734: 1508/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1509 1510"use strict"; 1511 1512exports.addHours = addHours; 1513var _index = __webpack_require__(854176); 1514var _index2 = __webpack_require__(241836); 1515 1516/** 1517 * The {@link addHours} function options. 1518 */ 1519 1520/** 1521 * @name addHours 1522 * @category Hour Helpers 1523 * @summary Add the specified number of hours to the given date. 1524 * 1525 * @description 1526 * Add the specified number of hours to the given date. 1527 * 1528 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1529 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1530 * 1531 * @param date - The date to be changed 1532 * @param amount - The amount of hours to be added 1533 * @param options - An object with options 1534 * 1535 * @returns The new date with the hours added 1536 * 1537 * @example 1538 * // Add 2 hours to 10 July 2014 23:00:00: 1539 * const result = addHours(new Date(2014, 6, 10, 23, 0), 2) 1540 * //=> Fri Jul 11 2014 01:00:00 1541 */ 1542function addHours(date, amount, options) { 1543 return (0, _index.addMilliseconds)( 1544 date, 1545 amount * _index2.millisecondsInHour, 1546 options, 1547 ); 1548} 1549 1550 1551/***/ }), 1552 1553/***/ 178304: 1554/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1555 1556"use strict"; 1557 1558exports.addISOWeekYears = addISOWeekYears; 1559var _index = __webpack_require__(196914); 1560var _index2 = __webpack_require__(205523); 1561 1562/** 1563 * The {@link addISOWeekYears} function options. 1564 */ 1565 1566/** 1567 * @name addISOWeekYears 1568 * @category ISO Week-Numbering Year Helpers 1569 * @summary Add the specified number of ISO week-numbering years to the given date. 1570 * 1571 * @description 1572 * Add the specified number of ISO week-numbering years to the given date. 1573 * 1574 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 1575 * 1576 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1577 * 1578 * @param date - The date to be changed 1579 * @param amount - The amount of ISO week-numbering years to be added. 1580 * @param options - An object with options 1581 * 1582 * @returns The new date with the ISO week-numbering years added 1583 * 1584 * @example 1585 * // Add 5 ISO week-numbering years to 2 July 2010: 1586 * const result = addISOWeekYears(new Date(2010, 6, 2), 5) 1587 * //=> Fri Jun 26 2015 00:00:00 1588 */ 1589function addISOWeekYears(date, amount, options) { 1590 return (0, _index2.setISOWeekYear)( 1591 date, 1592 (0, _index.getISOWeekYear)(date, options) + amount, 1593 options, 1594 ); 1595} 1596 1597 1598/***/ }), 1599 1600/***/ 854176: 1601/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1602 1603"use strict"; 1604 1605exports.addMilliseconds = addMilliseconds; 1606var _index = __webpack_require__(658612); 1607var _index2 = __webpack_require__(807799); 1608 1609/** 1610 * The {@link addMilliseconds} function options. 1611 */ 1612 1613/** 1614 * @name addMilliseconds 1615 * @category Millisecond Helpers 1616 * @summary Add the specified number of milliseconds to the given date. 1617 * 1618 * @description 1619 * Add the specified number of milliseconds to the given date. 1620 * 1621 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1622 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1623 * 1624 * @param date - The date to be changed 1625 * @param amount - The amount of milliseconds to be added. 1626 * @param options - The options object 1627 * 1628 * @returns The new date with the milliseconds added 1629 * 1630 * @example 1631 * // Add 750 milliseconds to 10 July 2014 12:45:30.000: 1632 * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750) 1633 * //=> Thu Jul 10 2014 12:45:30.750 1634 */ 1635function addMilliseconds(date, amount, options) { 1636 return (0, _index.constructFrom)( 1637 options?.in || date, 1638 +(0, _index2.toDate)(date) + amount, 1639 ); 1640} 1641 1642 1643/***/ }), 1644 1645/***/ 609025: 1646/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1647 1648"use strict"; 1649 1650exports.addMinutes = addMinutes; 1651var _index = __webpack_require__(241836); 1652var _index2 = __webpack_require__(807799); 1653 1654/** 1655 * The {@link addMinutes} function options. 1656 */ 1657 1658/** 1659 * @name addMinutes 1660 * @category Minute Helpers 1661 * @summary Add the specified number of minutes to the given date. 1662 * 1663 * @description 1664 * Add the specified number of minutes to the given date. 1665 * 1666 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1667 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1668 * 1669 * @param date - The date to be changed 1670 * @param amount - The amount of minutes to be added. 1671 * @param options - An object with options 1672 * 1673 * @returns The new date with the minutes added 1674 * 1675 * @example 1676 * // Add 30 minutes to 10 July 2014 12:00:00: 1677 * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30) 1678 * //=> Thu Jul 10 2014 12:30:00 1679 */ 1680function addMinutes(date, amount, options) { 1681 const _date = (0, _index2.toDate)(date, options?.in); 1682 _date.setTime(_date.getTime() + amount * _index.millisecondsInMinute); 1683 return _date; 1684} 1685 1686 1687/***/ }), 1688 1689/***/ 292361: 1690/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1691 1692"use strict"; 1693 1694exports.addMonths = addMonths; 1695var _index = __webpack_require__(658612); 1696var _index2 = __webpack_require__(807799); 1697 1698/** 1699 * The {@link addMonths} function options. 1700 */ 1701 1702/** 1703 * @name addMonths 1704 * @category Month Helpers 1705 * @summary Add the specified number of months to the given date. 1706 * 1707 * @description 1708 * Add the specified number of months to the given date. 1709 * 1710 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1711 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1712 * 1713 * @param date - The date to be changed 1714 * @param amount - The amount of months to be added. 1715 * @param options - The options object 1716 * 1717 * @returns The new date with the months added 1718 * 1719 * @example 1720 * // Add 5 months to 1 September 2014: 1721 * const result = addMonths(new Date(2014, 8, 1), 5) 1722 * //=> Sun Feb 01 2015 00:00:00 1723 * 1724 * // Add one month to 30 January 2023: 1725 * const result = addMonths(new Date(2023, 0, 30), 1) 1726 * //=> Tue Feb 28 2023 00:00:00 1727 */ 1728function addMonths(date, amount, options) { 1729 const _date = (0, _index2.toDate)(date, options?.in); 1730 if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN); 1731 if (!amount) { 1732 // If 0 months, no-op to avoid changing times in the hour before end of DST 1733 return _date; 1734 } 1735 const dayOfMonth = _date.getDate(); 1736 1737 // The JS Date object supports date math by accepting out-of-bounds values for 1738 // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and 1739 // new Date(2020, 13, 1) returns 1 Feb 2021. This is *almost* the behavior we 1740 // want except that dates will wrap around the end of a month, meaning that 1741 /
1741/ new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So 1742 // we'll default to the end of the desired month by adding 1 to the desired 1743 // month and using a date of 0 to back up one day to the end of the desired 1744 // month. 1745 const endOfDesiredMonth = (0, _index.constructFrom)( 1746 options?.in || date, 1747 _date.getTime(), 1748 ); 1749 endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0); 1750 const daysInMonth = endOfDesiredMonth.getDate(); 1751 if (dayOfMonth >= daysInMonth) { 1752 // If we're already at the end of the month, then this is the correct date 1753 // and we're done. 1754 return endOfDesiredMonth; 1755 } else { 1756 // Otherwise, we now know that setting the original day-of-month value won't 1757 // cause an overflow, so set the desired day-of-month. Note that we can't 1758 // just set the date of `endOfDesiredMonth` because that object may have had 1759 // its time changed in the unusual case where where a DST transition was on 1760 // the last day of the month and its local time was in the hour skipped or 1761 // repeated next to a DST transition. So we use `date` instead which is 1762 // guaranteed to still have the original time. 1763 _date.setFullYear( 1764 endOfDesiredMonth.getFullYear(), 1765 endOfDesiredMonth.getMonth(), 1766 dayOfMonth, 1767 ); 1768 return _date; 1769 } 1770} 1771 1772 1773/***/ }), 1774 1775/***/ 953970: 1776/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1777 1778"use strict"; 1779 1780exports.addQuarters = addQuarters; 1781var _index = __webpack_require__(292361); 1782 1783/** 1784 * The {@link addQuarters} function options. 1785 */ 1786 1787/** 1788 * @name addQuarters 1789 * @category Quarter Helpers 1790 * @summary Add the specified number of year quarters to the given date. 1791 * 1792 * @description 1793 * Add the specified number of year quarters to the given date. 1794 * 1795 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1796 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1797 * 1798 * @param date - The date to be changed 1799 * @param amount - The amount of quarters to be added. 1800 * @param options - An object with options 1801 * 1802 * @returns The new date with the quarters added 1803 * 1804 * @example 1805 * // Add 1 quarter to 1 September 2014: 1806 * const result = addQuarters(new Date(2014, 8, 1), 1) 1807 * //=; Mon Dec 01 2014 00:00:00 1808 */ 1809function addQuarters(date, amount, options) { 1810 return (0, _index.addMonths)(date, amount * 3, options); 1811} 1812 1813 1814/***/ }), 1815 1816/***/ 145124: 1817/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1818 1819"use strict"; 1820 1821exports.addSeconds = addSeconds; 1822var _index = __webpack_require__(854176); 1823 1824/** 1825 * The {@link addSeconds} function options. 1826 */ 1827 1828/** 1829 * @name addSeconds 1830 * @category Second Helpers 1831 * @summary Add the specified number of seconds to the given date. 1832 * 1833 * @description 1834 * Add the specified number of seconds to the given date. 1835 * 1836 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1837 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1838 * 1839 * @param date - The date to be changed 1840 * @param amount - The amount of seconds to be added. 1841 * @param options - An object with options 1842 * 1843 * @returns The new date with the seconds added 1844 * 1845 * @example 1846 * // Add 30 seconds to 10 July 2014 12:45:00: 1847 * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30) 1848 * //=> Thu Jul 10 2014 12:45:30 1849 */ 1850function addSeconds(date, amount, options) { 1851 return (0, _index.addMilliseconds)(date, amount * 1000, options); 1852} 1853 1854 1855/***/ }), 1856 1857/***/ 59786: 1858/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1859 1860"use strict"; 1861 1862exports.addWeeks = addWeeks; 1863var _index = __webpack_require__(519746); 1864 1865/** 1866 * The {@link addWeeks} function options. 1867 */ 1868 1869/** 1870 * @name addWeeks 1871 * @category Week Helpers 1872 * @summary Add the specified number of weeks to the given date. 1873 * 1874 * @description 1875 * Add the specified number of weeks to the given date. 1876 * 1877 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1878 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 1879 * 1880 * @param date - The date to be changed 1881 * @param amount - The amount of weeks to be added. 1882 * @param options - An object with options 1883 * 1884 * @returns The new date with the weeks added 1885 * 1886 * @example 1887 * // Add 4 weeks to 1 September 2014: 1888 * const result = addWeeks(new Date(2014, 8, 1), 4) 1889 * //=> Mon Sep 29 2014 00:00:00 1890 */ 1891function addWeeks(date, amount, options) { 1892 return (0, _index.addDays)(date, amount * 7, options); 1893} 1894 1895 1896/***/ }), 1897 1898/***/ 786156: 1899/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1900 1901"use strict"; 1902 1903exports.addYears = addYears; 1904var _index = __webpack_require__(292361); 1905 1906/** 1907 * The {@link addYears} function options. 1908 */ 1909 1910/** 1911 * @name addYears 1912 * @category Year Helpers 1913 * @summary Add the specified number of years to the given date. 1914 * 1915 * @description 1916 * Add the specified number of years to the given date. 1917 * 1918 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 1919 * @typeParam ResultDate - The result `Date` type. 1920 * 1921 * @param date - The date to be changed 1922 * @param amount - The amount of years to be added. 1923 * @param options - The options 1924 * 1925 * @returns The new date with the years added 1926 * 1927 * @example 1928 * // Add 5 years to 1 September 2014: 1929 * const result = addYears(new Date(2014, 8, 1), 5) 1930 * //=> Sun Sep 01 2019 00:00:00 1931 */ 1932function addYears(date, amount, options) { 1933 return (0, _index.addMonths)(date, amount * 12, options); 1934} 1935 1936 1937/***/ }), 1938 1939/***/ 546145: 1940/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1941 1942"use strict"; 1943 1944exports.areIntervalsOverlapping = areIntervalsOverlapping; 1945var _index = __webpack_require__(807799); 1946 1947/** 1948 * The {@link areIntervalsOverlapping} function options. 1949 */ 1950 1951/** 1952 * @name areIntervalsOverlapping 1953 * @category Interval Helpers 1954 * @summary Is the given time interval overlapping with another time interval? 1955 * 1956 * @description 1957 * Is the given time interval overlapping with another time interval? Adjacent intervals do not count as overlapping unless `inclusive` is set to `true`. 1958 * 1959 * @param intervalLeft - The first interval to compare. 1960 * @param intervalRight - The second interval to compare. 1961 * @param options - The object with options 1962 * 1963 * @returns Whether the time intervals are overlapping 1964 * 1965 * @example 1966 * // For overlapping time intervals: 1967 * areIntervalsOverlapping( 1968 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 1969 * { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) } 1970 * ) 1971 * //=> true 1972 * 1973 * @example 1974 * // For non-overlapping time intervals: 1975 * areIntervalsOverlapping( 1976 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 1977 * { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) } 1978 * ) 1979 * //=> false 1980 * 1981 * @example 1982 * // For adjacent time intervals: 1983 * areIntervalsOverlapping( 1984 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 1985 * { start: new Date(2014, 0, 20), end: new Date(2014, 0, 30) } 1986 * ) 1987 * //=> false 1988 * 1989 * @example 1990 * // Using the inclusive option: 1991 * areIntervalsOverlapping( 1992 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 1993 * { start: new Date(2014, 0, 20), end: new Date(2014, 0, 24) }, 1994 * { inclusive: true } 1995 * ) 1996 * //=> true 1997 */ 1998function areIntervalsOverlapping(intervalLeft, intervalRight, options) { 1999 const [leftStartTime, leftEndTime] = [ 2000 +(0, _index.toDate)(intervalLeft.start, options?.in), 2001 +(0, _index.toDate)(intervalLeft.end, options?.in), 2002 ].sort((a, b) => a - b); 2003 const [rightStartTime, rightEndTime] = [ 2004 +(0, _index.toDate)(intervalRight.start, options?.in), 2005 +(0, _index.toDate)(intervalRight.end, options?.in), 2006 ].sort((a, b) => a - b); 2007 2008 if (options?.inclusive) 2009 return leftStartTime <= rightEndTime && rightStartTime <= leftEndTime; 2010 2011 return leftStartTime < rightEndTime && rightStartTime < leftEndTime; 2012} 2013 2014 2015/***/ }), 2016 2017/***/ 717413: 2018/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2019 2020"use strict"; 2021 2022exports.clamp = clamp; 2023var _index = __webpack_require__(947561); 2024var _index2 = __webpack_require__(418809); 2025var _index3 = __webpack_require__(746226); 2026 2027/** 2028 * The {@link clamp} function options. 2029 */ 2030 2031/** 2032 * The {@link clamp} function result type. It resolves the proper data type. 2033 * It uses the first argument date object type, starting from the date argument, 2034 * then the start interval date, and finally the end interval date. If 2035 * a context function is passed, it uses the context function return type. 2036 */ 2037 2038/** 2039 * @name clamp 2040 * @category Interval Helpers 2041 * @summary Return a date bounded by the start and the end of the given interval. 2042 * 2043 * @description 2044 * Clamps a date to the lower bound with the start of the interval and the upper 2045 * bound with the end of the interval. 2046 * 2047 * - When the date is less than the start of the interval, the start is returned. 2048 * - When the date is greater than the end of the interval, the end is returned. 2049 * - Otherwise the date is returned. 2050 * 2051 * @typeParam DateType - Date argument type. 2052 * @typeParam IntervalType - Interval argument type. 2053 * @typeParam Options - Options type. 2054 * 2055 * @param date - The date to be bounded
2056 * @param interval - The interval to bound to 2057 * @param options - An object with options 2058 * 2059 * @returns The date bounded by the start and the end of the interval 2060 * 2061 * @example 2062 * // What is Mar 21, 2021 bounded to an interval starting at Mar 22, 2021 and ending at Apr 01, 2021 2063 * const result = clamp(new Date(2021, 2, 21), { 2064 * start: new Date(2021, 2, 22), 2065 * end: new Date(2021, 3, 1), 2066 * }) 2067 * //=> Mon Mar 22 2021 00:00:00 2068 */ 2069function clamp(date, interval, options) { 2070 const [date_, start, end] = (0, _index.normalizeDates)( 2071 options?.in, 2072 date, 2073 interval.start, 2074 interval.end, 2075 ); 2076 2077 return (0, _index3.min)( 2078 [(0, _index2.max)([date_, start], options), end], 2079 options, 2080 ); 2081} 2082 2083 2084/***/ }), 2085 2086/***/ 298147: 2087/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2088 2089"use strict"; 2090 2091exports.closestIndexTo = closestIndexTo; 2092var _index = __webpack_require__(807799); 2093 2094/** 2095 * @name closestIndexTo 2096 * @category Common Helpers 2097 * @summary Return an index of the closest date from the array comparing to the given date. 2098 * 2099 * @description 2100 * Return an index of the closest date from the array comparing to the given date. 2101 * 2102 * @param dateToCompare - The date to compare with 2103 * @param dates - The array to search 2104 * 2105 * @returns An index of the date closest to the given date or undefined if no valid value is given 2106 * 2107 * @example 2108 * // Which date is closer to 6 September 2015? 2109 * const dateToCompare = new Date(2015, 8, 6) 2110 * const datesArray = [ 2111 * new Date(2015, 0, 1), 2112 * new Date(2016, 0, 1), 2113 * new Date(2017, 0, 1) 2114 * ] 2115 * const result = closestIndexTo(dateToCompare, datesArray) 2116 * //=> 1 2117 */ 2118function closestIndexTo(dateToCompare, dates) { 2119 // [TODO] It would be better to return -1 here rather than undefined, as this 2120 // is how JS behaves, but it would be a breaking change, so we need 2121 // to consider it for v4. 2122 const timeToCompare = +(0, _index.toDate)(dateToCompare); 2123 2124 if (isNaN(timeToCompare)) return NaN; 2125 2126 let result; 2127 let minDistance; 2128 dates.forEach((date, index) => { 2129 const date_ = (0, _index.toDate)(date); 2130 2131 if (isNaN(+date_)) { 2132 result = NaN; 2133 minDistance = NaN; 2134 return; 2135 } 2136 2137 const distance = Math.abs(timeToCompare - +date_); 2138 if (result == null || distance < minDistance) { 2139 result = index; 2140 minDistance = distance; 2141 } 2142 }); 2143 2144 return result; 2145} 2146 2147 2148/***/ }), 2149 2150/***/ 174284: 2151/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2152 2153"use strict"; 2154 2155exports.closestTo = closestTo; 2156var _index = __webpack_require__(947561); 2157var _index2 = __webpack_require__(298147); 2158var _index3 = __webpack_require__(658612); 2159 2160/** 2161 * The {@link closestTo} function options. 2162 */ 2163 2164/** 2165 * The {@link closestTo} function result type. It resolves the proper data type. 2166 * It uses the first argument date object type, starting from the date argument, 2167 * then the start interval date, and finally the end interval date. If 2168 * a context function is passed, it uses the context function return type. 2169 */ 2170 2171/** 2172 * @name closestTo 2173 * @category Common Helpers 2174 * @summary Return a date from the array closest to the given date. 2175 * 2176 * @description 2177 * Return a date from the array closest to the given date. 2178 * 2179 * @typeParam DateToCompare - Date to compare argument type. 2180 * @typeParam DatesType - Dates array argument type. 2181 * @typeParam Options - Options type. 2182 * 2183 * @param dateToCompare - The date to compare with 2184 * @param dates - The array to search 2185 * 2186 * @returns The date from the array closest to the given date or undefined if no valid value is given 2187 * 2188 * @example 2189 * // Which date is closer to 6 September 2015: 1 January 2000 or 1 January 2030? 2190 * const dateToCompare = new Date(2015, 8, 6) 2191 * const result = closestTo(dateToCompare, [ 2192 * new Date(2000, 0, 1), 2193 * new Date(2030, 0, 1) 2194 * ]) 2195 * //=> Tue Jan 01 2030 00:00:00 2196 */ 2197function closestTo(dateToCompare, dates, options) { 2198 const [dateToCompare_, ...dates_] = (0, _index.normalizeDates)( 2199 options?.in, 2200 dateToCompare, 2201 ...dates, 2202 ); 2203 2204 const index = (0, _index2.closestIndexTo)(dateToCompare_, dates_); 2205 2206 if (typeof index === "number" && isNaN(index)) 2207 return (0, _index3.constructFrom)(dateToCompare_, NaN); 2208 2209 if (index !== undefined) return dates_[index]; 2210} 2211 2212 2213/***/ }), 2214 2215/***/ 636374: 2216/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2217 2218"use strict"; 2219 2220exports.compareAsc = compareAsc; 2221var _index = __webpack_require__(807799); 2222 2223/** 2224 * @name compareAsc 2225 * @category Common Helpers 2226 * @summary Compare the two dates and return -1, 0 or 1. 2227 * 2228 * @description 2229 * Compare the two dates and return 1 if the first date is after the second, 2230 * -1 if the first date is before the second or 0 if dates are equal. 2231 * 2232 * @param dateLeft - The first date to compare 2233 * @param dateRight - The second date to compare 2234 * 2235 * @returns The result of the comparison 2236 * 2237 * @example 2238 * // Compare 11 February 1987 and 10 July 1989: 2239 * const result = compareAsc(new Date(1987, 1, 11), new Date(1989, 6, 10)) 2240 * //=>
2240 -1 2241 * 2242 * @example 2243 * // Sort the array of dates: 2244 * const result = [ 2245 * new Date(1995, 6, 2), 2246 * new Date(1987, 1, 11), 2247 * new Date(1989, 6, 10) 2248 * ].sort(compareAsc) 2249 * //=> [ 2250 * // Wed Feb 11 1987 00:00:00, 2251 * // Mon Jul 10 1989 00:00:00, 2252 * // Sun Jul 02 1995 00:00:00 2253 * // ] 2254 */ 2255function compareAsc(dateLeft, dateRight) { 2256 const diff = +(0, _index.toDate)(dateLeft) - +(0, _index.toDate)(dateRight); 2257 2258 if (diff < 0) return -1; 2259 else if (diff > 0) return 1; 2260 2261 // Return 0 if diff is 0; return NaN if diff is NaN 2262 return diff; 2263} 2264 2265 2266/***/ }), 2267 2268/***/ 684121: 2269/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2270 2271"use strict"; 2272 2273exports.compareDesc = compareDesc; 2274var _index = __webpack_require__(807799); 2275 2276/** 2277 * @name compareDesc 2278 * @category Common Helpers 2279 * @summary Compare the two dates reverse chronologically and return -1, 0 or 1. 2280 * 2281 * @description 2282 * Compare the two dates and return -1 if the first date is after the second, 2283 * 1 if the first date is before the second or 0 if dates are equal. 2284 * 2285 * @param dateLeft - The first date to compare 2286 * @param dateRight - The second date to compare 2287 * 2288 * @returns The result of the comparison 2289 * 2290 * @example 2291 * // Compare 11 February 1987 and 10 July 1989 reverse chronologically: 2292 * const result = compareDesc(new Date(1987, 1, 11), new Date(1989, 6, 10)) 2293 * //=> 1 2294 * 2295 * @example 2296 * // Sort the array of dates in reverse chronological order: 2297 * const result = [ 2298 * new Date(1995, 6, 2), 2299 * new Date(1987, 1, 11), 2300 * new Date(1989, 6, 10) 2301 * ].sort(compareDesc) 2302 * //=> [ 2303 * // Sun Jul 02 1995 00:00:00, 2304 * // Mon Jul 10 1989 00:00:00, 2305 * // Wed Feb 11 1987 00:00:00 2306 * // ] 2307 */ 2308function compareDesc(dateLeft, dateRight) { 2309 const diff = +(0, _index.toDate)(dateLeft) - +(0, _index.toDate)(dateRight); 2310 2311 if (diff > 0) return -1; 2312 else if (diff < 0) return 1; 2313 2314 // Return 0 if diff is 0; return NaN if diff is NaN 2315 return diff; 2316} 2317 2318 2319/***/ }), 2320 2321/***/ 241836: 2322/***/ (function(__unused_webpack_module, exports) { 2323 2324"use strict"; 2325 2326exports.secondsInYear = 2327 exports.secondsInWeek = 2328 exports.secondsInQuarter = 2329 exports.secondsInMonth = 2330 exports.secondsInMinute = 2331 exports.secondsInHour = 2332 exports.secondsInDay = 2333 exports.quartersInYear = 2334 exports.monthsInYear = 2335 exports.monthsInQuarter = 2336 exports.minutesInYear = 2337 exports.minutesInMonth = 2338 exports.minutesInHour = 2339 exports.minutesInDay = 2340 exports.minTime = 2341 exports.millisecondsInWeek = 2342 exports.millisecondsInSecond = 2343 exports.millisecondsInMinute = 2344 exports.millisecondsInHour = 2345 exports.millisecondsInDay = 2346 exports.maxTime = 2347 exports.daysInYear = 2348 exports.daysInWeek = 2349 exports.constructFromSymbol = 2350 void 0; /** 2351 * @module constants 2352 * @summary Useful constants 2353 * @description 2354 * Collection of useful date constants. 2355 * 2356 * The constants could be imported from `date-fns/constants`: 2357 * 2358 * ```ts 2359 * import { maxTime, minTime } from "date-fns/constants"; 2360 * 2361 * function isAllowedTime(time) { 2362 * return time <= maxTime && time >= minTime; 2363 * } 2364 * ``` 2365 */ 2366 2367/** 2368 * @constant 2369 * @name daysInWeek 2370 * @summary Days in 1 week. 2371 */ 2372const daysInWeek = (exports.daysInWeek = 7); 2373 2374/** 2375 * @constant 2376 * @name daysInYear 2377 * @summary Days in 1 year. 2378 * 2379 * @description 2380 * How many days in a year. 2381 * 2382 * One years equals 365.2425 days according to the formula: 2383 * 2384 * > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400. 2385 * > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days 2386 */ 2387const daysInYear = (exports.daysInYear = 365.2425); 2388 2389/** 2390 * @constant 2391 * @name maxTime 2392 * @summary Maximum allowed time. 2393 * 2394 * @example 2395 * import { maxTime } from "date-fns/constants"; 2396 * 2397 * const isValid = 8640000000000001 <= maxTime; 2398 * //=> false 2399 * 2400 * new Date(8640000000000001); 2401 * //=> Invalid Date 2402 */ 2403const maxTime = (exports.maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000); 2404 2405/** 2406 * @constant 2407 * @name minTime 2408 * @summary Minimum allowed time. 2409 * 2410 * @example 2411 * import { minTime } from "date-fns/constants"; 2412 * 2413 * const isValid = -8640000000000001 >= minTime; 2414 * //=> false 2415 * 2416 * new Date(-8640000000000001) 2417 * //=> Invalid Date 2418 */ 2419const minTime = (exports.minTime = -maxTime); 2420 2421/** 2422 * @constant 2423 * @name millisecondsInWeek 2424 * @summary Milliseconds in 1 week. 2425 */ 2426const millisecondsInWeek = (exports.millisecondsInWeek = 604800000); 2427 2428/** 2429 * @constant 2430 * @name millisecondsInDay 2431 * @summary Milliseconds in 1 day. 2432 */ 2433const millisecondsInDay = (exports.millisecondsInDay = 86400000); 2434 2435/** 2436 * @constant 2437 * @name millisecondsInMinute 2438 * @summary Milliseconds in 1 minute 2439 */ 2440const millisecondsInMinute = (exports.millisecondsInMinute = 60000); 2441 2442/** 2443 * @constant 2444 * @name millisecondsInHour 2445 * @summary Milliseconds in 1 hour 2446 */ 2447const millisecondsInHour = (exports.millisecondsInHour = 3600000); 2448 2449/** 2450 * @constant 2451 * @name millisecondsInSecond 2452 * @summary Milliseconds in 1 second 2453 */ 2454const millisecondsInSecond = (exports.millisecondsInSecond = 1000); 2455 2456/** 2457 * @constant 2458 * @name minutesInYear 2459 * @summary Minutes in 1 year. 2460 */ 2461const minutesInYear = (exports.minutesInYear = 525600); 2462 2463/** 2464 * @constant 2465 * @name minutesInMonth 2466 * @summary Minutes in 1 month. 2467 */ 2468const minutesInMonth = (exports.minutesInMonth = 43200); 2469 2470/** 2471 * @constant 2472 * @name minutesInDay 2473 * @summary Minutes in 1 day. 2474 */ 2475const minutesInDay = (exports.minutesInDay = 1440); 2476 2477/** 2478 * @constant 2479 * @name minutesInHour 2480 * @summary Minutes in 1 hour. 2481 */ 2482const minutesInHour = (exports.minutesInHour = 60); 2483 2484/** 2485 * @constant 2486 * @name monthsInQuarter 2487 * @summary Months in 1 quarter. 2488 */ 2489const monthsInQuarter = (exports.monthsInQuarter = 3); 2490 2491/** 2492 * @constant 2493 * @name monthsInYear 2494 * @summary Months in 1 year. 2495 */ 2496const monthsInYear = (exports.monthsInYear = 12); 2497 2498/** 2499 * @constant 2500 * @name quartersInYear 2501 * @summary Quarters in 1 year 2502 */ 2503const quartersInYear = (exports.quartersInYear = 4); 2504 2505/** 2506 * @constant 2507 * @name secondsInHour
2508 * @summary Seconds in 1 hour. 2509 */ 2510const secondsInHour = (exports.secondsInHour = 3600); 2511 2512/** 2513 * @constant 2514 * @name secondsInMinute 2515 * @summary Seconds in 1 minute. 2516 */ 2517const secondsInMinute = (exports.secondsInMinute = 60); 2518 2519/** 2520 * @constant 2521 * @name secondsInDay 2522 * @summary Seconds in 1 day. 2523 */ 2524const secondsInDay = (exports.secondsInDay = secondsInHour * 24); 2525 2526/** 2527 * @constant 2528 * @name secondsInWeek 2529 * @summary Seconds in 1 week. 2530 */ 2531const secondsInWeek = (exports.secondsInWeek = secondsInDay * 7); 2532 2533/** 2534 * @constant 2535 * @name secondsInYear 2536 * @summary Seconds in 1 year. 2537 */ 2538const secondsInYear = (exports.secondsInYear = secondsInDay * daysInYear); 2539 2540/** 2541 * @constant 2542 * @name secondsInMonth 2543 * @summary Seconds in 1 month 2544 */ 2545const secondsInMonth = (exports.secondsInMonth = secondsInYear / 12); 2546 2547/** 2548 * @constant 2549 * @name secondsInQuarter 2550 * @summary Seconds in 1 quarter. 2551 */ 2552const secondsInQuarter = (exports.secondsInQuarter = secondsInMonth * 3); 2553 2554/** 2555 * @constant 2556 * @name constructFromSymbol 2557 * @summary Symbol enabling Date extensions to inherit properties from the reference date. 2558 * 2559 * The symbol is used to enable the `constructFrom` function to construct a date 2560 * using a reference date and a value. It allows to transfer extra properties 2561 * from the reference date to the new date. It's useful for extensions like 2562 * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as 2563 * a constructor argument. 2564 */ 2565const constructFromSymbol = (exports.constructFromSymbol = 2566 Symbol.for("constructDateFrom")); 2567 2568 2569/***/ }), 2570 2571/***/ 658612: 2572/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2573 2574"use strict"; 2575 2576exports.constructFrom = constructFrom; 2577var _index = __webpack_require__(241836); 2578 2579/** 2580 * @name constructFrom 2581 * @category Generic Helpers 2582 * @summary Constructs a date using the reference date and the value 2583 * 2584 * @description 2585 * The function constructs a new date using the constructor from the reference 2586 * date and the given value. It helps to build generic functions that accept 2587 * date extensions. 2588 * 2589 * It defaults to `Date` if the passed reference date is a number or a string. 2590 * 2591 * Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]` 2592 * enabling to transfer extra properties from the reference date to the new date. 2593 * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz) 2594 * that accept a time zone as a constructor argument. 2595 * 2596 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 2597 * 2598 * @param date - The reference date to take constructor from 2599 * @param value - The value to create the date 2600 * 2601 * @returns Date initialized using the given date and value 2602 * 2603 * @example 2604 * import { constructFrom } from "date-fns"; 2605 * 2606 * // A function that clones a date preserving the original type 2607 * function cloneDate<DateType extends Date>(date: DateType): DateType { 2608 * return constructFrom( 2609 * date, // Use constructor from the given date 2610 * date.getTime() // Use the date value to create a new date 2611 * ); 2612 * } 2613 */ 2614function constructFrom(date, value) { 2615 if (typeof date === "function") return date(value); 2616 2617 if (date && typeof date === "object" && _index.constructFromSymbol in date) 2618 return date[_index.constructFromSymbol](value); 2619 2620 if (date instanceof Date) return new date.constructor(value); 2621 2622 return new Date(value); 2623} 2624 2625 2626/***/ }), 2627 2628/***/ 560533: 2629/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2630 2631"use strict"; 2632 2633exports.constructNow = constructNow; 2634var _index = __webpack_require__(658612); 2635 2636/** 2637 * @name constructNow 2638 * @category Generic Helpers 2639 * @summary Constructs a new current date using the passed value constructor. 2640 * @pure false 2641 * 2642 * @description 2643 * The function constructs a new current date using the constructor from 2644 * the reference date. It helps to build generic functions that accept date 2645 * extensions and use the current date. 2646 * 2647 * It defaults to `Date` if the passed reference date is a number or a string. 2648 * 2649 * @param date - The reference date to take constructor from 2650 * 2651 * @returns Current date initialized using the given date constructor 2652 * 2653 * @example 2654 * import { constructNow, isSameDay } from 'date-fns' 2655 * 2656 * function isToday<DateType extends Date>( 2657 * date: DateArg<DateType>, 2658 * ): boolean { 2659 * // If we were to use `new Date()` directly, the function would behave 2660 * // differently in different timezones and return false for the same date. 2661 * return isSameDay(date, constructNow(date)); 2662 * } 2663 */ 2664function constructNow(date) { 2665 return (0, _index.constructFrom)(date, Date.now()); 2666} 2667 2668 2669/***/ }), 2670 2671/***/ 812836: 2672/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2673 2674"use strict"; 2675 2676exports.daysToWeeks = daysToWeeks; 2677var _index = __webpack_require__(241836); 2678 2679/** 2680 * @name daysToWeeks 2681 * @category Conversion Helpers 2682 * @summary Convert days to weeks. 2683 * 2684 * @description 2685 * Convert a number of days to a full number of weeks. 2686 * 2687 * @param days - The number of days to be converted 2688 * 2689 * @returns The number of days converted in weeks 2690 * 2691 * @example 2692 * // Convert 14 days to weeks: 2693 * const result = daysToWeeks(14) 2694 * //=> 2 2695 * 2696 * @example 2697 * // It uses trunc rounding: 2698 * const result = daysToWeeks(13) 2699 * //=> 1 2700 */ 2701function daysToWeeks(days) { 2702 const result = Math.trunc(days / _index.daysInWeek); 2703 // Prevent negative zero 2704 return result === 0 ? 0 : result; 2705} 2706 2707 2708/***/ }), 2709 2710/***/ 115893: 2711/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2712 2713"use strict"; 2714 2715exports.differenceInBusinessDays = differenceInBusinessDays; 2716var _index = __webpack_require__(947561); 2717var _index2 = __webpack_require__(519746); 2718var _index3 = __webpack_require__(72028); 2719var _index4 = __webpack_require__(373958); 2720var _index5 = __webpack_require__(533209); 2721var _index6 = __webpack_require__(356804); 2722 2723/** 2724 * The {@link differenceInBusinessDays} function options. 2725 */ 2726 2727/** 2728 * @name differenceInBusinessDays 2729 * @category Day Helpers 2730 * @summary Get the number of business days between the given dates. 2731 * 2732 * @description 2733 * Get the number of business day periods between the given dates. 2734 * Business days being days that aren't in the weekend. 2735 * Like `differenceInCalendarDays`, the function removes the times from 2736 * the dates before calculating the difference. 2737 * 2738 * @param laterDate - The later date 2739 * @param earlierDate - The earlier date 2740 * @param options - An object with options 2741 * 2742 * @returns The number of business days 2743 * 2744 * @example 2745 * // How many business days are between 2746 * // 10 January 2014 and 20 July 2014? 2747 * const result = differenceInBusinessDays( 2748 * new Date(2014, 6, 20), 2749 * new Date(2014, 0, 10) 2750 * ) 2751 * //=> 136 2752 * 2753 * // How many business days are between 2754 * // 30 November 2021 and 1 November 2021? 2755 * const result = differenceInBusinessDays( 2756 * new Date(2021, 10, 30), 2757 * new Date(2021, 10, 1) 2758 * ) 2759 * //=> 21 2760 * 2761 * // How many business days are between 2762 * // 1 November 2021 and 1 December 2021? 2763 * const result = differenceInBusinessDays( 2764 * new Date(2021, 10, 1), 2765 * new Date(2021, 11, 1) 2766 * ) 2767 * //=>
2767 -22 2768 * 2769 * // How many business days are between 2770 * // 1 November 2021 and 1 November 2021 ? 2771 * const result = differenceInBusinessDays( 2772 * new Date(2021, 10, 1), 2773 * new Date(2021, 10, 1) 2774 * ) 2775 * //=> 0 2776 */ 2777function differenceInBusinessDays(laterDate, earlierDate, options) { 2778 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 2779 options?.in, 2780 laterDate, 2781 earlierDate, 2782 ); 2783 2784 if (!(0, _index5.isValid)(laterDate_) || !(0, _index5.isValid)(earlierDate_)) 2785 return NaN; 2786 2787 const diff = (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_); 2788 const sign = diff < 0 ? -1 : 1; 2789 const weeks = Math.trunc(diff / 7); 2790 2791 let result = weeks * 5; 2792 let movingDate = (0, _index2.addDays)(earlierDate_, weeks * 7); 2793 2794 // the loop below will run at most 6 times to account for the remaining days that don't makeup a full week 2795 while (!(0, _index4.isSameDay)(laterDate_, movingDate)) { 2796 // sign is used to account for both negative and positive differences 2797 result += (0, _index6.isWeekend)(movingDate, options) ? 0 : sign; 2798 movingDate = (0, _index2.addDays)(movingDate, sign); 2799 } 2800 2801 // Prevent negative zero 2802 return result === 0 ? 0 : result; 2803} 2804 2805 2806/***/ }), 2807 2808/***/ 72028: 2809/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2810 2811"use strict"; 2812 2813exports.differenceInCalendarDays = differenceInCalendarDays; 2814var _index = __webpack_require__(158228); 2815var _index2 = __webpack_require__(947561); 2816var _index3 = __webpack_require__(241836); 2817var _index4 = __webpack_require__(731010); 2818 2819/** 2820 * The {@link differenceInCalendarDays} function options. 2821 */ 2822 2823/** 2824 * @name differenceInCalendarDays 2825 * @category Day Helpers 2826 * @summary Get the number of calendar days between the given dates. 2827 * 2828 * @description 2829 * Get the number of calendar days between the given dates. This means that the times are removed 2830 * from the dates and then the difference in days is calculated. 2831 * 2832 * @param laterDate - The later date 2833 * @param earlierDate - The earlier date 2834 * @param options - The options object 2835 * 2836 * @returns The number of calendar days 2837 * 2838 * @example 2839 * // How many calendar days are between 2840 * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00? 2841 * const result = differenceInCalendarDays( 2842 * new Date(2012, 6, 2, 0, 0), 2843 * new Date(2011, 6, 2, 23, 0) 2844 * ) 2845 * //=> 366 2846 * // How many calendar days are between 2847 * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00? 2848 * const result = differenceInCalendarDays( 2849 * new Date(2011, 6, 3, 0, 1), 2850 * new Date(2011, 6, 2, 23, 59) 2851 * ) 2852 * //=> 1 2853 */ 2854function differenceInCalendarDays(laterDate, earlierDate, options) { 2855 const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)( 2856 options?.in, 2857 laterDate, 2858 earlierDate, 2859 ); 2860 2861 const laterStartOfDay = (0, _index4.startOfDay)(laterDate_); 2862 const earlierStartOfDay = (0, _index4.startOfDay)(earlierDate_); 2863 2864 const laterTimestamp = 2865 +laterStartOfDay - 2866 (0, _index.getTimezoneOffsetInMilliseconds)(laterStartOfDay); 2867 const earlierTimestamp = 2868 +earlierStartOfDay - 2869 (0, _index.getTimezoneOffsetInMilliseconds)(earlierStartOfDay); 2870 2871 // Round the number of days to the nearest integer because the number of 2872 // milliseconds in a day is not constant (e.g. it's different in the week of 2873 // the daylight saving time clock shift). 2874 return Math.round( 2875 (laterTimestamp - earlierTimestamp) / _index3.millisecondsInDay, 2876 ); 2877} 2878 2879 2880/***/ }), 2881 2882/***/ 61500: 2883/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2884 2885"use strict"; 2886 2887exports.differenceInCalendarISOWeekYears = differenceInCalendarISOWeekYears; 2888var _index = __webpack_require__(947561); 2889var _index2 = __webpack_require__(196914); 2890 2891/** 2892 * The {@link differenceInCalendarISOWeekYears} function options. 2893 */ 2894 2895/** 2896 * @name differenceInCalendarISOWeekYears 2897 * @category ISO Week-Numbering Year Helpers 2898 * @summary Get the number of calendar ISO week-numbering years between the given dates. 2899 * 2900 * @description 2901 * Get the number of calendar ISO week-numbering years between the given dates. 2902 * 2903 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 2904 * 2905 * @param laterDate - The later date 2906 * @param earlierDate - The earlier date 2907 * @param options - An object with options 2908 * 2909 * @returns The number of calendar ISO week-numbering years 2910 * 2911 * @example 2912 * // How many calendar ISO week-numbering years are 1 January 2010 and 1 January 2012? 2913 * const result = differenceInCalendarISOWeekYears( 2914 * new Date(2012, 0, 1), 2915 * new Date(2010, 0, 1) 2916 * ) 2917 * //=> 2 2918 */ 2919function differenceInCalendarISOWeekYears(laterDate, earlierDate, options) {
2920 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 2921 options?.in, 2922 laterDate, 2923 earlierDate, 2924 ); 2925 return ( 2926 (0, _index2.getISOWeekYear)(laterDate_, options) - 2927 (0, _index2.getISOWeekYear)(earlierDate_, options) 2928 ); 2929} 2930 2931 2932/***/ }), 2933 2934/***/ 122345: 2935/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 2936 2937"use strict"; 2938 2939exports.differenceInCalendarISOWeeks = differenceInCalendarISOWeeks; 2940var _index = __webpack_require__(158228); 2941var _index2 = __webpack_require__(947561); 2942var _index3 = __webpack_require__(241836); 2943var _index4 = __webpack_require__(266795); 2944 2945/** 2946 * The {@link differenceInCalendarISOWeeks} function options. 2947 */ 2948 2949/** 2950 * @name differenceInCalendarISOWeeks 2951 * @category ISO Week Helpers 2952 * @summary Get the number of calendar ISO weeks between the given dates. 2953 * 2954 * @description 2955 * Get the number of calendar ISO weeks between the given dates. 2956 * 2957 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 2958 * 2959 * @param laterDate - The later date 2960 * @param earlierDate - The earlier date 2961 * @param options - An object with options 2962 * 2963 * @returns The number of calendar ISO weeks 2964 * 2965 * @example 2966 * // How many calendar ISO weeks are between 6 July 2014 and 21 July 2014? 2967 * const result = differenceInCalendarISOWeeks( 2968 * new Date(2014, 6, 21), 2969 * new Date(2014, 6, 6), 2970 * ); 2971 * //=> 3 2972 */ 2973function differenceInCalendarISOWeeks(laterDate, earlierDate, options) { 2974 const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)( 2975 options?.in, 2976 laterDate, 2977 earlierDate, 2978 ); 2979 2980 const startOfISOWeekLeft = (0, _index4.startOfISOWeek)(laterDate_); 2981 const startOfISOWeekRight = (0, _index4.startOfISOWeek)(earlierDate_); 2982 2983 const timestampLeft = 2984 +startOfISOWeekLeft - 2985 (0, _index.getTimezoneOffsetInMilliseconds)(startOfISOWeekLeft); 2986 const timestampRight = 2987 +startOfISOWeekRight - 2988 (0, _index.getTimezoneOffsetInMilliseconds)(startOfISOWeekRight); 2989 2990 // Round the number of weeks to the nearest integer because the number of 2991 // milliseconds in a week is not constant (e.g. it's different in the week of 2992 // the daylight saving time clock shift). 2993 return Math.round( 2994 (timestampLeft - timestampRight) / _index3.millisecondsInWeek, 2995 ); 2996} 2997 2998 2999/***/ }), 3000 3001/***/ 362530: 3002/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3003 3004"use strict"; 3005 3006exports.differenceInCalendarMonths = differenceInCalendarMonths; 3007var _index = __webpack_require__(947561); 3008 3009/** 3010 * The {@link differenceInCalendarMonths} function options. 3011 */ 3012 3013/** 3014 * @name differenceInCalendarMonths 3015 * @category Month Helpers 3016 * @summary Get the number of calendar months between the given dates. 3017 * 3018 * @description 3019 * Get the number of calendar months between the given dates. 3020 * 3021 * @param laterDate - The later date 3022 * @param earlierDate - The earlier date 3023 * @param options - An object with options 3024 * 3025 * @returns The number of calendar months 3026 * 3027 * @example 3028 * // How many calendar months are between 31 January 2014 and 1 September 2014? 3029 * const result = differenceInCalendarMonths( 3030 * new Date(2014, 8, 1), 3031 * new Date(2014, 0, 31) 3032 * ) 3033 * //=> 8 3034 */ 3035function differenceInCalendarMonths(laterDate, earlierDate, options) { 3036 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3037 options?.in, 3038 laterDate, 3039 earlierDate, 3040 ); 3041 3042 const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear(); 3043 const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth(); 3044 3045 return yearsDiff * 12 + monthsDiff; 3046} 3047 3048 3049/***/ }), 3050 3051/***/ 900677: 3052/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3053 3054"use strict"; 3055 3056exports.differenceInCalendarQuarters = differenceInCalendarQuarters; 3057var _index = __webpack_require__(947561); 3058var _index2 = __webpack_require__(69662); 3059 3060/** 3061 * The {@link differenceInCalendarQuarters} function options. 3062 */ 3063 3064/** 3065 * @name differenceInCalendarQuarters 3066 * @category Quarter Helpers 3067 * @summary Get the number of calendar quarters between the given dates. 3068 * 3069 * @description 3070 * Get the number of calendar quarters between the given dates. 3071 * 3072 * @param laterDate - The later date 3073 * @param earlierDate - The earlier date 3074 * @param options - An object with options 3075 * 3076 * @returns The number of calendar quarters 3077 * 3078 * @example 3079 * // How many calendar quarters are between 31 December 2013 and 2 July 2014? 3080 * const result = differenceInCalendarQuarters( 3081 * new Date(2014, 6, 2), 3082 * new Date(2013, 11, 31) 3083 * ) 3084 * //=> 3 3085 */ 3086function differenceInCalendarQuarters(laterDate, earlierDate, options) {
3087 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3088 options?.in, 3089 laterDate, 3090 earlierDate, 3091 ); 3092 3093 const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear(); 3094 const quartersDiff = 3095 (0, _index2.getQuarter)(laterDate_) - (0, _index2.getQuarter)(earlierDate_); 3096 3097 return yearsDiff * 4 + quartersDiff; 3098} 3099 3100 3101/***/ }), 3102 3103/***/ 124071: 3104/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3105 3106"use strict"; 3107 3108exports.differenceInCalendarWeeks = differenceInCalendarWeeks; 3109var _index = __webpack_require__(158228); 3110var _index2 = __webpack_require__(947561); 3111var _index3 = __webpack_require__(241836); 3112var _index4 = __webpack_require__(517805); 3113 3114/** 3115 * The {@link differenceInCalendarWeeks} function options. 3116 */ 3117 3118/** 3119 * @name differenceInCalendarWeeks 3120 * @category Week Helpers 3121 * @summary Get the number of calendar weeks between the given dates. 3122 * 3123 * @description 3124 * Get the number of calendar weeks between the given dates. 3125 * 3126 * @param laterDate - The later date 3127 * @param earlierDate - The earlier date 3128 * @param options - An object with options. 3129 * 3130 * @returns The number of calendar weeks 3131 * 3132 * @example 3133 * // How many calendar weeks are between 5 July 2014 and 20 July 2014? 3134 * const result = differenceInCalendarWeeks( 3135 * new Date(2014, 6, 20), 3136 * new Date(2014, 6, 5) 3137 * ) 3138 * //=> 3 3139 * 3140 * @example 3141 * // If the week starts on Monday, 3142 * // how many calendar weeks are between 5 July 2014 and 20 July 2014? 3143 * const result = differenceInCalendarWeeks( 3144 * new Date(2014, 6, 20), 3145 * new Date(2014, 6, 5), 3146 * { weekStartsOn: 1 } 3147 * ) 3148 * //=> 2 3149 */ 3150function differenceInCalendarWeeks(laterDate, earlierDate, options) { 3151 const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)( 3152 options?.in, 3153 laterDate, 3154 earlierDate, 3155 ); 3156 3157 const laterStartOfWeek = (0, _index4.startOfWeek)(laterDate_, options); 3158 const earlierStartOfWeek = (0, _index4.startOfWeek)(earlierDate_, options); 3159 3160 const laterTimestamp = 3161 +laterStartOfWeek - 3162 (0, _index.getTimezoneOffsetInMilliseconds)(laterStartOfWeek); 3163 const earlierTimestamp = 3164 +earlierStartOfWeek - 3165 (0, _index.getTimezoneOffsetInMilliseconds)(earlierStartOfWeek); 3166 3167 return Math.round( 3168 (laterTimestamp - earlierTimestamp) / _index3.millisecondsInWeek, 3169 ); 3170} 3171 3172 3173/***/ }), 3174 3175/***/ 199067: 3176/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3177 3178"use strict"; 3179 3180exports.differenceInCalendarYears = differenceInCalendarYears; 3181var _index = __webpack_require__(947561); 3182 3183/** 3184 * The {@link differenceInCalendarYears} function options. 3185 */ 3186 3187/** 3188 * @name differenceInCalendarYears 3189 * @category Year Helpers 3190 * @summary Get the number of calendar years between the given dates. 3191 * 3192 * @description 3193 * Get the number of calendar years between the given dates. 3194 * 3195 * @param laterDate - The later date 3196 * @param earlierDate - The earlier date 3197 * @param options - An object with options 3198 3199 * @returns The number of calendar years 3200 * 3201 * @example 3202 * // How many calendar years are between 31 December 2013 and 11 February 2015? 3203 * const result = differenceInCalendarYears( 3204 * new Date(2015, 1, 11), 3205 * new Date(2013, 11, 31) 3206 * ); 3207 * //=> 2 3208 */ 3209function differenceInCalendarYears(laterDate, earlierDate, options) { 3210 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3211 options?.in, 3212 laterDate, 3213 earlierDate, 3214 ); 3215 return laterDate_.getFullYear() - earlierDate_.getFullYear(); 3216} 3217 3218 3219/***/ }), 3220 3221/***/ 820537: 3222/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3223 3224"use strict"; 3225 3226exports.differenceInDays = differenceInDays; 3227var _index = __webpack_require__(947561); 3228var _index2 = __webpack_require__(72028); 3229 3230/** 3231 * The {@link differenceInDays} function options. 3232 */ 3233 3234/** 3235 * @name differenceInDays 3236 * @category Day Helpers 3237 * @summary Get the number of full days between the given dates. 3238 * 3239 * @description 3240 * Get the number of full day periods between two dates. Fractional days are 3241 * truncated towards zero. 3242 * 3243 * One "full day" is the distance between a local time in one day to the same 3244 * local time on the next or previous day. A full day can sometimes be less than 3245 * or more than 24 hours if a daylight savings change happens between two dates. 3246 * 3247 * To ignore DST and only measure exact 24-hour periods, use this instead: 3248 * `Math.trunc(differenceInHours(dateLeft, dateRight)/24)|0`. 3249 * 3250 * @param laterDate - The later date 3251 * @param earlierDate - The earlier date 3252 * @param options - An object with options 3253 * 3254 * @returns The number of full days according to the local timezone 3255 * 3256 * @example 3257 * // How many full days are between 3258 * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00? 3259 * const result = differenceInDays( 3260 * new Date(2012, 6, 2, 0, 0), 3261 * new Date(2011, 6, 2, 23, 0) 3262 * ) 3263 * //=> 365 3264 * 3265 * @example 3266 * // How many full days are between 3267 * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00? 3268 * const result = differenceInDays( 3269 * new Date(2011, 6, 3, 0, 1), 3270 * new Date(2011, 6, 2, 23, 59) 3271 * ) 3272 * //=> 0 3273 * 3274 * @example 3275 * // How many full days are between 3276 * // 1 March 2020 0:00 and 1 June 2020 0:00 ? 3277 * // Note: because local time is used, the 3278 * // result will always be 92 days, even in 3279 * // time zones where DST starts and the 3280 * // period has only 92*24-1 hours. 3281 * const result = differenceInDays( 3282 * new Date(2020, 5, 1), 3283 * new Date(2020, 2, 1) 3284 * ) 3285 * //=> 92 3286 */ 3287function differenceInDays(laterDate, earlierDate, options) {
vendor: 12,691 bytes, lines 3288-3744
3288 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3289 options?.in, 3290 laterDate, 3291 earlierDate, 3292 ); 3293 3294 const sign = compareLocalAsc(laterDate_, earlierDate_); 3295 const difference = Math.abs( 3296 (0, _index2.differenceInCalendarDays)(laterDate_, earlierDate_), 3297 ); 3298 3299 laterDate_.setDate(laterDate_.getDate() - sign * difference); 3300 3301 // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full 3302 // If so, result must be decreased by 1 in absolute value 3303 const isLastDayNotFull = Number( 3304 compareLocalAsc(laterDate_, earlierDate_) === -sign, 3305 ); 3306 3307 const result = sign * (difference - isLastDayNotFull); 3308 // Prevent negative zero 3309 return result === 0 ? 0 : result; 3310} 3311 3312// Like `compareAsc` but uses local time not UTC, which is needed 3313// for accurate equality comparisons of UTC timestamps that end up 3314// having the same representation in local time, e.g. one hour before 3315// DST ends vs. the instant that DST ends. 3316function compareLocalAsc(laterDate, earlierDate) { 3317 const diff = 3318 laterDate.getFullYear() - earlierDate.getFullYear() || 3319 laterDate.getMonth() - earlierDate.getMonth() || 3320 laterDate.getDate() - earlierDate.getDate() || 3321 laterDate.getHours() - earlierDate.getHours() || 3322 laterDate.getMinutes() - earlierDate.getMinutes() || 3323 laterDate.getSeconds() - earlierDate.getSeconds() || 3324 laterDate.getMilliseconds() - earlierDate.getMilliseconds(); 3325 3326 if (diff < 0) return -1; 3327 if (diff > 0) return 1; 3328 3329 // Return 0 if diff is 0; return NaN if diff is NaN 3330 return diff; 3331} 3332 3333 3334/***/ }), 3335 3336/***/ 937549: 3337/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3338 3339"use strict"; 3340 3341exports.differenceInHours = differenceInHours; 3342var _index = __webpack_require__(839886); 3343var _index2 = __webpack_require__(947561); 3344var _index3 = __webpack_require__(241836); 3345 3346/** 3347 * The {@link differenceInHours} function options. 3348 */ 3349 3350/** 3351 * @name differenceInHours 3352 * @category Hour Helpers 3353 * @summary Get the number of hours between the given dates. 3354 * 3355 * @description 3356 * Get the number of hours between the given dates. 3357 * 3358 * @param laterDate - The later date 3359 * @param earlierDate - The earlier date 3360 * @param options - An object with options. 3361 * 3362 * @returns The number of hours 3363 * 3364 * @example 3365 * // How many hours are between 2 July 2014 06:50:00 and 2 July 2014 19:00:00? 3366 * const result = differenceInHours( 3367 * new Date(2014, 6, 2, 19, 0), 3368 * new Date(2014, 6, 2, 6, 50) 3369 * ) 3370 * //=> 12 3371 */ 3372function differenceInHours(laterDate, earlierDate, options) { 3373 const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)( 3374 options?.in, 3375 laterDate, 3376 earlierDate, 3377 ); 3378 const diff = (+laterDate_ - +earlierDate_) / _index3.millisecondsInHour; 3379 return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff); 3380} 3381 3382 3383/***/ }), 3384 3385/***/ 693221: 3386/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3387 3388"use strict"; 3389 3390exports.differenceInISOWeekYears = differenceInISOWeekYears; 3391var _index = __webpack_require__(947561); 3392var _index2 = __webpack_require__(636374); 3393var _index3 = __webpack_require__(61500); 3394var _index4 = __webpack_require__(120582); 3395 3396/** 3397 * The {@link differenceInISOWeekYears} function options. 3398 */ 3399 3400/** 3401 * @name differenceInISOWeekYears 3402 * @category ISO Week-Numbering Year Helpers 3403 * @summary Get the number of full ISO week-numbering years between the given dates. 3404 * 3405 * @description 3406 * Get the number of full ISO week-numbering years between the given dates. 3407 * 3408 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 3409 * 3410 * @param laterDate - The later date 3411 * @param earlierDate - The earlier date 3412 * @param options - The options 3413 * 3414 * @returns The number of full ISO week-numbering years 3415 * 3416 * @example 3417 * // How many full ISO week-numbering years are between 1 January 2010 and 1 January 2012? 3418 * const result = differenceInISOWeekYears( 3419 * new Date(2012, 0, 1), 3420 * new Date(2010, 0, 1) 3421 * ) 3422 * // => 1 3423 */ 3424function differenceInISOWeekYears(laterDate, earlierDate, options) { 3425 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3426 options?.in, 3427 laterDate, 3428 earlierDate, 3429 ); 3430 3431 const sign = (0, _index2.compareAsc)(laterDate_, earlierDate_); 3432 const diff = Math.abs( 3433 (0, _index3.differenceInCalendarISOWeekYears)( 3434 laterDate_, 3435 earlierDate_, 3436 options, 3437 ), 3438 ); 3439 3440 const adjustedDate = (0, _index4.subISOWeekYears)( 3441 laterDate_, 3442 sign * diff, 3443 options, 3444 ); 3445 3446 const isLastISOWeekYearNotFull = Number( 3447 (0, _index2.compareAsc)(adjustedDate, earlierDate_) === -sign, 3448 ); 3449 const result = sign * (diff - isLastISOWeekYearNotFull); 3450 3451 // Prevent negative zero 3452 return result === 0 ? 0 : result; 3453} 3454 3455 3456/***/ }), 3457 3458/***/ 400743: 3459/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3460 3461"use strict"; 3462 3463exports.differenceInMilliseconds = differenceInMilliseconds; 3464var _index = __webpack_require__(807799); 3465 3466/** 3467 * @name differenceInMilliseconds 3468 * @category Millisecond Helpers 3469 * @summary Get the number of milliseconds between the given dates. 3470 * 3471 * @description 3472 * Get the number of milliseconds between the given dates. 3473 * 3474 * @param laterDate - The later date 3475 * @param earlierDate - The earlier date 3476 * 3477 * @returns The number of milliseconds 3478 * 3479 * @example 3480 * // How many milliseconds are between 3481 * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700? 3482 * const result = differenceInMilliseconds( 3483 * new Date(2014, 6, 2, 12, 30, 21, 700), 3484 * new Date(2014, 6, 2, 12, 30, 20, 600) 3485 * ) 3486 * //=> 1100 3487 */ 3488function differenceInMilliseconds(laterDate, earlierDate) { 3489 return +(0, _index.toDate)(laterDate) - +(0, _index.toDate)(earlierDate); 3490} 3491 3492 3493/***/ }), 3494 3495/***/ 371501: 3496/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3497 3498"use strict"; 3499 3500exports.differenceInMinutes = differenceInMinutes; 3501var _index = __webpack_require__(839886); 3502var _index2 = __webpack_require__(241836); 3503var _index3 = __webpack_require__(400743); 3504 3505/** 3506 * The {@link differenceInMinutes} function options. 3507 */ 3508 3509/** 3510 * @name differenceInMinutes 3511 * @category Minute Helpers 3512 * @summary Get the number of minutes between the given dates. 3513 * 3514 * @description 3515 * Get the signed number of full (rounded towards 0) minutes between the given dates. 3516 * 3517 * @param dateLeft - The later date 3518 * @param dateRight - The earlier date 3519 * @param options - An object with options. 3520 * 3521 * @returns The number of minutes 3522 * 3523 * @example 3524 * // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00? 3525 * const result = differenceInMinutes( 3526 * new Date(2014, 6, 2, 12, 20, 0), 3527 * new Date(2014, 6, 2, 12, 7, 59) 3528 * ) 3529 * //=> 12 3530 * 3531 * @example 3532 * // How many minutes are between 10:01:59 and 10:00:00 3533 * const result = differenceInMinutes( 3534 * new Date(2000, 0, 1, 10, 0, 0), 3535 * new Date(2000, 0, 1, 10, 1, 59) 3536 * ) 3537 * //=> -1 3538 */ 3539function differenceInMinutes(dateLeft, dateRight, options) { 3540 const diff = 3541 (0, _index3.differenceInMilliseconds)(dateLeft, dateRight) / 3542 _index2.millisecondsInMinute; 3543 return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff); 3544} 3545 3546 3547/***/ }), 3548 3549/***/ 976081: 3550/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3551 3552"use strict"; 3553 3554exports.differenceInMonths = differenceInMonths; 3555var _index = __webpack_require__(947561); 3556var _index2 = __webpack_require__(636374); 3557var _index3 = __webpack_require__(362530); 3558var _index4 = __webpack_require__(941447); 3559 3560/** 3561 * The {@link differenceInMonths} function options. 3562 */ 3563 3564/** 3565 * @name differenceInMonths 3566 * @category Month Helpers 3567 * @summary Get the number of full months between the given dates. 3568 * 3569 * @param laterDate - The later date 3570 * @param earlierDate - The earlier date 3571 * @param options - An object with options 3572 * 3573 * @returns The number of full months 3574 * 3575 * @example 3576 * // How many full months are between 31 January 2014 and 1 September 2014? 3577 * const result = differenceInMonths(new Date(2014, 8, 1), new Date(2014, 0, 31)) 3578 * //=> 7 3579 */ 3580function differenceInMonths(laterDate, earlierDate, options) { 3581 const [laterDate_, workingLaterDate, earlierDate_] = (0, 3582 _index.normalizeDates)(options?.in, laterDate, laterDate, earlierDate); 3583 3584 const sign = (0, _index2.compareAsc)(workingLaterDate, earlierDate_); 3585 const difference = Math.abs( 3586 (0, _index3.differenceInCalendarMonths)(workingLaterDate, earlierDate_), 3587 ); 3588 3589 if (difference < 1) return 0; 3590 3591 if (workingLaterDate.getMonth() === 1 && workingLaterDate.getDate() > 27) 3592 workingLaterDate.setDate(30); 3593 3594 workingLaterDate.setMonth(workingLaterDate.getMonth() - sign * difference); 3595 3596 let isLastMonthNotFull = 3597 (0, _index2.compareAsc)(workingLaterDate, earlierDate_) === -sign; 3598 3599 if ( 3600 (0, _index4.isLastDayOfMonth)(laterDate_) && 3601 difference === 1 && 3602 (0, _index2.compareAsc)(laterDate_, earlierDate_) === 1 3603 ) { 3604 isLastMonthNotFull = false; 3605 } 3606 3607 const result = sign * (difference - +isLastMonthNotFull); 3608 return result === 0 ? 0 : result; 3609} 3610 3611 3612/***/ }), 3613 3614/***/ 105464: 3615/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3616 3617"use strict"; 3618 3619exports.differenceInQuarters = differenceInQuarters; 3620var _index = __webpack_require__(839886); 3621var _index2 = __webpack_require__(976081); 3622 3623/** 3624 * The {@link differenceInQuarters} function options. 3625 */ 3626 3627/** 3628 * @name differenceInQuarters 3629 * @category Quarter Helpers 3630 * @summary Get the number of quarters between the given dates. 3631 * 3632 * @description 3633 * Get the number of quarters between the given dates. 3634 * 3635 * @param laterDate - The later date 3636 * @param earlierDate - The earlier date 3637 * @param options - An object with options. 3638 * 3639 * @returns The number of full quarters 3640 * 3641 * @example 3642 * // How many full quarters are between 31 December 2013 and 2 July 2014? 3643 * const result = differenceInQuarters(new Date(2014, 6, 2), new Date(2013, 11, 31)) 3644 * //=> 2 3645 */ 3646function differenceInQuarters(laterDate, earlierDate, options) { 3647 const diff = 3648 (0, _index2.differenceInMonths)(laterDate, earlierDate, options) / 3; 3649 return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff); 3650} 3651 3652 3653/***/ }), 3654 3655/***/ 454975: 3656/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3657 3658"use strict"; 3659 3660exports.differenceInSeconds = differenceInSeconds; 3661var _index = __webpack_require__(839886); 3662var _index2 = __webpack_require__(400743); 3663 3664/** 3665 * The {@link differenceInSeconds} function options. 3666 */ 3667 3668/** 3669 * @name differenceInSeconds 3670 * @category Second Helpers 3671 * @summary Get the number of seconds between the given dates. 3672 * 3673 * @description 3674 * Get the number of seconds between the given dates. 3675 * 3676 * @param laterDate - The later date 3677 * @param earlierDate - The earlier date 3678 * @param options - An object with options. 3679 * 3680 * @returns The number of seconds 3681 * 3682 * @example 3683 * // How many seconds are between 3684 * // 2 July 2014 12:30:07.999 and 2 July 2014 12:30:20.000? 3685 * const result = differenceInSeconds( 3686 * new Date(2014, 6, 2, 12, 30, 20, 0), 3687 * new Date(2014, 6, 2, 12, 30, 7, 999) 3688 * ) 3689 * //=> 12 3690 */ 3691function differenceInSeconds(laterDate, earlierDate, options) { 3692 const diff = 3693 (0, _index2.differenceInMilliseconds)(laterDate, earlierDate) / 1000; 3694 return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff); 3695} 3696 3697 3698/***/ }), 3699 3700/***/ 833368: 3701/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3702 3703"use strict"; 3704 3705exports.differenceInWeeks = differenceInWeeks; 3706var _index = __webpack_require__(839886); 3707var _index2 = __webpack_require__(820537); 3708 3709/** 3710 * The {@link differenceInWeeks} function options. 3711 */ 3712 3713/** 3714 * @name differenceInWeeks 3715 * @category Week Helpers 3716 * @summary Get the number of full weeks between the given dates. 3717 * 3718 * @description 3719 * Get the number of full weeks between two dates. Fractional weeks are 3720 * truncated towards zero by default. 3721 * 3722 * One "full week" is the distance between a local time in one day to the same 3723 * local time 7 days earlier or later. A full week can sometimes be less than 3724 * or more than 7*24 hours if a daylight savings change happens between two dates. 3725 * 3726 * To ignore DST and only measure exact 7*24-hour periods, use this instead: 3727 * `Math.trunc(differenceInHours(dateLeft, dateRight)/(7*24))|0`. 3728 * 3729 * @param laterDate - The later date 3730 * @param earlierDate - The earlier date 3731 * @param options - An object with options 3732 * 3733 * @returns The number of full weeks 3734 * 3735 * @example 3736 * // How many full weeks are between 5 July 2014 and 20 July 2014? 3737 * const result = differenceInWeeks(new Date(2014, 6, 20), new Date(2014, 6, 5)) 3738 * //=> 2 3739 * 3740 * @example 3741 * // How many full weeks are between 3742 * // 1 March 2020 0:00 and 6 June 2020 0:00 ? 3743 * // Note: because local time is used, the 3744 * // result will always be 8 weeks (54 days),
3745 * // even if DST starts and the period has 3746 * // only 54*24-1 hours. 3747 * const result = differenceInWeeks( 3748 * new Date(2020, 5, 1), 3749 * new Date(2020, 2, 6) 3750 * ) 3751 * //=> 8 3752 */ 3753function differenceInWeeks(laterDate, earlierDate, options) { 3754 const diff = 3755 (0, _index2.differenceInDays)(laterDate, earlierDate, options) / 7; 3756 return (0, _index.getRoundingMethod)(options?.roundingMethod)(diff); 3757} 3758 3759 3760/***/ }), 3761 3762/***/ 144528: 3763/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3764 3765"use strict"; 3766 3767exports.differenceInYears = differenceInYears; 3768var _index = __webpack_require__(947561); 3769var _index2 = __webpack_require__(636374); 3770var _index3 = __webpack_require__(199067); 3771 3772/** 3773 * The {@link differenceInYears} function options. 3774 */ 3775 3776/** 3777 * @name differenceInYears 3778 * @category Year Helpers 3779 * @summary Get the number of full years between the given dates. 3780 * 3781 * @description 3782 * Get the number of full years between the given dates. 3783 * 3784 * @param laterDate - The later date 3785 * @param earlierDate - The earlier date 3786 * @param options - An object with options 3787 * 3788 * @returns The number of full years 3789 * 3790 * @example 3791 * // How many full years are between 31 December 2013 and 11 February 2015? 3792 * const result = differenceInYears(new Date(2015, 1, 11), new Date(2013, 11, 31)) 3793 * //=> 1 3794 */ 3795function differenceInYears(laterDate, earlierDate, options) { 3796 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 3797 options?.in, 3798 laterDate, 3799 earlierDate, 3800 ); 3801 3802 // -1 if the left date is earlier than the right date 3803 // 2023-12-31 - 2024-01-01 = -1 3804 const sign = (0, _index2.compareAsc)(laterDate_, earlierDate_); 3805 3806 // First calculate the difference in calendar years 3807 // 2024-01-01 - 2023-12-31 = 1 year 3808 const diff = Math.abs( 3809 (0, _index3.differenceInCalendarYears)(laterDate_, earlierDate_), 3810 ); 3811 3812 // Now we need to calculate if the difference is full. To do that we set 3813 // both dates to the same year and check if the both date's month and day 3814 // form a full year. 3815 laterDate_.setFullYear(1584); 3816 earlierDate_.setFullYear(1584); 3817 3818 // For it to be true, when the later date is indeed later than the earlier date 3819 // (2026-02-01 - 2023-12-10 = 3 years), the difference is full if 3820 // the normalized later date is also later than the normalized earlier date. 3821 // In our example, 1584-02-01 is earlier than 1584-12-10, so the difference 3822 // is partial, hence we need to subtract 1 from the difference 3 - 1 = 2. 3823 const partial = (0, _index2.compareAsc)(laterDate_, earlierDate_) === -sign; 3824 3825 const result = sign * (diff - +partial); 3826 3827 // Prevent negative zero 3828 return result === 0 ? 0 : result; 3829} 3830 3831 3832/***/ }), 3833 3834/***/ 281278: 3835/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3836 3837"use strict"; 3838 3839exports.eachDayOfInterval = eachDayOfInterval; 3840var _index = __webpack_require__(525175); 3841var _index2 = __webpack_require__(658612); 3842 3843/** 3844 * The {@link eachDayOfInterval} function options. 3845 */ 3846 3847/** 3848 * The {@link eachDayOfInterval} function result type. It resolves the proper data type. 3849 * It uses the first argument date object type, starting from the date argument, 3850 * then the start interval date, and finally the end interval date. If 3851 * a context function is passed, it uses the context function return type. 3852 */ 3853 3854/** 3855 * @name eachDayOfInterval 3856 * @category Interval Helpers 3857 * @summary Return the array of dates within the specified time interval. 3858 * 3859 * @description 3860 * Return the array of dates within the specified time interval. 3861 * 3862 * @typeParam IntervalType - Interval type. 3863 * @typeParam Options - Options type. 3864 * 3865 * @param interval - The interval. 3866 * @param options - An object with options. 3867 * 3868 * @returns The array with starts of days from the day of the interval start to the day of the interval end 3869 * 3870 * @example 3871 * // Each day between 6 October 2014 and 10 October 2014: 3872 * const result = eachDayOfInterval({ 3873 * start: new Date(2014, 9, 6), 3874 * end: new Date(2014, 9, 10) 3875 * }) 3876 * //=> [ 3877 * // Mon Oct 06 2014 00:00:00, 3878 * // Tue Oct 07 2014 00:00:00, 3879 * // Wed Oct 08 2014 00:00:00, 3880 * // Thu Oct 09 2014 00:00:00, 3881 * // Fri Oct 10 2014 00:00:00 3882 * // ] 3883 */
vendor: 28,128 bytes, lines 3884-4871
3884function eachDayOfInterval(interval, options) { 3885 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 3886 3887 let reversed = +start > +end; 3888 const endTime = reversed ? +start : +end; 3889 const date = reversed ? end : start; 3890 date.setHours(0, 0, 0, 0); 3891 3892 let step = options?.step ?? 1; 3893 if (!step) return []; 3894 if (step < 0) { 3895 step = -step; 3896 reversed = !reversed; 3897 } 3898 3899 const dates = []; 3900 3901 while (+date <= endTime) { 3902 dates.push((0, _index2.constructFrom)(start, date)); 3903 date.setDate(date.getDate() + step); 3904 date.setHours(0, 0, 0, 0); 3905 } 3906 3907 return reversed ? dates.reverse() : dates; 3908} 3909 3910 3911/***/ }), 3912 3913/***/ 521818: 3914/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3915 3916"use strict"; 3917 3918exports.eachHourOfInterval = eachHourOfInterval; 3919var _index = __webpack_require__(525175); 3920var _index2 = __webpack_require__(658612); 3921 3922/** 3923 * The {@link eachHourOfInterval} function options. 3924 */ 3925 3926/** 3927 * The {@link eachHourOfInterval} function result type. 3928 * Resolves to the appropriate date type based on inputs. 3929 */ 3930 3931/** 3932 * @name eachHourOfInterval 3933 * @category Interval Helpers 3934 * @summary Return the array of hours within the specified time interval. 3935 * 3936 * @description 3937 * Return the array of hours within the specified time interval. 3938 * 3939 * @typeParam IntervalType - Interval type. 3940 * @typeParam Options - Options type. 3941 * 3942 * @param interval - The interval. 3943 * @param options - An object with options. 3944 * 3945 * @returns The array with starts of hours from the hour of the interval start to the hour of the interval end 3946 * 3947 * @example 3948 * // Each hour between 6 October 2014, 12:00 and 6 October 2014, 15:00 3949 * const result = eachHourOfInterval({ 3950 * start: new Date(2014, 9, 6, 12), 3951 * end: new Date(2014, 9, 6, 15) 3952 * }); 3953 * //=> [ 3954 * // Mon Oct 06 2014 12:00:00, 3955 * // Mon Oct 06 2014 13:00:00, 3956 * // Mon Oct 06 2014 14:00:00, 3957 * // Mon Oct 06 2014 15:00:00 3958 * // ] 3959 */ 3960function eachHourOfInterval(interval, options) { 3961 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 3962 3963 let reversed = +start > +end; 3964 const endTime = reversed ? +start : +end; 3965 const date = reversed ? end : start; 3966 date.setMinutes(0, 0, 0); 3967 3968 let step = options?.step ?? 1; 3969 if (!step) return []; 3970 if (step < 0) { 3971 step = -step; 3972 reversed = !reversed; 3973 } 3974 3975 const dates = []; 3976 3977 while (+date <= endTime) { 3978 dates.push((0, _index2.constructFrom)(start, date)); 3979 date.setHours(date.getHours() + step); 3980 } 3981 3982 return reversed ? dates.reverse() : dates; 3983} 3984 3985 3986/***/ }), 3987 3988/***/ 53846: 3989/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 3990 3991"use strict"; 3992 3993exports.eachMinuteOfInterval = eachMinuteOfInterval; 3994var _index = __webpack_require__(525175); 3995var _index2 = __webpack_require__(609025); 3996var _index3 = __webpack_require__(658612); 3997 3998/** 3999 * The {@link eachMinuteOfInterval} function options. 4000 */ 4001 4002/** 4003 * The {@link eachMinuteOfInterval} function result type. It resolves the proper data type. 4004 * It uses the first argument date object type, starting from the date argument, 4005 * then the start interval date, and finally the end interval date. If 4006 * a context function is passed, it uses the context function return type. 4007 */ 4008 4009/** 4010 * @name eachMinuteOfInterval 4011 * @category Interval Helpers 4012 * @summary Return the array of minutes within the specified time interval. 4013 * 4014 * @description 4015 * Returns the array of minutes within the specified time interval. 4016 * 4017 * @typeParam IntervalType - Interval type. 4018 * @typeParam Options - Options type. 4019 * 4020 * @param interval - The interval. 4021 * @param options - An object with options. 4022 * 4023 * @returns The array with starts of minutes from the minute of the interval start to the minute of the interval end 4024 * 4025 * @example 4026 * // Each minute between 14 October 2020, 13:00 and 14 October 2020, 13:03 4027 * const result = eachMinuteOfInterval({ 4028 * start: new Date(2014, 9, 14, 13), 4029 * end: new Date(2014, 9, 14, 13, 3) 4030 * }) 4031 * //=> [ 4032 * // Wed Oct 14 2014 13:00:00, 4033 * // Wed Oct 14 2014 13:01:00, 4034 * // Wed Oct 14 2014 13:02:00, 4035 * // Wed Oct 14 2014 13:03:00 4036 * // ] 4037 */ 4038function eachMinuteOfInterval(interval, options) { 4039 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4040 // Set to the start of the minute 4041 start.setSeconds(0, 0); 4042 4043 let reversed = +start > +end; 4044 const endTime = reversed ? +start : +end; 4045 let date = reversed ? end : start; 4046 4047 let step = options?.step ?? 1; 4048 if (!step) return []; 4049 if (step < 0) { 4050 step = -step; 4051 reversed = !reversed; 4052 } 4053 4054 const dates = []; 4055 4056 while (+date <= endTime) { 4057 dates.push((0, _index3.constructFrom)(start, date)); 4058 date = (0, _index2.addMinutes)(date, step); 4059 } 4060 4061 return reversed ? dates.reverse() : dates; 4062} 4063 4064 4065/***/ }), 4066 4067/***/ 323874: 4068/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4069 4070"use strict"; 4071 4072exports.eachMonthOfInterval = eachMonthOfInterval; 4073var _index = __webpack_require__(525175); 4074var _index2 = __webpack_require__(658612); 4075 4076/** 4077 * The {@link eachMonthOfInterval} function options. 4078 */ 4079 4080/** 4081 * The {@link eachMonthOfInterval} function result type. It resolves the proper data type. 4082 */ 4083 4084/** 4085 * @name eachMonthOfInterval 4086 * @category Interval Helpers 4087 * @summary Return the array of months within the specified time interval. 4088 * 4089 * @description 4090 * Return the array of months within the specified time interval. 4091 * 4092 * @typeParam IntervalType - Interval type. 4093 * @typeParam Options - Options type. 4094 * 4095 * @param interval - The interval. 4096 * @param options - An object with options. 4097 * 4098 * @returns The array with starts of months from the month of the interval start to the month of the interval end 4099 * 4100 * @example 4101 * // Each month between 6 February 2014 and 10 August 2014: 4102 * const result = eachMonthOfInterval({ 4103 * start: new Date(2014, 1, 6), 4104 * end: new Date(2014, 7, 10) 4105 * }) 4106 * //=> [ 4107 * // Sat Feb 01 2014 00:00:00, 4108 * // Sat Mar 01 2014 00:00:00, 4109 * // Tue Apr 01 2014 00:00:00, 4110 * // Thu May 01 2014 00:00:00, 4111 * // Sun Jun 01 2014 00:00:00, 4112 * // Tue Jul 01 2014 00:00:00, 4113 * // Fri Aug 01 2014 00:00:00 4114 * // ] 4115 */ 4116function eachMonthOfInterval(interval, options) { 4117 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4118 4119 let reversed = +start > +end; 4120 const endTime = reversed ? +start : +end; 4121 const date = reversed ? end : start; 4122 date.setHours(0, 0, 0, 0); 4123 date.setDate(1); 4124 4125 let step = options?.step ?? 1; 4126 if (!step) return []; 4127 if (step < 0) { 4128 step = -step; 4129 reversed = !reversed; 4130 } 4131 4132 const dates = []; 4133 4134 while (+date <= endTime) { 4135 dates.push((0, _index2.constructFrom)(start, date)); 4136 date.setMonth(date.getMonth() + step); 4137 } 4138 4139 return reversed ? dates.reverse() : dates; 4140} 4141 4142 4143/***/ }), 4144 4145/***/ 422132: 4146/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4147 4148"use strict"; 4149 4150exports.eachQuarterOfInterval = eachQuarterOfInterval; 4151var _index = __webpack_require__(525175); 4152var _index2 = __webpack_require__(953970); 4153var _index3 = __webpack_require__(658612); 4154var _index4 = __webpack_require__(927907); 4155 4156/** 4157 * The {@link eachQuarterOfInterval} function options. 4158 */ 4159 4160/** 4161 * The {@link eachQuarterOfInterval} function result type. It resolves the proper data type. 4162 * It uses the first argument date object type, starting from the date argument, 4163 * then the start interval date, and finally the end interval date. If 4164 * a context function is passed, it uses the context function return type. 4165 */ 4166 4167/** 4168 * @name eachQuarterOfInterval 4169 * @category Interval Helpers 4170 * @summary Return the array of quarters within the specified time interval. 4171 * 4172 * @description 4173 * Return the array of quarters within the specified time interval. 4174 * 4175 * @typeParam IntervalType - Interval type. 4176 * @typeParam Options - Options type. 4177 * 4178 * @param interval - The interval 4179 * @param options - An object with options 4180 * 4181 * @returns The array with starts of quarters from the quarter of the interval start to the quarter of the interval end 4182 * 4183 * @example 4184 * // Each quarter within interval 6 February 2014 - 10 August 2014: 4185 * const result = eachQuarterOfInterval({ 4186 * start: new Date(2014, 1, 6), 4187 * end: new Date(2014, 7, 10), 4188 * }) 4189 * //=> [ 4190 * // Wed Jan 01 2014 00:00:00, 4191 * // Tue Apr 01 2014 00:00:00, 4192 * // Tue Jul 01 2014 00:00:00, 4193 * // ] 4194 */ 4195function eachQuarterOfInterval(interval, options) { 4196 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4197 4198 let reversed = +start > +end; 4199 const endTime = reversed 4200 ? +(0, _index4.startOfQuarter)(start) 4201 : +(0, _index4.startOfQuarter)(end); 4202 let date = reversed 4203 ? (0, _index4.startOfQuarter)(end) 4204 : (0, _index4.startOfQuarter)(start); 4205 4206 let step = options?.step ?? 1; 4207 if (!step) return []; 4208 if (step < 0) { 4209 step = -step; 4210 reversed = !reversed; 4211 } 4212 4213 const dates = []; 4214 4215 while (+date <= endTime) { 4216 dates.push((0, _index3.constructFrom)(start, date)); 4217 date = (0, _index2.addQuarters)(date, step); 4218 } 4219 4220 return reversed ? dates.reverse() : dates; 4221} 4222 4223 4224/***/ }), 4225 4226/***/ 371274: 4227/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4228 4229"use strict"; 4230 4231exports.eachWeekOfInterval = eachWeekOfInterval; 4232var _index = __webpack_require__(525175); 4233var _index2 = __webpack_require__(59786); 4234var _index3 = __webpack_require__(658612); 4235var _index4 = __webpack_require__(517805); 4236 4237/** 4238 * The {@link eachWeekOfInterval} function options. 4239 */ 4240 4241/** 4242 * The {@link eachWeekOfInterval} function result type. It resolves the proper data type. 4243 * It uses the first argument date object type, starting from the interval start date, 4244 * then the end interval date. If a context function is passed, it uses the context function return type. 4245 */ 4246 4247/** 4248 * @name eachWeekOfInterval 4249 * @category Interval Helpers 4250 * @summary Return the array of weeks within the specified time interval. 4251 * 4252 * @description 4253 * Return the array of weeks within the specified time interval. 4254 * 4255 * @param interval - The interval. 4256 * @param options - An object with options. 4257 * 4258 * @returns The array with starts of weeks from the week of the interval start to the week of the interval end 4259 * 4260 * @example 4261 * // Each week within interval 6 October 2014 - 23 November 2014: 4262 * const result = eachWeekOfInterval({ 4263 * start: new Date(2014, 9, 6), 4264 * end: new Date(2014, 10, 23) 4265 * }) 4266 * //=> [ 4267 * // Sun Oct 05 2014 00:00:00, 4268 * // Sun Oct 12 2014 00:00:00, 4269 * // Sun Oct 19 2014 00:00:00, 4270 * // Sun Oct 26 2014 00:00:00, 4271 * // Sun Nov 02 2014 00:00:00, 4272 * // Sun Nov 09 2014 00:00:00, 4273 * // Sun Nov 16 2014 00:00:00, 4274 * // Sun Nov 23 2014 00:00:00 4275 * // ] 4276 */ 4277function eachWeekOfInterval(interval, options) { 4278 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4279 4280 let reversed = +start > +end; 4281 const startDateWeek = reversed 4282 ? (0, _index4.startOfWeek)(end, options) 4283 : (0, _index4.startOfWeek)(start, options); 4284 const endDateWeek = reversed 4285 ? (0, _index4.startOfWeek)(start, options) 4286 : (0, _index4.startOfWeek)(end, options); 4287 4288 startDateWeek.setHours(15); 4289 endDateWeek.setHours(15); 4290 4291 const endTime = +endDateWeek.getTime(); 4292 let currentDate = startDateWeek; 4293 4294 let step = options?.step ?? 1; 4295 if (!step) return []; 4296 if (step < 0) { 4297 step = -step; 4298 reversed = !reversed; 4299 } 4300 4301 const dates = []; 4302 4303 while (+currentDate <= endTime) { 4304 currentDate.setHours(0); 4305 dates.push((0, _index3.constructFrom)(start, currentDate)); 4306 currentDate = (0, _index2.addWeeks)(currentDate, step); 4307 currentDate.setHours(15); 4308 } 4309 4310 return reversed ? dates.reverse() : dates; 4311} 4312 4313 4314/***/ }), 4315 4316/***/ 979033: 4317/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4318 4319"use strict"; 4320 4321exports.eachWeekendOfInterval = eachWeekendOfInterval; 4322var _index = __webpack_require__(525175); 4323var _index2 = __webpack_require__(658612); 4324var _index3 = __webpack_require__(281278); 4325var _index4 = __webpack_require__(356804); 4326 4327/** 4328 * The {@link eachWeekendOfInterval} function options. 4329 */ 4330 4331/** 4332 * The {@link eachWeekendOfInterval} function result type. 4333 */ 4334 4335/** 4336 * @name eachWeekendOfInterval 4337 * @category Interval Helpers 4338 * @summary List all the Saturdays and Sundays in the given date interval. 4339 * 4340 * @description 4341 * Get all the Saturdays and Sundays in the given date interval. 4342 * 4343 * @typeParam IntervalType - Interval type. 4344 * @typeParam Options - Options type. 4345 * 4346 * @param interval - The given interval 4347 * @param options - An object with options 4348 * 4349 * @returns An array containing all the Saturdays and Sundays 4350 * 4351 * @example 4352 * // Lists all Saturdays and Sundays in the given date interval 4353 * const result = eachWeekendOfInterval({ 4354 * start: new Date(2018, 8, 17), 4355 * end: new Date(2018, 8, 30) 4356 * }) 4357 * //=> [ 4358 * // Sat Sep 22 2018 00:00:00, 4359 * // Sun Sep 23 2018 00:00:00, 4360 * // Sat Sep 29 2018 00:00:00, 4361 * // Sun Sep 30 2018 00:00:00 4362 * // ] 4363 */ 4364function eachWeekendOfInterval(interval, options) { 4365 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4366 const dateInterval = (0, _index3.eachDayOfInterval)({ start, end }, options); 4367 const weekends = []; 4368 let index = 0; 4369 while (index < dateInterval.length) { 4370 const date = dateInterval[index++]; 4371 if ((0, _index4.isWeekend)(date)) 4372 weekends.push((0, _index2.constructFrom)(start, date)); 4373 } 4374 return weekends; 4375} 4376 4377 4378/***/ }), 4379 4380/***/ 660195: 4381/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4382 4383"use strict"; 4384 4385exports.eachWeekendOfMonth = eachWeekendOfMonth; 4386var _index = __webpack_require__(979033); 4387var _index2 = __webpack_require__(458842); 4388var _index3 = __webpack_require__(185557); 4389 4390/** 4391 * The {@link eachWeekendOfMonth} function options. 4392 */ 4393 4394/** 4395 * @name eachWeekendOfMonth 4396 * @category Month Helpers 4397 * @summary List all the Saturdays and Sundays in the given month. 4398 * 4399 * @description 4400 * Get all the Saturdays and Sundays in the given month. 4401 * 4402 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4403 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4404 * 4405 * @param date - The given month 4406 * @param options - An object with options 4407 * 4408 * @returns An array containing all the Saturdays and Sundays 4409 * 4410 * @example 4411 * // Lists all Saturdays and Sundays in the given month 4412 * const result = eachWeekendOfMonth(new Date(2022, 1, 1)) 4413 * //=> [ 4414 * // Sat Feb 05 2022 00:00:00, 4415 * // Sun Feb 06 2022 00:00:00, 4416 * // Sat Feb 12 2022 00:00:00, 4417 * // Sun Feb 13 2022 00:00:00, 4418 * // Sat Feb 19 2022 00:00:00, 4419 * // Sun Feb 20 2022 00:00:00, 4420 * // Sat Feb 26 2022 00:00:00, 4421 * // Sun Feb 27 2022 00:00:00 4422 * // ] 4423 */ 4424function eachWeekendOfMonth(date, options) { 4425 const start = (0, _index3.startOfMonth)(date, options); 4426 const end = (0, _index2.endOfMonth)(date, options); 4427 return (0, _index.eachWeekendOfInterval)({ start, end }, options); 4428} 4429 4430 4431/***/ }), 4432 4433/***/ 683543: 4434/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4435 4436"use strict"; 4437 4438exports.eachWeekendOfYear = eachWeekendOfYear; 4439var _index = __webpack_require__(979033); 4440var _index2 = __webpack_require__(925916); 4441var _index3 = __webpack_require__(215913); 4442 4443/** 4444 * The {@link eachWeekendOfYear} function options. 4445 */ 4446 4447/** 4448 * @name eachWeekendOfYear 4449 * @category Year Helpers 4450 * @summary List all the Saturdays and Sundays in the year. 4451 * 4452 * @description 4453 * Get all the Saturdays and Sundays in the year. 4454 * 4455 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4456 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4457 * 4458 * @param date - The given year 4459 * @param options - An object with options 4460 * 4461 * @returns An array containing all the Saturdays and Sundays 4462 * 4463 * @example 4464 * // Lists all Saturdays and Sundays in the year 4465 * const result = eachWeekendOfYear(new Date(2020, 1, 1)) 4466 * //=> [ 4467 * // Sat Jan 03 2020 00:00:00, 4468 * // Sun Jan 04 2020 00:00:00, 4469 * // ... 4470 * // Sun Dec 27 2020 00:00:00 4471 * // ] 4472 * ] 4473 */ 4474function eachWeekendOfYear(date, options) { 4475 const start = (0, _index3.startOfYear)(date, options); 4476 const end = (0, _index2.endOfYear)(date, options); 4477 return (0, _index.eachWeekendOfInterval)({ start, end }, options); 4478} 4479 4480 4481/***/ }), 4482 4483/***/ 42766: 4484/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4485 4486"use strict"; 4487 4488exports.eachYearOfInterval = eachYearOfInterval; 4489var _index = __webpack_require__(525175); 4490var _index2 = __webpack_require__(658612); 4491 4492/** 4493 * The {@link eachYearOfInterval} function options. 4494 */ 4495 4496/** 4497 * The {@link eachYearOfInterval} function result type. It resolves the proper data type. 4498 * It uses the first argument date object type, starting from the date argument, 4499 * then the start interval date, and finally the end interval date. If 4500 * a context function is passed, it uses the context function return type. 4501 */ 4502 4503/** 4504 * @name eachYearOfInterval 4505 * @category Interval Helpers 4506 * @summary Return the array of yearly timestamps within the specified time interval. 4507 * 4508 * @description 4509 * Return the array of yearly timestamps within the specified time interval. 4510 * 4511 * @typeParam IntervalType - Interval type. 4512 * @typeParam Options - Options type. 4513 * 4514 * @param interval - The interval. 4515 * @param options - An object with options. 4516 * 4517 * @returns The array with starts of yearly timestamps from the month of the interval start to the month of the interval end 4518 * 4519 * @example 4520 * // Each year between 6 February 2014 and 10 August 2017: 4521 * const result = eachYearOfInterval({ 4522 * start: new Date(2014, 1, 6), 4523 * end: new Date(2017, 7, 10) 4524 * }) 4525 * //=> [ 4526 * // Wed Jan 01 2014 00:00:00, 4527 * // Thu Jan 01 2015 00:00:00, 4528 * // Fri Jan 01 2016 00:00:00, 4529 * // Sun Jan 01 2017 00:00:00 4530 * // ] 4531 */ 4532function eachYearOfInterval(interval, options) { 4533 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 4534 4535 let reversed = +start > +end; 4536 const endTime = reversed ? +start : +end; 4537 const date = reversed ? end : start; 4538 date.setHours(0, 0, 0, 0); 4539 date.setMonth(0, 1); 4540 4541 let step = options?.step ?? 1; 4542 if (!step) return []; 4543 if (step < 0) { 4544 step = -step; 4545 reversed = !reversed; 4546 } 4547 4548 const dates = []; 4549 4550 while (+date <= endTime) { 4551 dates.push((0, _index2.constructFrom)(start, date)); 4552 date.setFullYear(date.getFullYear() + step); 4553 } 4554 4555 return reversed ? dates.reverse() : dates; 4556} 4557 4558 4559/***/ }), 4560 4561/***/ 294210: 4562/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4563 4564"use strict"; 4565 4566exports.endOfDay = endOfDay; 4567var _index = __webpack_require__(807799); 4568 4569/** 4570 * The {@link endOfDay} function options. 4571 */ 4572 4573/** 4574 * @name endOfDay 4575 * @category Day Helpers 4576 * @summary Return the end of a day for the given date. 4577 * 4578 * @description 4579 * Return the end of a day for the given date. 4580 * The result will be in the local timezone. 4581 * 4582 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4583 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4584 * 4585 * @param date - The original date 4586 * @param options - An object with options 4587 * 4588 * @returns The end of a day 4589 * 4590 * @example 4591 * // The end of a day for 2 September 2014 11:55:00: 4592 * const result = endOfDay(new Date(2014, 8, 2, 11, 55, 0)) 4593 * //=> Tue Sep 02 2014 23:59:59.999 4594 */ 4595function endOfDay(date, options) { 4596 const _date = (0, _index.toDate)(date, options?.in); 4597 _date.setHours(23, 59, 59, 999); 4598 return _date; 4599} 4600 4601 4602/***/ }), 4603 4604/***/ 962526: 4605/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4606 4607"use strict"; 4608 4609exports.endOfDecade = endOfDecade; 4610var _index = __webpack_require__(807799); 4611 4612/** 4613 * The {@link endOfDecade} function options. 4614 */ 4615 4616/** 4617 * @name endOfDecade 4618 * @category Decade Helpers 4619 * @summary Return the end of a decade for the given date. 4620 * 4621 * @description 4622 * Return the end of a decade for the given date. 4623 * 4624 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4625 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4626 * 4627 * @param date - The original date 4628 * @param options - An object with options 4629 * 4630 * @returns The end of a decade 4631 * 4632 * @example 4633 * // The end of a decade for 12 May 1984 00:00:00: 4634 * const result = endOfDecade(new Date(1984, 4, 12, 00, 00, 00)) 4635 * //=> Dec 31 1989 23:59:59.999 4636 */ 4637function endOfDecade(date, options) { 4638 // TODO: Switch to more technical definition in of decades that start with 1 4639 // end with 0. I.e. 2001-2010 instead of current 2000-2009. It's a breaking 4640 // change, so it can only be done in 4.0. 4641 const _date = (0, _index.toDate)(date, options?.in); 4642 const year = _date.getFullYear(); 4643 const decade = 9 + Math.floor(year / 10) * 10; 4644 _date.setFullYear(decade, 11, 31); 4645 _date.setHours(23, 59, 59, 999); 4646 return _date; 4647} 4648 4649 4650/***/ }), 4651 4652/***/ 405026: 4653/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4654 4655"use strict"; 4656 4657exports.endOfHour = endOfHour; 4658var _index = __webpack_require__(807799); 4659 4660/** 4661 * The {@link endOfHour} function options. 4662 */ 4663 4664/** 4665 * @name endOfHour 4666 * @category Hour Helpers 4667 * @summary Return the end of an hour for the given date. 4668 * 4669 * @description 4670 * Return the end of an hour for the given date. 4671 * The result will be in the local timezone. 4672 * 4673 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4674 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4675 * 4676 * @param date - The original date 4677 * @param options - An object with options 4678 * 4679 * @returns The end of an hour 4680 * 4681 * @example 4682 * // The end of an hour for 2 September 2014 11:55:00: 4683 * const result = endOfHour(new Date(2014, 8, 2, 11, 55)) 4684 * //=> Tue Sep 02 2014 11:59:59.999 4685 */ 4686function endOfHour(date, options) { 4687 const _date = (0, _index.toDate)(date, options?.in); 4688 _date.setMinutes(59, 59, 999); 4689 return _date; 4690} 4691 4692 4693/***/ }), 4694 4695/***/ 144661: 4696/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4697 4698"use strict"; 4699 4700exports.endOfISOWeek = endOfISOWeek; 4701var _index = __webpack_require__(9036); 4702 4703/** 4704 * The {@link endOfISOWeek} function options. 4705 */ 4706 4707/** 4708 * @name endOfISOWeek 4709 * @category ISO Week Helpers 4710 * @summary Return the end of an ISO week for the given date. 4711 * 4712 * @description 4713 * Return the end of an ISO week for the given date. 4714 * The result will be in the local timezone. 4715 * 4716 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 4717 * 4718 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4719 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4720 * 4721 * @param date - The original date 4722 * @param options - An object with options 4723 * 4724 * @returns The end of an ISO week 4725 * 4726 * @example 4727 * // The end of an ISO week for 2 September 2014 11:55:00: 4728 * const result = endOfISOWeek(new Date(2014, 8, 2, 11, 55, 0)) 4729 * //=> Sun Sep 07 2014 23:59:59.999 4730 */ 4731function endOfISOWeek(date, options) { 4732 return (0, _index.endOfWeek)(date, { ...options, weekStartsOn: 1 }); 4733} 4734 4735 4736/***/ }), 4737 4738/***/ 173909: 4739/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4740 4741"use strict"; 4742 4743exports.endOfISOWeekYear = endOfISOWeekYear; 4744var _index = __webpack_require__(658612); 4745var _index2 = __webpack_require__(196914); 4746var _index3 = __webpack_require__(266795); 4747 4748/** 4749 * The {@link endOfISOWeekYear} function options. 4750 */ 4751 4752/** 4753 * @name endOfISOWeekYear 4754 * @category ISO Week-Numbering Year Helpers 4755 * @summary Return the end of an ISO week-numbering year for the given date. 4756 * 4757 * @description 4758 * Return the end of an ISO week-numbering year, 4759 * which always starts 3 days before the year's first Thursday. 4760 * The result will be in the local timezone. 4761 * 4762 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 4763 * 4764 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4765 * @typeParam ContextDate - The `Date` type of the context function. 4766 * 4767 * @param date - The original date 4768 * @param options - The options 4769 * 4770 * @returns The end of an ISO week-numbering year 4771 * 4772 * @example 4773 * // The end of an ISO week-numbering year for 2 July 2005: 4774 * const result = endOfISOWeekYear(new Date(2005, 6, 2)) 4775 * //=> Sun Jan 01 2006 23:59:59.999 4776 */ 4777function endOfISOWeekYear(date, options) { 4778 const year = (0, _index2.getISOWeekYear)(date, options); 4779 const fourthOfJanuaryOfNextYear = (0, _index.constructFrom)( 4780 options?.in || date, 4781 0, 4782 ); 4783 fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4); 4784 fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0); 4785 const _date = (0, _index3.startOfISOWeek)(fourthOfJanuaryOfNextYear, options); 4786 _date.setMilliseconds(_date.getMilliseconds() - 1); 4787 return _date; 4788} 4789 4790 4791/***/ }), 4792 4793/***/ 110820: 4794/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4795 4796"use strict"; 4797 4798exports.endOfMinute = endOfMinute; 4799var _index = __webpack_require__(807799); 4800 4801/** 4802 * The {@link endOfMinute} function options. 4803 */ 4804 4805/** 4806 * @name endOfMinute 4807 * @category Minute Helpers 4808 * @summary Return the end of a minute for the given date. 4809 * 4810 * @description 4811 * Return the end of a minute for the given date. 4812 * The result will be in the local timezone or the provided context. 4813 * 4814 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4815 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4816 * 4817 * @param date - The original date 4818 * @param options - An object with options 4819 * 4820 * @returns The end of a minute 4821 * 4822 * @example 4823 * // The end of a minute for 1 December 2014 22:15:45.400: 4824 * const result = endOfMinute(new Date(2014, 11, 1, 22, 15, 45, 400)) 4825 * //=> Mon Dec 01 2014 22:15:59.999 4826 */ 4827function endOfMinute(date, options) { 4828 const _date = (0, _index.toDate)(date, options?.in); 4829 _date.setSeconds(59, 999); 4830 return _date; 4831} 4832 4833 4834/***/ }), 4835 4836/***/ 458842: 4837/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4838 4839"use strict"; 4840 4841exports.endOfMonth = endOfMonth; 4842var _index = __webpack_require__(807799); 4843 4844/** 4845 * The {@link endOfMonth} function options. 4846 */ 4847 4848/** 4849 * @name endOfMonth 4850 * @category Month Helpers 4851 * @summary Return the end of a month for the given date. 4852 * 4853 * @description 4854 * Return the end of a month for the given date. 4855 * The result will be in the local timezone. 4856 * 4857 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4858 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4859 * 4860 * @param date - The original date 4861 * @param options - An object with options 4862 * 4863 * @returns The end of a month 4864 * 4865 * @example 4866 * // The end of a month for 2 September 2014 11:55:00: 4867 * const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0)) 4868 * //=> Tue Sep 30 2014 23:59:59.999 4869 */ 4870function endOfMonth(date, options) { 4871 const _date = (0, _index.toDate)(date, options?.in);
4872 const month = _date.getMonth(); 4873 _date.setFullYear(_date.getFullYear(), month + 1, 0); 4874 _date.setHours(23, 59, 59, 999); 4875 return _date; 4876} 4877 4878 4879/***/ }), 4880 4881/***/ 864631: 4882/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4883 4884"use strict"; 4885 4886exports.endOfQuarter = endOfQuarter; 4887var _index = __webpack_require__(807799); 4888 4889/** 4890 * The {@link endOfQuarter} function options. 4891 */ 4892 4893/** 4894 * @name endOfQuarter 4895 * @category Quarter Helpers 4896 * @summary Return the end of a year quarter for the given date. 4897 * 4898 * @description 4899 * Return the end of a year quarter for the given date. 4900 * The result will be in the local timezone. 4901 * 4902 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4903 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4904 * 4905 * @param date - The original date 4906 * @param options - An object with options 4907 * 4908 * @returns The end of a quarter 4909 * 4910 * @example 4911 * // The end of a quarter for 2 September 2014 11:55:00: 4912 * const result = endOfQuarter(new Date(2014, 8, 2, 11, 55, 0)) 4913 * //=> Tue Sep 30 2014 23:59:59.999 4914 */ 4915function endOfQuarter(date, options) { 4916 const _date = (0, _index.toDate)(date, options?.in); 4917 const currentMonth = _date.getMonth();
4918 const month = currentMonth - (currentMonth % 3) + 3; 4919 _date.setMonth(month, 0); 4920 _date.setHours(23, 59, 59, 999); 4921 return _date; 4922} 4923 4924 4925/***/ }), 4926 4927/***/ 619753: 4928/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4929 4930"use strict"; 4931 4932exports.endOfSecond = endOfSecond; 4933var _index = __webpack_require__(807799); 4934 4935/** 4936 * The {@link endOfSecond} function options. 4937 */ 4938 4939/** 4940 * @name endOfSecond 4941 * @category Second Helpers 4942 * @summary Return the end of a second for the given date. 4943 * 4944 * @description 4945 * Return the end of a second for the given date. 4946 * The result will be in the local timezone if no `in` option is specified. 4947 * 4948 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4949 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4950 * 4951 * @param date - The original date 4952 * @param options - An object with options 4953 * 4954 * @returns The end of a second 4955 * 4956 * @example 4957 * // The end of a second for 1 December 2014 22:15:45.400: 4958 * const result = endOfSecond(new Date(2014, 11, 1, 22, 15, 45, 400)) 4959 * //=> Mon Dec 01 2014 22:15:45.999 4960 */ 4961function endOfSecond(date, options) { 4962 const _date = (0, _index.toDate)(date, options?.in); 4963 _date.setMilliseconds(999); 4964 return _date; 4965} 4966 4967 4968/***/ }), 4969 4970/***/ 431312: 4971/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 4972 4973"use strict"; 4974 4975exports.endOfToday = endOfToday; 4976var _index = __webpack_require__(294210); 4977 4978/** 4979 * The {@link endOfToday} function options. 4980 */ 4981 4982/** 4983 * @name endOfToday 4984 * @category Day Helpers 4985 * @summary Return the end of today. 4986 * @pure false 4987 * 4988 * @description 4989 * Return the end of today. 4990 * 4991 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 4992 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 4993 * 4994 * @param options - The options 4995 * 4996 * @returns The end of today 4997 * 4998 * @example 4999 * // If today is 6 October 2014: 5000 * const result = endOfToday() 5001 * //=> Mon Oct 6 2014 23:59:59.999 5002 */ 5003function endOfToday(options) { 5004 return (0, _index.endOfDay)(Date.now(), options); 5005} 5006 5007 5008/***/ }), 5009 5010/***/ 873312: 5011/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5012 5013"use strict"; 5014 5015exports.endOfTomorrow = endOfTomorrow; 5016var _index = __webpack_require__(560533); 5017 5018/** 5019 * The {@link endOfTomorrow} function options. 5020 */ 5021 5022/** 5023 * @name endOfTomorrow 5024 * @category Day Helpers 5025 * @summary Return the end of tomorrow. 5026 * @pure false 5027 * 5028 * @description 5029 * Return the end of tomorrow. 5030 * 5031 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 5032 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 5033 * 5034 * @param options - The options 5035 * @returns The end of tomorrow 5036 * 5037 * @example 5038 * // If today is 6 October 2014: 5039 * const result = endOfTomorrow() 5040 * //=> Tue Oct 7 2014 23:59:59.999 5041 */ 5042function endOfTomorrow(options) { 5043 const now = (0, _index.constructNow)(options?.in); 5044 const year = now.getFullYear();
vendor: 6,006 bytes, lines 5045-5244
5045 const month = now.getMonth(); 5046 const day = now.getDate(); 5047 5048 const date = (0, _index.constructNow)(options?.in); 5049 date.setFullYear(year, month, day + 1); 5050 date.setHours(23, 59, 59, 999); 5051 return options?.in ? options.in(date) : date; 5052} 5053 5054 5055/***/ }), 5056 5057/***/ 9036: 5058/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5059 5060"use strict"; 5061 5062exports.endOfWeek = endOfWeek; 5063var _index = __webpack_require__(983074); 5064var _index2 = __webpack_require__(807799); 5065 5066/** 5067 * The {@link endOfWeek} function options. 5068 */ 5069 5070/** 5071 * @name endOfWeek 5072 * @category Week Helpers 5073 * @summary Return the end of a week for the given date. 5074 * 5075 * @description 5076 * Return the end of a week for the given date. 5077 * The result will be in the local timezone. 5078 * 5079 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 5080 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 5081 * 5082 * @param date - The original date 5083 * @param options - An object with options 5084 * 5085 * @returns The end of a week 5086 * 5087 * @example 5088 * // The end of a week for 2 September 2014 11:55:00: 5089 * const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0)) 5090 * //=> Sat Sep 06 2014 23:59:59.999 5091 * 5092 * @example 5093 * // If the week starts on Monday, the end of the week for 2 September 2014 11:55:00: 5094 * const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 }) 5095 * //=> Sun Sep 07 2014 23:59:59.999 5096 */ 5097function endOfWeek(date, options) { 5098 const defaultOptions = (0, _index.getDefaultOptions)(); 5099 const weekStartsOn = 5100 options?.weekStartsOn ?? 5101 options?.locale?.options?.weekStartsOn ?? 5102 defaultOptions.weekStartsOn ?? 5103 defaultOptions.locale?.options?.weekStartsOn ?? 5104 0; 5105 5106 const _date = (0, _index2.toDate)(date, options?.in); 5107 const day = _date.getDay(); 5108 const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn); 5109 5110 _date.setDate(_date.getDate() + diff); 5111 _date.setHours(23, 59, 59, 999); 5112 return _date; 5113} 5114 5115 5116/***/ }), 5117 5118/***/ 925916: 5119/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5120 5121"use strict"; 5122 5123exports.endOfYear = endOfYear; 5124var _index = __webpack_require__(807799); 5125 5126/** 5127 * The {@link endOfYear} function options. 5128 */ 5129 5130/** 5131 * @name endOfYear 5132 * @category Year Helpers 5133 * @summary Return the end of a year for the given date. 5134 * 5135 * @description 5136 * Return the end of a year for the given date. 5137 * The result will be in the local timezone. 5138 * 5139 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 5140 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 5141 * 5142 * @param date - The original date 5143 * @param options - The options 5144 * 5145 * @returns The end of a year 5146 * 5147 * @example 5148 * // The end of a year for 2 September 2014 11:55:00: 5149 * const result = endOfYear(new Date(2014, 8, 2, 11, 55, 0)) 5150 * //=> Wed Dec 31 2014 23:59:59.999 5151 */ 5152function endOfYear(date, options) { 5153 const _date = (0, _index.toDate)(date, options?.in); 5154 const year = _date.getFullYear(); 5155 _date.setFullYear(year + 1, 0, 0); 5156 _date.setHours(23, 59, 59, 999); 5157 return _date; 5158} 5159 5160 5161/***/ }), 5162 5163/***/ 701804: 5164/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5165 5166"use strict"; 5167 5168exports.endOfYesterday = endOfYesterday; 5169var _index = __webpack_require__(658612); 5170var _index2 = __webpack_require__(560533); 5171 5172/** 5173 * The {@link endOfYesterday} function options. 5174 */ 5175 5176/** 5177 * @name endOfYesterday 5178 * @category Day Helpers 5179 * @summary Return the end of yesterday. 5180 * @pure false 5181 * 5182 * @description 5183 * Return the end of yesterday. 5184 * 5185 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 5186 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 5187 * 5188 * @returns The end of yesterday 5189 * 5190 * @example 5191 * // If today is 6 October 2014: 5192 * const result = endOfYesterday() 5193 * //=> Sun Oct 5 2014 23:59:59.999 5194 */ 5195function endOfYesterday(options) { 5196 const now = (0, _index2.constructNow)(options?.in); 5197 const date = (0, _index.constructFrom)(options?.in, 0); 5198 date.setFullYear(now.getFullYear(), now.getMonth(), now.getDate() - 1); 5199 date.setHours(23, 59, 59, 999); 5200 return date; 5201} 5202 5203 5204/***/ }), 5205 5206/***/ 797892: 5207/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5208 5209"use strict"; 5210 5211exports.format = exports.formatDate = format; 5212Object.defineProperty(exports, "formatters", ({ 5213 enumerable: true, 5214 get: function () { 5215 return _index3.formatters; 5216 }, 5217})); 5218Object.defineProperty(exports, "longFormatters", ({ 5219 enumerable: true, 5220 get: function () { 5221 return _index4.longFormatters; 5222 }, 5223})); 5224var _index = __webpack_require__(65099); 5225var _index2 = __webpack_require__(983074); 5226var _index3 = __webpack_require__(882833); 5227var _index4 = __webpack_require__(690419); 5228var _index5 = __webpack_require__(697569); 5229 5230var _index6 = __webpack_require__(533209); 5231var _index7 = __webpack_require__(807799); 5232 5233// Rexports of internal for libraries to use. 5234// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874 5235 5236// This RegExp consists of three parts separated by `|`: 5237// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token 5238// (one of the certain letters followed by `o`) 5239// - (\w)\1* matches any sequences of the same letter 5240// - '' matches two quote characters in a row 5241// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('), 5242// except a single quote symbol, which ends the sequence. 5243// Two quote characters do not end the sequence. 5244// If there is no matching single quote
5245// then the sequence will continue until the end of the string. 5246// - . matches any single character unmatched by previous parts of the RegExps 5247const formattingTokensRegExp = 5248 /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g; 5249 5250// This RegExp catches symbols escaped by quotes, and also 5251// sequences of symbols P, p, and the combinations like `PPPPPPPppppp` 5252const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g; 5253 5254const escapedStringRegExp = /^'([^]*?)'?$/; 5255const doubleQuoteRegExp = /''/g; 5256const unescapedLatinCharacterRegExp
vendor: 20,405 bytes, lines 5256-5547
5256 = /[a-zA-Z]/; 5257 5258/** 5259 * The {@link format} function options. 5260 */ 5261 5262/** 5263 * @name format 5264 * @alias formatDate 5265 * @category Common Helpers 5266 * @summary Format the date. 5267 * 5268 * @description 5269 * Return the formatted date string in the given format. The result may vary by locale. 5270 * 5271 * > â ï¸ Please note that the `format` tokens differ from Moment.js and other libraries. 5272 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5273 * 5274 * The characters wrapped between two single quotes characters (') are escaped. 5275 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote. 5276 * (see the last example) 5277 * 5278 * Format of the string is based on Unicode Technical Standard #35: 5279 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table 5280 * with a few additions (see note 7 below the table). 5281 * 5282 * Accepted patterns: 5283 * | Unit | Pattern | Result examples | Notes | 5284 * |---------------------------------|---------|-----------------------------------|-------| 5285 * | Era | G..GGG | AD, BC | | 5286 * | | GGGG | Anno Domini, Before Christ | 2 | 5287 * | | GGGGG | A, B | | 5288 * | Calendar year | y | 44, 1, 1900, 2017 | 5 | 5289 * | | yo | 44th, 1st, 0th, 17th | 5,7 | 5290 * | | yy | 44, 01, 00, 17 | 5 | 5291 * | | yyy | 044, 001, 1900, 2017 | 5 | 5292 * | | yyyy | 0044, 0001, 1900, 2017 | 5 | 5293 * | | yyyyy | ... | 3,5 | 5294 * | Local week-numbering year | Y | 44, 1, 1900, 2017 | 5 | 5295 * | | Yo | 44th, 1st, 1900th, 2017th | 5,7 | 5296 * | | YY | 44, 01, 00, 17 | 5,8 | 5297 * | | YYY | 044, 001, 1900, 2017 | 5 | 5298 * | | YYYY | 0044, 0001, 1900, 2017 | 5,8 | 5299 * | | YYYYY | ... | 3,5 | 5300 * | ISO week-numbering year | R | -43, 0, 1, 1900, 2017 | 5,7 | 5301 * | | RR | -43, 00, 01, 1900, 2017 | 5,7 | 5302 * | | RRR | -043, 000, 001, 1900, 2017 | 5,7 | 5303 * | | RRRR | -0043, 0000, 0001, 1900, 2017 | 5,7 | 5304 * | | RRRRR | ... | 3,5,7 | 5305 * | Extended year | u | -43, 0, 1, 1900, 2017 | 5 | 5306 * | | uu | -43, 01, 1900, 2017 | 5 | 5307 * | | uuu | -043, 001, 1900, 2017 | 5 | 5308 * | | uuuu | -0043, 0001, 1900, 2017 | 5 | 5309 * | | uuuuu | ... | 3,5 | 5310 * | Quarter (formatting) | Q | 1, 2, 3, 4 | | 5311 * | | Qo | 1st, 2nd, 3rd, 4th | 7 | 5312 * | | QQ | 01, 02, 03, 04 | | 5313 * | | QQQ | Q1, Q2, Q3, Q4 | | 5314 * | | QQQQ | 1st quarter, 2nd quarter, ... | 2 | 5315 * | | QQQQQ | 1, 2, 3, 4 | 4 | 5316 * | Quarter (stand-alone) | q | 1, 2, 3, 4 | | 5317 * | | qo | 1st, 2nd, 3rd, 4th | 7 | 5318 * | | qq | 01, 02, 03, 04 | | 5319 * | | qqq | Q1, Q2, Q3, Q4 | | 5320 * | | qqqq | 1st quarter, 2nd quarter, ... | 2 | 5321 * | | qqqqq | 1, 2, 3, 4 | 4 | 5322 * | Month (formatting) | M | 1, 2, ..., 12 | | 5323 * | | Mo | 1st, 2nd, ..., 12th | 7 | 5324 * | | MM | 01, 02, ..., 12 | | 5325 * | | MMM | Jan, Feb, ..., Dec | | 5326 * | | MMMM | January, February, ..., December | 2 | 5327 * | | MMMMM | J, F, ..., D | | 5328 * | Month (stand-alone) | L | 1, 2, ..., 12 | | 5329 * | | Lo | 1st, 2nd, ..., 12th | 7 | 5330 * | | LL | 01, 02, ..., 12 | | 5331 * | | LLL | Jan, Feb, ..., Dec | | 5332 * | | LLLL | January, February, ..., December | 2 | 5333 * | | LLLLL | J, F, ..., D | | 5334 * | Local week of year | w | 1, 2, ..., 53 | | 5335 * | | wo | 1st, 2nd, ..., 53th | 7 | 5336 * | | ww | 01, 02, ..., 53 | | 5337 * | ISO week of year | I | 1, 2, ..., 53 | 7 | 5338 * | | Io | 1st, 2nd, ..., 53th | 7 | 5339 * | | II | 01, 02, ..., 53 | 7 | 5340 * | Day of month | d | 1, 2, ..., 31 | | 5341 * | | do | 1st, 2nd, ..., 31st | 7 | 5342 * | | dd | 01, 02, ..., 31 | | 5343 * | Day of year | D | 1, 2, ..., 365, 366 | 9 | 5344 * | | Do | 1st, 2nd, ..., 365th, 366th | 7 | 5345 * | | DD | 01, 02, ..., 365, 366 | 9 | 5346 * | | DDD | 001, 002, ..., 365, 366 | | 5347 * | | DDDD | ... | 3 | 5348 * | Day of week (formatting) | E..EEE | Mon, Tue, Wed, ..., Sun | | 5349 * | | EEEE | Monday, Tuesday, ..., Sunday | 2 | 5350 * | | EEEEE | M, T, W, T, F, S, S | | 5351 * | | EEEEEE | Mo, Tu, We, Th, Fr, Sa, Su | | 5352 * | ISO day of week (formatting) | i | 1, 2, 3, ..., 7 | 7 | 5353 * | | io | 1st, 2nd, ..., 7th | 7 | 5354 * | | ii | 01, 02, ..., 07 | 7 | 5355 * | | iii | Mon, Tue, Wed, ..., Sun | 7 | 5356 * | | iiii | Monday, Tuesday, ..., Sunday | 2,7 | 5357 * | | iiiii | M, T, W, T, F, S, S | 7 | 5358 * | | iiiiii | Mo, Tu, We, Th, Fr, Sa, Su | 7 | 5359 * | Local day of week (formatting) | e | 2, 3, 4, ..., 1 | | 5360 * | | eo | 2nd, 3rd, ..., 1st | 7 | 5361 * | | ee | 02, 03, ..., 01 | | 5362 * | | eee | Mon, Tue, Wed, ..., Sun | | 5363 * | | eeee | Monday, Tuesday, ..., Sunday | 2 | 5364 * | | eeeee | M, T, W, T, F, S, S | | 5365 * | | eeeeee | Mo, Tu, We, Th, Fr, Sa, Su | | 5366 * | Local day of week (stand-alone) | c | 2, 3, 4, ..., 1 | | 5367 * | | co | 2nd, 3rd, ..., 1st | 7 | 5368 * | | cc | 02, 03, ..., 01 | | 5369 * | | ccc | Mon, Tue, Wed, ..., Sun | | 5370 * | | cccc | Monday, Tuesday, ..., Sunday | 2 | 5371 * | | ccccc | M, T, W, T, F, S, S | | 5372 * | | cccccc | Mo, Tu, We, Th, Fr, Sa, Su | | 5373 * | AM, PM | a..aa | AM, PM | | 5374 * | | aaa | am, pm | | 5375 * | | aaaa | a.m., p.m. | 2 | 5376 * | | aaaaa | a, p | | 5377 * | AM, PM, noon, midnight | b..bb | AM, PM, noon, midnight | | 5378 * | | bbb | am, pm, noon, midnight | | 5379 * | | bbbb | a.m., p.m., noon, midnight | 2 | 5380 * | | bbbbb | a, p, n, mi | | 5381 * | Flexible day period | B..BBB | at night, in the morning, ... | | 5382 * | | BBBB | at night, in the morning, ... | 2 | 5383 * | | BBBBB | at night, in the morning, ... | | 5384 * | Hour [1-12] | h | 1, 2, ..., 11, 12 | | 5385 * | | ho | 1st, 2nd, ..., 11th, 12th | 7 | 5386 * | | hh | 01, 02, ..., 11, 12 | | 5387 * | Hour [0-23] | H | 0, 1, 2, ..., 23 | | 5388 * | | Ho | 0th, 1st, 2nd, ..., 23rd | 7 | 5389 * | | HH | 00, 01, 02, ..., 23 | | 5390 * | Hour [0-11] | K | 1, 2, ..., 11, 0 | | 5391 * | | Ko | 1st, 2nd, ..., 11th, 0th | 7 | 5392 * | | KK | 01, 02, ..., 11, 00 | | 5393 * | Hour [1-24] | k | 24, 1, 2, ..., 23 | | 5394 * | | ko | 24th, 1st, 2nd, ..., 23rd | 7 | 5395 * | | kk | 24, 01, 02, ..., 23 | | 5396 * | Minute | m | 0, 1, ..., 59 | | 5397 * | | mo | 0th, 1st, ..., 59th | 7 | 5398 * | | mm | 00, 01, ..., 59 | | 5399 * | Second | s | 0, 1, ..., 59 | | 5400 * | | so | 0th, 1st, ..., 59th | 7 | 5401 * | | ss | 00, 01, ..., 59 | | 5402 * | Fraction of second | S | 0, 1, ..., 9 | | 5403 * | | SS | 00, 01, ..., 99 | | 5404 * | | SSS | 000, 001, ..., 999 | | 5405 * | | SSSS | ... | 3 | 5406 * | Timezone (ISO-8601 w/ Z) | X | -08, +0530, Z | | 5407 * | | XX | -0800, +0530, Z | | 5408 * | | XXX | -08:00, +05:30, Z | | 5409 * | | XXXX | -0800, +0530, Z, +123456 | 2 | 5410 * | | XXXXX | -08:00, +05:30, Z, +12:34:56 | | 5411 * | Timezone (ISO-8601 w/o Z) | x | -08, +0530, +00 | | 5412 * | | xx | -0800, +0530, +0000 | | 5413 * | | xxx | -08:00, +05:30, +00:00 | 2 | 5414 * | | xxxx | -0800, +0530, +0000, +123456 | | 5415 * | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | | 5416 * | Timezone (GMT) | O...OOO | GMT-8, GMT+5:30, GMT+0 | | 5417 * | | OOOO | GMT-08:00, GMT+05:30, GMT+00:00 | 2 | 5418 * | Timezone (specific non-locat.) | z...zzz | GMT-8, GMT+5:30, GMT+0 | 6 | 5419 * | | zzzz | GMT-08:00, GMT+05:30, GMT+00:00 | 2,6 | 5420 * | Seconds timestamp | t | 512969520 | 7 | 5421 * | | tt | ... | 3,7 | 5422 * | Milliseconds timestamp | T | 512969520900 | 7 | 5423 * | | TT | ... | 3,7 | 5424 * | Long localized date | P | 04/29/1453 | 7 | 5425 * | | PP | Apr 29, 1453 | 7 | 5426 * | | PPP | April 29th, 1453 | 7 | 5427 * | | PPPP | Friday, April 29th, 1453 | 2,7 | 5428 * | Long localized time | p | 12:00 AM | 7 | 5429 * | | pp | 12:00:00 AM | 7 | 5430 * | | ppp | 12:00:00 AM GMT+2 | 7 | 5431 * | | pppp | 12:00:00 AM GMT+02:00 | 2,7 | 5432 * | Combination of date and time | Pp | 04/29/1453, 12:00 AM | 7 | 5433 * | | PPpp | Apr 29, 1453, 12:00:00 AM | 7 | 5434 * | | PPPppp | April 29th, 1453 at ... | 7 | 5435 * | | PPPPpppp| Friday, April 29th, 1453 at ... | 2,7 | 5436 * Notes: 5437 * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale 5438 * are the same as "stand-alone" units, but are different in some languages. 5439 * "Formatting" units are declined according to the rules of the language 5440 * in the context of a date. "Stand-alone" units are always nominative singular: 5441 * 5442 * `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'` 5443 * 5444 * `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'` 5445 * 5446 * 2. Any sequence of the identical letters is a pattern, unless it is escaped by 5447 * the single quote characters (see below). 5448 * If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`) 5449 * the output will be the same as default pattern for this unit, usually 5450 * the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units 5451 * are marked with "2" in the last column of the table. 5452 * 5453 * `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'` 5454 * 5455 * `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'` 5456 * 5457 * `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'` 5458 * 5459 * `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'` 5460 * 5461 * `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'` 5462 * 5463 * 3. Some patterns could be unlimited length (such as `yyyyyyyy`). 5464 * The output will be padded with zeros to match the length of the pattern. 5465 * 5466 * `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'` 5467 * 5468 * 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales. 5469 * These tokens represent the shortest form of the quarter. 5470 * 5471 * 5. The main difference between `y` and `u` patterns are B.C. years: 5472 * 5473 * | Year | `y` | `u` | 5474 * |------|-----|-----| 5475 * | AC 1 | 1 | 1 | 5476 * | BC 1 | 1 | 0 | 5477 * | BC 2 | 2 | -1 | 5478 * 5479 * Also `yy` always returns the last two digits of a year, 5480 * while `uu` pads single digit years to 2 characters and returns other years unchanged: 5481 * 5482 * | Year | `yy` | `uu` | 5483 * |------|------|------| 5484 * | 1 | 01 | 01 | 5485 * | 14 | 14 | 14 | 5486 * | 376 | 76 | 376 | 5487 * | 1453 | 53 | 1453 | 5488 * 5489 * The same difference is true for local and ISO week-numbering years (`Y` and `R`), 5490 * except local week-numbering years are dependent on `options.weekStartsOn` 5491 * and `options.firstWeekContainsDate` (compare [getISOWeekYear](https://date-fns.org/docs/getISOWeekYear) 5492 * and [getWeekYear](https://date-fns.org/docs/getWeekYear)). 5493 * 5494 * 6. Specific non-location timezones are currently unavailable in `date-fns`, 5495 * so right now these tokens fall back to GMT timezones. 5496 * 5497 * 7. These patterns are not in the Unicode Technical Standard #35: 5498 * - `i`: ISO day of week 5499 * - `I`: ISO week of year 5500 * - `R`: ISO week-numbering year 5501 * - `t`: seconds timestamp 5502 * - `T`: milliseconds timestamp 5503 * - `o`: ordinal number modifier 5504 * - `P`: long localized date 5505 * - `p`: long localized time 5506 * 5507 * 8. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years. 5508 * You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5509 * 5510 * 9. `D` and `DD` tokens represent days of the year but they are often confused with days of the month. 5511 * You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5512 * 5513 * @param date - The original date 5514 * @param format - The string of tokens 5515 * @param options - An object with options 5516 * 5517 * @returns The formatted date string 5518 * 5519 * @throws `date` must not be Invalid Date 5520 * @throws `options.locale` must contain `localize` property 5521 * @throws `options.locale` must contain `formatLong` property 5522 * @throws use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5523 * @throws use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5524 * @throws use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5525 * @throws use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 5526 * @throws format string contains an unescaped latin alphabet character 5527 * 5528 * @example 5529 * // Represent 11 February 2014 in middle-endian format: 5530 * const result = format(new Date(2014, 1, 11), 'MM/dd/yyyy') 5531 * //=> '02/11/2014' 5532 * 5533 * @example 5534 * // Represent 2 July 2014 in Esperanto: 5535 * import { eoLocale } from 'date-fns/locale/eo' 5536 * const result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", { 5537 * locale: eoLocale 5538 * }) 5539 * //=> '2-a de julio 2014' 5540 * 5541 * @example 5542 * // Escape string by single quote characters: 5543 * const result = format(new Date(2014, 6, 2, 15), "h 'o''clock'") 5544 * //=> "3 o'clock" 5545 */ 5546function format(date, formatStr, options) { 5547 const defaultOptions =
vendor: 5,775 bytes, lines 5547-5706
5547(0, _index2.getDefaultOptions)(); 5548 const locale = 5549 options?.locale ?? defaultOptions.locale ?? _index.defaultLocale; 5550 5551 const firstWeekContainsDate = 5552 options?.firstWeekContainsDate ?? 5553 options?.locale?.options?.firstWeekContainsDate ?? 5554 defaultOptions.firstWeekContainsDate ?? 5555 defaultOptions.locale?.options?.firstWeekContainsDate ?? 5556 1; 5557 5558 const weekStartsOn = 5559 options?.weekStartsOn ?? 5560 options?.locale?.options?.weekStartsOn ?? 5561 defaultOptions.weekStartsOn ?? 5562 defaultOptions.locale?.options?.weekStartsOn ?? 5563 0; 5564 5565 const originalDate = (0, _index7.toDate)(date, options?.in); 5566 5567 if (!(0, _index6.isValid)(originalDate)) { 5568 throw new RangeError("Invalid time value"); 5569 } 5570 5571 let parts = formatStr 5572 .match(longFormattingTokensRegExp) 5573 .map((substring) => { 5574 const firstCharacter = substring[0]; 5575 if (firstCharacter === "p" || firstCharacter === "P") { 5576 const longFormatter = _index4.longFormatters[firstCharacter]; 5577 return longFormatter(substring, locale.formatLong); 5578 } 5579 return substring; 5580 }) 5581 .join("") 5582 .match(formattingTokensRegExp) 5583 .map((substring) => { 5584 // Replace two single quote characters with one single quote character 5585 if (substring === "''") { 5586 return { isToken: false, value: "'" }; 5587 } 5588 5589 const firstCharacter = substring[0]; 5590 if (firstCharacter === "'") { 5591 return { isToken: false, value: cleanEscapedString(substring) }; 5592 } 5593 5594 if (_index3.formatters[firstCharacter]) { 5595 return { isToken: true, value: substring }; 5596 } 5597 5598 if (firstCharacter.match(unescapedLatinCharacterRegExp)) { 5599 throw new RangeError( 5600 "Format string contains an unescaped latin alphabet character `" + 5601 firstCharacter + 5602 "`", 5603 ); 5604 } 5605 5606 return { isToken: false, value: substring }; 5607 }); 5608 5609 // invoke localize preprocessor (only for french locales at the moment) 5610 if (locale.localize.preprocessor) { 5611 parts = locale.localize.preprocessor(originalDate, parts); 5612 } 5613 5614 const formatterOptions = { 5615 firstWeekContainsDate, 5616 weekStartsOn, 5617 locale, 5618 }; 5619 5620 return parts 5621 .map((part) => { 5622 if (!part.isToken) return part.value; 5623 5624 const token = part.value; 5625 5626 if ( 5627 (!options?.useAdditionalWeekYearTokens && 5628 (0, _index5.isProtectedWeekYearToken)(token)) || 5629 (!options?.useAdditionalDayOfYearTokens && 5630 (0, _index5.isProtectedDayOfYearToken)(token)) 5631 ) { 5632 (0, _index5.warnOrThrowProtectedError)(token, formatStr, String(date)); 5633 } 5634 5635 const formatter = _index3.formatters[token[0]]; 5636 return formatter(originalDate, token, locale.localize, formatterOptions); 5637 }) 5638 .join(""); 5639} 5640 5641function cleanEscapedString(input) { 5642 const matched = input.match(escapedStringRegExp); 5643 5644 if (!matched) { 5645 return input; 5646 } 5647 5648 return matched[1].replace(doubleQuoteRegExp, "'"); 5649} 5650 5651 5652/***/ }), 5653 5654/***/ 298385: 5655/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5656 5657"use strict"; 5658 5659exports.formatDistance = formatDistance; 5660var _index = __webpack_require__(65099); 5661var _index2 = __webpack_require__(983074); 5662var _index3 = __webpack_require__(158228); 5663var _index4 = __webpack_require__(947561); 5664var _index5 = __webpack_require__(636374); 5665var _index6 = __webpack_require__(241836); 5666var _index7 = __webpack_require__(976081); 5667var _index8 = __webpack_require__(454975); 5668 5669/** 5670 * The {@link formatDistance} function options. 5671 */ 5672 5673/** 5674 * @name formatDistance 5675 * @category Common Helpers 5676 * @summary Return the distance between the given dates in words. 5677 * 5678 * @description 5679 * Return the distance between the given dates in words. 5680 * 5681 * | Distance between dates | Result | 5682 * |-------------------------------------------------------------------|---------------------| 5683 * | 0 ... 30 secs | less than a minute | 5684 * | 30 secs ... 1 min 30 secs | 1 minute | 5685 * | 1 min 30 secs ... 44 mins 30 secs | [2..44] minutes | 5686 * | 44 mins ... 30 secs ... 89 mins 30 secs | about 1 hour | 5687 * | 89 mins 30 secs ... 23 hrs 59 mins 30 secs | about [2..24] hours | 5688 * | 23 hrs 59 mins 30 secs ... 41 hrs 59 mins 30 secs | 1 day | 5689 * | 41 hrs 59 mins 30 secs ... 29 days 23 hrs 59 mins 30 secs | [2..30] days | 5690 * | 29 days 23 hrs 59 mins 30 secs ... 44 days 23 hrs 59 mins 30 secs | about 1 month | 5691 * | 44 days 23 hrs 59 mins 30 secs ... 59 days 23 hrs 59 mins 30 secs | about 2 months | 5692 * | 59 days 23 hrs 59 mins 30 secs ... 1 yr | [2..12] months | 5693 * | 1 yr ... 1 yr 3 months | about 1 year | 5694 * | 1 yr 3 months ... 1 yr 9 month s | over 1 year | 5695 * | 1 yr 9 months ... 2 yrs | almost 2 years | 5696 * | N yrs ... N yrs 3 months | about N years | 5697 * | N yrs 3 months ... N yrs 9 months | over N years | 5698 * | N yrs 9 months ... N+1 yrs | almost N+1 years | 5699 * 5700 * With `options.includeSeconds == true`: 5701 * | Distance between dates | Result | 5702 * |------------------------|----------------------| 5703 * | 0 secs ... 5 secs | less than 5 seconds | 5704 * | 5 secs ... 10 secs | less than 10 seconds | 5705 * | 10 secs ... 20 secs | less than 20 seconds | 5706 * | 20 secs ... 40 secs | half a minute |
5707 * | 40 secs ... 60 secs | less than a minute | 5708 * | 60 secs ... 90 secs | 1 minute | 5709 * 5710 * @param laterDate - The date 5711 * @param earlierDate - The date to compare with 5712 * @param options - An object with options 5713 * 5714 * @returns The distance in words 5715 * 5716 * @throws `date` must not be Invalid Date 5717 * @throws `baseDate` must not be Invalid Date 5718 * @throws `options.locale` must contain `formatDistance` property 5719 * 5720 * @example 5721 * // What is the distance between 2 July 2014 and 1 January 2015? 5722 * const result = formatDistance(new Date(2014, 6, 2), new Date(2015, 0, 1)) 5723 * //=> '6 months' 5724 * 5725 * @example 5726 * // What is the distance between 1 January 2015 00:00:15 5727 * // and 1 January 2015 00:00:00, including seconds? 5728 * const result = formatDistance( 5729 * new Date(2015, 0, 1, 0, 0, 15), 5730 * new Date(2015, 0, 1, 0, 0, 0), 5731 * { includeSeconds: true } 5732 * ) 5733 * //=> 'less than 20 seconds' 5734 * 5735 * @example 5736 * // What is the distance from 1 January 2016 5737 * // to 1 January 2015, with a suffix? 5738 * const result = formatDistance(new Date(2015, 0, 1), new Date(2016, 0, 1), { 5739 * addSuffix: true 5740 * }) 5741 * //=> 'about 1 year ago' 5742 * 5743 * @example 5744 * // What is the distance between 1 August 2016 and 1 January 2015 in Esperanto? 5745 * import { eoLocale } from 'date-fns/locale/eo' 5746 * const result = formatDistance(new Date(2016, 7, 1), new Date(2015, 0, 1), { 5747 * locale: eoLocale 5748 * }) 5749 * //=> 'pli ol 1 jaro' 5750 */ 5751function formatDistance(laterDate, earlierDate, options) { 5752 const defaultOptions = (0, _index2.getDefaultOptions)(); 5753 const locale = 5754 options?.locale ?? defaultOptions.locale ?? _index.defaultLocale; 5755 const minutesInAlmostTwoDays = 2520; 5756 5757 const comparison = (0, _index5.compareAsc)(laterDate, earlierDate); 5758 5759 if (isNaN(comparison)) throw new RangeError("Invalid time value"); 5760 5761 const localizeOptions = Object.assign({}, options, { 5762 addSuffix: options?.addSuffix, 5763 comparison: comparison, 5764 }); 5765 5766 const [laterDate_, earlierDate_] = (0, _index4.normalizeDates)( 5767 options?.in, 5768 ...(comparison > 0 ? [earlierDate, laterDate] : [laterDate, earlierDate]), 5769 ); 5770 5771 const seconds = (0, _index8.differenceInSeconds)(earlierDate_, laterDate_); 5772 const offsetInSeconds = 5773 ((0, _index3.getTimezoneOffsetInMilliseconds)(earlierDate_) - 5774 (0, _index3.getTimezoneOffsetInMilliseconds)(laterDate_)) / 5775 1000; 5776 const minutes = Math.round((seconds - offsetInSeconds) / 60); 5777 let months; 5778 5779 // 0 up to 2 mins 5780 if (minutes < 2) { 5781 if (options?.includeSeconds) { 5782 if (seconds < 5) { 5783 return locale.formatDistance("lessThanXSeconds", 5, localizeOptions); 5784 } else if (seconds < 10) { 5785 return locale.formatDistance("lessThanXSeconds", 10, localizeOptions); 5786 } else if (seconds < 20) { 5787 return locale.formatDistance("lessThanXSeconds", 20, localizeOptions); 5788 } else if (seconds < 40) { 5789 return locale.formatDistance("halfAMinute", 0, localizeOptions); 5790 } else if (seconds < 60) { 5791 return locale.formatDistance("lessThanXMinutes", 1, localizeOptions); 5792 } else { 5793 return locale.formatDistance("xMinutes", 1, localizeOptions); 5794 } 5795 } else { 5796 if (minutes === 0) { 5797 return locale.formatDistance("lessThanXMinutes", 1, localizeOptions); 5798 } else { 5799 return locale.formatDistance("xMinutes", minutes, localizeOptions); 5800 } 5801 } 5802 5803 // 2 mins up to 0.75 hrs 5804 } else if (minutes < 45) { 5805 return locale.formatDistance("xMinutes", minutes, localizeOptions); 5806 5807 // 0.75 hrs up to 1.5 hrs 5808 } else if (minutes < 90) { 5809 return locale.formatDistance("aboutXHours", 1, localizeOptions); 5810 5811 // 1.5 hrs up to 24 hrs 5812 } else if (minutes < _index6.minutesInDay) { 5813 const hours = Math.round(minutes / 60); 5814 return locale.formatDistance("aboutXHours", hours, localizeOptions); 5815 5816 // 1 day up to 1.75 days 5817 } else if (minutes < minutesInAlmostTwoDays) { 5818 return locale.formatDistance("xDays", 1, localizeOptions); 5819 5820 // 1.75 days up to 30 days 5821 } else if (minutes < _index6.minutesInMonth) { 5822 const days = Math.round(minutes / _index6.minutesInDay); 5823 return locale.formatDistance("xDays", days, localizeOptions); 5824 5825 // 1 month up to 2 months 5826 } else if (minutes < _index6.minutesInMonth * 2) { 5827 months = Math.round(minutes / _index6.minutesInMonth); 5828 return locale.formatDistance("aboutXMonths", months, localizeOptions); 5829 } 5830 5831 months = (0, _index7.differenceInMonths)(earlierDate_, laterDate_); 5832 5833 // 2 months up to 12 months 5834 if (months < 12) { 5835 const nearestMonth = Math.round(minutes / _index6.minutesInMonth); 5836 return locale.formatDistance("xMonths", nearestMonth, localizeOptions); 5837 5838 // 1 year up to max Date 5839 } else { 5840 const monthsSinceStartOfYear = months % 12; 5841 const years = Math.trunc(months / 12); 5842 5843 // N years up to 1 years 3 months 5844 if (monthsSinceStartOfYear < 3) { 5845 return locale.formatDistance("aboutXYears", years, localizeOptions); 5846 5847 // N years 3 months up to N years 9 months 5848 } else if (monthsSinceStartOfYear < 9) { 5849 return locale.formatDistance("overXYears", years, localizeOptions); 5850 5851 // N years 9 months up to N year 12 months 5852 } else { 5853 return locale.formatDistance("almostXYears", years + 1, localizeOptions); 5854 } 5855 } 5856} 5857 5858 5859/***/ }), 5860 5861/***/ 215563: 5862/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 5863 5864"use strict"; 5865 5866exports.formatDistanceStrict = formatDistanceStrict; 5867var _index = __webpack_require__(65099); 5868var _index2 = __webpack_require__(983074); 5869var _index3 = __webpack_require__(839886); 5870var _index4 = __webpack_require__(158228); 5871var _index5 = __webpack_require__(947561); 5872var _index6 = __webpack_require__(636374); 5873var _index7 = __webpack_require__(241836); 5874 5875/** 5876 * The {@link formatDistanceStrict} function options. 5877 */ 5878 5879/** 5880 * The unit used to format the distance in {@link formatDistanceStrict}. 5881 */ 5882 5883/** 5884 * @name formatDistanceStrict 5885 * @category Common Helpers 5886 * @summary Return the distance between the given dates in words. 5887 * 5888 * @description 5889 * Return the distance between the given dates in words, using strict units. 5890 * This is like `formatDistance`, but does not use helpers like 'almost', 'over', 5891 * 'less than' and the like. 5892 * 5893 * | Distance between dates | Result | 5894 * |------------------------|---------------------| 5895 * | 0 ... 59 secs | [0..59] seconds | 5896 * | 1 ... 59 mins | [1..59] minutes | 5897 * | 1 ... 23 hrs | [1..23] hours | 5898 * | 1 ... 29 days | [1..29] days | 5899 * | 1 ... 11 months | [1..11] months | 5900 * | 1 ... N years | [1..N] years | 5901 * 5902 * @param laterDate - The date 5903 * @param earlierDate - The date to compare with 5904 * @param options - An object with options 5905 * 5906 * @returns The distance in words 5907 * 5908 * @throws `date` must not be Invalid Date 5909 * @throws `baseDate` must not be Invalid Date 5910 * @throws `options.unit` must be 'second', 'minute', 'hour', 'day', 'month' or 'year' 5911 * @throws `options.locale` must contain `formatDistance` property 5912 * 5913 * @example 5914 * // What is the distance between 2 July 2014 and 1 January 2015? 5915 * const result = formatDistanceStrict(new Date(2014, 6, 2), new Date(2015, 0, 2)) 5916 * //=> '6 months' 5917 * 5918 * @example 5919 * // What is the distance between 1 January 2015 00:00:15 5920 * // and 1 January 2015 00:00:00? 5921 * const result = formatDistanceStrict( 5922 * new Date(2015, 0, 1, 0, 0, 15), 5923 * new Date(2015, 0, 1, 0, 0, 0) 5924 * ) 5925 * //=> '15 seconds' 5926 * 5927 * @example 5928 * // What is the distance from 1 January 2016 5929 * // to 1 January 2015, with a suffix? 5930 * const result = formatDistanceStrict(new Date(2015, 0, 1), new Date(2016, 0, 1), { 5931 * addSuffix: true 5932 * }) 5933 * //=> '1 year ago' 5934 * 5935 * @example 5936 * // What is the distance from 1 January 2016 5937 * // to 1 January 2015, in minutes? 5938 * const result = formatDistanceStrict(new Date(2016, 0, 1), new Date(2015, 0, 1), { 5939 * unit: 'minute' 5940 * }) 5941 * //=> '525600 minutes' 5942 * 5943 * @example 5944 * // What is the distance from 1 January 2015
vendor: 6,144 bytes, lines 5945-6105
5945 * // to 28 January 2015, in months, rounded up? 5946 * const result = formatDistanceStrict(new Date(2015, 0, 28), new Date(2015, 0, 1), { 5947 * unit: 'month', 5948 * roundingMethod: 'ceil' 5949 * }) 5950 * //=> '1 month' 5951 * 5952 * @example 5953 * // What is the distance between 1 August 2016 and 1 January 2015 in Esperanto? 5954 * import { eoLocale } from 'date-fns/locale/eo' 5955 * const result = formatDistanceStrict(new Date(2016, 7, 1), new Date(2015, 0, 1), { 5956 * locale: eoLocale 5957 * }) 5958 * //=> '1 jaro' 5959 */ 5960 5961function formatDistanceStrict(laterDate, earlierDate, options) { 5962 const defaultOptions = (0, _index2.getDefaultOptions)(); 5963 const locale = 5964 options?.locale ?? defaultOptions.locale ?? _index.defaultLocale; 5965 5966 const comparison = (0, _index6.compareAsc)(laterDate, earlierDate); 5967 5968 if (isNaN(comparison)) { 5969 throw new RangeError("Invalid time value"); 5970 } 5971 5972 const localizeOptions = Object.assign({}, options, { 5973 addSuffix: options?.addSuffix, 5974 comparison: comparison, 5975 }); 5976 5977 const [laterDate_, earlierDate_] = (0, _index5.normalizeDates)( 5978 options?.in, 5979 ...(comparison > 0 ? [earlierDate, laterDate] : [laterDate, earlierDate]), 5980 ); 5981 5982 const roundingMethod = (0, _index3.getRoundingMethod)( 5983 options?.roundingMethod ?? "round", 5984 ); 5985 5986 const milliseconds = earlierDate_.getTime() - laterDate_.getTime(); 5987 const minutes = milliseconds / _index7.millisecondsInMinute; 5988 5989 const timezoneOffset = 5990 (0, _index4.getTimezoneOffsetInMilliseconds)(earlierDate_) - 5991 (0, _index4.getTimezoneOffsetInMilliseconds)(laterDate_); 5992 5993 // Use DST-normalized difference in minutes for years, months and days; 5994 // use regular difference in minutes for hours, minutes and seconds. 5995 const dstNormalizedMinutes = 5996 (milliseconds - timezoneOffset) / _index7.millisecondsInMinute; 5997 5998 const defaultUnit = options?.unit; 5999 let unit; 6000 if (!defaultUnit) { 6001 if (minutes < 1) { 6002 unit = "second"; 6003 } else if (minutes < 60) { 6004 unit = "minute"; 6005 } else if (minutes < _index7.minutesInDay) { 6006 unit = "hour"; 6007 } else if (dstNormalizedMinutes < _index7.minutesInMonth) { 6008 unit = "day"; 6009 } else if (dstNormalizedMinutes < _index7.minutesInYear) { 6010 unit = "month"; 6011 } else { 6012 unit = "year"; 6013 } 6014 } else { 6015 unit = defaultUnit; 6016 } 6017 6018 // 0 up to 60 seconds 6019 if (unit === "second") { 6020 const seconds = roundingMethod(milliseconds / 1000); 6021 return locale.formatDistance("xSeconds", seconds, localizeOptions); 6022 6023 // 1 up to 60 mins 6024 } else if (unit === "minute") { 6025 const roundedMinutes = roundingMethod(minutes); 6026 return locale.formatDistance("xMinutes", roundedMinutes, localizeOptions); 6027 6028 // 1 up to 24 hours 6029 } else if (unit === "hour") { 6030 const hours = roundingMethod(minutes / 60); 6031 return locale.formatDistance("xHours", hours, localizeOptions); 6032 6033 // 1 up to 30 days 6034 } else if (unit === "day") { 6035 const days = roundingMethod(dstNormalizedMinutes / _index7.minutesInDay); 6036 return locale.formatDistance("xDays", days, localizeOptions); 6037 6038 // 1 up to 12 months 6039 } else if (unit === "month") { 6040 const months = roundingMethod( 6041 dstNormalizedMinutes / _index7.minutesInMonth, 6042 ); 6043 return months === 12 && defaultUnit !== "month" 6044 ? locale.formatDistance("xYears", 1, localizeOptions) 6045 : locale.formatDistance("xMonths", months, localizeOptions); 6046 6047 // 1 year up to max Date 6048 } else { 6049 const years = roundingMethod(dstNormalizedMinutes / _index7.minutesInYear); 6050 return locale.formatDistance("xYears", years, localizeOptions); 6051 } 6052} 6053 6054 6055/***/ }), 6056 6057/***/ 665557: 6058/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6059 6060"use strict"; 6061 6062exports.formatDistanceToNow = formatDistanceToNow; 6063var _index = __webpack_require__(560533); 6064 6065var _index2 = __webpack_require__(298385); 6066 6067/** 6068 * The {@link formatDistanceToNow} function options. 6069 */ 6070 6071/** 6072 * @name formatDistanceToNow 6073 * @category Common Helpers 6074 * @summary Return the distance between the given date and now in words. 6075 * @pure false 6076 * 6077 * @description 6078 * Return the distance between the given date and now in words. 6079 * 6080 * | Distance to now | Result | 6081 * |-------------------------------------------------------------------|---------------------| 6082 * | 0 ... 30 secs | less than a minute | 6083 * | 30 secs ... 1 min 30 secs | 1 minute | 6084 * | 1 min 30 secs ... 44 mins 30 secs | [2..44] minutes | 6085 * | 44 mins ... 30 secs ... 89 mins 30 secs | about 1 hour | 6086 * | 89 mins 30 secs ... 23 hrs 59 mins 30 secs | about [2..24] hours | 6087 * | 23 hrs 59 mins 30 secs ... 41 hrs 59 mins 30 secs | 1 day | 6088 * | 41 hrs 59 mins 30 secs ... 29 days 23 hrs 59 mins 30 secs | [2..30] days | 6089 * | 29 days 23 hrs 59 mins 30 secs ... 44 days 23 hrs 59 mins 30 secs | about 1 month | 6090 * | 44 days 23 hrs 59 mins 30 secs ... 59 days 23 hrs 59 mins 30 secs | about 2 months | 6091 * | 59 days 23 hrs 59 mins 30 secs ... 1 yr | [2..12] months | 6092 * | 1 yr ... 1 yr 3 months | about 1 year | 6093 * | 1 yr 3 months ... 1 yr 9 month s | over 1 year | 6094 * | 1 yr 9 months ... 2 yrs | almost 2 years | 6095 * | N yrs ... N yrs 3 months | about N years | 6096 * | N yrs 3 months ... N yrs 9 months | over N years | 6097 * | N yrs 9 months ... N+1 yrs | almost N+1 years | 6098 * 6099 * With `options.includeSeconds == true`: 6100 * | Distance to now | Result | 6101 * |---------------------|----------------------| 6102 * | 0 secs ... 5 secs | less than 5 seconds | 6103 * | 5 secs ... 10 secs | less than 10 seconds | 6104 * | 10 secs ... 20 secs | less than 20 seconds | 6105 * | 20 secs ... 40 secs | half a minute |
6106 * | 40 secs ... 60 secs | less than a minute | 6107 * | 60 secs ... 90 secs | 1 minute | 6108 * 6109 * @param date - The given date 6110 * @param options - The object with options 6111 * 6112 * @returns The distance in words 6113 * 6114 * @throws `date` must not be Invalid Date 6115 * @throws `options.locale` must contain `formatDistance` property 6116 * 6117 * @example 6118 * // If today is 1 January 2015, what is the distance to 2 July 2014? 6119 * const result = formatDistanceToNow( 6120 * new Date(2014, 6, 2) 6121 * ) 6122 * //=> '6 months' 6123 * 6124 * @example 6125 * // If now is 1 January 2015 00:00:00, 6126 * // what is the distance to 1 January 2015 00:00:15, including seconds? 6127 * const result = formatDistanceToNow( 6128 * new Date(2015, 0, 1, 0, 0, 15), 6129 * {includeSeconds: true} 6130 * ) 6131 * //=> 'less than 20 seconds' 6132 * 6133 * @example 6134 * // If today is 1 January 2015, 6135 * // what is the distance to 1 January 2016, with a suffix? 6136 * const result = formatDistanceToNow( 6137 * new Date(2016, 0, 1), 6138 * {addSuffix: true} 6139 * ) 6140 * //=> 'in about 1 year' 6141 * 6142 * @example 6143 * // If today is 1 January 2015, 6144 * // what is the distance to 1 August 2016 in Esperanto? 6145 * const eoLocale = require('date-fns/locale/eo') 6146 * const result = formatDistanceToNow( 6147 * new Date(2016, 7, 1), 6148 * {locale: eoLocale} 6149 * ) 6150 * //=> 'pli ol 1 jaro' 6151 */ 6152function formatDistanceToNow(date, options) { 6153 return (0, _index2.formatDistance)( 6154 date, 6155 (0, _index.constructNow)(date), 6156 options, 6157 ); 6158} 6159 6160 6161/***/ }), 6162 6163/***/ 735915: 6164/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6165 6166"use strict"; 6167 6168exports.formatDistanceToNowStrict = formatDistanceToNowStrict; 6169var _index = __webpack_require__(560533); 6170 6171var _index2 = __webpack_require__(215563); 6172 6173/** 6174 * The {@link formatDistanceToNowStrict} function options. 6175 */ 6176 6177/** 6178 * @name formatDistanceToNowStrict 6179 * @category Common Helpers 6180 * @summary Return the distance between the given date and now in words. 6181 * @pure false 6182 * 6183 * @description 6184 * Return the distance between the given dates in words, using strict units. 6185 * This is like `formatDistance`, but does not use helpers like 'almost', 'over', 6186 * 'less than' and the like. 6187 * 6188 * | Distance between dates | Result | 6189 * |------------------------|---------------------| 6190 * | 0 ... 59 secs | [0..59] seconds | 6191 * | 1 ... 59 mins | [1..59] minutes | 6192 * | 1 ... 23 hrs | [1..23] hours | 6193 * | 1 ... 29 days | [1..29] days | 6194 * | 1 ... 11 months | [1..11] months | 6195 * | 1 ... N years | [1..N] years | 6196 * 6197 * @param date - The given date 6198 * @param options - An object with options. 6199 * 6200 * @returns The distance in words 6201 * 6202 * @throws `date` must not be Invalid Date 6203 * @throws `options.locale` must contain `formatDistance` property 6204 * 6205 * @example 6206 * // If today is 1 January 2015, what is the distance to 2 July 2014? 6207 * const result = formatDistanceToNowStrict( 6208 * new Date(2014, 6, 2) 6209 * ) 6210 * //=> '6 months' 6211 * 6212 * @example 6213 * // If now is 1 January 2015 00:00:00, 6214 * // what is the distance to 1 January 2015 00:00:15, including seconds? 6215 * const result = formatDistanceToNowStrict( 6216 * new Date(2015, 0, 1, 0, 0, 15) 6217 * ) 6218 * //=> '15 seconds' 6219 * 6220 * @example 6221 * // If today is 1 January 2015, 6222 * // what is the distance to 1 January 2016, with a suffix? 6223 * const result = formatDistanceToNowStrict( 6224 * new Date(2016, 0, 1), 6225 * {addSuffix: true} 6226 * ) 6227 * //=> 'in 1 year' 6228 * 6229 * @example 6230 * // If today is 28 January 2015, 6231 * // what is the distance to 1 January 2015, in months, rounded up?? 6232 * const result = formatDistanceToNowStrict(new Date(2015, 0, 1), { 6233 * unit: 'month',
6234 * roundingMethod: 'ceil' 6235 * }) 6236 * //=> '1 month' 6237 * 6238 * @example 6239 * // If today is 1 January 2015, 6240 * // what is the distance to 1 January 2016 in Esperanto? 6241 * const eoLocale = require('date-fns/locale/eo') 6242 * const result = formatDistanceToNowStrict( 6243 * new Date(2016, 0, 1), 6244 * {locale: eoLocale} 6245 * ) 6246 * //=> '1 jaro' 6247 */ 6248function formatDistanceToNowStrict(date, options) { 6249 return (0, _index2.formatDistanceStrict)( 6250 date, 6251 (0, _index.constructNow)(date), 6252 options, 6253 ); 6254} 6255 6256 6257/***/ }), 6258 6259/***/ 612236: 6260/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6261 6262"use strict"; 6263 6264exports.formatDuration = formatDuration; 6265 6266var _index = __webpack_require__(65099); 6267var _index2 = __webpack_require__(983074); 6268 6269/** 6270 * The {@link formatDuration} function options. 6271 */ 6272 6273const defaultFormat = [ 6274 "years", 6275 "months", 6276 "weeks", 6277 "days", 6278 "hours", 6279 "minutes", 6280 "seconds", 6281]; 6282 6283/** 6284 * @name formatDuration 6285 * @category Common Helpers 6286 * @summary Formats a duration in human-readable format 6287 * 6288 * @description 6289 * Return human-readable duration string i.e. "9 months 2 days" 6290 * 6291 * @param duration - The duration to format 6292 * @param options - An object with options. 6293 * 6294 * @returns The formatted date string 6295 * 6296 * @example 6297 * // Format full duration 6298 * formatDuration({ 6299 * years: 2, 6300 * months: 9, 6301 * weeks: 1, 6302 * days: 7, 6303 * hours: 5, 6304 * minutes: 9, 6305 * seconds: 30 6306 * }) 6307 * //=> '2 years 9 months 1 week 7 days 5 hours 9 minutes 30 seconds' 6308 * 6309 * @example 6310 * // Format partial duration 6311 * formatDuration({ months: 9, days: 2 }) 6312 * //=> '9 months 2 days' 6313 * 6314 * @example 6315 * // Customize the format 6316 * formatDuration( 6317 * { 6318 * years: 2, 6319 * months: 9, 6320 * weeks: 1, 6321 * days: 7, 6322 * hours: 5, 6323 * minutes: 9, 6324 * seconds: 30 6325 * }, 6326 * { format: ['months', 'weeks'] } 6327 * ) === '9 months 1 week' 6328 * 6329 * @example 6330 * // Customize the zeros presence 6331 * formatDuration({ years: 0, months: 9 }) 6332 * //=> '9 months' 6333 * formatDuration({ years: 0, months: 9 }, { zero: true }) 6334 * //=> '0 years 9 months' 6335 * 6336 * @example 6337 * // Customize the delimiter 6338 * formatDuration({ years: 2, months: 9, weeks: 3 }, { delimiter: ', ' }) 6339 * //=> '2 years, 9 months, 3 weeks' 6340 */ 6341function formatDuration(duration, options) { 6342 const defaultOptions = (0, _index2.getDefaultOptions)(); 6343 const locale = 6344 options?.locale ?? defaultOptions.locale ?? _index.defaultLocale; 6345 const format = options?.format ?? defaultFormat; 6346 const zero = options?.zero ?? false; 6347 const delimiter = options?.delimiter ?? " "; 6348 6349 if (!locale.formatDistance) { 6350 return ""; 6351 } 6352 6353 const result = format 6354 .reduce((acc, unit) => { 6355 const token = `x${unit.replace(/(^.)/, (m) => m.toUpperCase())}`; 6356 const value = duration[unit]; 6357 if (value !== undefined && (zero || duration[unit])) { 6358 return acc.concat(locale.formatDistance(token, value)); 6359 } 6360 return acc; 6361 }, []) 6362 .join(delimiter); 6363 6364 return result; 6365} 6366 6367 6368/***/ }), 6369 6370/***/ 638233: 6371/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6372 6373"use strict"; 6374 6375exports.formatISO = formatISO; 6376var _index = __webpack_require__(616660); 6377var _index2 = __webpack_require__(807799); 6378 6379/** 6380 * The {@link formatISO} function options. 6381 */ 6382 6383/** 6384 * @name formatISO 6385 * @category Common Helpers 6386 * @summary Format the date according to the ISO 8601 standard (https://support.sas.com/documentation/cdl/en/lrdict/64316/HTML/default/viewer.htm#a003169814.htm). 6387 * 6388 * @description 6389 * Return the formatted date string in ISO 8601 format. Options may be passed to control the parts and notations of the date. 6390 * 6391 * @param date - The original date 6392 * @param options - An object with options. 6393 * 6394 * @returns The formatted date string (in local time zone) 6395 * 6396 * @throws `date` must not be Invalid Date 6397 * 6398 * @example 6399 * // Represent 18 September 2019 in ISO 8601 format (local time zone is UTC): 6400 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52)) 6401 * //=> '2019-09-18T19:00:52Z' 6402 * 6403 * @example 6404 * // Represent 18 September 2019 in ISO 8601, short format (local time zone is UTC): 6405 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { format: 'basic' }) 6406 * //=> '20190918T190052' 6407 * 6408 * @example 6409 * // Represent 18 September 2019 in ISO 8601 format, date only: 6410 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { representation: 'date' }) 6411 * //=> '2019-09-18' 6412 * 6413 * @example 6414 * // Represent 18 September 2019 in ISO 8601 format, time only (local time zone is UTC): 6415 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { representation: 'time' }) 6416 * //=> '19:00:52Z' 6417 */ 6418function formatISO(date, options) { 6419 const date_ = (0, _index2.toDate)(date, options?.in); 6420 6421 if (isNaN(+date_)) { 6422 throw new RangeError("Invalid time value"); 6423 } 6424 6425 const format = options?.format ?? "extended"; 6426 const representation = options?.representation ?? "complete"; 6427 6428 let result = ""; 6429 let tzOffset = ""; 6430 6431 const dateDelimiter = format === "extended" ? "-" : "";
vendor: 3,888 bytes, lines 6432-6550
6432 const timeDelimiter = format === "extended" ? ":" : ""; 6433 6434 // Representation is either 'date' or 'complete' 6435 if (representation !== "time") { 6436 const day = (0, _index.addLeadingZeros)(date_.getDate(), 2); 6437 const month = (0, _index.addLeadingZeros)(date_.getMonth() + 1, 2); 6438 const year = (0, _index.addLeadingZeros)(date_.getFullYear(), 4); 6439 6440 // yyyyMMdd or yyyy-MM-dd. 6441 result = `${year}${dateDelimiter}${month}${dateDelimiter}${day}`; 6442 } 6443 6444 // Representation is either 'time' or 'complete' 6445 if (representation !== "date") { 6446 // Add the timezone. 6447 const offset = date_.getTimezoneOffset(); 6448 6449 if (offset !== 0) { 6450 const absoluteOffset = Math.abs(offset); 6451 const hourOffset = (0, _index.addLeadingZeros)( 6452 Math.trunc(absoluteOffset / 60), 6453 2, 6454 ); 6455 const minuteOffset = (0, _index.addLeadingZeros)(absoluteOffset % 60, 2); 6456 // If less than 0, the sign is +, because it is ahead of time. 6457 const sign = offset < 0 ? "+" : "-"; 6458 6459 tzOffset = `${sign}${hourOffset}:${minuteOffset}`; 6460 } else { 6461 tzOffset = "Z"; 6462 } 6463 6464 const hour = (0, _index.addLeadingZeros)(date_.getHours(), 2); 6465 const minute = (0, _index.addLeadingZeros)(date_.getMinutes(), 2); 6466 const second = (0, _index.addLeadingZeros)(date_.getSeconds(), 2); 6467 6468 // If there's also date, separate it with time with 'T' 6469 const separator = result === "" ? "" : "T"; 6470 6471 // Creates a time string consisting of hour, minute, and second, separated by delimiters, if defined. 6472 const time = [hour, minute, second].join(timeDelimiter); 6473 6474 // HHmmss or HH:mm:ss. 6475 result = `${result}${separator}${time}${tzOffset}`; 6476 } 6477 6478 return result; 6479} 6480 6481 6482/***/ }), 6483 6484/***/ 235638: 6485/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6486 6487"use strict"; 6488 6489exports.formatISO9075 = formatISO9075; 6490var _index = __webpack_require__(616660); 6491var _index2 = __webpack_require__(533209); 6492var _index3 = __webpack_require__(807799); 6493 6494/** 6495 * The {@link formatISO9075} function options. 6496 */ 6497 6498/** 6499 * @name formatISO9075 6500 * @category Common Helpers 6501 * @summary Format the date according to the ISO 9075 standard (https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_get-format). 6502 * 6503 * @description 6504 * Return the formatted date string in ISO 9075 format. Options may be passed to control the parts and notations of the date. 6505 * 6506 * @param date - The original date 6507 * @param options - An object with options. 6508 * 6509 * @returns The formatted date string 6510 * 6511 * @throws `date` must not be Invalid Date 6512 * 6513 * @example 6514 * // Represent 18 September 2019 in ISO 9075 format: 6515 * const result = formatISO9075(new Date(2019, 8, 18, 19, 0, 52)) 6516 * //=> '2019-09-18 19:00:52' 6517 * 6518 * @example 6519 * // Represent 18 September 2019 in ISO 9075, short format: 6520 * const result = formatISO9075(new Date(2019, 8, 18, 19, 0, 52), { format: 'basic' }) 6521 * //=> '20190918 190052' 6522 * 6523 * @example 6524 * // Represent 18 September 2019 in ISO 9075 format, date only: 6525 * const result = formatISO9075(new Date(2019, 8, 18, 19, 0, 52), { representation: 'date' }) 6526 * //=> '2019-09-18' 6527 * 6528 * @example 6529 * // Represent 18 September 2019 in ISO 9075 format, time only: 6530 * const result = formatISO9075(new Date(2019, 8, 18, 19, 0, 52), { representation: 'time' }) 6531 * //=> '19:00:52' 6532 */ 6533function formatISO9075(date, options) { 6534 const date_ = (0, _index3.toDate)(date, options?.in); 6535 6536 if (!(0, _index2.isValid)(date_)) { 6537 throw new RangeError("Invalid time value"); 6538 } 6539 6540 const format = options?.format ?? "extended"; 6541 const representation = options?.representation ?? "complete"; 6542 6543 let result = ""; 6544 6545 const dateDelimiter = format === "extended" ? "-" : ""; 6546 const timeDelimiter = format === "extended" ? ":" : ""; 6547 6548 // Representation is either 'date' or 'complete' 6549 if (representation !== "time") { 6550 const day = (0, _index.addLeadingZeros)(date_.getDate(), 2);
6551 const month = (0, _index.addLeadingZeros)(date_.getMonth() + 1, 2); 6552 const year = (0, _index.addLeadingZeros)(date_.getFullYear(), 4); 6553 6554 // yyyyMMdd or yyyy-MM-dd. 6555 result = `${year}${dateDelimiter}${month}${dateDelimiter}${day}`; 6556 } 6557 6558 // Representation is either 'time' or 'complete' 6559 if (representation !== "date") { 6560 const hour = (0, _index.addLeadingZeros)(date_.getHours(), 2); 6561 const minute = (0, _index.addLeadingZeros)(date_.getMinutes(), 2); 6562 const second = (0, _index.addLeadingZeros)(date_.getSeconds(), 2); 6563 6564 // If there's also date, separate it with time with a space 6565 const separator = result === "" ? "" : " "; 6566 6567 // HHmmss or HH:mm:ss. 6568 result = `${result}${separator}${hour}${timeDelimiter}${minute}${timeDelimiter}${second}`; 6569 } 6570 6571 return result; 6572} 6573 6574 6575/***/ }), 6576 6577/***/ 756257: 6578/***/ (function(__unused_webpack_module, exports) { 6579 6580"use strict"; 6581 6582exports.formatISODuration = formatISODuration; 6583 6584/** 6585 * @name formatISODuration 6586 * @category Common Helpers 6587 * @summary Format a duration object according as ISO 8601 duration string 6588 * 6589 * @description 6590 * Format a duration object according to the ISO 8601 duration standard (https://www.digi.com/resources/documentation/digidocs//90001488-13/reference/r_iso_8601_duration_format.htm) 6591 * 6592 * @param duration - The duration to format 6593 * 6594 * @returns The ISO 8601 duration string 6595 * 6596 * @example 6597 * // Format the given duration as ISO 8601 string 6598 * const result = formatISODuration({ 6599 * years: 39, 6600 * months: 2, 6601 * days: 20, 6602 * hours: 7, 6603 * minutes: 5, 6604 * seconds: 0 6605 * }) 6606 * //=> 'P39Y2M20DT0H0M0S' 6607 */ 6608function formatISODuration(duration) { 6609 const { 6610 years = 0, 6611 months = 0, 6612 days = 0, 6613 hours = 0, 6614 minutes = 0, 6615 seconds = 0, 6616 } = duration; 6617 6618 return `P${years}Y${months}M${days}DT${hours}H${minutes}M${seconds}S`; 6619} 6620 6621 6622/***/ }), 6623 6624/***/ 362756: 6625/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6626 6627"use strict"; 6628 6629exports.formatRFC3339 = formatRFC3339; 6630var _index = __webpack_require__(616660); 6631var _index2 = __webpack_require__(533209); 6632var _index3 = __webpack_require__(807799); 6633 6634/** 6635 * The {@link formatRFC3339} function options. 6636 */ 6637 6638/** 6639 * @name formatRFC3339 6640 * @category Common Helpers 6641 * @summary Format the date according to the RFC 3339 standard (https://tools.ietf.org/html/rfc3339#section-5.6). 6642 * 6643 * @description 6644 * Return the formatted date string in RFC 3339 format. Options may be passed to control the parts and notations of the date. 6645 * 6646 * @param date - The original date 6647 * @param options - An object with options. 6648 * 6649 * @returns The formatted date string 6650 * 6651 * @throws `date` must not be Invalid Date 6652 * 6653 * @example 6654 * // Represent 18 September 2019 in RFC 3339 format: 6655 * formatRFC3339(new Date(2019, 8, 18, 19, 0, 52)) 6656 * //=> '2019-09-18T19:00:52Z' 6657 * 6658 * @example 6659 * // Represent 18 September 2019 in RFC 3339 format, 3 digits of second fraction 6660 * formatRFC3339(new Date(2019, 8, 18, 19, 0, 52, 234), { 6661 * fractionDigits: 3 6662 * }) 6663 * //=> '2019-09-18T19:00:52.234Z' 6664 */ 6665function formatRFC3339(date, options) { 6666 const date_ = (0, _index3.toDate)(date, options?.in); 6667 6668 if (!(0, _index2.isValid)(date_)) { 6669 throw new RangeError("Invalid time value"); 6670 } 6671 6672 const fractionDigits = options?.fractionDigits ?? 0; 6673 6674 const day = (0, _index.addLeadingZeros)(date_.getDate(), 2);
vendor: 37,854 bytes, lines 6675-8182
6675 const month = (0, _index.addLeadingZeros)(date_.getMonth() + 1, 2); 6676 const year = date_.getFullYear(); 6677 6678 const hour = (0, _index.addLeadingZeros)(date_.getHours(), 2); 6679 const minute = (0, _index.addLeadingZeros)(date_.getMinutes(), 2); 6680 const second = (0, _index.addLeadingZeros)(date_.getSeconds(), 2); 6681 6682 let fractionalSecond = ""; 6683 if (fractionDigits > 0) { 6684 const milliseconds = date_.getMilliseconds(); 6685 const fractionalSeconds = Math.trunc( 6686 milliseconds * Math.pow(10, fractionDigits - 3), 6687 ); 6688 fractionalSecond = 6689 "." + (0, _index.addLeadingZeros)(fractionalSeconds, fractionDigits); 6690 } 6691 6692 let offset = ""; 6693 const tzOffset = date_.getTimezoneOffset(); 6694 6695 if (tzOffset !== 0) { 6696 const absoluteOffset = Math.abs(tzOffset); 6697 const hourOffset = (0, _index.addLeadingZeros)( 6698 Math.trunc(absoluteOffset / 60), 6699 2, 6700 ); 6701 const minuteOffset = (0, _index.addLeadingZeros)(absoluteOffset % 60, 2); 6702 // If less than 0, the sign is +, because it is ahead of time. 6703 const sign = tzOffset < 0 ? "+" : "-"; 6704 6705 offset = `${sign}${hourOffset}:${minuteOffset}`; 6706 } else { 6707 offset = "Z"; 6708 } 6709 6710 return `${year}-${month}-${day}T${hour}:${minute}:${second}${fractionalSecond}${offset}`; 6711} 6712 6713 6714/***/ }), 6715 6716/***/ 399435: 6717/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6718 6719"use strict"; 6720 6721exports.formatRFC7231 = formatRFC7231; 6722var _index = __webpack_require__(616660); 6723var _index2 = __webpack_require__(533209); 6724var _index3 = __webpack_require__(807799); 6725 6726const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; 6727 6728const months = [ 6729 "Jan", 6730 "Feb", 6731 "Mar", 6732 "Apr", 6733 "May", 6734 "Jun", 6735 "Jul", 6736 "Aug", 6737 "Sep", 6738 "Oct", 6739 "Nov", 6740 "Dec", 6741]; 6742 6743/** 6744 * @name formatRFC7231 6745 * @category Common Helpers 6746 * @summary Format the date according to the RFC 7231 standard (https://tools.ietf.org/html/rfc7231#section-7.1.1.1). 6747 * 6748 * @description 6749 * Return the formatted date string in RFC 7231 format. 6750 * The result will always be in UTC timezone. 6751 * 6752 * @param date - The original date 6753 * 6754 * @returns The formatted date string 6755 * 6756 * @throws `date` must not be Invalid Date 6757 * 6758 * @example 6759 * // Represent 18 September 2019 in RFC 7231 format: 6760 * const result = formatRFC7231(new Date(2019, 8, 18, 19, 0, 52)) 6761 * //=> 'Wed, 18 Sep 2019 19:00:52 GMT' 6762 */ 6763function formatRFC7231(date) { 6764 const _date = (0, _index3.toDate)(date); 6765 6766 if (!(0, _index2.isValid)(_date)) { 6767 throw new RangeError("Invalid time value"); 6768 } 6769 6770 const dayName = days[_date.getUTCDay()]; 6771 const dayOfMonth = (0, _index.addLeadingZeros)(_date.getUTCDate(), 2); 6772 const monthName = months[_date.getUTCMonth()]; 6773 const year = _date.getUTCFullYear(); 6774 6775 const hour = (0, _index.addLeadingZeros)(_date.getUTCHours(), 2); 6776 const minute = (0, _index.addLeadingZeros)(_date.getUTCMinutes(), 2); 6777 const second = (0, _index.addLeadingZeros)(_date.getUTCSeconds(), 2); 6778 6779 // Result variables. 6780 return `${dayName}, ${dayOfMonth} ${monthName} ${year} ${hour}:${minute}:${second} GMT`; 6781} 6782 6783 6784/***/ }), 6785 6786/***/ 748369: 6787/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6788 6789"use strict"; 6790 6791exports.formatRelative = formatRelative; 6792var _index = __webpack_require__(65099); 6793var _index2 = __webpack_require__(983074); 6794var _index3 = __webpack_require__(947561); 6795var _index4 = __webpack_require__(72028); 6796var _index5 = __webpack_require__(797892); 6797 6798/** 6799 * The {@link formatRelative} function options. 6800 */ 6801 6802/** 6803 * @name formatRelative 6804 * @category Common Helpers 6805 * @summary Represent the date in words relative to the given base date. 6806 * 6807 * @description 6808 * Represent the date in words relative to the given base date. 6809 * 6810 * | Distance to the base date | Result | 6811 * |---------------------------|---------------------------| 6812 * | Previous 6 days | last Sunday at 04:30 AM | 6813 * | Last day | yesterday at 04:30 AM | 6814 * | Same day | today at 04:30 AM | 6815 * | Next day | tomorrow at 04:30 AM | 6816 * | Next 6 days | Sunday at 04:30 AM | 6817 * | Other | 12/31/2017 | 6818 * 6819 * @param date - The date to format 6820 * @param baseDate - The date to compare with 6821 * @param options - An object with options 6822 * 6823 * @returns The date in words 6824 * 6825 * @throws `date` must not be Invalid Date 6826 * @throws `baseDate` must not be Invalid Date 6827 * @throws `options.locale` must contain `localize` property 6828 * @throws `options.locale` must contain `formatLong` property 6829 * @throws `options.locale` must contain `formatRelative` property 6830 * 6831 * @example 6832 * // Represent the date of 6 days ago in words relative to the given base date. In this example, today is Wednesday 6833 * const result = formatRelative(subDays(new Date(), 6), new Date()) 6834 * //=> "last Thursday at 12:45 AM" 6835 */ 6836function formatRelative(date, baseDate, options) { 6837 const [date_, baseDate_] = (0, _index3.normalizeDates)( 6838 options?.in, 6839 date, 6840 baseDate, 6841 ); 6842 6843 const defaultOptions = (0, _index2.getDefaultOptions)(); 6844 const locale = 6845 options?.locale ?? defaultOptions.locale ?? _index.defaultLocale; 6846 const weekStartsOn = 6847 options?.weekStartsOn ?? 6848 options?.locale?.options?.weekStartsOn ?? 6849 defaultOptions.weekStartsOn ?? 6850 defaultOptions.locale?.options?.weekStartsOn ?? 6851 0; 6852 6853 const diff = (0, _index4.differenceInCalendarDays)(date_, baseDate_); 6854 6855 if (isNaN(diff)) { 6856 throw new RangeError("Invalid time value"); 6857 } 6858 6859 let token; 6860 if (diff < -6) { 6861 token = "other"; 6862 } else if (diff < -1) { 6863 token = "lastWeek"; 6864 } else if (diff < 0) { 6865 token = "yesterday"; 6866 } else if (diff < 1) { 6867 token = "today"; 6868 } else if (diff < 2) { 6869 token = "tomorrow"; 6870 } else if (diff < 7) { 6871 token = "nextWeek"; 6872 } else { 6873 token = "other"; 6874 } 6875 6876 const formatStr = locale.formatRelative(token, date_, baseDate_, { 6877 locale, 6878 weekStartsOn, 6879 }); 6880 return (0, _index5.format)(date_, formatStr, { locale, weekStartsOn }); 6881} 6882 6883 6884/***/ }), 6885 6886/***/ 795320: 6887/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6888 6889"use strict"; 6890 6891exports.fromUnixTime = fromUnixTime; 6892var _index = __webpack_require__(807799); 6893 6894/** 6895 * The {@link fromUnixTime} function options. 6896 */ 6897 6898/** 6899 * @name fromUnixTime 6900 * @category Timestamp Helpers 6901 * @summary Create a date from a Unix timestamp. 6902 * 6903 * @description 6904 * Create a date from a Unix timestamp (in seconds). Decimal values will be discarded. 6905 * 6906 * @param unixTime - The given Unix timestamp (in seconds) 6907 * @param options - An object with options. Allows to pass a context. 6908 * 6909 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 6910 * 6911 * @returns The date 6912 * 6913 * @example 6914 * // Create the date 29 February 2012 11:45:05: 6915 * const result = fromUnixTime(1330515905) 6916 * //=> Wed Feb 29 2012 11:45:05 6917 */ 6918function fromUnixTime(unixTime, options) { 6919 return (0, _index.toDate)(unixTime * 1000, options?.in); 6920} 6921 6922 6923/***/ }), 6924 6925/***/ 57593: 6926/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6927 6928"use strict"; 6929 6930exports.getDate = getDate; 6931var _index = __webpack_require__(807799); 6932 6933/** 6934 * The {@link getDate} function options. 6935 */ 6936 6937/** 6938 * @name getDate 6939 * @category Day Helpers 6940 * @summary Get the day of the month of the given date. 6941 * 6942 * @description 6943 * Get the day of the month of the given date. 6944 * 6945 * @param date - The given date 6946 * @param options - An object with options. 6947 * 6948 * @returns The day of month 6949 * 6950 * @example 6951 * // Which day of the month is 29 February 2012? 6952 * const result = getDate(new Date(2012, 1, 29)) 6953 * //=> 29 6954 */ 6955function getDate(date, options) { 6956 return (0, _index.toDate)(date, options?.in).getDate(); 6957} 6958 6959 6960/***/ }), 6961 6962/***/ 119142: 6963/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6964 6965"use strict"; 6966 6967exports.getDay = getDay; 6968var _index = __webpack_require__(807799); 6969 6970/** 6971 * The {@link getDay} function options. 6972 */ 6973 6974/** 6975 * @name getDay 6976 * @category Weekday Helpers 6977 * @summary Get the day of the week of the given date. 6978 * 6979 * @description 6980 * Get the day of the week of the given date. 6981 * 6982 * @param date - The given date 6983 * @param options - The options 6984 * 6985 * @returns The day of week, 0 represents Sunday 6986 * 6987 * @example 6988 * // Which day of the week is 29 February 2012? 6989 * const result = getDay(new Date(2012, 1, 29)) 6990 * //=> 3 6991 */ 6992function getDay(date, options) { 6993 return (0, _index.toDate)(date, options?.in).getDay(); 6994} 6995 6996 6997/***/ }), 6998 6999/***/ 824866: 7000/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7001 7002"use strict"; 7003 7004exports.getDayOfYear = getDayOfYear; 7005var _index = __webpack_require__(72028); 7006var _index2 = __webpack_require__(215913); 7007var _index3 = __webpack_require__(807799); 7008 7009/** 7010 * The {@link getDayOfYear} function options. 7011 */ 7012 7013/** 7014 * @name getDayOfYear 7015 * @category Day Helpers 7016 * @summary Get the day of the year of the given date. 7017 * 7018 * @description 7019 * Get the day of the year of the given date. 7020 * 7021 * @param date - The given date 7022 * @param options - The options 7023 * 7024 * @returns The day of year 7025 * 7026 * @example 7027 * // Which day of the year is 2 July 2014? 7028 * const result = getDayOfYear(new Date(2014, 6, 2)) 7029 * //=> 183 7030 */ 7031function getDayOfYear(date, options) { 7032 const _date = (0, _index3.toDate)(date, options?.in); 7033 const diff = (0, _index.differenceInCalendarDays)( 7034 _date, 7035 (0, _index2.startOfYear)(_date), 7036 ); 7037 const dayOfYear = diff + 1; 7038 return dayOfYear; 7039} 7040 7041 7042/***/ }), 7043 7044/***/ 942703: 7045/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7046 7047"use strict"; 7048 7049exports.getDaysInMonth = getDaysInMonth; 7050var _index = __webpack_require__(658612); 7051var _index2 = __webpack_require__(807799); 7052 7053/** 7054 * The {@link getDaysInMonth} function options. 7055 */ 7056 7057/** 7058 * @name getDaysInMonth 7059 * @category Month Helpers 7060 * @summary Get the number of days in a month of the given date. 7061 * 7062 * @description 7063 * Get the number of days in a month of the given date, considering the context if provided. 7064 * 7065 * @param date - The given date 7066 * @param options - An object with options 7067 * 7068 * @returns The number of days in a month 7069 * 7070 * @example 7071 * // How many days are in February 2000? 7072 * const result = getDaysInMonth(new Date(2000, 1)) 7073 * //=> 29 7074 */ 7075function getDaysInMonth(date, options) { 7076 const _date = (0, _index2.toDate)(date, options?.in); 7077 const year = _date.getFullYear(); 7078 const monthIndex = _date.getMonth(); 7079 const lastDayOfMonth = (0, _index.constructFrom)(_date, 0); 7080 lastDayOfMonth.setFullYear(year, monthIndex + 1, 0); 7081 lastDayOfMonth.setHours(0, 0, 0, 0); 7082 return lastDayOfMonth.getDate(); 7083} 7084 7085 7086/***/ }), 7087 7088/***/ 922343: 7089/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7090 7091"use strict"; 7092 7093exports.getDaysInYear = getDaysInYear; 7094var _index = __webpack_require__(450519); 7095var _index2 = __webpack_require__(807799); 7096 7097/** 7098 * The {@link getDaysInYear} function options. 7099 */ 7100 7101/** 7102 * @name getDaysInYear 7103 * @category Year Helpers 7104 * @summary Get the number of days in a year of the given date. 7105 * 7106 * @description 7107 * Get the number of days in a year of the given date. 7108 * 7109 * @param date - The given date 7110 * @param options - An object with options 7111 * 7112 * @returns The number of days in a year 7113 * 7114 * @example 7115 * // How many days are in 2012? 7116 * const result = getDaysInYear(new Date(2012, 0, 1)) 7117 * //=> 366 7118 */ 7119function getDaysInYear(date, options) { 7120 const _date = (0, _index2.toDate)(date, options?.in); 7121 if (Number.isNaN(+_date)) return NaN; 7122 return (0, _index.isLeapYear)(_date) ? 366 : 365; 7123} 7124 7125 7126/***/ }), 7127 7128/***/ 851276: 7129/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7130 7131"use strict"; 7132 7133exports.getDecade = getDecade; 7134var _index = __webpack_require__(807799); 7135 7136/** 7137 * The {@link getDecade} function options. 7138 */ 7139 7140/** 7141 * @name getDecade 7142 * @category Decade Helpers 7143 * @summary Get the decade of the given date. 7144 * 7145 * @description 7146 * Get the decade of the given date. 7147 * 7148 * @param date - The given date 7149 * @param options - An object with options 7150 * 7151 * @returns The year of decade 7152 * 7153 * @example 7154 * // Which decade belongs 27 November 1942? 7155 * const result = getDecade(new Date(1942, 10, 27)) 7156 * //=> 1940 7157 */ 7158function getDecade(date, options) { 7159 // TODO: Switch to more technical definition in of decades that start with 1 7160 // end with 0. I.e. 2001-2010 instead of current 2000-2009. It's a breaking 7161 // change, so it can only be done in 4.0. 7162 const _date = (0, _index.toDate)(date, options?.in); 7163 const year = _date.getFullYear(); 7164 const decade = Math.floor(year / 10) * 10; 7165 return decade; 7166} 7167 7168 7169/***/ }), 7170 7171/***/ 637213: 7172/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7173 7174"use strict"; 7175 7176exports.getDefaultOptions = getDefaultOptions; 7177 7178var _index = __webpack_require__(983074); 7179 7180/** 7181 * @name getDefaultOptions 7182 * @category Common Helpers 7183 * @summary Get default options. 7184 * @pure false 7185 * 7186 * @description 7187 * Returns an object that contains defaults for 7188 * `options.locale`, `options.weekStartsOn` and `options.firstWeekContainsDate` 7189 * arguments for all functions. 7190 * 7191 * You can change these with [setDefaultOptions](https://date-fns.org/docs/setDefaultOptions). 7192 * 7193 * @returns The default options 7194 * 7195 * @example 7196 * const result = getDefaultOptions() 7197 * //=> {} 7198 * 7199 * @example 7200 * setDefaultOptions({ weekStarsOn: 1, firstWeekContainsDate: 4 }) 7201 * const result = getDefaultOptions() 7202 * //=> { weekStarsOn: 1, firstWeekContainsDate: 4 } 7203 */ 7204function getDefaultOptions() { 7205 return Object.assign({}, (0, _index.getDefaultOptions)()); 7206} 7207 7208 7209/***/ }), 7210 7211/***/ 269546: 7212/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7213 7214"use strict"; 7215 7216exports.getHours = getHours; 7217var _index = __webpack_require__(807799); 7218 7219/** 7220 * The {@link getHours} function options. 7221 */ 7222 7223/** 7224 * @name getHours 7225 * @category Hour Helpers 7226 * @summary Get the hours of the given date. 7227 * 7228 * @description 7229 * Get the hours of the given date. 7230 * 7231 * @param date - The given date 7232 * @param options - An object with options 7233 * 7234 * @returns The hours 7235 * 7236 * @example 7237 * // Get the hours of 29 February 2012 11:45:00: 7238 * const result = getHours(new Date(2012, 1, 29, 11, 45)) 7239 * //=> 11 7240 */ 7241function getHours(date, options) { 7242 return (0, _index.toDate)(date, options?.in).getHours(); 7243} 7244 7245 7246/***/ }), 7247 7248/***/ 628209: 7249/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7250 7251"use strict"; 7252 7253exports.getISODay = getISODay; 7254var _index = __webpack_require__(807799); 7255 7256/** 7257 * The {@link getISODay} function options. 7258 */ 7259 7260/** 7261 * @name getISODay 7262 * @category Weekday Helpers 7263 * @summary Get the day of the ISO week of the given date. 7264 * 7265 * @description 7266 * Get the day of the ISO week of the given date, 7267 * which is 7 for Sunday, 1 for Monday etc. 7268 * 7269 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 7270 * 7271 * @param date - The given date 7272 * @param options - An object with options 7273 * 7274 * @returns The day of ISO week 7275 * 7276 * @example 7277 * // Which day of the ISO week is 26 February 2012? 7278 * const result = getISODay(new Date(2012, 1, 26)) 7279 * //=> 7 7280 */ 7281function getISODay(date, options) { 7282 const day = (0, _index.toDate)(date, options?.in).getDay(); 7283 return day === 0 ? 7 : day; 7284} 7285 7286 7287/***/ }), 7288 7289/***/ 125691: 7290/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7291 7292"use strict"; 7293 7294exports.getISOWeek = getISOWeek; 7295var _index = __webpack_require__(241836); 7296var _index2 = __webpack_require__(266795); 7297var _index3 = __webpack_require__(116666); 7298var _index4 = __webpack_require__(807799); 7299 7300/** 7301 * The {@link getISOWeek} function options. 7302 */ 7303 7304/** 7305 * @name getISOWeek 7306 * @category ISO Week Helpers 7307 * @summary Get the ISO week of the given date. 7308 * 7309 * @description 7310 * Get the ISO week of the given date. 7311 * 7312 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 7313 * 7314 * @param date - The given date 7315 * @param options - The options 7316 * 7317 * @returns The ISO week 7318 * 7319 * @example 7320 * // Which week of the ISO-week numbering year is 2 January 2005? 7321 * const result = getISOWeek(new Date(2005, 0, 2)) 7322 * //=> 53 7323 */ 7324function getISOWeek(date, options) { 7325 const _date = (0, _index4.toDate)(date, options?.in); 7326 const diff = 7327 +(0, _index2.startOfISOWeek)(_date) - 7328 +(0, _index3.startOfISOWeekYear)(_date); 7329 7330 // Round the number of weeks to the nearest integer because the number of 7331 // milliseconds in a week is not constant (e.g. it's different in the week of 7332 // the daylight saving time clock shift). 7333 return Math.round(diff / _index.millisecondsInWeek) + 1; 7334} 7335 7336 7337/***/ }), 7338 7339/***/ 196914: 7340/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7341 7342"use strict"; 7343 7344exports.getISOWeekYear = getISOWeekYear; 7345var _index = __webpack_require__(658612); 7346var _index2 = __webpack_require__(266795); 7347var _index3 = __webpack_require__(807799); 7348 7349/** 7350 * The {@link getISOWeekYear} function options. 7351 */ 7352 7353/** 7354 * @name getISOWeekYear 7355 * @category ISO Week-Numbering Year Helpers 7356 * @summary Get the ISO week-numbering year of the given date. 7357 * 7358 * @description 7359 * Get the ISO week-numbering year of the given date, 7360 * which always starts 3 days before the year's first Thursday. 7361 * 7362 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 7363 * 7364 * @param date - The given date 7365 * 7366 * @returns The ISO week-numbering year 7367 * 7368 * @example 7369 * // Which ISO-week numbering year is 2 January 2005? 7370 * const result = getISOWeekYear(new Date(2005, 0, 2)) 7371 * //=> 2004 7372 */ 7373function getISOWeekYear(date, options) { 7374 const _date = (0, _index3.toDate)(date, options?.in); 7375 const year = _date.getFullYear(); 7376 7377 const fourthOfJanuaryOfNextYear = (0, _index.constructFrom)(_date, 0); 7378 fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4); 7379 fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0); 7380 const startOfNextYear = (0, _index2.startOfISOWeek)( 7381 fourthOfJanuaryOfNextYear, 7382 ); 7383 7384 const fourthOfJanuaryOfThisYear = (0, _index.constructFrom)(_date, 0); 7385 fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4); 7386 fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0); 7387 const startOfThisYear = (0, _index2.startOfISOWeek)( 7388 fourthOfJanuaryOfThisYear, 7389 ); 7390 7391 if (_date.getTime() >= startOfNextYear.getTime()) { 7392 return year + 1; 7393 } else if (_date.getTime() >= startOfThisYear.getTime()) { 7394 return year; 7395 } else { 7396 return year - 1; 7397 } 7398} 7399 7400 7401/***/ }), 7402 7403/***/ 86239: 7404/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7405 7406"use strict"; 7407 7408exports.getISOWeeksInYear = getISOWeeksInYear; 7409var _index = __webpack_require__(59786); 7410var _index2 = __webpack_require__(241836); 7411var _index3 = __webpack_require__(116666); 7412 7413/** 7414 * The {@link getISOWeeksInYear} function options. 7415 */ 7416 7417/** 7418 * @name getISOWeeksInYear 7419 * @category ISO Week-Numbering Year Helpers 7420 * @summary Get the number of weeks in an ISO week-numbering year of the given date. 7421 * 7422 * @description 7423 * Get the number of weeks in an ISO week-numbering year of the given date. 7424 * 7425 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 7426 * 7427 * @param date - The given date 7428 * @param options - An object with options 7429 * 7430 * @returns The number of ISO weeks in a year 7431 * 7432 * @example 7433 * // How many weeks are in ISO week-numbering year 2015? 7434 * const result = getISOWeeksInYear(new Date(2015, 1, 11)) 7435 * //=> 53 7436 */ 7437function getISOWeeksInYear(date, options) { 7438 const thisYear = (0, _index3.startOfISOWeekYear)(date, options); 7439 const nextYear = (0, _index3.startOfISOWeekYear)( 7440 (0, _index.addWeeks)(thisYear, 60), 7441 ); 7442 const diff = +nextYear - +thisYear; 7443 7444 // Round the number of weeks to the nearest integer because the number of 7445 // milliseconds in a week is not constant (e.g. it's different in the week of 7446 // the daylight saving time clock shift). 7447 return Math.round(diff / _index2.millisecondsInWeek); 7448} 7449 7450 7451/***/ }), 7452 7453/***/ 439150: 7454/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7455 7456"use strict"; 7457 7458exports.getMilliseconds = getMilliseconds; 7459var _index = __webpack_require__(807799); 7460 7461/** 7462 * @name getMilliseconds 7463 * @category Millisecond Helpers 7464 * @summary Get the milliseconds of the given date. 7465 * 7466 * @description 7467 * Get the milliseconds of the given date. 7468 * 7469 * @param date - The given date 7470 * 7471 * @returns The milliseconds 7472 * 7473 * @example 7474 * // Get the milliseconds of 29 February 2012 11:45:05.123: 7475 * const result = getMilliseconds(new Date(2012, 1, 29, 11, 45, 5, 123)) 7476 * //=> 123 7477 */ 7478function getMilliseconds(date) { 7479 return (0, _index.toDate)(date).getMilliseconds(); 7480} 7481 7482 7483/***/ }), 7484 7485/***/ 129729: 7486/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7487 7488"use strict"; 7489 7490exports.getMinutes = getMinutes; 7491var _index = __webpack_require__(807799); 7492 7493/** 7494 * The {@link getMinutes} function options. 7495 */ 7496 7497/** 7498 * @name getMinutes 7499 * @category Minute Helpers 7500 * @summary Get the minutes of the given date. 7501 * 7502 * @description 7503 * Get the minutes of the given date. 7504 * 7505 * @param date - The given date 7506 * @param options - The options 7507 * 7508 * @returns The minutes 7509 * 7510 * @example 7511 * // Get the minutes of 29 February 2012 11:45:05: 7512 * const result = getMinutes(new Date(2012, 1, 29, 11, 45, 5)) 7513 * //=> 45 7514 */ 7515function getMinutes(date, options) { 7516 return (0, _index.toDate)(date, options?.in).getMinutes(); 7517} 7518 7519 7520/***/ }), 7521 7522/***/ 544536: 7523/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7524 7525"use strict"; 7526 7527exports.getMonth = getMonth; 7528var _index = __webpack_require__(807799); 7529 7530/** 7531 * The {@link getMonth} function options. 7532 */ 7533 7534/** 7535 * @name getMonth 7536 * @category Month Helpers 7537 * @summary Get the month of the given date. 7538 * 7539 * @description 7540 * Get the month of the given date. 7541 * 7542 * @param date - The given date 7543 * @param options - An object with options 7544 * 7545 * @returns The month index (0-11) 7546 * 7547 * @example 7548 * // Which month is 29 February 2012? 7549 * const result = getMonth(new Date(2012, 1, 29)) 7550 * //=> 1 7551 */ 7552function getMonth(date, options) { 7553 return (0, _index.toDate)(date, options?.in).getMonth(); 7554} 7555 7556 7557/***/ }), 7558 7559/***/ 308615: 7560/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7561 7562"use strict"; 7563 7564exports.getOverlappingDaysInIntervals = getOverlappingDaysInIntervals; 7565var _index = __webpack_require__(158228); 7566var _index2 = __webpack_require__(241836); 7567var _index3 = __webpack_require__(807799); 7568 7569/** 7570 * @name getOverlappingDaysInIntervals 7571 * @category Interval Helpers 7572 * @summary Get the number of days that overlap in two time intervals 7573 * 7574 * @description 7575 * Get the number of days that overlap in two time intervals. It uses the time 7576 * between dates to calculate the number of days, rounding it up to include 7577 * partial days. 7578 * 7579 * Two equal 0-length intervals will result in 0. Two equal 1ms intervals will 7580 * result in 1. 7581 * 7582 * @param intervalLeft - The first interval to compare. 7583 * @param intervalRight - The second interval to compare. 7584 * @param options - An object with options 7585 * 7586 * @returns The number of days that overlap in two time intervals 7587 * 7588 * @example 7589 * // For overlapping time intervals adds 1 for each started overlapping day: 7590 * getOverlappingDaysInIntervals( 7591 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 7592 * { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) } 7593 * ) 7594 * //=> 3 7595 * 7596 * @example 7597 * // For non-overlapping time intervals returns 0: 7598 * getOverlappingDaysInIntervals( 7599 * { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }, 7600 * { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) } 7601 * ) 7602 * //=> 0 7603 */ 7604 7605function getOverlappingDaysInIntervals(intervalLeft, intervalRight) { 7606 const [leftStart, leftEnd] = [ 7607 +(0, _index3.toDate)(intervalLeft.start), 7608 +(0, _index3.toDate)(intervalLeft.end), 7609 ].sort((a, b) => a - b); 7610 const [rightStart, rightEnd] = [ 7611 +(0, _index3.toDate)(intervalRight.start), 7612 +(0, _index3.toDate)(intervalRight.end), 7613 ].sort((a, b) => a - b); 7614 7615 // Prevent NaN result if intervals don't overlap at all. 7616 const isOverlapping = leftStart < rightEnd && rightStart < leftEnd; 7617 if (!isOverlapping) return 0; 7618 7619 // Remove the timezone offset to negate the DST effect on calculations. 7620 const overlapLeft = rightStart < leftStart ? leftStart : rightStart; 7621 const left = 7622 overlapLeft - (0, _index.getTimezoneOffsetInMilliseconds)(overlapLeft); 7623 const overlapRight = rightEnd > leftEnd ? leftEnd : rightEnd; 7624 const right = 7625 overlapRight - (0, _index.getTimezoneOffsetInMilliseconds)(overlapRight); 7626 7627 // Ceil the number to include partial days too. 7628 return Math.ceil((right - left) / _index2.millisecondsInDay); 7629} 7630 7631 7632/***/ }), 7633 7634/***/ 69662: 7635/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7636 7637"use strict"; 7638 7639exports.getQuarter = getQuarter; 7640var _index = __webpack_require__(807799); 7641 7642/** 7643 * The {@link getQuarter} function options. 7644 */ 7645 7646/** 7647 * @name getQuarter 7648 * @category Quarter Helpers 7649 * @summary Get the year quarter of the given date. 7650 * 7651 * @description 7652 * Get the year quarter of the given date. 7653 * 7654 * @param date - The given date 7655 * @param options - An object with options 7656 * 7657 * @returns The quarter 7658 * 7659 * @example 7660 * // Which quarter is 2 July 2014? 7661 * const result = getQuarter(new Date(2014, 6, 2)); 7662 * //=> 3 7663 */ 7664function getQuarter(date, options) { 7665 const _date = (0, _index.toDate)(date, options?.in); 7666 const quarter = Math.trunc(_date.getMonth() / 3) + 1; 7667 return quarter; 7668} 7669 7670 7671/***/ }), 7672 7673/***/ 830031: 7674/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7675 7676"use strict"; 7677 7678exports.getSeconds = getSeconds; 7679var _index = __webpack_require__(807799); 7680 7681/** 7682 * @name getSeconds 7683 * @category Second Helpers 7684 * @summary Get the seconds of the given date. 7685 * 7686 * @description 7687 * Get the seconds of the given date. 7688 * 7689 * @param date - The given date 7690 * 7691 * @returns The seconds 7692 * 7693 * @example 7694 * // Get the seconds of 29 February 2012 11:45:05.123: 7695 * const result = getSeconds(new Date(2012, 1, 29, 11, 45, 5, 123)) 7696 * //=> 5 7697 */ 7698function getSeconds(date) { 7699 return (0, _index.toDate)(date).getSeconds(); 7700} 7701 7702 7703/***/ }), 7704 7705/***/ 486793: 7706/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7707 7708"use strict"; 7709 7710exports.getTime = getTime; 7711var _index = __webpack_require__(807799); 7712 7713/** 7714 * @name getTime 7715 * @category Timestamp Helpers 7716 * @summary Get the milliseconds timestamp of the given date. 7717 * 7718 * @description 7719 * Get the milliseconds timestamp of the given date. 7720 * 7721 * @param date - The given date 7722 * 7723 * @returns The timestamp 7724 * 7725 * @example 7726 * // Get the timestamp of 29 February 2012 11:45:05.123: 7727 * const result = getTime(new Date(2012, 1, 29, 11, 45, 5, 123)) 7728 * //=> 1330515905123 7729 */ 7730function getTime(date) { 7731 return +(0, _index.toDate)(date); 7732} 7733 7734 7735/***/ }), 7736 7737/***/ 604590: 7738/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7739 7740"use strict"; 7741 7742exports.getUnixTime = getUnixTime; 7743var _index = __webpack_require__(807799); 7744 7745/** 7746 * @name getUnixTime 7747 * @category Timestamp Helpers 7748 * @summary Get the seconds timestamp of the given date. 7749 * 7750 * @description 7751 * Get the seconds timestamp of the given date. 7752 * 7753 * @param date - The given date 7754 * 7755 * @returns The timestamp 7756 * 7757 * @example 7758 * // Get the timestamp of 29 February 2012 11:45:05 CET: 7759 * const result = getUnixTime(new Date(2012, 1, 29, 11, 45, 5)) 7760 * //=> 1330512305 7761 */ 7762function getUnixTime(date) { 7763 return Math.trunc(+(0, _index.toDate)(date) / 1000); 7764} 7765 7766 7767/***/ }), 7768 7769/***/ 461625: 7770/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7771 7772"use strict"; 7773 7774exports.getWeek = getWeek; 7775var _index = __webpack_require__(241836); 7776var _index2 = __webpack_require__(517805); 7777var _index3 = __webpack_require__(264616); 7778var _index4 = __webpack_require__(807799); 7779 7780/** 7781 * The {@link getWeek} function options. 7782 */ 7783 7784/** 7785 * @name getWeek 7786 * @category Week Helpers 7787 * @summary Get the local week index of the given date. 7788 * 7789 * @description 7790 * Get the local week index of the given date. 7791 * The exact calculation depends on the values of 7792 * `options.weekStartsOn` (which is the index of the first day of the week) 7793 * and `options.firstWeekContainsDate` (which is the day of January, which is always in 7794 * the first week of the week-numbering year) 7795 * 7796 * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system 7797 * 7798 * @param date - The given date 7799 * @param options - An object with options 7800 * 7801 * @returns The week 7802 * 7803 * @example 7804 * // Which week of the local week numbering year is 2 January 2005 with default options? 7805 * const result = getWeek(new Date(2005, 0, 2)) 7806 * //=> 2 7807 * 7808 * @example 7809 * // Which week of the local week numbering year is 2 January 2005, 7810 * // if Monday is the first day of the week, 7811 * // and the first week of the year always contains 4 January? 7812 * const result = getWeek(new Date(2005, 0, 2), { 7813 * weekStartsOn: 1, 7814 * firstWeekContainsDate: 4 7815 * }) 7816 * //=> 53 7817 */ 7818function getWeek(date, options) { 7819 const _date = (0, _index4.toDate)(date, options?.in); 7820 const diff = 7821 +(0, _index2.startOfWeek)(_date, options) - 7822 +(0, _index3.startOfWeekYear)(_date, options); 7823 7824 // Round the number of weeks to the nearest integer because the number of 7825 // milliseconds in a week is not constant (e.g. it's different in the week of 7826 // the daylight saving time clock shift). 7827 return Math.round(diff / _index.millisecondsInWeek) + 1; 7828} 7829 7830 7831/***/ }), 7832 7833/***/ 866247: 7834/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7835 7836"use strict"; 7837 7838exports.getWeekOfMonth = getWeekOfMonth; 7839var _index = __webpack_require__(983074); 7840var _index2 = __webpack_require__(57593); 7841var _index3 = __webpack_require__(119142); 7842var _index4 = __webpack_require__(185557); 7843var _index5 = __webpack_require__(807799); 7844 7845/** 7846 * The {@link getWeekOfMonth} function options. 7847 */ 7848 7849/** 7850 * @name getWeekOfMonth 7851 * @category Week Helpers 7852 * @summary Get the week of the month of the given date. 7853 * 7854 * @description 7855 * Get the week of the month of the given date. 7856 * 7857 * @param date - The given date 7858 * @param options - An object with options. 7859 * 7860 * @returns The week of month 7861 * 7862 * @example 7863 * // Which week of the month is 9 November 2017? 7864 * const result = getWeekOfMonth(new Date(2017, 10, 9)) 7865 * //=> 2 7866 */ 7867function getWeekOfMonth(date, options) { 7868 const defaultOptions = (0, _index.getDefaultOptions)(); 7869 const weekStartsOn = 7870 options?.weekStartsOn ?? 7871 options?.locale?.options?.weekStartsOn ?? 7872 defaultOptions.weekStartsOn ?? 7873 defaultOptions.locale?.options?.weekStartsOn ?? 7874 0; 7875 7876 const currentDayOfMonth = (0, _index2.getDate)( 7877 (0, _index5.toDate)(date, options?.in), 7878 ); 7879 if (isNaN(currentDayOfMonth)) return NaN; 7880 7881 const startWeekDay = (0, _index3.getDay)( 7882 (0, _index4.startOfMonth)(date, options), 7883 ); 7884 7885 let lastDayOfFirstWeek = weekStartsOn - startWeekDay; 7886 if (lastDayOfFirstWeek <= 0) lastDayOfFirstWeek += 7; 7887 7888 const remainingDaysAfterFirstWeek = currentDayOfMonth - lastDayOfFirstWeek; 7889 return Math.ceil(remainingDaysAfterFirstWeek / 7) + 1; 7890} 7891 7892 7893/***/ }), 7894 7895/***/ 23928: 7896/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7897 7898"use strict"; 7899 7900exports.getWeekYear = getWeekYear; 7901var _index = __webpack_require__(983074); 7902var _index2 = __webpack_require__(658612); 7903var _index3 = __webpack_require__(517805); 7904var _index4 = __webpack_require__(807799); 7905 7906/** 7907 * The {@link getWeekYear} function options. 7908 */ 7909 7910/** 7911 * @name getWeekYear 7912 * @category Week-Numbering Year Helpers 7913 * @summary Get the local week-numbering year of the given date. 7914 * 7915 * @description 7916 * Get the local week-numbering year of the given date. 7917 * The exact calculation depends on the values of 7918 * `options.weekStartsOn` (which is the index of the first day of the week) 7919 * and `options.firstWeekContainsDate` (which is the day of January, which is always in 7920 * the first week of the week-numbering year) 7921 * 7922 * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system 7923 * 7924 * @param date - The given date 7925 * @param options - An object with options. 7926 * 7927 * @returns The local week-numbering year 7928 * 7929 * @example 7930 * // Which week numbering year is 26 December 2004 with the default settings? 7931 * const result = getWeekYear(new Date(2004, 11, 26)) 7932 * //=> 2005 7933 * 7934 * @example 7935 * // Which week numbering year is 26 December 2004 if week starts on Saturday? 7936 * const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 }) 7937 * //=> 2004 7938 * 7939 * @example 7940 * // Which week numbering year is 26 December 2004 if the first week contains 4 January? 7941 * const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 }) 7942 * //=> 2004 7943 */ 7944function getWeekYear(date, options) { 7945 const _date = (0, _index4.toDate)(date, options?.in); 7946 const year = _date.getFullYear(); 7947 7948 const defaultOptions = (0, _index.getDefaultOptions)(); 7949 const firstWeekContainsDate = 7950 options?.firstWeekContainsDate ?? 7951 options?.locale?.options?.firstWeekContainsDate ?? 7952 defaultOptions.firstWeekContainsDate ?? 7953 defaultOptions.locale?.options?.firstWeekContainsDate ?? 7954 1; 7955 7956 const firstWeekOfNextYear = (0, _index2.constructFrom)( 7957 options?.in || date, 7958 0, 7959 ); 7960 firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate); 7961 firstWeekOfNextYear.setHours(0, 0, 0, 0); 7962 const startOfNextYear = (0, _index3.startOfWeek)( 7963 firstWeekOfNextYear, 7964 options, 7965 ); 7966 7967 const firstWeekOfThisYear = (0, _index2.constructFrom)( 7968 options?.in || date, 7969 0, 7970 ); 7971 firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate); 7972 firstWeekOfThisYear.setHours(0, 0, 0, 0); 7973 const startOfThisYear = (0, _index3.startOfWeek)( 7974 firstWeekOfThisYear, 7975 options, 7976 ); 7977 7978 if (+_date >= +startOfNextYear) { 7979 return year + 1; 7980 } else if (+_date >= +startOfThisYear) { 7981 return year; 7982 } else { 7983 return year - 1; 7984 } 7985} 7986 7987 7988/***/ }), 7989 7990/***/ 530173: 7991/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 7992 7993"use strict"; 7994 7995exports.getWeeksInMonth = getWeeksInMonth; 7996var _index = __webpack_require__(124071); 7997var _index2 = __webpack_require__(251596); 7998var _index3 = __webpack_require__(185557); 7999var _index4 = __webpack_require__(807799); 8000 8001/** 8002 * The {@link getWeeksInMonth} function options. 8003 */ 8004 8005/** 8006 * @name getWeeksInMonth 8007 * @category Week Helpers 8008 * @summary Get the number of calendar weeks a month spans. 8009 * 8010 * @description 8011 * Get the number of calendar weeks the month in the given date spans. 8012 * 8013 * @param date - The given date 8014 * @param options - An object with options. 8015 * 8016 * @returns The number of calendar weeks 8017 * 8018 * @example 8019 * // How many calendar weeks does February 2015 span? 8020 * const result = getWeeksInMonth(new Date(2015, 1, 8)) 8021 * //=> 4 8022 * 8023 * @example 8024 * // If the week starts on Monday, 8025 * // how many calendar weeks does July 2017 span? 8026 * const result = getWeeksInMonth(new Date(2017, 6, 5), { weekStartsOn: 1 }) 8027 * //=> 6 8028 */ 8029function getWeeksInMonth(date, options) { 8030 const contextDate = (0, _index4.toDate)(date, options?.in); 8031 return ( 8032 (0, _index.differenceInCalendarWeeks)( 8033 (0, _index2.lastDayOfMonth)(contextDate, options), 8034 (0, _index3.startOfMonth)(contextDate, options), 8035 options, 8036 ) + 1 8037 ); 8038} 8039 8040 8041/***/ }), 8042 8043/***/ 465769: 8044/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 8045 8046"use strict"; 8047 8048exports.getYear = getYear; 8049var _index = __webpack_require__(807799); 8050 8051/** 8052 * The {@link getYear} function options. 8053 */ 8054 8055/** 8056 * @name getYear 8057 * @category Year Helpers 8058 * @summary Get the year of the given date. 8059 * 8060 * @description 8061 * Get the year of the given date. 8062 * 8063 * @param date - The given date 8064 * @param options - An object with options 8065 * 8066 * @returns The year 8067 * 8068 * @example 8069 * // Which year is 2 July 2014? 8070 * const result = getYear(new Date(2014, 6, 2)) 8071 * //=> 2014 8072 */ 8073function getYear(date, options) { 8074 return (0, _index.toDate)(date, options?.in).getFullYear(); 8075} 8076 8077 8078/***/ }), 8079 8080/***/ 637459: 8081/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 8082 8083"use strict"; 8084 8085exports.hoursToMilliseconds = hoursToMilliseconds; 8086var _index = __webpack_require__(241836); 8087 8088/** 8089 * @name hoursToMilliseconds 8090 * @category Conversion Helpers 8091 * @summary Convert hours to milliseconds. 8092 * 8093 * @description 8094 * Convert a number of hours to a full number of milliseconds. 8095 * 8096 * @param hours - number of hours to be converted 8097 * 8098 * @returns The number of hours converted to milliseconds 8099 * 8100 * @example 8101 * // Convert 2 hours to milliseconds: 8102 * const result = hoursToMilliseconds(2) 8103 * //=> 7200000 8104 */ 8105function hoursToMilliseconds(hours) { 8106 return Math.trunc(hours * _index.millisecondsInHour); 8107} 8108 8109 8110/***/ }), 8111 8112/***/ 519480: 8113/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 8114 8115"use strict"; 8116 8117exports.hoursToMinutes = hoursToMinutes; 8118var _index = __webpack_require__(241836); 8119 8120/** 8121 * @name hoursToMinutes 8122 * @category Conversion Helpers 8123 * @summary Convert hours to minutes. 8124 * 8125 * @description 8126 * Convert a number of hours to a full number of minutes. 8127 * 8128 * @param hours - number of hours to be converted 8129 * 8130 * @returns The number of hours converted in minutes 8131 * 8132 * @example 8133 * // Convert 2 hours to minutes: 8134 * const result = hoursToMinutes(2) 8135 * //=> 120 8136 */ 8137function hoursToMinutes(hours) { 8138 return Math.trunc(hours * _index.minutesInHour); 8139} 8140 8141 8142/***/ }), 8143 8144/***/ 610881: 8145/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 8146 8147"use strict"; 8148 8149exports.hoursToSeconds = hoursToSeconds; 8150var _index = __webpack_require__(241836); 8151 8152/** 8153 * @name hoursToSeconds 8154 * @category Conversion Helpers 8155 * @summary Convert hours to seconds. 8156 * 8157 * @description 8158 * Convert a number of hours to a full number of seconds. 8159 * 8160 * @param hours - The number of hours to be converted 8161 * 8162 * @returns The number of hours converted in seconds 8163 * 8164 * @example 8165 * // Convert 2 hours to seconds: 8166 * const result = hoursToSeconds(2) 8167 * //=> 7200 8168 */ 8169function hoursToSeconds(hours) { 8170 return Math.trunc(hours * _index.secondsInHour); 8171} 8172 8173 8174/***/ }), 8175 8176/***/ 94886: 8177/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 8178 8179"use strict"; 8180 8181 8182var _index = __webpack_require__(789198);
8183Object.keys(_index).forEach(function (key) { 8184 if (key === "default" || key === "__esModule") return; 8185 if (key in exports && exports[key] === _index[key]) return; 8186 Object.defineProperty(exports, key, { 8187 enumerable: true, 8188 get: function () { 8189 return _index[key]; 8190 }, 8191 }); 8192}); 8193var _index2 = __webpack_require__(835168); 8194Object.keys(_index2).forEach(function (key) { 8195 if (key === "default" || key === "__esModule") return; 8196 if (key in exports && exports[key] === _index2[key]) return; 8197 Object.defineProperty(exports, key, { 8198 enumerable: true, 8199 get: function () { 8200 return _index2[key]; 8201 }, 8202 }); 8203}); 8204var _index3 = __webpack_require__(519746); 8205Object.keys(_index3).forEach(function (key) { 8206 if (key === "default" || key === "__esModule") return; 8207 if (key in exports && exports[key] === _index3[key]) return; 8208 Object.defineProperty(exports, key, { 8209 enumerable: true, 8210 get: function () { 8211 return _index3[key]; 8212 }, 8213 }); 8214}); 8215var _index4 = __webpack_require__(935734); 8216Object.keys(_index4).forEach(function (key) { 8217 if (key === "default" || key === "__esModule") return; 8218 if (key in exports && exports[key] === _index4[key]) return; 8219 Object.defineProperty(exports, key, { 8220 enumerable: true, 8221 get: function () { 8222 return _index4[key]; 8223 }, 8224 }); 8225}); 8226var _index5 = __webpack_require__(178304); 8227Object.keys(_index5).forEach(function (key) { 8228 if (key === "default" || key === "__esModule") return; 8229 if (key in exports && exports[key] === _index5[key]) return; 8230 Object.defineProperty(exports, key, { 8231 enumerable: true, 8232 get: function () { 8233 return _index5[key]; 8234 }, 8235 }); 8236}); 8237var _index6 = __webpack_require__(854176); 8238Object.keys(_index6).forEach(function (key) { 8239 if (key === "default" || key === "__esModule") return; 8240 if (key in exports && exports[key] === _index6[key]) return; 8241 Object.defineProperty(exports, key, { 8242 enumerable: true, 8243 get: function () { 8244 return _index6[key]; 8245 }, 8246 }); 8247}); 8248var _index7 = __webpack_require__(609025); 8249Object.keys(_index7).forEach(function (key) { 8250 if (key === "default" || key === "__esModule") return; 8251 if (key in exports && exports[key] === _index7[key]) return; 8252 Object.defineProperty(exports, key, { 8253 enumerable: true, 8254 get: function () { 8255 return _index7[key]; 8256 }, 8257 }); 8258}); 8259var _index8 = __webpack_require__(292361); 8260Object.keys(_index8).forEach(function (key) { 8261 if (key === "default" || key === "__esModule") return; 8262 if (key in exports && exports[key] === _index8[key]) return; 8263 Object.defineProperty(exports, key, { 8264 enumerable: true, 8265 get: function () { 8266 return _index8[key]; 8267 }, 8268 }); 8269}); 8270var _index9 = __webpack_require__(953970); 8271Object.keys(_index9).forEach(function (key) { 8272 if (key === "default" || key === "__esModule") return; 8273 if (key in exports && exports[key] === _index9[key]) return; 8274 Object.defineProperty(exports, key, { 8275 enumerable: true, 8276 get: function () { 8277 return _index9[key]; 8278 }, 8279 }); 8280}); 8281var _index10 = __webpack_require__(145124); 8282Object.keys(_index10).forEach(function (key) { 8283 if (key === "default" || key === "__esModule") return; 8284 if (key in exports && exports[key] === _index10[key]) return; 8285 Object.defineProperty(exports, key, { 8286 enumerable: true, 8287 get: function () { 8288 return _index10[key]; 8289 }, 8290 }); 8291}); 8292var _index11 = __webpack_require__(59786); 8293Object.keys(_index11).forEach(function (key) { 8294 if (key === "default" || key === "__esModule") return; 8295 if (key in exports && exports[key] === _index11[key]) return; 8296 Object.defineProperty(exports, key, { 8297 enumerable: true, 8298 get: function () { 8299 return _index11[key]; 8300 }, 8301 }); 8302}); 8303var _index12 = __webpack_require__(786156); 8304Object.keys(_index12).forEach(function (key) { 8305 if (key === "default" || key === "__esModule") return; 8306 if (key in exports && exports[key] === _index12[key]) return; 8307 Object.defineProperty(exports, key, { 8308 enumerable: true, 8309 get: function () { 8310 return _index12[key]; 8311 }, 8312 }); 8313}); 8314var _index13 = __webpack_require__(546145); 8315Object.keys(_index13).forEach(function (key) {
8316 if (key === "default" || key === "__esModule") return; 8317 if (key in exports && exports[key] === _index13[key]) return; 8318 Object.defineProperty(exports, key, { 8319 enumerable: true, 8320 get: function () { 8321 return _index13[key]; 8322 }, 8323 }); 8324}); 8325var _index14 = __webpack_require__(717413); 8326Object.keys(_index14).forEach(function (key) { 8327 if (key === "default" || key === "__esModule") return; 8328 if (key in exports && exports[key] === _index14[key]) return; 8329 Object.defineProperty(exports, key, { 8330 enumerable: true, 8331 get: function () { 8332 return _index14[key]; 8333 }, 8334 }); 8335}); 8336var _index15 = __webpack_require__(298147); 8337Object.keys(_index15).forEach(function (key) { 8338 if (key === "default" || key === "__esModule") return; 8339 if (key in exports && exports[key] === _index15[key]) return; 8340 Object.defineProperty(exports, key, { 8341 enumerable: true, 8342 get: function () { 8343 return _index15[key]; 8344 }, 8345 }); 8346}); 8347var _index16 = __webpack_require__(174284); 8348Object.keys(_index16).forEach(function (key) { 8349 if (key === "default" || key === "__esModule") return; 8350 if (key in exports && exports[key] === _index16[key]) return; 8351 Object.defineProperty(exports, key, { 8352 enumerable: true, 8353 get: function () { 8354 return _index16[key]; 8355 }, 8356 }); 8357}); 8358var _index17 = __webpack_require__(636374); 8359Object.keys(_index17).forEach(function (key) { 8360 if (key === "default" || key === "__esModule") return; 8361 if (key in exports && exports[key] === _index17[key]) return; 8362 Object.defineProperty(exports, key, { 8363 enumerable: true, 8364 get: function () { 8365 return _index17[key]; 8366 }, 8367 }); 8368}); 8369var _index18 = __webpack_require__(684121); 8370Object.keys(_index18).forEach(function (key) { 8371 if (key === "default" || key === "__esModule") return; 8372 if (key in exports && exports[key] === _index18[key]) return; 8373 Object.defineProperty(exports, key, { 8374 enumerable: true, 8375 get: function () { 8376 return _index18[key]; 8377 }, 8378 }); 8379}); 8380var _index19 = __webpack_require__(658612); 8381Object.keys(_index19).forEach(function (key) { 8382 if (key === "default" || key === "__esModule") return; 8383 if (key in exports && exports[key] === _index19[key]) return; 8384 Object.defineProperty(exports, key, { 8385 enumerable: true, 8386 get: function () { 8387 return _index19[key]; 8388 }, 8389 }); 8390}); 8391var _index20 = __webpack_require__(560533); 8392Object.keys(_index20).forEach(function (key) { 8393 if (key === "default" || key === "__esModule") return; 8394 if (key in exports && exports[key] === _index20[key]) return; 8395 Object.defineProperty(exports, key, { 8396 enumerable: true, 8397 get: function () { 8398 return _index20[key]; 8399 }, 8400 }); 8401}); 8402var _index21 = __webpack_require__(812836); 8403Object.keys(_index21).forEach(function (key) { 8404 if (key === "default" || key === "__esModule") return; 8405 if (key in exports && exports[key] === _index21[key]) return; 8406 Object.defineProperty(exports, key, { 8407 enumerable: true, 8408 get: function () { 8409 return _index21[key]; 8410 }, 8411 }); 8412}); 8413var _index22 = __webpack_require__(115893); 8414Object.keys(_index22).forEach(function (key) { 8415 if (key === "default" || key === "__esModule") return; 8416 if (key in exports && exports[key] === _index22[key]) return; 8417 Object.defineProperty(exports, key, { 8418 enumerable: true, 8419 get: function () { 8420 return _index22[key]; 8421 }, 8422 }); 8423}); 8424var _index23 = __webpack_require__(72028); 8425Object.keys(_index23).forEach(function (key) { 8426 if (key === "default" || key === "__esModule") return; 8427 if (key in exports && exports[key] === _index23[key]) return; 8428 Object.defineProperty(exports, key, { 8429 enumerable: true, 8430 get: function () { 8431 return _index23[key]; 8432 }, 8433 }); 8434}); 8435var _index24 = __webpack_require__(61500); 8436Object.keys(_index24).forEach(function (key) { 8437 if (key === "default" || key === "__esModule") return; 8438 if (key in exports && exports[key] === _index24[key]) return; 8439 Object.defineProperty(exports, key, { 8440 enumerable: true, 8441 get: function () { 8442 return _index24[key]; 8443 }, 8444 }); 8445}); 8446var _index25 = __webpack_require__(122345);
8447Object.keys(_index25).forEach(function (key) { 8448 if (key === "default" || key === "__esModule") return; 8449 if (key in exports && exports[key] === _index25[key]) return; 8450 Object.defineProperty(exports, key, { 8451 enumerable: true, 8452 get: function () { 8453 return _index25[key]; 8454 }, 8455 }); 8456}); 8457var _index26 = __webpack_require__(362530); 8458Object.keys(_index26).forEach(function (key) { 8459 if (key === "default" || key === "__esModule") return; 8460 if (key in exports && exports[key] === _index26[key]) return; 8461 Object.defineProperty(exports, key, { 8462 enumerable: true, 8463 get: function () { 8464 return _index26[key]; 8465 }, 8466 }); 8467}); 8468var _index27 = __webpack_require__(900677); 8469Object.keys(_index27).forEach(function (key) { 8470 if (key === "default" || key === "__esModule") return; 8471 if (key in exports && exports[key] === _index27[key]) return; 8472 Object.defineProperty(exports, key, { 8473 enumerable: true, 8474 get: function () { 8475 return _index27[key]; 8476 }, 8477 }); 8478}); 8479var _index28 = __webpack_require__(124071); 8480Object.keys(_index28).forEach(function (key) { 8481 if (key === "default" || key === "__esModule") return; 8482 if (key in exports && exports[key] === _index28[key]) return; 8483 Object.defineProperty(exports, key, { 8484 enumerable: true, 8485 get: function () { 8486 return _index28[key]; 8487 }, 8488 }); 8489}); 8490var _index29 = __webpack_require__(199067); 8491Object.keys(_index29).forEach(function (key) { 8492 if (key === "default" || key === "__esModule") return; 8493 if (key in exports && exports[key] === _index29[key]) return; 8494 Object.defineProperty(exports, key, { 8495 enumerable: true, 8496 get: function () { 8497 return _index29[key]; 8498 }, 8499 }); 8500}); 8501var _index30 = __webpack_require__(820537); 8502Object.keys(_index30).forEach(function (key) { 8503 if (key === "default" || key === "__esModule") return; 8504 if (key in exports && exports[key] === _index30[key]) return; 8505 Object.defineProperty(exports, key, { 8506 enumerable: true, 8507 get: function () { 8508 return _index30[key]; 8509 }, 8510 }); 8511}); 8512var _index31 = __webpack_require__(937549); 8513Object.keys(_index31).forEach(function (key) { 8514 if (key === "default" || key === "__esModule") return; 8515 if (key in exports && exports[key] === _index31[key]) return; 8516 Object.defineProperty(exports, key, { 8517 enumerable: true, 8518 get: function () { 8519 return _index31[key]; 8520 }, 8521 }); 8522}); 8523var _index32 = __webpack_require__(693221); 8524Object.keys(_index32).forEach(function (key) { 8525 if (key === "default" || key === "__esModule") return; 8526 if (key in exports && exports[key] === _index32[key]) return; 8527 Object.defineProperty(exports, key, { 8528 enumerable: true, 8529 get: function () { 8530 return _index32[key]; 8531 }, 8532 }); 8533}); 8534var _index33 = __webpack_require__(400743); 8535Object.keys(_index33).forEach(function (key) { 8536 if (key === "default" || key === "__esModule") return; 8537 if (key in exports && exports[key] === _index33[key]) return; 8538 Object.defineProperty(exports, key, { 8539 enumerable: true, 8540 get: function () { 8541 return _index33[key]; 8542 }, 8543 }); 8544}); 8545var _index34 = __webpack_require__(371501); 8546Object.keys(_index34).forEach(function (key) { 8547 if (key === "default" || key === "__esModule") return; 8548 if (key in exports && exports[key] === _index34[key]) return; 8549 Object.defineProperty(exports, key, { 8550 enumerable: true, 8551 get: function () { 8552 return _index34[key]; 8553 }, 8554 }); 8555}); 8556var _index35 = __webpack_require__(976081); 8557Object.keys(_index35).forEach(function (key) { 8558 if (key === "default" || key === "__esModule") return; 8559 if (key in exports && exports[key] === _index35[key]) return; 8560 Object.defineProperty(exports, key, { 8561 enumerable: true, 8562 get: function () { 8563 return _index35[key]; 8564 }, 8565 }); 8566}); 8567var _index36 = __webpack_require__(105464); 8568Object.keys(_index36).forEach(function (key) { 8569 if (key === "default" || key === "__esModule") return; 8570 if (key in exports && exports[key] === _index36[key]) return; 8571 Object.defineProperty(exports, key, { 8572 enumerable: true, 8573 get: function () { 8574 return _index36[key]; 8575 }, 8576 }); 8577}); 8578var _index37 = __webpack_require__(454975);
8579Object.keys(_index37).forEach(function (key) { 8580 if (key === "default" || key === "__esModule") return; 8581 if (key in exports && exports[key] === _index37[key]) return; 8582 Object.defineProperty(exports, key, { 8583 enumerable: true, 8584 get: function () { 8585 return _index37[key]; 8586 }, 8587 }); 8588}); 8589var _index38 = __webpack_require__(833368); 8590Object.keys(_index38).forEach(function (key) { 8591 if (key === "default" || key === "__esModule") return; 8592 if (key in exports && exports[key] === _index38[key]) return; 8593 Object.defineProperty(exports, key, { 8594 enumerable: true, 8595 get: function () { 8596 return _index38[key]; 8597 }, 8598 }); 8599}); 8600var _index39 = __webpack_require__(144528); 8601Object.keys(_index39).forEach(function (key) { 8602 if (key === "default" || key === "__esModule") return; 8603 if (key in exports && exports[key] === _index39[key]) return; 8604 Object.defineProperty(exports, key, { 8605 enumerable: true, 8606 get: function () { 8607 return _index39[key]; 8608 }, 8609 }); 8610}); 8611var _index40 = __webpack_require__(281278); 8612Object.keys(_index40).forEach(function (key) { 8613 if (key === "default" || key === "__esModule") return; 8614 if (key in exports && exports[key] === _index40[key]) return; 8615 Object.defineProperty(exports, key, { 8616 enumerable: true, 8617 get: function () { 8618 return _index40[key]; 8619 }, 8620 }); 8621}); 8622var _index41 = __webpack_require__(521818); 8623Object.keys(_index41).forEach(function (key) { 8624 if (key === "default" || key === "__esModule") return; 8625 if (key in exports && exports[key] === _index41[key]) return; 8626 Object.defineProperty(exports, key, { 8627 enumerable: true, 8628 get: function () { 8629 return _index41[key]; 8630 }, 8631 }); 8632}); 8633var _index42 = __webpack_require__(53846); 8634Object.keys(_index42).forEach(function (key) { 8635 if (key === "default" || key === "__esModule") return; 8636 if (key in exports && exports[key] === _index42[key]) return; 8637 Object.defineProperty(exports, key, { 8638 enumerable: true, 8639 get: function () { 8640 return _index42[key]; 8641 }, 8642 }); 8643}); 8644var _index43 = __webpack_require__(323874); 8645Object.keys(_index43).forEach(function (key) { 8646 if (key === "default" || key === "__esModule") return; 8647 if (key in exports && exports[key] === _index43[key]) return; 8648 Object.defineProperty(exports, key, { 8649 enumerable: true, 8650 get: function () { 8651 return _index43[key]; 8652 }, 8653 }); 8654}); 8655var _index44 = __webpack_require__(422132); 8656Object.keys(_index44).forEach(function (key) { 8657 if (key === "default" || key === "__esModule") return; 8658 if (key in exports && exports[key] === _index44[key]) return; 8659 Object.defineProperty(exports, key, { 8660 enumerable: true, 8661 get: function () { 8662 return _index44[key]; 8663 }, 8664 }); 8665}); 8666var _index45 = __webpack_require__(371274); 8667Object.keys(_index45).forEach(function (key) { 8668 if (key === "default" || key === "__esModule") return; 8669 if (key in exports && exports[key] === _index45[key]) return; 8670 Object.defineProperty(exports, key, { 8671 enumerable: true, 8672 get: function () { 8673 return _index45[key]; 8674 }, 8675 }); 8676}); 8677var _index46 = __webpack_require__(979033); 8678Object.keys(_index46).forEach(function (key) { 8679 if (key === "default" || key === "__esModule") return; 8680 if (key in exports && exports[key] === _index46[key]) return; 8681 Object.defineProperty(exports, key, { 8682 enumerable: true, 8683 get: function () { 8684 return _index46[key]; 8685 }, 8686 }); 8687}); 8688var _index47 = __webpack_require__(660195);
8689Object.keys(_index47).forEach(function (key) { 8690 if (key === "default" || key === "__esModule") return; 8691 if (key in exports && exports[key] === _index47[key]) return; 8692 Object.defineProperty(exports, key, { 8693 enumerable: true, 8694 get: function () { 8695 return _index47[key]; 8696 }, 8697 }); 8698}); 8699var _index48 = __webpack_require__(683543); 8700Object.keys(_index48).forEach(function (key) { 8701 if (key === "default" || key === "__esModule") return; 8702 if (key in exports && exports[key] === _index48[key]) return; 8703 Object.defineProperty(exports, key, { 8704 enumerable: true, 8705 get: function () { 8706 return _index48[key]; 8707 }, 8708 }); 8709}); 8710var _index49 = __webpack_require__(42766); 8711Object.keys(_index49).forEach(function (key) { 8712 if (key === "default" || key === "__esModule") return; 8713 if (key in exports && exports[key] === _index49[key]) return; 8714 Object.defineProperty(exports, key, { 8715 enumerable: true, 8716 get: function () { 8717 return _index49[key]; 8718 }, 8719 }); 8720}); 8721var _index50 = __webpack_require__(294210); 8722Object.keys(_index50).forEach(function (key) { 8723 if (key === "default" || key === "__esModule") return; 8724 if (key in exports && exports[key] === _index50[key]) return; 8725 Object.defineProperty(exports, key, { 8726 enumerable: true, 8727 get: function () { 8728 return _index50[key]; 8729 }, 8730 }); 8731}); 8732var _index51 = __webpack_require__(962526); 8733Object.keys(_index51).forEach(function (key) { 8734 if (key === "default" || key === "__esModule") return; 8735 if (key in exports && exports[key] === _index51[key]) return; 8736 Object.defineProperty(exports, key, { 8737 enumerable: true, 8738 get: function () { 8739 return _index51[key]; 8740 }, 8741 }); 8742}); 8743var _index52 = __webpack_require__(405026); 8744Object.keys(_index52).forEach(function (key) { 8745 if (key === "default" || key === "__esModule") return; 8746 if (key in exports && exports[key] === _index52[key]) return; 8747 Object.defineProperty(exports, key, { 8748 enumerable: true, 8749 get: function () { 8750 return _index52[key]; 8751 }, 8752 }); 8753}); 8754var _index53 = __webpack_require__(144661); 8755Object.keys(_index53).forEach(function (key) { 8756 if (key === "default" || key === "__esModule") return; 8757 if (key in exports && exports[key] === _index53[key]) return; 8758 Object.defineProperty(exports, key, { 8759 enumerable: true, 8760 get: function () { 8761 return _index53[key]; 8762 }, 8763 }); 8764}); 8765var _index54 = __webpack_require__(173909); 8766Object.keys(_index54).forEach(function (key) { 8767 if (key === "default" || key === "__esModule") return; 8768 if (key in exports && exports[key] === _index54[key]) return; 8769 Object.defineProperty(exports, key, { 8770 enumerable: true, 8771 get: function () { 8772 return _index54[key]; 8773 }, 8774 }); 8775}); 8776var _index55 = __webpack_require__(110820); 8777Object.keys(_index55).forEach(function (key) { 8778 if (key === "default" || key === "__esModule") return; 8779 if (key in exports && exports[key] === _index55[key]) return; 8780 Object.defineProperty(exports, key, { 8781 enumerable: true, 8782 get: function () { 8783 return _index55[key]; 8784 }, 8785 }); 8786}); 8787var _index56 = __webpack_require__(458842); 8788Object.keys(_index56).forEach(function (key) { 8789 if (key === "default" || key === "__esModule") return; 8790 if (key in exports && exports[key] === _index56[key]) return; 8791 Object.defineProperty(exports, key, { 8792 enumerable: true, 8793 get: function () { 8794 return _index56[key]; 8795 }, 8796 }); 8797}); 8798var _index57 = __webpack_require__(864631); 8799Object.keys(_index57).forEach(function (key) { 8800 if (key === "default" || key === "__esModule") return; 8801 if (key in exports && exports[key] === _index57[key]) return; 8802 Object.defineProperty(exports, key, { 8803 enumerable: true, 8804 get: function () { 8805 return _index57[key]; 8806 }, 8807 }); 8808}); 8809var _index58 = __webpack_require__(619753); 8810Object.keys(_index58).forEach(function (key) { 8811 if (key === "default" || key === "__esModule") return; 8812 if (key in exports && exports[key] === _index58[key]) return; 8813 Object.defineProperty(exports, key, { 8814 enumerable: true, 8815 get: function () { 8816 return _index58[key]; 8817 }, 8818 }); 8819}); 8820var _index59 = __webpack_require__(431312); 8821Object.keys(_index59).forEach(function (key) {
8822 if (key === "default" || key === "__esModule") return; 8823 if (key in exports && exports[key] === _index59[key]) return; 8824 Object.defineProperty(exports, key, { 8825 enumerable: true, 8826 get: function () { 8827 return _index59[key]; 8828 }, 8829 }); 8830}); 8831var _index60 = __webpack_require__(873312); 8832Object.keys(_index60).forEach(function (key) { 8833 if (key === "default" || key === "__esModule") return; 8834 if (key in exports && exports[key] === _index60[key]) return; 8835 Object.defineProperty(exports, key, { 8836 enumerable: true, 8837 get: function () { 8838 return _index60[key]; 8839 }, 8840 }); 8841}); 8842var _index61 = __webpack_require__(9036); 8843Object.keys(_index61).forEach(function (key) { 8844 if (key === "default" || key === "__esModule") return; 8845 if (key in exports && exports[key] === _index61[key]) return; 8846 Object.defineProperty(exports, key, { 8847 enumerable: true, 8848 get: function () { 8849 return _index61[key]; 8850 }, 8851 }); 8852}); 8853var _index62 = __webpack_require__(925916); 8854Object.keys(_index62).forEach(function (key) { 8855 if (key === "default" || key === "__esModule") return; 8856 if (key in exports && exports[key] === _index62[key]) return; 8857 Object.defineProperty(exports, key, { 8858 enumerable: true, 8859 get: function () { 8860 return _index62[key]; 8861 }, 8862 }); 8863}); 8864var _index63 = __webpack_require__(701804); 8865Object.keys(_index63).forEach(function (key) { 8866 if (key === "default" || key === "__esModule") return; 8867 if (key in exports && exports[key] === _index63[key]) return; 8868 Object.defineProperty(exports, key, { 8869 enumerable: true, 8870 get: function () { 8871 return _index63[key]; 8872 }, 8873 }); 8874}); 8875var _index64 = __webpack_require__(797892); 8876Object.keys(_index64).forEach(function (key) { 8877 if (key === "default" || key === "__esModule") return; 8878 if (key in exports && exports[key] === _index64[key]) return; 8879 Object.defineProperty(exports, key, { 8880 enumerable: true, 8881 get: function () { 8882 return _index64[key]; 8883 }, 8884 }); 8885}); 8886var _index65 = __webpack_require__(298385); 8887Object.keys(_index65).forEach(function (key) { 8888 if (key === "default" || key === "__esModule") return; 8889 if (key in exports && exports[key] === _index65[key]) return; 8890 Object.defineProperty(exports, key, { 8891 enumerable: true, 8892 get: function () { 8893 return _index65[key]; 8894 }, 8895 }); 8896}); 8897var _index66 = __webpack_require__(215563); 8898Object.keys(_index66).forEach(function (key) { 8899 if (key === "default" || key === "__esModule") return; 8900 if (key in exports && exports[key] === _index66[key]) return; 8901 Object.defineProperty(exports, key, { 8902 enumerable: true, 8903 get: function () { 8904 return _index66[key]; 8905 }, 8906 }); 8907}); 8908var _index67 = __webpack_require__(665557); 8909Object.keys(_index67).forEach(function (key) { 8910 if (key === "default" || key === "__esModule") return; 8911 if (key in exports && exports[key] === _index67[key]) return; 8912 Object.defineProperty(exports, key, { 8913 enumerable: true, 8914 get: function () { 8915 return _index67[key]; 8916 }, 8917 }); 8918}); 8919var _index68 = __webpack_require__(735915); 8920Object.keys(_index68).forEach(function (key) { 8921 if (key === "default" || key === "__esModule") return; 8922 if (key in exports && exports[key] === _index68[key]) return; 8923 Object.defineProperty(exports, key, { 8924 enumerable: true, 8925 get: function () { 8926 return _index68[key]; 8927 }, 8928 }); 8929}); 8930var _index69 = __webpack_require__(612236); 8931Object.keys(_index69).forEach(function (key) { 8932 if (key === "default" || key === "__esModule") return; 8933 if (key in exports && exports[key] === _index69[key]) return; 8934 Object.defineProperty(exports, key, { 8935 enumerable: true, 8936 get: function () { 8937 return _index69[key]; 8938 }, 8939 }); 8940}); 8941var _index70 = __webpack_require__(638233); 8942Object.keys(_index70).forEach(function (key) { 8943 if (key === "default" || key === "__esModule") return; 8944 if (key in exports && exports[key] === _index70[key]) return; 8945 Object.defineProperty(exports, key, { 8946 enumerable: true, 8947 get: function () { 8948 return _index70[key]; 8949 }, 8950 }); 8951}); 8952var _index71 = __webpack_require__(235638); 8953Object.keys(_index71).forEach(function (key) {
8954 if (key === "default" || key === "__esModule") return; 8955 if (key in exports && exports[key] === _index71[key]) return; 8956 Object.defineProperty(exports, key, { 8957 enumerable: true, 8958 get: function () { 8959 return _index71[key]; 8960 }, 8961 }); 8962}); 8963var _index72 = __webpack_require__(756257); 8964Object.keys(_index72).forEach(function (key) { 8965 if (key === "default" || key === "__esModule") return; 8966 if (key in exports && exports[key] === _index72[key]) return; 8967 Object.defineProperty(exports, key, { 8968 enumerable: true, 8969 get: function () { 8970 return _index72[key]; 8971 }, 8972 }); 8973}); 8974var _index73 = __webpack_require__(362756); 8975Object.keys(_index73).forEach(function (key) { 8976 if (key === "default" || key === "__esModule") return; 8977 if (key in exports && exports[key] === _index73[key]) return; 8978 Object.defineProperty(exports, key, { 8979 enumerable: true, 8980 get: function () { 8981 return _index73[key]; 8982 }, 8983 }); 8984}); 8985var _index74 = __webpack_require__(399435); 8986Object.keys(_index74).forEach(function (key) { 8987 if (key === "default" || key === "__esModule") return; 8988 if (key in exports && exports[key] === _index74[key]) return; 8989 Object.defineProperty(exports, key, { 8990 enumerable: true, 8991 get: function () { 8992 return _index74[key]; 8993 }, 8994 }); 8995}); 8996var _index75 = __webpack_require__(748369); 8997Object.keys(_index75).forEach(function (key) { 8998 if (key === "default" || key === "__esModule") return; 8999 if (key in exports && exports[key] === _index75[key]) return; 9000 Object.defineProperty(exports, key, { 9001 enumerable: true, 9002 get: function () { 9003 return _index75[key]; 9004 }, 9005 }); 9006}); 9007var _index76 = __webpack_require__(795320); 9008Object.keys(_index76).forEach(function (key) { 9009 if (key === "default" || key === "__esModule") return; 9010 if (key in exports && exports[key] === _index76[key]) return; 9011 Object.defineProperty(exports, key, { 9012 enumerable: true, 9013 get: function () { 9014 return _index76[key]; 9015 }, 9016 }); 9017}); 9018var _index77 = __webpack_require__(57593); 9019Object.keys(_index77).forEach(function (key) { 9020 if (key === "default" || key === "__esModule") return; 9021 if (key in exports && exports[key] === _index77[key]) return; 9022 Object.defineProperty(exports, key, { 9023 enumerable: true, 9024 get: function () { 9025 return _index77[key]; 9026 }, 9027 }); 9028}); 9029var _index78 = __webpack_require__(119142); 9030Object.keys(_index78).forEach(function (key) { 9031 if (key === "default" || key === "__esModule") return; 9032 if (key in exports && exports[key] === _index78[key]) return; 9033 Object.defineProperty(exports, key, { 9034 enumerable: true, 9035 get: function () { 9036 return _index78[key]; 9037 }, 9038 }); 9039}); 9040var _index79 = __webpack_require__(824866); 9041Object.keys(_index79).forEach(function (key) { 9042 if (key === "default" || key === "__esModule") return; 9043 if (key in exports && exports[key] === _index79[key]) return; 9044 Object.defineProperty(exports, key, { 9045 enumerable: true, 9046 get: function () { 9047 return _index79[key]; 9048 }, 9049 }); 9050}); 9051var _index80 = __webpack_require__(942703); 9052Object.keys(_index80).forEach(function (key) { 9053 if (key === "default" || key === "__esModule") return; 9054 if (key in exports && exports[key] === _index80[key]) return; 9055 Object.defineProperty(exports, key, { 9056 enumerable: true, 9057 get: function () { 9058 return _index80[key]; 9059 }, 9060 }); 9061}); 9062var _index81 = __webpack_require__(922343); 9063Object.keys(_index81).forEach(function (key) { 9064 if (key === "default" || key === "__esModule") return; 9065 if (key in exports && exports[key] === _index81[key]) return; 9066 Object.defineProperty(exports, key, { 9067 enumerable: true, 9068 get: function () { 9069 return _index81[key]; 9070 }, 9071 }); 9072}); 9073var _index82 = __webpack_require__(851276); 9074Object.keys(_index82).forEach(function (key) { 9075 if (key === "default" || key === "__esModule") return; 9076 if (key in exports && exports[key] === _index82[key]) return; 9077 Object.defineProperty(exports, key, { 9078 enumerable: true, 9079 get: function () { 9080 return _index82[key]; 9081 }, 9082 }); 9083}); 9084var _index83 = __webpack_require__(637213); 9085Object.keys(_index83).forEach(function (key) {
9086 if (key === "default" || key === "__esModule") return; 9087 if (key in exports && exports[key] === _index83[key]) return; 9088 Object.defineProperty(exports, key, { 9089 enumerable: true, 9090 get: function () { 9091 return _index83[key]; 9092 }, 9093 }); 9094}); 9095var _index84 = __webpack_require__(269546); 9096Object.keys(_index84).forEach(function (key) { 9097 if (key === "default" || key === "__esModule") return; 9098 if (key in exports && exports[key] === _index84[key]) return; 9099 Object.defineProperty(exports, key, { 9100 enumerable: true, 9101 get: function () { 9102 return _index84[key]; 9103 }, 9104 }); 9105}); 9106var _index85 = __webpack_require__(628209); 9107Object.keys(_index85).forEach(function (key) { 9108 if (key === "default" || key === "__esModule") return; 9109 if (key in exports && exports[key] === _index85[key]) return; 9110 Object.defineProperty(exports, key, { 9111 enumerable: true, 9112 get: function () { 9113 return _index85[key]; 9114 }, 9115 }); 9116}); 9117var _index86 = __webpack_require__(125691); 9118Object.keys(_index86).forEach(function (key) { 9119 if (key === "default" || key === "__esModule") return; 9120 if (key in exports && exports[key] === _index86[key]) return; 9121 Object.defineProperty(exports, key, { 9122 enumerable: true, 9123 get: function () { 9124 return _index86[key]; 9125 }, 9126 }); 9127}); 9128var _index87 = __webpack_require__(196914); 9129Object.keys(_index87).forEach(function (key) { 9130 if (key === "default" || key === "__esModule") return; 9131 if (key in exports && exports[key] === _index87[key]) return; 9132 Object.defineProperty(exports, key, { 9133 enumerable: true, 9134 get: function () { 9135 return _index87[key]; 9136 }, 9137 }); 9138}); 9139var _index88 = __webpack_require__(86239); 9140Object.keys(_index88).forEach(function (key) { 9141 if (key === "default" || key === "__esModule") return; 9142 if (key in exports && exports[key] === _index88[key]) return; 9143 Object.defineProperty(exports, key, { 9144 enumerable: true, 9145 get: function () { 9146 return _index88[key]; 9147 }, 9148 }); 9149}); 9150var _index89 = __webpack_require__(439150); 9151Object.keys(_index89).forEach(function (key) { 9152 if (key === "default" || key === "__esModule") return; 9153 if (key in exports && exports[key] === _index89[key]) return; 9154 Object.defineProperty(exports, key, { 9155 enumerable: true, 9156 get: function () { 9157 return _index89[key]; 9158 }, 9159 }); 9160}); 9161var _index90 = __webpack_require__(129729); 9162Object.keys(_index90).forEach(function (key) { 9163 if (key === "default" || key === "__esModule") return; 9164 if (key in exports && exports[key] === _index90[key]) return; 9165 Object.defineProperty(exports, key, { 9166 enumerable: true, 9167 get: function () { 9168 return _index90[key]; 9169 }, 9170 }); 9171}); 9172var _index91 = __webpack_require__(544536); 9173Object.keys(_index91).forEach(function (key) { 9174 if (key === "default" || key === "__esModule") return; 9175 if (key in exports && exports[key] === _index91[key]) return; 9176 Object.defineProperty(exports, key, { 9177 enumerable: true, 9178 get: function () { 9179 return _index91[key]; 9180 }, 9181 }); 9182}); 9183var _index92 = __webpack_require__(308615); 9184Object.keys(_index92).forEach(function (key) { 9185 if (key === "default" || key === "__esModule") return; 9186 if (key in exports && exports[key] === _index92[key]) return; 9187 Object.defineProperty(exports, key, { 9188 enumerable: true, 9189 get: function () { 9190 return _index92[key]; 9191 }, 9192 }); 9193}); 9194var _index93 = __webpack_require__(69662); 9195Object.keys(_index93).forEach(function (key) { 9196 if (key === "default" || key === "__esModule") return; 9197 if (key in exports && exports[key] === _index93[key]) return; 9198 Object.defineProperty(exports, key, { 9199 enumerable: true, 9200 get: function () { 9201 return _index93[key]; 9202 }, 9203 }); 9204}); 9205var _index94 = __webpack_require__(830031); 9206Object.keys(_index94).forEach(function (key) { 9207 if (key === "default" || key === "__esModule") return; 9208 if (key in exports && exports[key] === _index94[key]) return; 9209 Object.defineProperty(exports, key, { 9210 enumerable: true, 9211 get: function () { 9212 return _index94[key]; 9213 }, 9214 }); 9215}); 9216var _index95 = __webpack_require__(486793); 9217Object.keys(_index95).forEach(function (key) {
9218 if (key === "default" || key === "__esModule") return; 9219 if (key in exports && exports[key] === _index95[key]) return; 9220 Object.defineProperty(exports, key, { 9221 enumerable: true, 9222 get: function () { 9223 return _index95[key]; 9224 }, 9225 }); 9226}); 9227var _index96 = __webpack_require__(604590); 9228Object.keys(_index96).forEach(function (key) { 9229 if (key === "default" || key === "__esModule") return; 9230 if (key in exports && exports[key] === _index96[key]) return; 9231 Object.defineProperty(exports, key, { 9232 enumerable: true, 9233 get: function () { 9234 return _index96[key]; 9235 }, 9236 }); 9237}); 9238var _index97 = __webpack_require__(461625); 9239Object.keys(_index97).forEach(function (key) { 9240 if (key === "default" || key === "__esModule") return; 9241 if (key in exports && exports[key] === _index97[key]) return; 9242 Object.defineProperty(exports, key, { 9243 enumerable: true, 9244 get: function () { 9245 return _index97[key]; 9246 }, 9247 }); 9248}); 9249var _index98 = __webpack_require__(866247); 9250Object.keys(_index98).forEach(function (key) { 9251 if (key === "default" || key === "__esModule") return; 9252 if (key in exports && exports[key] === _index98[key]) return; 9253 Object.defineProperty(exports, key, { 9254 enumerable: true, 9255 get: function () { 9256 return _index98[key]; 9257 }, 9258 }); 9259}); 9260var _index99 = __webpack_require__(23928); 9261Object.keys(_index99).forEach(function (key) { 9262 if (key === "default" || key === "__esModule") return; 9263 if (key in exports && exports[key] === _index99[key]) return; 9264 Object.defineProperty(exports, key, { 9265 enumerable: true, 9266 get: function () { 9267 return _index99[key]; 9268 }, 9269 }); 9270}); 9271var _index100 = __webpack_require__(530173); 9272Object.keys(_index100).forEach(function (key) { 9273 if (key === "default" || key === "__esModule") return; 9274 if (key in exports && exports[key] === _index100[key]) return; 9275 Object.defineProperty(exports, key, { 9276 enumerable: true, 9277 get: function () { 9278 return _index100[key]; 9279 }, 9280 }); 9281}); 9282var _index101 = __webpack_require__(465769); 9283Object.keys(_index101).forEach(function (key) { 9284 if (key === "default" || key === "__esModule") return; 9285 if (key in exports && exports[key] === _index101[key]) return; 9286 Object.defineProperty(exports, key, { 9287 enumerable: true, 9288 get: function () { 9289 return _index101[key]; 9290 }, 9291 }); 9292}); 9293var _index102 = __webpack_require__(637459); 9294Object.keys(_index102).forEach(function (key) { 9295 if (key === "default" || key === "__esModule") return; 9296 if (key in exports && exports[key] === _index102[key]) return; 9297 Object.defineProperty(exports, key, { 9298 enumerable: true, 9299 get: function () { 9300 return _index102[key]; 9301 }, 9302 }); 9303}); 9304var _index103 = __webpack_require__(519480); 9305Object.keys(_index103).forEach(function (key) { 9306 if (key === "default" || key === "__esModule") return; 9307 if (key in exports && exports[key] === _index103[key]) return; 9308 Object.defineProperty(exports, key, { 9309 enumerable: true, 9310 get: function () { 9311 return _index103[key]; 9312 }, 9313 }); 9314}); 9315var _index104 = __webpack_require__(610881); 9316Object.keys(_index104).forEach(function (key) { 9317 if (key === "default" || key === "__esModule") return; 9318 if (key in exports && exports[key] === _index104[key]) return; 9319 Object.defineProperty(exports, key, { 9320 enumerable: true, 9321 get: function () { 9322 return _index104[key]; 9323 }, 9324 }); 9325}); 9326var _index105 = __webpack_require__(711276); 9327Object.keys(_index105).forEach(function (key) { 9328 if (key === "default" || key === "__esModule") return; 9329 if (key in exports && exports[key] === _index105[key]) return; 9330 Object.defineProperty(exports, key, { 9331 enumerable: true, 9332 get: function () { 9333 return _index105[key]; 9334 }, 9335 }); 9336}); 9337var _index106 = __webpack_require__(732715); 9338Object.keys(_index106).forEach(function (key) { 9339 if (key === "default" || key === "__esModule") return; 9340 if (key in exports && exports[key] === _index106[key]) return; 9341 Object.defineProperty(exports, key, { 9342 enumerable: true, 9343 get: function () { 9344 return _index106[key]; 9345 }, 9346 }); 9347}); 9348var _index107 = __webpack_require__(282596);
9349Object.keys(_index107).forEach(function (key) { 9350 if (key === "default" || key === "__esModule") return; 9351 if (key in exports && exports[key] === _index107[key]) return; 9352 Object.defineProperty(exports, key, { 9353 enumerable: true, 9354 get: function () { 9355 return _index107[key]; 9356 }, 9357 }); 9358}); 9359var _index108 = __webpack_require__(913197); 9360Object.keys(_index108).forEach(function (key) { 9361 if (key === "default" || key === "__esModule") return; 9362 if (key in exports && exports[key] === _index108[key]) return; 9363 Object.defineProperty(exports, key, { 9364 enumerable: true, 9365 get: function () { 9366 return _index108[key]; 9367 }, 9368 }); 9369}); 9370var _index109 = __webpack_require__(34619); 9371Object.keys(_index109).forEach(function (key) { 9372 if (key === "default" || key === "__esModule") return; 9373 if (key in exports && exports[key] === _index109[key]) return; 9374 Object.defineProperty(exports, key, { 9375 enumerable: true, 9376 get: function () { 9377 return _index109[key]; 9378 }, 9379 }); 9380}); 9381var _index110 = __webpack_require__(32651); 9382Object.keys(_index110).forEach(function (key) { 9383 if (key === "default" || key === "__esModule") return; 9384 if (key in exports && exports[key] === _index110[key]) return; 9385 Object.defineProperty(exports, key, { 9386 enumerable: true, 9387 get: function () { 9388 return _index110[key]; 9389 }, 9390 }); 9391}); 9392var _index111 = __webpack_require__(348233); 9393Object.keys(_index111).forEach(function (key) { 9394 if (key === "default" || key === "__esModule") return; 9395 if (key in exports && exports[key] === _index111[key]) return; 9396 Object.defineProperty(exports, key, { 9397 enumerable: true, 9398 get: function () { 9399 return _index111[key]; 9400 }, 9401 }); 9402}); 9403var _index112 = __webpack_require__(506979); 9404Object.keys(_index112).forEach(function (key) { 9405 if (key === "default" || key === "__esModule") return; 9406 if (key in exports && exports[key] === _index112[key]) return; 9407 Object.defineProperty(exports, key, { 9408 enumerable: true, 9409 get: function () { 9410 return _index112[key]; 9411 }, 9412 }); 9413}); 9414var _index113 = __webpack_require__(236325); 9415Object.keys(_index113).forEach(function (key) { 9416 if (key === "default" || key === "__esModule") return; 9417 if (key in exports && exports[key] === _index113[key]) return; 9418 Object.defineProperty(exports, key, { 9419 enumerable: true, 9420 get: function () { 9421 return _index113[key]; 9422 }, 9423 }); 9424}); 9425var _index114 = __webpack_require__(44339); 9426Object.keys(_index114).forEach(function (key) { 9427 if (key === "default" || key === "__esModule") return; 9428 if (key in exports && exports[key] === _index114[key]) return; 9429 Object.defineProperty(exports, key, { 9430 enumerable: true, 9431 get: function () { 9432 return _index114[key]; 9433 }, 9434 }); 9435}); 9436var _index115 = __webpack_require__(217133); 9437Object.keys(_index115).forEach(function (key) { 9438 if (key === "default" || key === "__esModule") return; 9439 if (key in exports && exports[key] === _index115[key]) return; 9440 Object.defineProperty(exports, key, { 9441 enumerable: true, 9442 get: function () { 9443 return _index115[key]; 9444 }, 9445 }); 9446}); 9447var _index116 = __webpack_require__(426144); 9448Object.keys(_index116).forEach(function (key) { 9449 if (key === "default" || key === "__esModule") return; 9450 if (key in exports && exports[key] === _index116[key]) return; 9451 Object.defineProperty(exports, key, { 9452 enumerable: true, 9453 get: function () { 9454 return _index116[key]; 9455 }, 9456 }); 9457}); 9458var _index117 = __webpack_require__(941447); 9459Object.keys(_index117).forEach(function (key) { 9460 if (key === "default" || key === "__esModule") return; 9461 if (key in exports && exports[key] === _index117[key]) return; 9462 Object.defineProperty(exports, key, { 9463 enumerable: true, 9464 get: function () { 9465 return _index117[key]; 9466 }, 9467 }); 9468}); 9469var _index118 = __webpack_require__(450519); 9470Object.keys(_index118).forEach(function (key) { 9471 if (key === "default" || key === "__esModule") return; 9472 if (key in exports && exports[key] === _index118[key]) return; 9473 Object.defineProperty(exports, key, { 9474 enumerable: true, 9475 get: function () { 9476 return _index118[key]; 9477 }, 9478 }); 9479}); 9480var _index119 = __webpack_require__(373102); 9481Object.keys(_index119).forEach(function (key) {
9482 if (key === "default" || key === "__esModule") return; 9483 if (key in exports && exports[key] === _index119[key]) return; 9484 Object.defineProperty(exports, key, { 9485 enumerable: true, 9486 get: function () { 9487 return _index119[key]; 9488 }, 9489 }); 9490}); 9491var _index120 = __webpack_require__(542649); 9492Object.keys(_index120).forEach(function (key) { 9493 if (key === "default" || key === "__esModule") return; 9494 if (key in exports && exports[key] === _index120[key]) return; 9495 Object.defineProperty(exports, key, { 9496 enumerable: true, 9497 get: function () { 9498 return _index120[key]; 9499 }, 9500 }); 9501}); 9502var _index121 = __webpack_require__(800999); 9503Object.keys(_index121).forEach(function (key) { 9504 if (key === "default" || key === "__esModule") return; 9505 if (key in exports && exports[key] === _index121[key]) return; 9506 Object.defineProperty(exports, key, { 9507 enumerable: true, 9508 get: function () { 9509 return _index121[key]; 9510 }, 9511 }); 9512}); 9513var _index122 = __webpack_require__(373958); 9514Object.keys(_index122).forEach(function (key) { 9515 if (key === "default" || key === "__esModule") return; 9516 if (key in exports && exports[key] === _index122[key]) return; 9517 Object.defineProperty(exports, key, { 9518 enumerable: true, 9519 get: function () { 9520 return _index122[key]; 9521 }, 9522 }); 9523}); 9524var _index123 = __webpack_require__(461908); 9525Object.keys(_index123).forEach(function (key) { 9526 if (key === "default" || key === "__esModule") return; 9527 if (key in exports && exports[key] === _index123[key]) return; 9528 Object.defineProperty(exports, key, { 9529 enumerable: true, 9530 get: function () { 9531 return _index123[key]; 9532 }, 9533 }); 9534}); 9535var _index124 = __webpack_require__(389706); 9536Object.keys(_index124).forEach(function (key) { 9537 if (key === "default" || key === "__esModule") return; 9538 if (key in exports && exports[key] === _index124[key]) return; 9539 Object.defineProperty(exports, key, { 9540 enumerable: true, 9541 get: function () { 9542 return _index124[key]; 9543 }, 9544 }); 9545}); 9546var _index125 = __webpack_require__(860928); 9547Object.keys(_index125).forEach(function (key) { 9548 if (key === "default" || key === "__esModule") return; 9549 if (key in exports && exports[key] === _index125[key]) return; 9550 Object.defineProperty(exports, key, { 9551 enumerable: true, 9552 get: function () { 9553 return _index125[key]; 9554 }, 9555 }); 9556}); 9557var _index126 = __webpack_require__(32648); 9558Object.keys(_index126).forEach(function (key) { 9559 if (key === "default" || key === "__esModule") return; 9560 if (key in exports && exports[key] === _index126[key]) return; 9561 Object.defineProperty(exports, key, { 9562 enumerable: true, 9563 get: function () { 9564 return _index126[key]; 9565 }, 9566 }); 9567}); 9568var _index127 = __webpack_require__(458331); 9569Object.keys(_index127).forEach(function (key) { 9570 if (key === "default" || key === "__esModule") return; 9571 if (key in exports && exports[key] === _index127[key]) return; 9572 Object.defineProperty(exports, key, { 9573 enumerable: true, 9574 get: function () { 9575 return _index127[key]; 9576 }, 9577 }); 9578}); 9579var _index128 = __webpack_require__(637184); 9580Object.keys(_index128).forEach(function (key) { 9581 if (key === "default" || key === "__esModule") return; 9582 if (key in exports && exports[key] === _index128[key]) return; 9583 Object.defineProperty(exports, key, { 9584 enumerable: true, 9585 get: function () { 9586 return _index128[key]; 9587 }, 9588 }); 9589}); 9590var _index129 = __webpack_require__(516248); 9591Object.keys(_index129).forEach(function (key) { 9592 if (key === "default" || key === "__esModule") return; 9593 if (key in exports && exports[key] === _index129[key]) return; 9594 Object.defineProperty(exports, key, { 9595 enumerable: true, 9596 get: function () { 9597 return _index129[key]; 9598 }, 9599 }); 9600}); 9601var _index130 = __webpack_require__(463373); 9602Object.keys(_index130).forEach(function (key) { 9603 if (key === "default" || key === "__esModule") return; 9604 if (key in exports && exports[key] === _index130[key]) return; 9605 Object.defineProperty(exports, key, { 9606 enumerable: true, 9607 get: function () { 9608 return _index130[key]; 9609 }, 9610 }); 9611}); 9612var _index131 = __webpack_require__(777751);
9613Object.keys(_index131).forEach(function (key) { 9614 if (key === "default" || key === "__esModule") return; 9615 if (key in exports && exports[key] === _index131[key]) return; 9616 Object.defineProperty(exports, key, { 9617 enumerable: true, 9618 get: function () { 9619 return _index131[key]; 9620 }, 9621 }); 9622}); 9623var _index132 = __webpack_require__(852642); 9624Object.keys(_index132).forEach(function (key) { 9625 if (key === "default" || key === "__esModule") return; 9626 if (key in exports && exports[key] === _index132[key]) return; 9627 Object.defineProperty(exports, key, { 9628 enumerable: true, 9629 get: function () { 9630 return _index132[key]; 9631 }, 9632 }); 9633}); 9634var _index133 = __webpack_require__(843239); 9635Object.keys(_index133).forEach(function (key) { 9636 if (key === "default" || key === "__esModule") return; 9637 if (key in exports && exports[key] === _index133[key]) return; 9638 Object.defineProperty(exports, key, { 9639 enumerable: true, 9640 get: function () { 9641 return _index133[key]; 9642 }, 9643 }); 9644}); 9645var _index134 = __webpack_require__(527719); 9646Object.keys(_index134).forEach(function (key) { 9647 if (key === "default" || key === "__esModule") return; 9648 if (key in exports && exports[key] === _index134[key]) return; 9649 Object.defineProperty(exports, key, { 9650 enumerable: true, 9651 get: function () { 9652 return _index134[key]; 9653 }, 9654 }); 9655}); 9656var _index135 = __webpack_require__(452027); 9657Object.keys(_index135).forEach(function (key) { 9658 if (key === "default" || key === "__esModule") return; 9659 if (key in exports && exports[key] === _index135[key]) return; 9660 Object.defineProperty(exports, key, { 9661 enumerable: true, 9662 get: function () { 9663 return _index135[key]; 9664 }, 9665 }); 9666}); 9667var _index136 = __webpack_require__(978989); 9668Object.keys(_index136).forEach(function (key) { 9669 if (key === "default" || key === "__esModule") return; 9670 if (key in exports && exports[key] === _index136[key]) return; 9671 Object.defineProperty(exports, key, { 9672 enumerable: true, 9673 get: function () { 9674 return _index136[key]; 9675 }, 9676 }); 9677}); 9678var _index137 = __webpack_require__(575812); 9679Object.keys(_index137).forEach(function (key) { 9680 if (key === "default" || key === "__esModule") return; 9681 if (key in exports && exports[key] === _index137[key]) return; 9682 Object.defineProperty(exports, key, { 9683 enumerable: true, 9684 get: function () { 9685 return _index137[key]; 9686 }, 9687 }); 9688}); 9689var _index138 = __webpack_require__(350274); 9690Object.keys(_index138).forEach(function (key) { 9691 if (key === "default" || key === "__esModule") return; 9692 if (key in exports && exports[key] === _index138[key]) return; 9693 Object.defineProperty(exports, key, { 9694 enumerable: true, 9695 get: function () { 9696 return _index138[key]; 9697 }, 9698 }); 9699}); 9700var _index139 = __webpack_require__(383826); 9701Object.keys(_index139).forEach(function (key) { 9702 if (key === "default" || key === "__esModule") return; 9703 if (key in exports && exports[key] === _index139[key]) return; 9704 Object.defineProperty(exports, key, { 9705 enumerable: true, 9706 get: function () { 9707 return _index139[key]; 9708 }, 9709 }); 9710}); 9711var _index140 = __webpack_require__(870987); 9712Object.keys(_index140).forEach(function (key) { 9713 if (key === "default" || key === "__esModule") return; 9714 if (key in exports && exports[key] === _index140[key]) return; 9715 Object.defineProperty(exports, key, { 9716 enumerable: true, 9717 get: function () { 9718 return _index140[key]; 9719 }, 9720 }); 9721}); 9722var _index141 = __webpack_require__(500251); 9723Object.keys(_index141).forEach(function (key) { 9724 if (key === "default" || key === "__esModule") return; 9725 if (key in exports && exports[key] === _index141[key]) return; 9726 Object.defineProperty(exports, key, { 9727 enumerable: true, 9728 get: function () { 9729 return _index141[key]; 9730 }, 9731 }); 9732}); 9733var _index142 = __webpack_require__(608529); 9734Object.keys(_index142).forEach(function (key) { 9735 if (key === "default" || key === "__esModule") return; 9736 if (key in exports && exports[key] === _index142[key]) return; 9737 Object.defineProperty(exports, key, { 9738 enumerable: true, 9739 get: function () { 9740 return _index142[key]; 9741 }, 9742 }); 9743}); 9744var _index143 = __webpack_require__(390689); 9745Object.keys(_index143).forEach(function (key) {
9746 if (key === "default" || key === "__esModule") return; 9747 if (key in exports && exports[key] === _index143[key]) return; 9748 Object.defineProperty(exports, key, { 9749 enumerable: true, 9750 get: function () { 9751 return _index143[key]; 9752 }, 9753 }); 9754}); 9755var _index144 = __webpack_require__(718721); 9756Object.keys(_index144).forEach(function (key) { 9757 if (key === "default" || key === "__esModule") return; 9758 if (key in exports && exports[key] === _index144[key]) return; 9759 Object.defineProperty(exports, key, { 9760 enumerable: true, 9761 get: function () { 9762 return _index144[key]; 9763 }, 9764 }); 9765}); 9766var _index145 = __webpack_require__(166787); 9767Object.keys(_index145).forEach(function (key) { 9768 if (key === "default" || key === "__esModule") return; 9769 if (key in exports && exports[key] === _index145[key]) return; 9770 Object.defineProperty(exports, key, { 9771 enumerable: true, 9772 get: function () { 9773 return _index145[key]; 9774 }, 9775 }); 9776}); 9777var _index146 = __webpack_require__(533209); 9778Object.keys(_index146).forEach(function (key) { 9779 if (key === "default" || key === "__esModule") return; 9780 if (key in exports && exports[key] === _index146[key]) return; 9781 Object.defineProperty(exports, key, { 9782 enumerable: true, 9783 get: function () { 9784 return _index146[key]; 9785 }, 9786 }); 9787}); 9788var _index147 = __webpack_require__(735098); 9789Object.keys(_index147).forEach(function (key) { 9790 if (key === "default" || key === "__esModule") return; 9791 if (key in exports && exports[key] === _index147[key]) return; 9792 Object.defineProperty(exports, key, { 9793 enumerable: true, 9794 get: function () { 9795 return _index147[key]; 9796 }, 9797 }); 9798}); 9799var _index148 = __webpack_require__(356804); 9800Object.keys(_index148).forEach(function (key) { 9801 if (key === "default" || key === "__esModule") return; 9802 if (key in exports && exports[key] === _index148[key]) return; 9803 Object.defineProperty(exports, key, { 9804 enumerable: true, 9805 get: function () { 9806 return _index148[key]; 9807 }, 9808 }); 9809}); 9810var _index149 = __webpack_require__(769816); 9811Object.keys(_index149).forEach(function (key) { 9812 if (key === "default" || key === "__esModule") return; 9813 if (key in exports && exports[key] === _index149[key]) return; 9814 Object.defineProperty(exports, key, { 9815 enumerable: true, 9816 get: function () { 9817 return _index149[key]; 9818 }, 9819 }); 9820}); 9821var _index150 = __webpack_require__(115706); 9822Object.keys(_index150).forEach(function (key) { 9823 if (key === "default" || key === "__esModule") return; 9824 if (key in exports && exports[key] === _index150[key]) return; 9825 Object.defineProperty(exports, key, { 9826 enumerable: true, 9827 get: function () { 9828 return _index150[key]; 9829 }, 9830 }); 9831}); 9832var _index151 = __webpack_require__(520549); 9833Object.keys(_index151).forEach(function (key) { 9834 if (key === "default" || key === "__esModule") return; 9835 if (key in exports && exports[key] === _index151[key]) return; 9836 Object.defineProperty(exports, key, { 9837 enumerable: true, 9838 get: function () { 9839 return _index151[key]; 9840 }, 9841 }); 9842}); 9843var _index152 = __webpack_require__(865149); 9844Object.keys(_index152).forEach(function (key) { 9845 if (key === "default" || key === "__esModule") return; 9846 if (key in exports && exports[key] === _index152[key]) return; 9847 Object.defineProperty(exports, key, { 9848 enumerable: true, 9849 get: function () { 9850 return _index152[key]; 9851 }, 9852 }); 9853}); 9854var _index153 = __webpack_require__(263256); 9855Object.keys(_index153).forEach(function (key) { 9856 if (key === "default" || key === "__esModule") return; 9857 if (key in exports && exports[key] === _index153[key]) return; 9858 Object.defineProperty(exports, key, { 9859 enumerable: true, 9860 get: function () { 9861 return _index153[key]; 9862 }, 9863 }); 9864}); 9865var _index154 = __webpack_require__(251596); 9866Object.keys(_index154).forEach(function (key) { 9867 if (key === "default" || key === "__esModule") return; 9868 if (key in exports && exports[key] === _index154[key]) return; 9869 Object.defineProperty(exports, key, { 9870 enumerable: true, 9871 get: function () { 9872 return _index154[key]; 9873 }, 9874 }); 9875}); 9876var _index155 = __webpack_require__(118050);
9877Object.keys(_index155).forEach(function (key) { 9878 if (key === "default" || key === "__esModule") return; 9879 if (key in exports && exports[key] === _index155[key]) return; 9880 Object.defineProperty(exports, key, { 9881 enumerable: true, 9882 get: function () { 9883 return _index155[key]; 9884 }, 9885 }); 9886}); 9887var _index156 = __webpack_require__(485601); 9888Object.keys(_index156).forEach(function (key) { 9889 if (key === "default" || key === "__esModule") return; 9890 if (key in exports && exports[key] === _index156[key]) return; 9891 Object.defineProperty(exports, key, { 9892 enumerable: true, 9893 get: function () { 9894 return _index156[key]; 9895 }, 9896 }); 9897}); 9898var _index157 = __webpack_require__(426347); 9899Object.keys(_index157).forEach(function (key) { 9900 if (key === "default" || key === "__esModule") return; 9901 if (key in exports && exports[key] === _index157[key]) return; 9902 Object.defineProperty(exports, key, { 9903 enumerable: true, 9904 get: function () { 9905 return _index157[key]; 9906 }, 9907 }); 9908}); 9909var _index158 = __webpack_require__(692266); 9910Object.keys(_index158).forEach(function (key) { 9911 if (key === "default" || key === "__esModule") return; 9912 if (key in exports && exports[key] === _index158[key]) return; 9913 Object.defineProperty(exports, key, { 9914 enumerable: true, 9915 get: function () { 9916 return _index158[key]; 9917 }, 9918 }); 9919}); 9920var _index159 = __webpack_require__(418809); 9921Object.keys(_index159).forEach(function (key) { 9922 if (key === "default" || key === "__esModule") return; 9923 if (key in exports && exports[key] === _index159[key]) return; 9924 Object.defineProperty(exports, key, { 9925 enumerable: true, 9926 get: function () { 9927 return _index159[key]; 9928 }, 9929 }); 9930}); 9931var _index160 = __webpack_require__(507983); 9932Object.keys(_index160).forEach(function (key) { 9933 if (key === "default" || key === "__esModule") return; 9934 if (key in exports && exports[key] === _index160[key]) return; 9935 Object.defineProperty(exports, key, { 9936 enumerable: true, 9937 get: function () { 9938 return _index160[key]; 9939 }, 9940 }); 9941}); 9942var _index161 = __webpack_require__(557603); 9943Object.keys(_index161).forEach(function (key) { 9944 if (key === "default" || key === "__esModule") return; 9945 if (key in exports && exports[key] === _index161[key]) return; 9946 Object.defineProperty(exports, key, { 9947 enumerable: true, 9948 get: function () { 9949 return _index161[key]; 9950 }, 9951 }); 9952}); 9953var _index162 = __webpack_require__(95553); 9954Object.keys(_index162).forEach(function (key) { 9955 if (key === "default" || key === "__esModule") return; 9956 if (key in exports && exports[key] === _index162[key]) return; 9957 Object.defineProperty(exports, key, { 9958 enumerable: true, 9959 get: function () { 9960 return _index162[key]; 9961 }, 9962 }); 9963}); 9964var _index163 = __webpack_require__(9217); 9965Object.keys(_index163).forEach(function (key) { 9966 if (key === "default" || key === "__esModule") return; 9967 if (key in exports && exports[key] === _index163[key]) return; 9968 Object.defineProperty(exports, key, { 9969 enumerable: true, 9970 get: function () { 9971 return _index163[key]; 9972 }, 9973 }); 9974}); 9975var _index164 = __webpack_require__(746226); 9976Object.keys(_index164).forEach(function (key) { 9977 if (key === "default" || key === "__esModule") return; 9978 if (key in exports && exports[key] === _index164[key]) return; 9979 Object.defineProperty(exports, key, { 9980 enumerable: true, 9981 get: function () { 9982 return _index164[key]; 9983 }, 9984 }); 9985}); 9986var _index165 = __webpack_require__(538056); 9987Object.keys(_index165).forEach(function (key) { 9988 if (key === "default" || key === "__esModule") return; 9989 if (key in exports && exports[key] === _index165[key]) return; 9990 Object.defineProperty(exports, key, { 9991 enumerable: true, 9992 get: function () { 9993 return _index165[key]; 9994 }, 9995 }); 9996}); 9997var _index166 = __webpack_require__(980790); 9998Object.keys(_index166).forEach(function (key) { 9999 if (key === "default" || key === "__esModule") return; 10000 if (key in exports && exports[key] === _index166[key]) return; 10001 Object.defineProperty(exports, key, { 10002 enumerable: true, 10003 get: function () { 10004 return _index166[key]; 10005 }, 10006 }); 10007}); 10008var _index167 = __webpack_require__(446765);
10009Object.keys(_index167).forEach(function (key) { 10010 if (key === "default" || key === "__esModule") return; 10011 if (key in exports && exports[key] === _index167[key]) return; 10012 Object.defineProperty(exports, key, { 10013 enumerable: true, 10014 get: function () { 10015 return _index167[key]; 10016 }, 10017 }); 10018}); 10019var _index168 = __webpack_require__(274306); 10020Object.keys(_index168).forEach(function (key) { 10021 if (key === "default" || key === "__esModule") return; 10022 if (key in exports && exports[key] === _index168[key]) return; 10023 Object.defineProperty(exports, key, { 10024 enumerable: true, 10025 get: function () { 10026 return _index168[key]; 10027 }, 10028 }); 10029}); 10030var _index169 = __webpack_require__(209419); 10031Object.keys(_index169).forEach(function (key) { 10032 if (key === "default" || key === "__esModule") return; 10033 if (key in exports && exports[key] === _index169[key]) return; 10034 Object.defineProperty(exports, key, { 10035 enumerable: true, 10036 get: function () { 10037 return _index169[key]; 10038 }, 10039 }); 10040}); 10041var _index170 = __webpack_require__(335285); 10042Object.keys(_index170).forEach(function (key) { 10043 if (key === "default" || key === "__esModule") return; 10044 if (key in exports && exports[key] === _index170[key]) return; 10045 Object.defineProperty(exports, key, { 10046 enumerable: true, 10047 get: function () { 10048 return _index170[key]; 10049 }, 10050 }); 10051}); 10052var _index171 = __webpack_require__(972273); 10053Object.keys(_index171).forEach(function (key) { 10054 if (key === "default" || key === "__esModule") return; 10055 if (key in exports && exports[key] === _index171[key]) return; 10056 Object.defineProperty(exports, key, { 10057 enumerable: true, 10058 get: function () { 10059 return _index171[key]; 10060 }, 10061 }); 10062}); 10063var _index172 = __webpack_require__(787767); 10064Object.keys(_index172).forEach(function (key) { 10065 if (key === "default" || key === "__esModule") return; 10066 if (key in exports && exports[key] === _index172[key]) return; 10067 Object.defineProperty(exports, key, { 10068 enumerable: true, 10069 get: function () { 10070 return _index172[key]; 10071 }, 10072 }); 10073}); 10074var _index173 = __webpack_require__(676965); 10075Object.keys(_index173).forEach(function (key) { 10076 if (key === "default" || key === "__esModule") return; 10077 if (key in exports && exports[key] === _index173[key]) return; 10078 Object.defineProperty(exports, key, { 10079 enumerable: true, 10080 get: function () { 10081 return _index173[key]; 10082 }, 10083 }); 10084}); 10085var _index174 = __webpack_require__(554589); 10086Object.keys(_index174).forEach(function (key) { 10087 if (key === "default" || key === "__esModule") return; 10088 if (key in exports && exports[key] === _index174[key]) return; 10089 Object.defineProperty(exports, key, { 10090 enumerable: true, 10091 get: function () { 10092 return _index174[key]; 10093 }, 10094 }); 10095}); 10096var _index175 = __webpack_require__(824790); 10097Object.keys(_index175).forEach(function (key) { 10098 if (key === "default" || key === "__esModule") return; 10099 if (key in exports && exports[key] === _index175[key]) return; 10100 Object.defineProperty(exports, key, { 10101 enumerable: true, 10102 get: function () { 10103 return _index175[key]; 10104 }, 10105 }); 10106}); 10107var _index176 = __webpack_require__(74109); 10108Object.keys(_index176).forEach(function (key) { 10109 if (key === "default" || key === "__esModule") return; 10110 if (key in exports && exports[key] === _index176[key]) return; 10111 Object.defineProperty(exports, key, { 10112 enumerable: true, 10113 get: function () { 10114 return _index176[key]; 10115 }, 10116 }); 10117}); 10118var _index177 = __webpack_require__(699877); 10119Object.keys(_index177).forEach(function (key) { 10120 if (key === "default" || key === "__esModule") return; 10121 if (key in exports && exports[key] === _index177[key]) return; 10122 Object.defineProperty(exports, key, { 10123 enumerable: true, 10124 get: function () { 10125 return _index177[key]; 10126 }, 10127 }); 10128}); 10129var _index178 = __webpack_require__(756971); 10130Object.keys(_index178).forEach(function (key) { 10131 if (key === "default" || key === "__esModule") return; 10132 if (key in exports && exports[key] === _index178[key]) return; 10133 Object.defineProperty(exports, key, { 10134 enumerable: true, 10135 get: function () { 10136 return _index178[key]; 10137 }, 10138 }); 10139}); 10140var _index179 = __webpack_require__(67416); 10141Object.keys(_index179).forEach(function (key) {
10142 if (key === "default" || key === "__esModule") return; 10143 if (key in exports && exports[key] === _index179[key]) return; 10144 Object.defineProperty(exports, key, { 10145 enumerable: true, 10146 get: function () { 10147 return _index179[key]; 10148 }, 10149 }); 10150}); 10151var _index180 = __webpack_require__(605393); 10152Object.keys(_index180).forEach(function (key) { 10153 if (key === "default" || key === "__esModule") return; 10154 if (key in exports && exports[key] === _index180[key]) return; 10155 Object.defineProperty(exports, key, { 10156 enumerable: true, 10157 get: function () { 10158 return _index180[key]; 10159 }, 10160 }); 10161}); 10162var _index181 = __webpack_require__(156138); 10163Object.keys(_index181).forEach(function (key) { 10164 if (key === "default" || key === "__esModule") return; 10165 if (key in exports && exports[key] === _index181[key]) return; 10166 Object.defineProperty(exports, key, { 10167 enumerable: true, 10168 get: function () { 10169 return _index181[key]; 10170 }, 10171 }); 10172}); 10173var _index182 = __webpack_require__(512901); 10174Object.keys(_index182).forEach(function (key) { 10175 if (key === "default" || key === "__esModule") return; 10176 if (key in exports && exports[key] === _index182[key]) return; 10177 Object.defineProperty(exports, key, { 10178 enumerable: true, 10179 get: function () { 10180 return _index182[key]; 10181 }, 10182 }); 10183}); 10184var _index183 = __webpack_require__(812822); 10185Object.keys(_index183).forEach(function (key) { 10186 if (key === "default" || key === "__esModule") return; 10187 if (key in exports && exports[key] === _index183[key]) return; 10188 Object.defineProperty(exports, key, { 10189 enumerable: true, 10190 get: function () { 10191 return _index183[key]; 10192 }, 10193 }); 10194}); 10195var _index184 = __webpack_require__(55662); 10196Object.keys(_index184).forEach(function (key) { 10197 if (key === "default" || key === "__esModule") return; 10198 if (key in exports && exports[key] === _index184[key]) return; 10199 Object.defineProperty(exports, key, { 10200 enumerable: true, 10201 get: function () { 10202 return _index184[key]; 10203 }, 10204 }); 10205}); 10206var _index185 = __webpack_require__(992518); 10207Object.keys(_index185).forEach(function (key) { 10208 if (key === "default" || key === "__esModule") return; 10209 if (key in exports && exports[key] === _index185[key]) return; 10210 Object.defineProperty(exports, key, { 10211 enumerable: true, 10212 get: function () { 10213 return _index185[key]; 10214 }, 10215 }); 10216}); 10217var _index186 = __webpack_require__(305289); 10218Object.keys(_index186).forEach(function (key) { 10219 if (key === "default" || key === "__esModule") return; 10220 if (key in exports && exports[key] === _index186[key]) return; 10221 Object.defineProperty(exports, key, { 10222 enumerable: true, 10223 get: function () { 10224 return _index186[key]; 10225 }, 10226 }); 10227}); 10228var _index187 = __webpack_require__(195056); 10229Object.keys(_index187).forEach(function (key) { 10230 if (key === "default" || key === "__esModule") return; 10231 if (key in exports && exports[key] === _index187[key]) return; 10232 Object.defineProperty(exports, key, { 10233 enumerable: true, 10234 get: function () { 10235 return _index187[key]; 10236 }, 10237 }); 10238}); 10239var _index188 = __webpack_require__(465465); 10240Object.keys(_index188).forEach(function (key) { 10241 if (key === "default" || key === "__esModule") return; 10242 if (key in exports && exports[key] === _index188[key]) return; 10243 Object.defineProperty(exports, key, { 10244 enumerable: true, 10245 get: function () { 10246 return _index188[key]; 10247 }, 10248 }); 10249}); 10250var _index189 = __webpack_require__(66233); 10251Object.keys(_index189).forEach(function (key) { 10252 if (key === "default" || key === "__esModule") return; 10253 if (key in exports && exports[key] === _index189[key]) return; 10254 Object.defineProperty(exports, key, { 10255 enumerable: true, 10256 get: function () { 10257 return _index189[key]; 10258 }, 10259 }); 10260}); 10261var _index190 = __webpack_require__(298999); 10262Object.keys(_index190).forEach(function (key) { 10263 if (key === "default" || key === "__esModule") return; 10264 if (key in exports && exports[key] === _index190[key]) return; 10265 Object.defineProperty(exports, key, { 10266 enumerable: true, 10267 get: function () { 10268 return _index190[key]; 10269 }, 10270 }); 10271}); 10272var _index191 = __webpack_require__(895829);
10273Object.keys(_index191).forEach(function (key) { 10274 if (key === "default" || key === "__esModule") return; 10275 if (key in exports && exports[key] === _index191[key]) return; 10276 Object.defineProperty(exports, key, { 10277 enumerable: true, 10278 get: function () { 10279 return _index191[key]; 10280 }, 10281 }); 10282}); 10283var _index192 = __webpack_require__(62450); 10284Object.keys(_index192).forEach(function (key) { 10285 if (key === "default" || key === "__esModule") return; 10286 if (key in exports && exports[key] === _index192[key]) return; 10287 Object.defineProperty(exports, key, { 10288 enumerable: true, 10289 get: function () { 10290 return _index192[key]; 10291 }, 10292 }); 10293}); 10294var _index193 = __webpack_require__(752405); 10295Object.keys(_index193).forEach(function (key) { 10296 if (key === "default" || key === "__esModule") return; 10297 if (key in exports && exports[key] === _index193[key]) return; 10298 Object.defineProperty(exports, key, { 10299 enumerable: true, 10300 get: function () { 10301 return _index193[key]; 10302 }, 10303 }); 10304}); 10305var _index194 = __webpack_require__(548802); 10306Object.keys(_index194).forEach(function (key) { 10307 if (key === "default" || key === "__esModule") return; 10308 if (key in exports && exports[key] === _index194[key]) return; 10309 Object.defineProperty(exports, key, { 10310 enumerable: true, 10311 get: function () { 10312 return _index194[key]; 10313 }, 10314 }); 10315}); 10316var _index195 = __webpack_require__(686580); 10317Object.keys(_index195).forEach(function (key) { 10318 if (key === "default" || key === "__esModule") return; 10319 if (key in exports && exports[key] === _index195[key]) return; 10320 Object.defineProperty(exports, key, { 10321 enumerable: true, 10322 get: function () { 10323 return _index195[key]; 10324 }, 10325 }); 10326}); 10327var _index196 = __webpack_require__(309146); 10328Object.keys(_index196).forEach(function (key) { 10329 if (key === "default" || key === "__esModule") return; 10330 if (key in exports && exports[key] === _index196[key]) return; 10331 Object.defineProperty(exports, key, { 10332 enumerable: true, 10333 get: function () { 10334 return _index196[key]; 10335 }, 10336 }); 10337}); 10338var _index197 = __webpack_require__(349501); 10339Object.keys(_index197).forEach(function (key) { 10340 if (key === "default" || key === "__esModule") return; 10341 if (key in exports && exports[key] === _index197[key]) return; 10342 Object.defineProperty(exports, key, { 10343 enumerable: true, 10344 get: function () { 10345 return _index197[key]; 10346 }, 10347 }); 10348}); 10349var _index198 = __webpack_require__(824308); 10350Object.keys(_index198).forEach(function (key) { 10351 if (key === "default" || key === "__esModule") return; 10352 if (key in exports && exports[key] === _index198[key]) return; 10353 Object.defineProperty(exports, key, { 10354 enumerable: true, 10355 get: function () { 10356 return _index198[key]; 10357 }, 10358 }); 10359}); 10360var _index199 = __webpack_require__(487358); 10361Object.keys(_index199).forEach(function (key) { 10362 if (key === "default" || key === "__esModule") return; 10363 if (key in exports && exports[key] === _index199[key]) return; 10364 Object.defineProperty(exports, key, { 10365 enumerable: true, 10366 get: function () { 10367 return _index199[key]; 10368 }, 10369 }); 10370}); 10371var _index200 = __webpack_require__(56373); 10372Object.keys(_index200).forEach(function (key) { 10373 if (key === "default" || key === "__esModule") return; 10374 if (key in exports && exports[key] === _index200[key]) return; 10375 Object.defineProperty(exports, key, { 10376 enumerable: true, 10377 get: function () { 10378 return _index200[key]; 10379 }, 10380 }); 10381}); 10382var _index201 = __webpack_require__(115408); 10383Object.keys(_index201).forEach(function (key) { 10384 if (key === "default" || key === "__esModule") return; 10385 if (key in exports && exports[key] === _index201[key]) return; 10386 Object.defineProperty(exports, key, { 10387 enumerable: true, 10388 get: function () { 10389 return _index201[key]; 10390 }, 10391 }); 10392}); 10393var _index202 = __webpack_require__(359184); 10394Object.keys(_index202).forEach(function (key) { 10395 if (key === "default" || key === "__esModule") return; 10396 if (key in exports && exports[key] === _index202[key]) return; 10397 Object.defineProperty(exports, key, { 10398 enumerable: true, 10399 get: function () { 10400 return _index202[key]; 10401 }, 10402 }); 10403}); 10404var _index203 = __webpack_require__(887958); 10405Object.keys(_index203).forEach(function (key) {
10406 if (key === "default" || key === "__esModule") return; 10407 if (key in exports && exports[key] === _index203[key]) return; 10408 Object.defineProperty(exports, key, { 10409 enumerable: true, 10410 get: function () { 10411 return _index203[key]; 10412 }, 10413 }); 10414}); 10415var _index204 = __webpack_require__(205523); 10416Object.keys(_index204).forEach(function (key) { 10417 if (key === "default" || key === "__esModule") return; 10418 if (key in exports && exports[key] === _index204[key]) return; 10419 Object.defineProperty(exports, key, { 10420 enumerable: true, 10421 get: function () { 10422 return _index204[key]; 10423 }, 10424 }); 10425}); 10426var _index205 = __webpack_require__(22219); 10427Object.keys(_index205).forEach(function (key) { 10428 if (key === "default" || key === "__esModule") return; 10429 if (key in exports && exports[key] === _index205[key]) return; 10430 Object.defineProperty(exports, key, { 10431 enumerable: true, 10432 get: function () { 10433 return _index205[key]; 10434 }, 10435 }); 10436}); 10437var _index206 = __webpack_require__(616689); 10438Object.keys(_index206).forEach(function (key) { 10439 if (key === "default" || key === "__esModule") return; 10440 if (key in exports && exports[key] === _index206[key]) return; 10441 Object.defineProperty(exports, key, { 10442 enumerable: true, 10443 get: function () { 10444 return _index206[key]; 10445 }, 10446 }); 10447}); 10448var _index207 = __webpack_require__(253553); 10449Object.keys(_index207).forEach(function (key) { 10450 if (key === "default" || key === "__esModule") return; 10451 if (key in exports && exports[key] === _index207[key]) return; 10452 Object.defineProperty(exports, key, { 10453 enumerable: true, 10454 get: function () { 10455 return _index207[key]; 10456 }, 10457 }); 10458}); 10459var _index208 = __webpack_require__(325108); 10460Object.keys(_index208).forEach(function (key) { 10461 if (key === "default" || key === "__esModule") return; 10462 if (key in exports && exports[key] === _index208[key]) return; 10463 Object.defineProperty(exports, key, { 10464 enumerable: true, 10465 get: function () { 10466 return _index208[key]; 10467 }, 10468 }); 10469}); 10470var _index209 = __webpack_require__(700273); 10471Object.keys(_index209).forEach(function (key) { 10472 if (key === "default" || key === "__esModule") return; 10473 if (key in exports && exports[key] === _index209[key]) return; 10474 Object.defineProperty(exports, key, { 10475 enumerable: true, 10476 get: function () { 10477 return _index209[key]; 10478 }, 10479 }); 10480}); 10481var _index210 = __webpack_require__(76242); 10482Object.keys(_index210).forEach(function (key) { 10483 if (key === "default" || key === "__esModule") return; 10484 if (key in exports && exports[key] === _index210[key]) return; 10485 Object.defineProperty(exports, key, { 10486 enumerable: true, 10487 get: function () { 10488 return _index210[key]; 10489 }, 10490 }); 10491}); 10492var _index211 = __webpack_require__(313074); 10493Object.keys(_index211).forEach(function (key) { 10494 if (key === "default" || key === "__esModule") return; 10495 if (key in exports && exports[key] === _index211[key]) return; 10496 Object.defineProperty(exports, key, { 10497 enumerable: true, 10498 get: function () { 10499 return _index211[key]; 10500 }, 10501 }); 10502}); 10503var _index212 = __webpack_require__(145580); 10504Object.keys(_index212).forEach(function (key) { 10505 if (key === "default" || key === "__esModule") return; 10506 if (key in exports && exports[key] === _index212[key]) return; 10507 Object.defineProperty(exports, key, { 10508 enumerable: true, 10509 get: function () { 10510 return _index212[key]; 10511 }, 10512 }); 10513}); 10514var _index213 = __webpack_require__(731010); 10515Object.keys(_index213).forEach(function (key) { 10516 if (key === "default" || key === "__esModule") return; 10517 if (key in exports && exports[key] === _index213[key]) return; 10518 Object.defineProperty(exports, key, { 10519 enumerable: true, 10520 get: function () { 10521 return _index213[key]; 10522 }, 10523 }); 10524}); 10525var _index214 = __webpack_require__(305637); 10526Object.keys(_index214).forEach(function (key) { 10527 if (key === "default" || key === "__esModule") return; 10528 if (key in exports && exports[key] === _index214[key]) return; 10529 Object.defineProperty(exports, key, { 10530 enumerable: true, 10531 get: function () { 10532 return _index214[key]; 10533 }, 10534 }); 10535}); 10536var _index215 = __webpack_require__(233849);
10537Object.keys(_index215).forEach(function (key) { 10538 if (key === "default" || key === "__esModule") return; 10539 if (key in exports && exports[key] === _index215[key]) return; 10540 Object.defineProperty(exports, key, { 10541 enumerable: true, 10542 get: function () { 10543 return _index215[key]; 10544 }, 10545 }); 10546}); 10547var _index216 = __webpack_require__(266795); 10548Object.keys(_index216).forEach(function (key) { 10549 if (key === "default" || key === "__esModule") return; 10550 if (key in exports && exports[key] === _index216[key]) return; 10551 Object.defineProperty(exports, key, { 10552 enumerable: true, 10553 get: function () { 10554 return _index216[key]; 10555 }, 10556 }); 10557}); 10558var _index217 = __webpack_require__(116666); 10559Object.keys(_index217).forEach(function (key) { 10560 if (key === "default" || key === "__esModule") return; 10561 if (key in exports && exports[key] === _index217[key]) return; 10562 Object.defineProperty(exports, key, { 10563 enumerable: true, 10564 get: function () { 10565 return _index217[key]; 10566 }, 10567 }); 10568}); 10569var _index218 = __webpack_require__(537104); 10570Object.keys(_index218).forEach(function (key) { 10571 if (key === "default" || key === "__esModule") return; 10572 if (key in exports && exports[key] === _index218[key]) return; 10573 Object.defineProperty(exports, key, { 10574 enumerable: true, 10575 get: function () { 10576 return _index218[key]; 10577 }, 10578 }); 10579}); 10580var _index219 = __webpack_require__(185557); 10581Object.keys(_index219).forEach(function (key) { 10582 if (key === "default" || key === "__esModule") return; 10583 if (key in exports && exports[key] === _index219[key]) return; 10584 Object.defineProperty(exports, key, { 10585 enumerable: true, 10586 get: function () { 10587 return _index219[key]; 10588 }, 10589 }); 10590}); 10591var _index220 = __webpack_require__(927907); 10592Object.keys(_index220).forEach(function (key) { 10593 if (key === "default" || key === "__esModule") return; 10594 if (key in exports && exports[key] === _index220[key]) return; 10595 Object.defineProperty(exports, key, { 10596 enumerable: true, 10597 get: function () { 10598 return _index220[key]; 10599 }, 10600 }); 10601}); 10602var _index221 = __webpack_require__(42247); 10603Object.keys(_index221).forEach(function (key) { 10604 if (key === "default" || key === "__esModule") return; 10605 if (key in exports && exports[key] === _index221[key]) return; 10606 Object.defineProperty(exports, key, { 10607 enumerable: true, 10608 get: function () { 10609 return _index221[key]; 10610 }, 10611 }); 10612}); 10613var _index222 = __webpack_require__(496716); 10614Object.keys(_index222).forEach(function (key) { 10615 if (key === "default" || key === "__esModule") return; 10616 if (key in exports && exports[key] === _index222[key]) return; 10617 Object.defineProperty(exports, key, { 10618 enumerable: true, 10619 get: function () { 10620 return _index222[key]; 10621 }, 10622 }); 10623}); 10624var _index223 = __webpack_require__(55923); 10625Object.keys(_index223).forEach(function (key) { 10626 if (key === "default" || key === "__esModule") return; 10627 if (key in exports && exports[key] === _index223[key]) return; 10628 Object.defineProperty(exports, key, { 10629 enumerable: true, 10630 get: function () { 10631 return _index223[key]; 10632 }, 10633 }); 10634}); 10635var _index224 = __webpack_require__(517805); 10636Object.keys(_index224).forEach(function (key) { 10637 if (key === "default" || key === "__esModule") return; 10638 if (key in exports && exports[key] === _index224[key]) return; 10639 Object.defineProperty(exports, key, { 10640 enumerable: true, 10641 get: function () { 10642 return _index224[key]; 10643 }, 10644 }); 10645}); 10646var _index225 = __webpack_require__(264616); 10647Object.keys(_index225).forEach(function (key) { 10648 if (key === "default" || key === "__esModule") return; 10649 if (key in exports && exports[key] === _index225[key]) return; 10650 Object.defineProperty(exports, key, { 10651 enumerable: true, 10652 get: function () { 10653 return _index225[key]; 10654 }, 10655 }); 10656}); 10657var _index226 = __webpack_require__(215913); 10658Object.keys(_index226).forEach(function (key) { 10659 if (key === "default" || key === "__esModule") return; 10660 if (key in exports && exports[key] === _index226[key]) return; 10661 Object.defineProperty(exports, key, { 10662 enumerable: true, 10663 get: function () { 10664 return _index226[key]; 10665 }, 10666 }); 10667}); 10668var _index227 = __webpack_require__(469316);
10669Object.keys(_index227).forEach(function (key) { 10670 if (key === "default" || key === "__esModule") return; 10671 if (key in exports && exports[key] === _index227[key]) return; 10672 Object.defineProperty(exports, key, { 10673 enumerable: true, 10674 get: function () { 10675 return _index227[key]; 10676 }, 10677 }); 10678}); 10679var _index228 = __webpack_require__(178240); 10680Object.keys(_index228).forEach(function (key) { 10681 if (key === "default" || key === "__esModule") return; 10682 if (key in exports && exports[key] === _index228[key]) return; 10683 Object.defineProperty(exports, key, { 10684 enumerable: true, 10685 get: function () { 10686 return _index228[key]; 10687 }, 10688 }); 10689}); 10690var _index229 = __webpack_require__(165102); 10691Object.keys(_index229).forEach(function (key) { 10692 if (key === "default" || key === "__esModule") return; 10693 if (key in exports && exports[key] === _index229[key]) return; 10694 Object.defineProperty(exports, key, { 10695 enumerable: true, 10696 get: function () { 10697 return _index229[key]; 10698 }, 10699 }); 10700}); 10701var _index230 = __webpack_require__(678293); 10702Object.keys(_index230).forEach(function (key) { 10703 if (key === "default" || key === "__esModule") return; 10704 if (key in exports && exports[key] === _index230[key]) return; 10705 Object.defineProperty(exports, key, { 10706 enumerable: true, 10707 get: function () { 10708 return _index230[key]; 10709 }, 10710 }); 10711}); 10712var _index231 = __webpack_require__(115713); 10713Object.keys(_index231).forEach(function (key) { 10714 if (key === "default" || key === "__esModule") return; 10715 if (key in exports && exports[key] === _index231[key]) return; 10716 Object.defineProperty(exports, key, { 10717 enumerable: true, 10718 get: function () { 10719 return _index231[key]; 10720 }, 10721 }); 10722}); 10723var _index232 = __webpack_require__(120582); 10724Object.keys(_index232).forEach(function (key) { 10725 if (key === "default" || key === "__esModule") return; 10726 if (key in exports && exports[key] === _index232[key]) return; 10727 Object.defineProperty(exports, key, { 10728 enumerable: true, 10729 get: function () { 10730 return _index232[key]; 10731 }, 10732 }); 10733}); 10734var _index233 = __webpack_require__(459995); 10735Object.keys(_index233).forEach(function (key) { 10736 if (key === "default" || key === "__esModule") return; 10737 if (key in exports && exports[key] === _index233[key]) return; 10738 Object.defineProperty(exports, key, { 10739 enumerable: true, 10740 get: function () { 10741 return _index233[key]; 10742 }, 10743 }); 10744}); 10745var _index234 = __webpack_require__(543117); 10746Object.keys(_index234).forEach(function (key) { 10747 if (key === "default" || key === "__esModule") return; 10748 if (key in exports && exports[key] === _index234[key]) return; 10749 Object.defineProperty(exports, key, { 10750 enumerable: true, 10751 get: function () { 10752 return _index234[key]; 10753 }, 10754 }); 10755}); 10756var _index235 = __webpack_require__(655758); 10757Object.keys(_index235).forEach(function (key) { 10758 if (key === "default" || key === "__esModule") return; 10759 if (key in exports && exports[key] === _index235[key]) return; 10760 Object.defineProperty(exports, key, { 10761 enumerable: true, 10762 get: function () { 10763 return _index235[key]; 10764 }, 10765 }); 10766}); 10767var _index236 = __webpack_require__(428366); 10768Object.keys(_index236).forEach(function (key) { 10769 if (key === "default" || key === "__esModule") return; 10770 if (key in exports && exports[key] === _index236[key]) return; 10771 Object.defineProperty(exports, key, { 10772 enumerable: true, 10773 get: function () { 10774 return _index236[key]; 10775 }, 10776 }); 10777}); 10778var _index237 = __webpack_require__(149892); 10779Object.keys(_index237).forEach(function (key) { 10780 if (key === "default" || key === "__esModule") return; 10781 if (key in exports && exports[key] === _index237[key]) return; 10782 Object.defineProperty(exports, key, { 10783 enumerable: true, 10784 get: function () { 10785 return _index237[key]; 10786 }, 10787 }); 10788}); 10789var _index238 = __webpack_require__(472861); 10790Object.keys(_index238).forEach(function (key) { 10791 if (key === "default" || key === "__esModule") return; 10792 if (key in exports && exports[key] === _index238[key]) return; 10793 Object.defineProperty(exports, key, { 10794 enumerable: true, 10795 get: function () { 10796 return _index238[key]; 10797 }, 10798 }); 10799}); 10800var _index239 = __webpack_require__(874148); 10801Object.keys(_index239).forEach(function (key) {
vendor: 6,142 bytes, lines 10802-11002
10802 if (key === "default" || key === "__esModule") return; 10803 if (key in exports && exports[key] === _index239[key]) return; 10804 Object.defineProperty(exports, key, { 10805 enumerable: true, 10806 get: function () { 10807 return _index239[key]; 10808 }, 10809 }); 10810}); 10811var _index240 = __webpack_require__(807799); 10812Object.keys(_index240).forEach(function (key) { 10813 if (key === "default" || key === "__esModule") return; 10814 if (key in exports && exports[key] === _index240[key]) return; 10815 Object.defineProperty(exports, key, { 10816 enumerable: true, 10817 get: function () { 10818 return _index240[key]; 10819 }, 10820 }); 10821}); 10822var _index241 = __webpack_require__(463941); 10823Object.keys(_index241).forEach(function (key) { 10824 if (key === "default" || key === "__esModule") return; 10825 if (key in exports && exports[key] === _index241[key]) return; 10826 Object.defineProperty(exports, key, { 10827 enumerable: true, 10828 get: function () { 10829 return _index241[key]; 10830 }, 10831 }); 10832}); 10833var _index242 = __webpack_require__(456440); 10834Object.keys(_index242).forEach(function (key) { 10835 if (key === "default" || key === "__esModule") return; 10836 if (key in exports && exports[key] === _index242[key]) return; 10837 Object.defineProperty(exports, key, { 10838 enumerable: true, 10839 get: function () { 10840 return _index242[key]; 10841 }, 10842 }); 10843}); 10844var _index243 = __webpack_require__(41387); 10845Object.keys(_index243).forEach(function (key) { 10846 if (key === "default" || key === "__esModule") return; 10847 if (key in exports && exports[key] === _index243[key]) return; 10848 Object.defineProperty(exports, key, { 10849 enumerable: true, 10850 get: function () { 10851 return _index243[key]; 10852 }, 10853 }); 10854}); 10855var _index244 = __webpack_require__(178996); 10856Object.keys(_index244).forEach(function (key) { 10857 if (key === "default" || key === "__esModule") return; 10858 if (key in exports && exports[key] === _index244[key]) return; 10859 Object.defineProperty(exports, key, { 10860 enumerable: true, 10861 get: function () { 10862 return _index244[key]; 10863 }, 10864 }); 10865}); 10866var _index245 = __webpack_require__(107443); 10867Object.keys(_index245).forEach(function (key) { 10868 if (key === "default" || key === "__esModule") return; 10869 if (key in exports && exports[key] === _index245[key]) return; 10870 Object.defineProperty(exports, key, { 10871 enumerable: true, 10872 get: function () { 10873 return _index245[key]; 10874 }, 10875 }); 10876}); 10877 10878 10879/***/ }), 10880 10881/***/ 711276: 10882/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 10883 10884"use strict"; 10885 10886exports.interval = interval; 10887var _index = __webpack_require__(947561); 10888 10889/** 10890 * The {@link interval} function options. 10891 */ 10892 10893/** 10894 * The {@link interval} function result type. It resolves the proper data type. 10895 * It uses the first argument date object type, starting from the start argument, 10896 * then the end interval date. If a context function is passed, it uses the context 10897 * function return type. 10898 */ 10899 10900/** 10901 * @name interval 10902 * @category Interval Helpers 10903 * @summary Creates an interval object and validates its values. 10904 * 10905 * @description 10906 * Creates a normalized interval object and validates its values. If the interval is invalid, an exception is thrown. 10907 * 10908 * @typeParam StartDate - Start date type. 10909 * @typeParam EndDate - End date type. 10910 * @typeParam Options - Options type. 10911 * 10912 * @param start - The start of the interval. 10913 * @param end - The end of the interval. 10914 * @param options - The options object. 10915 * 10916 * @throws `Start date is invalid` when `start` is invalid. 10917 * @throws `End date is invalid` when `end` is invalid. 10918 * @throws `End date must be after start date` when end is before `start` and `options.assertPositive` is true. 10919 * 10920 * @returns The normalized and validated interval object. 10921 */ 10922function interval(start, end, options) { 10923 const [_start, _end] = (0, _index.normalizeDates)(options?.in, start, end); 10924 10925 if (isNaN(+_start)) throw new TypeError("Start date is invalid"); 10926 if (isNaN(+_end)) throw new TypeError("End date is invalid"); 10927 10928 if (options?.assertPositive && +_start > +_end) 10929 throw new TypeError("End date must be after start date"); 10930 10931 return { start: _start, end: _end }; 10932} 10933 10934 10935/***/ }), 10936 10937/***/ 732715: 10938/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 10939 10940"use strict"; 10941 10942exports.intervalToDuration = intervalToDuration; 10943var _index = __webpack_require__(525175); 10944var _index2 = __webpack_require__(789198); 10945var _index3 = __webpack_require__(820537); 10946var _index4 = __webpack_require__(937549); 10947var _index5 = __webpack_require__(371501); 10948var _index6 = __webpack_require__(976081); 10949var _index7 = __webpack_require__(454975); 10950var _index8 = __webpack_require__(144528); 10951 10952/** 10953 * The {@link intervalToDuration} function options. 10954 */ 10955 10956/** 10957 * @name intervalToDuration 10958 * @category Common Helpers 10959 * @summary Convert interval to duration 10960 * 10961 * @description 10962 * Convert an interval object to a duration object. 10963 * 10964 * @param interval - The interval to convert to duration 10965 * @param options - The context options 10966 * 10967 * @returns The duration object 10968 * 10969 * @example 10970 * // Get the duration between January 15, 1929 and April 4, 1968. 10971 * intervalToDuration({ 10972 * start: new Date(1929, 0, 15, 12, 0, 0), 10973 * end: new Date(1968, 3, 4, 19, 5, 0) 10974 * }); 10975 * //=> { years: 39, months: 2, days: 20, hours: 7, minutes: 5, seconds: 0 } 10976 */ 10977function intervalToDuration(interval, options) { 10978 const { start, end } = (0, _index.normalizeInterval)(options?.in, interval); 10979 const duration = {}; 10980 10981 const years = (0, _index8.differenceInYears)(end, start); 10982 if (years) duration.years = years; 10983 10984 const remainingMonths = (0, _index2.add)(start, { years: duration.years }); 10985 const months = (0, _index6.differenceInMonths)(end, remainingMonths); 10986 if (months) duration.months = months; 10987 10988 const remainingDays = (0, _index2.add)(remainingMonths, { 10989 months: duration.months, 10990 }); 10991 const days = (0, _index3.differenceInDays)(end, remainingDays); 10992 if (days) duration.days = days; 10993 10994 const remainingHours = (0, _index2.add)(remainingDays, { 10995 days: duration.days, 10996 }); 10997 const hours = (0, _index4.differenceInHours)(end, remainingHours); 10998 if (hours) duration.hours = hours; 10999 11000 const remainingMinutes = (0, _index2.add)(remainingHours, { 11001 hours: duration.hours, 11002 });
11003 const minutes = (0, _index5.differenceInMinutes)(end, remainingMinutes); 11004 if (minutes) duration.minutes = minutes; 11005 11006 const remainingSeconds = (0, _index2.add)(remainingMinutes, { 11007 minutes: duration.minutes, 11008 }); 11009 const seconds = (0, _index7.differenceInSeconds)(end, remainingSeconds); 11010 if (seconds) duration.seconds = seconds; 11011 11012 return duration; 11013} 11014 11015 11016/***/ }), 11017 11018/***/ 282596: 11019/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11020 11021"use strict"; 11022 11023exports.intlFormat = intlFormat; 11024var _index = __webpack_require__(807799); 11025 11026/** 11027 * The locale string (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument). 11028 * @deprecated 11029 * 11030 * [TODO] Remove in v4 11031 */ 11032 11033/** 11034 * The format options (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#options) 11035 */ 11036 11037/** 11038 * The locale options. 11039 */ 11040 11041/** 11042 * @name intlFormat 11043 * @category Common Helpers 11044 * @summary Format the date with Intl.DateTimeFormat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat). 11045 * 11046 * @description 11047 * Return the formatted date string in the given format. 11048 * The method uses [`Intl.DateTimeFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) inside. 11049 * formatOptions are the same as [`Intl.DateTimeFormat` options](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options) 11050 * 11051 * > â ï¸ Please note that before Node version 13.0.0, only the locale data for en-US is available by default. 11052 * 11053 * @param date - The date to format 11054 * 11055 * @returns The formatted date string 11056 * 11057 * @throws `date` must not be Invalid Date 11058 * 11059 * @example 11060 * // Represent 4 October 2019 in middle-endian format: 11061 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456)) 11062 * //=> 10/4/2019 11063 */ 11064 11065/** 11066 * @param date - The date to format 11067 * @param localeOptions - An object with locale 11068 * 11069 * @returns The formatted date string 11070 * 11071 * @throws `date` must not be Invalid Date 11072 * 11073 * @example 11074 * // Represent 4 October 2019 in Korean. 11075 * // Convert the date with locale's options. 11076 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), { 11077 * locale: 'ko-KR', 11078 * }) 11079 * //=> 2019. 10. 4. 11080 */ 11081 11082/** 11083 * @param date - The date to format 11084 * @param formatOptions - The format options 11085 * 11086 * @returns The formatted date string 11087 * 11088 * @throws `date` must not be Invalid Date 11089 * 11090 * @example 11091 * // Represent 4 October 2019. 11092 * // Convert the date with format's options. 11093 * const result = intlFormat.default(new Date(2019, 9, 4, 12, 30, 13, 456), { 11094 * year: 'numeric', 11095 * month: 'numeric', 11096 * day: 'numeric', 11097 * hour: 'numeric', 11098 * }) 11099 * //=> 10/4/2019, 12 PM 11100 */ 11101 11102/** 11103 * @param date - The date to format 11104 * @param formatOptions - The format options 11105 * @param localeOptions - An object with locale 11106 * 11107 * @returns The formatted date string 11108 * 11109 * @throws `date` must not be Invalid Date 11110 * 11111 * @example 11112 * // Represent 4 October 2019 in German. 11113 * // Convert the date with format's options and locale's options. 11114 * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), { 11115 * weekday: 'long', 11116 * year: 'numeric', 11117 * month: 'long', 11118 * day: 'numeric', 11119 * }, { 11120 * locale: 'de-DE', 11121 * }) 11122 * //=> Freitag, 4. Oktober 2019 11123 */ 11124 11125function intlFormat(date, formatOrLocale, localeOptions) { 11126 let formatOptions; 11127 11128 if (isFormatOptions(formatOrLocale)) { 11129 formatOptions = formatOrLocale; 11130 } else { 11131 localeOptions = formatOrLocale; 11132 } 11133 11134 return new Intl.DateTimeFormat(localeOptions?.locale, formatOptions).format( 11135 (0, _index.toDate)(date), 11136 ); 11137} 11138 11139function isFormatOptions(opts) { 11140 return opts !== undefined && !("locale" in opts); 11141} 11142 11143 11144/***/ }), 11145 11146/***/ 913197: 11147/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11148 11149"use strict"; 11150 11151exports.intlFormatDistance = intlFormatDistance; 11152var _index = __webpack_require__(947561); 11153var _index2 = __webpack_require__(241836); 11154 11155var _index3 = __webpack_require__(72028); 11156var _index4 = __webpack_require__(362530); 11157var _index5 = __webpack_require__(900677); 11158var _index6 = __webpack_require__(124071); 11159var _index7 = __webpack_require__(199067); 11160var _index8 = __webpack_require__(937549); 11161var _index9 = __webpack_require__(371501); 11162var _index10 = __webpack_require__(454975); 11163 11164/** 11165 * The {@link intlFormatDistance} function options. 11166 */ 11167 11168/** 11169 * The unit used to format the distance in {@link intlFormatDistance}. 11170 */ 11171 11172/** 11173 * @name intlFormatDistance 11174 * @category Common Helpers 11175 * @summary Formats distance between two dates in a human-readable format 11176 * @description 11177 * The function calculates the difference between two dates and formats it as a human-readable string. 11178 * 11179 * The function will pick the most appropriate unit depending on the distance between dates. For example, if the distance is a few hours, it might return `x hours`. If the distance is a few months, it might return `x months`. 11180 * 11181 * You can also specify a unit to force using it regardless of the distance to get a result like `123456 hours`. 11182 * 11183 * See the table below for the unit picking logic: 11184 * 11185 * | Distance between dates | Result (past) | Result (future) | 11186 * | ---------------------- | -------------- | --------------- | 11187 * | 0 seconds | now | now | 11188 * | 1-59 seconds | X seconds ago | in X seconds | 11189 * | 1-59 minutes | X minutes ago | in X minutes | 11190 * | 1-23 hours | X hours ago | in X hours | 11191 * | 1 day | yesterday | tomorrow | 11192 * | 2-6 days | X days ago | in X days | 11193 * | 7 days | last week | next week | 11194 * | 8 days-1 month | X weeks ago | in X weeks | 11195 * | 1 month | last month | next month | 11196 * | 2-3 months | X months ago | in X months | 11197 * | 1 quarter | last quarter | next quarter | 11198 * | 2-3 quarters | X quarters ago | in X quarters | 11199 * | 1 year | last year | next year | 11200 * | 2+ years | X years ago | in X years | 11201 * 11202 * @param laterDate - The date 11203 * @param earlierDate - The date to compare with. 11204 * @param options - An object with options. 11205 * See MDN for details [Locale identification and negotiation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) 11206 * The narrow one could be similar to the short one for some locales. 11207 * 11208 * @returns The distance in words according to language-sensitive relative time formatting. 11209 * 11210 * @throws `date` must not be Invalid Date 11211 * @throws `baseDate` must not be Invalid Date 11212 * @throws `options.unit` must not be invalid Unit 11213 * @throws `options.locale` must not be invalid locale 11214 * @throws `options.localeMatcher` must not be invalid localeMatcher 11215 * @throws `options.numeric` must not be invalid numeric 11216 * @throws `options.style` must not be invalid style 11217 * 11218 * @example 11219 * // What is the distance between the dates when the fist date is after the second? 11220 * intlFormatDistance( 11221 * new Date(1986, 3, 4, 11, 30, 0), 11222 * new Date(1986, 3, 4, 10, 30, 0) 11223 * ) 11224 * //=> 'in 1 hour' 11225 * 11226 * // What is the distance between the dates when the fist date is before the second? 11227 * intlFormatDistance( 11228 * new Date(1986, 3, 4, 10, 30, 0), 11229 * new Date(1986, 3, 4, 11, 30, 0) 11230 * ) 11231 * //=> '1 hour ago' 11232 * 11233 * @example 11234 * // Use the unit option to force the function to output the result in quarters. Without setting it, the example would return "next year" 11235 * intlFormatDistance( 11236 * new Date(1987, 6, 4, 10, 30, 0), 11237 * new Date(1986, 3, 4, 10, 30, 0), 11238 * { unit: 'quarter' } 11239 * ) 11240 * //=> 'in 5 quarters' 11241 * 11242 * @example 11243 * // Use the locale option to get the result in Spanish. Without setting it, the example would return "in 1 hour". 11244 * intlFormatDistance( 11245 * new Date(1986, 3, 4, 11, 30, 0), 11246 * new Date(1986, 3, 4, 10, 30, 0), 11247 * { locale: 'es' } 11248 * ) 11249 * //=> 'dentro de 1 hora' 11250 * 11251 * @example 11252 * // Use the numeric option to force the function to use numeric values. Without setting it, the example would return "tomorrow". 11253 * intlFormatDistance( 11254 * new Date(1986, 3, 5, 11, 30, 0), 11255 * new Date(1986, 3, 4, 11, 30, 0), 11256 * { numeric: 'always' } 11257 * ) 11258 * //=> 'in 1 day' 11259 * 11260 * @example 11261 * // Use the style option to force the function to use short values. Without setting it, the example would return "in 2 years". 11262 * intlFormatDistance( 11263 * new Date(1988, 3, 4, 11, 30, 0), 11264 * new Date(1986, 3, 4, 11, 30, 0), 11265 * { style: 'short' } 11266 * ) 11267 * //=> 'in 2 yr' 11268 */ 11269function intlFormatDistance(laterDate, earlierDate, options) { 11270 let value = 0; 11271 let unit; 11272
vendor: 4,975 bytes, lines 11273-11438
11273 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 11274 options?.in, 11275 laterDate, 11276 earlierDate, 11277 ); 11278 11279 if (!options?.unit) { 11280 // Get the unit based on diffInSeconds calculations if no unit is specified 11281 const diffInSeconds = (0, _index10.differenceInSeconds)( 11282 laterDate_, 11283 earlierDate_, 11284 ); // The smallest unit 11285 11286 if (Math.abs(diffInSeconds) < _index2.secondsInMinute) { 11287 value = (0, _index10.differenceInSeconds)(laterDate_, earlierDate_); 11288 unit = "second"; 11289 } else if (Math.abs(diffInSeconds) < _index2.secondsInHour) { 11290 value = (0, _index9.differenceInMinutes)(laterDate_, earlierDate_); 11291 unit = "minute"; 11292 } else if ( 11293 Math.abs(diffInSeconds) < _index2.secondsInDay && 11294 Math.abs( 11295 (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_), 11296 ) < 1 11297 ) { 11298 value = (0, _index8.differenceInHours)(laterDate_, earlierDate_); 11299 unit = "hour"; 11300 } else if ( 11301 Math.abs(diffInSeconds) < _index2.secondsInWeek && 11302 (value = (0, _index3.differenceInCalendarDays)( 11303 laterDate_, 11304 earlierDate_, 11305 )) && 11306 Math.abs(value) < 7 11307 ) { 11308 unit = "day"; 11309 } else if (Math.abs(diffInSeconds) < _index2.secondsInMonth) { 11310 value = (0, _index6.differenceInCalendarWeeks)(laterDate_, earlierDate_); 11311 unit = "week"; 11312 } else if (Math.abs(diffInSeconds) < _index2.secondsInQuarter) { 11313 value = (0, _index4.differenceInCalendarMonths)(laterDate_, earlierDate_); 11314 unit = "month"; 11315 } else if (Math.abs(diffInSeconds) < _index2.secondsInYear) { 11316 if ( 11317 (0, _index5.differenceInCalendarQuarters)(laterDate_, earlierDate_) < 4 11318 ) { 11319 // To filter out cases that are less than a year but match 4 quarters 11320 value = (0, _index5.differenceInCalendarQuarters)( 11321 laterDate_, 11322 earlierDate_, 11323 ); 11324 unit = "quarter"; 11325 } else { 11326 value = (0, _index7.differenceInCalendarYears)( 11327 laterDate_, 11328 earlierDate_, 11329 ); 11330 unit = "year"; 11331 } 11332 } else { 11333 value = (0, _index7.differenceInCalendarYears)(laterDate_, earlierDate_); 11334 unit = "year"; 11335 } 11336 } else { 11337 // Get the value if unit is specified 11338 unit = options?.unit; 11339 if (unit === "second") { 11340 value = (0, _index10.differenceInSeconds)(laterDate_, earlierDate_); 11341 } else if (unit === "minute") { 11342 value = (0, _index9.differenceInMinutes)(laterDate_, earlierDate_); 11343 } else if (unit === "hour") { 11344 value = (0, _index8.differenceInHours)(laterDate_, earlierDate_); 11345 } else if (unit === "day") { 11346 value = (0, _index3.differenceInCalendarDays)(laterDate_, earlierDate_); 11347 } else if (unit === "week") { 11348 value = (0, _index6.differenceInCalendarWeeks)(laterDate_, earlierDate_); 11349 } else if (unit === "month") { 11350 value = (0, _index4.differenceInCalendarMonths)(laterDate_, earlierDate_); 11351 } else if (unit === "quarter") { 11352 value = (0, _index5.differenceInCalendarQuarters)( 11353 laterDate_, 11354 earlierDate_, 11355 ); 11356 } else if (unit === "year") { 11357 value = (0, _index7.differenceInCalendarYears)(laterDate_, earlierDate_); 11358 } 11359 } 11360 11361 const rtf = new Intl.RelativeTimeFormat(options?.locale, { 11362 numeric: "auto", 11363 ...options, 11364 }); 11365 11366 return rtf.format(value, unit); 11367} 11368 11369 11370/***/ }), 11371 11372/***/ 34619: 11373/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11374 11375"use strict"; 11376 11377exports.isAfter = isAfter; 11378var _index = __webpack_require__(807799); 11379 11380/** 11381 * @name isAfter 11382 * @category Common Helpers 11383 * @summary Is the first date after the second one? 11384 * 11385 * @description 11386 * Is the first date after the second one? 11387 * 11388 * @param date - The date that should be after the other one to return true 11389 * @param dateToCompare - The date to compare with 11390 * 11391 * @returns The first date is after the second date 11392 * 11393 * @example 11394 * // Is 10 July 1989 after 11 February 1987? 11395 * const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11)) 11396 * //=> true 11397 */ 11398function isAfter(date, dateToCompare) { 11399 return +(0, _index.toDate)(date) > +(0, _index.toDate)(dateToCompare); 11400} 11401 11402 11403/***/ }), 11404 11405/***/ 32651: 11406/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11407 11408"use strict"; 11409 11410exports.isBefore = isBefore; 11411var _index = __webpack_require__(807799); 11412 11413/** 11414 * @name isBefore 11415 * @category Common Helpers 11416 * @summary Is the first date before the second one? 11417 * 11418 * @description 11419 * Is the first date before the second one? 11420 * 11421 * @param date - The date that should be before the other one to return true 11422 * @param dateToCompare - The date to compare with 11423 * 11424 * @returns The first date is before the second date 11425 * 11426 * @example 11427 * // Is 10 July 1989 before 11 February 1987? 11428 * const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11)) 11429 * //=> false 11430 */ 11431function isBefore(date, dateToCompare) { 11432 return +(0, _index.toDate)(date) < +(0, _index.toDate)(dateToCompare); 11433} 11434 11435 11436/***/ }), 11437 11438/***/ 348233:
11439/***/ (function(__unused_webpack_module, exports) { 11440 11441"use strict"; 11442 11443exports.isDate = isDate; /** 11444 * @name isDate 11445 * @category Common Helpers 11446 * @summary Is the given value a date? 11447 * 11448 * @description 11449 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes. 11450 * 11451 * @param value - The value to check 11452 * 11453 * @returns True if the given value is a date 11454 * 11455 * @example 11456 * // For a valid date: 11457 * const result = isDate(new Date()) 11458 * //=> true 11459 * 11460 * @example 11461 * // For an invalid date: 11462 * const result = isDate(new Date(NaN)) 11463 * //=> true 11464 * 11465 * @example 11466 * // For some value: 11467 * const result = isDate('2014-02-31') 11468 * //=> false 11469 * 11470 * @example 11471 * // For an object: 11472 * const result = isDate({}) 11473 * //=> false 11474 */ 11475function isDate(value) { 11476 return ( 11477 value instanceof Date || 11478 (typeof value === "object" && 11479 Object.prototype.toString.call(value) === "[object Date]") 11480 ); 11481} 11482 11483 11484/***/ }), 11485 11486/***/ 506979: 11487/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11488 11489"use strict"; 11490 11491exports.isEqual = isEqual; 11492var _index = __webpack_require__(807799); 11493 11494/** 11495 * @name isEqual 11496 * @category Common Helpers 11497 * @summary Are the given dates equal? 11498 * 11499 * @description 11500 * Are the given dates equal? 11501 * 11502 * @param dateLeft - The first date to compare 11503 * @param dateRight - The second date to compare 11504 * 11505 * @returns The dates are equal 11506 * 11507 * @example 11508 * // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal? 11509 * const result = isEqual( 11510 * new Date(2014, 6, 2, 6, 30, 45, 0), 11511 * new Date(2014, 6, 2, 6, 30, 45, 500) 11512 * ) 11513 * //=> false 11514 */ 11515function isEqual(leftDate, rightDate) { 11516 return +(0, _index.toDate)(leftDate) === +(0, _index.toDate)(rightDate); 11517} 11518 11519 11520/***/ }), 11521 11522/***/ 236325: 11523/***/ (function(__unused_webpack_module, exports) { 11524 11525"use strict"; 11526 11527exports.isExists = isExists; /** 11528 * @name isExists 11529 * @category Common Helpers 11530 * @summary Is the given date exists? 11531 * 11532 * @description 11533 * Checks if the given arguments convert to an existing date. 11534 * 11535 * @param year - The year of the date to check 11536 * @param month - The month of the date to check 11537 * @param day - The day of the date to check 11538 * 11539 * @returns `true` if the date exists 11540 * 11541 * @example 11542 * // For the valid date: 11543 * const result = isExists(2018, 0, 31) 11544 * //=> true 11545 * 11546 * @example 11547 * // For the invalid date: 11548 * const result = isExists(2018, 1, 31) 11549 * //=> false 11550 */ 11551function isExists(year, month, day) { 11552 const date = new Date(year, month, day); 11553 return ( 11554 date.getFullYear() === year && 11555 date.getMonth() === month && 11556 date.getDate() === day 11557 ); 11558} 11559 11560 11561/***/ }), 11562 11563/***/ 44339: 11564/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11565 11566"use strict"; 11567 11568exports.isFirstDayOfMonth = isFirstDayOfMonth; 11569var _index = __webpack_require__(807799); 11570 11571/** 11572 * The {@link isFirstDayOfMonth} function options. 11573 */ 11574 11575/** 11576 * @name isFirstDayOfMonth 11577 * @category Month Helpers 11578 * @summary Is the given date the first day of a month? 11579 * 11580 * @description 11581 * Is the given date the first day of a month? 11582 * 11583 * @param date - The date to check 11584 * @param options - An object with options 11585 * 11586 * @returns The date is the first day of a month 11587 * 11588 * @example 11589 * // Is 1 September 2014 the first day of a month? 11590 * const result = isFirstDayOfMonth(new Date(2014, 8, 1)) 11591 * //=> true 11592 */ 11593function isFirstDayOfMonth(date, options) { 11594 return (0, _index.toDate)(date, options?.in).getDate() === 1; 11595} 11596 11597 11598/***/ }), 11599 11600/***/ 217133: 11601/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11602 11603"use strict"; 11604 11605exports.isFriday = isFriday; 11606var _index = __webpack_require__(807799); 11607 11608/** 11609 * The {@link isFriday} function options. 11610 */ 11611 11612/** 11613 * @name isFriday 11614 * @category Weekday Helpers 11615 * @summary Is the given date Friday? 11616 * 11617 * @description 11618 * Is the given date Friday? 11619 * 11620 * @param date - The date to check 11621 * @param options - An object with options 11622 * 11623 * @returns The date is Friday 11624 * 11625 * @example 11626 * // Is 26 September 2014 Friday? 11627 * const result = isFriday(new Date(2014, 8, 26)) 11628 * //=> true 11629 */ 11630function isFriday(date, options) { 11631 return (0, _index.toDate)(date, options?.in).getDay() === 5; 11632} 11633 11634 11635/***/ }), 11636 11637/***/ 426144: 11638/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11639 11640"use strict"; 11641 11642exports.isFuture = isFuture; 11643var _index = __webpack_require__(807799); 11644 11645/** 11646 * @name isFuture 11647 * @category Common Helpers 11648 * @summary Is the given date in the future? 11649 * @pure false 11650 * 11651 * @description 11652 * Is the given date in the future? 11653 * 11654 * @param date - The date to check 11655 * 11656 * @returns The date is in the future 11657 * 11658 * @example 11659 * // If today is 6 October 2014, is 31 December 2014 in the future? 11660 * const result = isFuture(new Date(2014, 11, 31)) 11661 * //=> true 11662 */ 11663function isFuture(date) { 11664 return +(0, _index.toDate)(date) > Date.now(); 11665} 11666 11667 11668/***/ }), 11669 11670/***/ 941447: 11671/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11672 11673"use strict"; 11674 11675exports.isLastDayOfMonth = isLastDayOfMonth; 11676var _index = __webpack_require__(294210); 11677var _index2 = __webpack_require__(458842); 11678var _index3 = __webpack_require__(807799); 11679 11680/** 11681 * @name isLastDayOfMonth 11682 * @category Month Helpers 11683 * @summary Is the given date the last day of a month? 11684 * 11685 * @description 11686 * Is the given date the last day of a month? 11687 * 11688 * @param date - The date to check 11689 * @param options - An object with options 11690 * 11691 * @returns The date is the last day of a month 11692 * 11693 * @example 11694 * // Is 28 February 2014 the last day of a month? 11695 * const result = isLastDayOfMonth(new Date(2014, 1, 28)) 11696 * //=> true 11697 */ 11698function isLastDayOfMonth(date, options) { 11699 const _date = (0, _index3.toDate)(date, options?.in); 11700 return ( 11701 +(0, _index.endOfDay)(_date, options) === 11702 +(0, _index2.endOfMonth)(_date, options) 11703 ); 11704} 11705 11706 11707/***/ }), 11708 11709/***/ 450519: 11710/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11711 11712"use strict"; 11713 11714exports.isLeapYear = isLeapYear; 11715var _index = __webpack_require__(807799); 11716 11717/** 11718 * @name isLeapYear 11719 * @category Year Helpers 11720 * @summary Is the given date in the leap year? 11721 * 11722 * @description 11723 * Is the given date in the leap year? 11724 * 11725 * @param date - The date to check 11726 * @param options - The options object 11727 * 11728 * @returns The date is in the leap year 11729 * 11730 * @example 11731 * // Is 1 September 2012 in the leap year? 11732 * const result = isLeapYear(new Date(2012, 8, 1)) 11733 * //=> true 11734 */ 11735function isLeapYear(date, options) { 11736 const _date = (0, _index.toDate)(date, options?.in); 11737 const year = _date.getFullYear(); 11738 return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0); 11739} 11740 11741 11742/***/ }), 11743 11744/***/ 373102: 11745/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11746 11747"use strict"; 11748 11749exports.isMatch = isMatch; 11750var _index = __webpack_require__(533209); 11751var _index2 = __webpack_require__(756971)
vendor: 21,010 bytes, lines 11751-12040
11751; 11752 11753/** 11754 * The {@link isMatch} function options. 11755 */ 11756 11757/** 11758 * @name isMatch 11759 * @category Common Helpers 11760 * @summary validates the date string against given formats 11761 * 11762 * @description 11763 * Return the true if given date is string correct against the given format else 11764 * will return false. 11765 * 11766 * > â ï¸ Please note that the `format` tokens differ from Moment.js and other libraries. 11767 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 11768 * 11769 * The characters in the format string wrapped between two single quotes characters (') are escaped. 11770 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote. 11771 * 11772 * Format of the format string is based on Unicode Technical Standard #35: 11773 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table 11774 * with a few additions (see note 5 below the table). 11775 * 11776 * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited 11777 * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception: 11778 * 11779 * ```javascript 11780 * isMatch('23 AM', 'HH a') 11781 * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time 11782 * ``` 11783 * 11784 * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true 11785 * 11786 * Accepted format string patterns: 11787 * | Unit |Prior| Pattern | Result examples | Notes | 11788 * |---------------------------------|-----|---------|-----------------------------------|-------| 11789 * | Era | 140 | G..GGG | AD, BC | | 11790 * | | | GGGG | Anno Domini, Before Christ | 2 | 11791 * | | | GGGGG | A, B | | 11792 * | Calendar year | 130 | y | 44, 1, 1900, 2017, 9999 | 4 | 11793 * | | | yo | 44th, 1st, 1900th, 9999999th | 4,5 | 11794 * | | | yy | 44, 01, 00, 17 | 4 | 11795 * | | | yyy | 044, 001, 123, 999 | 4 | 11796 * | | | yyyy | 0044, 0001, 1900, 2017 | 4 | 11797 * | | | yyyyy | ... | 2,4 | 11798 * | Local week-numbering year | 130 | Y | 44, 1, 1900, 2017, 9000 | 4 | 11799 * | | | Yo | 44th, 1st, 1900th, 9999999th | 4,5 | 11800 * | | | YY | 44, 01, 00, 17 | 4,6 | 11801 * | | | YYY | 044, 001, 123, 999 | 4 | 11802 * | | | YYYY | 0044, 0001, 1900, 2017 | 4,6 | 11803 * | | | YYYYY | ... | 2,4 | 11804 * | ISO week-numbering year | 130 | R | -43, 1, 1900, 2017, 9999, -9999 | 4,5 | 11805 * | | | RR | -43, 01, 00, 17 | 4,5 | 11806 * | | | RRR | -043, 001, 123, 999, -999 | 4,5 | 11807 * | | | RRRR | -0043, 0001, 2017, 9999, -9999 | 4,5 | 11808 * | | | RRRRR | ... | 2,4,5 | 11809 * | Extended year | 130 | u | -43, 1, 1900, 2017, 9999, -999 | 4 | 11810 * | | | uu | -43, 01, 99, -99 | 4 | 11811 * | | | uuu | -043, 001, 123, 999, -999 | 4 | 11812 * | | | uuuu | -0043, 0001, 2017, 9999, -9999 | 4 | 11813 * | | | uuuuu | ... | 2,4 | 11814 * | Quarter (formatting) | 120 | Q | 1, 2, 3, 4 | | 11815 * | | | Qo | 1st, 2nd, 3rd, 4th | 5 | 11816 * | | | QQ | 01, 02, 03, 04 | | 11817 * | | | QQQ | Q1, Q2, Q3, Q4 | | 11818 * | | | QQQQ | 1st quarter, 2nd quarter, ... | 2 | 11819 * | | | QQQQQ | 1, 2, 3, 4 | 4 | 11820 * | Quarter (stand-alone) | 120 | q | 1, 2, 3, 4 | | 11821 * | | | qo | 1st, 2nd, 3rd, 4th | 5 | 11822 * | | | qq | 01, 02, 03, 04 | | 11823 * | | | qqq | Q1, Q2, Q3, Q4 | | 11824 * | | | qqqq | 1st quarter, 2nd quarter, ... | 2 | 11825 * | | | qqqqq | 1, 2, 3, 4 | 3 | 11826 * | Month (formatting) | 110 | M | 1, 2, ..., 12 | | 11827 * | | | Mo | 1st, 2nd, ..., 12th | 5 | 11828 * | | | MM | 01, 02, ..., 12 | | 11829 * | | | MMM | Jan, Feb, ..., Dec | | 11830 * | | | MMMM | January, February, ..., December | 2 | 11831 * | | | MMMMM | J, F, ..., D | | 11832 * | Month (stand-alone) | 110 | L | 1, 2, ..., 12 | | 11833 * | | | Lo | 1st, 2nd, ..., 12th | 5 | 11834 * | | | LL | 01, 02, ..., 12 | | 11835 * | | | LLL | Jan, Feb, ..., Dec | | 11836 * | | | LLLL | January, February, ..., December | 2 | 11837 * | | | LLLLL | J, F, ..., D | | 11838 * | Local week of year | 100 | w | 1, 2, ..., 53 | | 11839 * | | | wo | 1st, 2nd, ..., 53th | 5 | 11840 * | | | ww | 01, 02, ..., 53 | | 11841 * | ISO week of year | 100 | I | 1, 2, ..., 53 | 5 | 11842 * | | | Io | 1st, 2nd, ..., 53th | 5 | 11843 * | | | II | 01, 02, ..., 53 | 5 | 11844 * | Day of month | 90 | d | 1, 2, ..., 31 | | 11845 * | | | do | 1st, 2nd, ..., 31st | 5 | 11846 * | | | dd | 01, 02, ..., 31 | | 11847 * | Day of year | 90 | D | 1, 2, ..., 365, 366 | 7 | 11848 * | | | Do | 1st, 2nd, ..., 365th, 366th | 5 | 11849 * | | | DD | 01, 02, ..., 365, 366 | 7 | 11850 * | | | DDD | 001, 002, ..., 365, 366 | | 11851 * | | | DDDD | ... | 2 | 11852 * | Day of week (formatting) | 90 | E..EEE | Mon, Tue, Wed, ..., Su | | 11853 * | | | EEEE | Monday, Tuesday, ..., Sunday | 2 | 11854 * | | | EEEEE | M, T, W, T, F, S, S | | 11855 * | | | EEEEEE | Mo, Tu, We, Th, Fr, Sa, Su | | 11856 * | ISO day of week (formatting) | 90 | i | 1, 2, 3, ..., 7 | 5 | 11857 * | | | io | 1st, 2nd, ..., 7th | 5 | 11858 * | | | ii | 01, 02, ..., 07 | 5 | 11859 * | | | iii | Mon, Tue, Wed, ..., Su | 5 | 11860 * | | | iiii | Monday, Tuesday, ..., Sunday | 2,5 | 11861 * | | | iiiii | M, T, W, T, F, S, S | 5 | 11862 * | | | iiiiii | Mo, Tu, We, Th, Fr, Sa, Su | 5 | 11863 * | Local day of week (formatting) | 90 | e | 2, 3, 4, ..., 1 | | 11864 * | | | eo | 2nd, 3rd, ..., 1st | 5 | 11865 * | | | ee | 02, 03, ..., 01 | | 11866 * | | | eee | Mon, Tue, Wed, ..., Su | | 11867 * | | | eeee | Monday, Tuesday, ..., Sunday | 2 | 11868 * | | | eeeee | M, T, W, T, F, S, S | | 11869 * | | | eeeeee | Mo, Tu, We, Th, Fr, Sa, Su | | 11870 * | Local day of week (stand-alone) | 90 | c | 2, 3, 4, ..., 1 | | 11871 * | | | co | 2nd, 3rd, ..., 1st | 5 | 11872 * | | | cc | 02, 03, ..., 01 | | 11873 * | | | ccc | Mon, Tue, Wed, ..., Su | | 11874 * | | | cccc | Monday, Tuesday, ..., Sunday | 2 | 11875 * | | | ccccc | M, T, W, T, F, S, S | | 11876 * | | | cccccc | Mo, Tu, We, Th, Fr, Sa, Su | | 11877 * | AM, PM | 80 | a..aaa | AM, PM | | 11878 * | | | aaaa | a.m., p.m. | 2 | 11879 * | | | aaaaa | a, p | | 11880 * | AM, PM, noon, midnight | 80 | b..bbb | AM, PM, noon, midnight | | 11881 * | | | bbbb | a.m., p.m., noon, midnight | 2 | 11882 * | | | bbbbb | a, p, n, mi | | 11883 * | Flexible day period | 80 | B..BBB | at night, in the morning, ... | | 11884 * | | | BBBB | at night, in the morning, ... | 2 | 11885 * | | | BBBBB | at night, in the morning, ... | | 11886 * | Hour [1-12] | 70 | h | 1, 2, ..., 11, 12 | | 11887 * | | | ho | 1st, 2nd, ..., 11th, 12th | 5 | 11888 * | | | hh | 01, 02, ..., 11, 12 | | 11889 * | Hour [0-23] | 70 | H | 0, 1, 2, ..., 23 | | 11890 * | | | Ho | 0th, 1st, 2nd, ..., 23rd | 5 | 11891 * | | | HH | 00, 01, 02, ..., 23 | | 11892 * | Hour [0-11] | 70 | K | 1, 2, ..., 11, 0 | | 11893 * | | | Ko | 1st, 2nd, ..., 11th, 0th | 5 | 11894 * | | | KK | 01, 02, ..., 11, 00 | | 11895 * | Hour [1-24] | 70 | k | 24, 1, 2, ..., 23 | | 11896 * | | | ko | 24th, 1st, 2nd, ..., 23rd | 5 | 11897 * | | | kk | 24, 01, 02, ..., 23 | | 11898 * | Minute | 60 | m | 0, 1, ..., 59 | | 11899 * | | | mo | 0th, 1st, ..., 59th | 5 | 11900 * | | | mm | 00, 01, ..., 59 | | 11901 * | Second | 50 | s | 0, 1, ..., 59 | | 11902 * | | | so | 0th, 1st, ..., 59th | 5 | 11903 * | | | ss | 00, 01, ..., 59 | | 11904 * | Seconds timestamp | 40 | t | 512969520 | | 11905 * | | | tt | ... | 2 | 11906 * | Fraction of second | 30 | S | 0, 1, ..., 9 | | 11907 * | | | SS | 00, 01, ..., 99 | | 11908 * | | | SSS | 000, 001, ..., 999 | | 11909 * | | | SSSS | ... | 2 | 11910 * | Milliseconds timestamp | 20 | T | 512969520900 | | 11911 * | | | TT | ... | 2 | 11912 * | Timezone (ISO-8601 w/ Z) | 10 | X | -08, +0530, Z | | 11913 * | | | XX | -0800, +0530, Z | | 11914 * | | | XXX | -08:00, +05:30, Z | | 11915 * | | | XXXX | -0800, +0530, Z, +123456 | 2 | 11916 * | | | XXXXX | -08:00, +05:30, Z, +12:34:56 | | 11917 * | Timezone (ISO-8601 w/o Z) | 10 | x | -08, +0530, +00 | | 11918 * | | | xx | -0800, +0530, +0000 | | 11919 * | | | xxx | -08:00, +05:30, +00:00 | 2 | 11920 * | | | xxxx | -0800, +0530, +0000, +123456 | | 11921 * | | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | | 11922 * | Long localized date | NA | P | 05/29/1453 | 5,8 | 11923 * | | | PP | May 29, 1453 | | 11924 * | | | PPP | May 29th, 1453 | | 11925 * | | | PPPP | Sunday, May 29th, 1453 | 2,5,8 | 11926 * | Long localized time | NA | p | 12:00 AM | 5,8 | 11927 * | | | pp | 12:00:00 AM | | 11928 * | Combination of date and time | NA | Pp | 05/29/1453, 12:00 AM | | 11929 * | | | PPpp | May 29, 1453, 12:00:00 AM | | 11930 * | | | PPPpp | May 29th, 1453 at ... | | 11931 * | | | PPPPpp | Sunday, May 29th, 1453 at ... | 2,5,8 | 11932 * Notes: 11933 * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale 11934 * are the same as "stand-alone" units, but are different in some languages. 11935 * "Formatting" units are declined according to the rules of the language 11936 * in the context of a date. "Stand-alone" units are always nominative singular. 11937 * In `format` function, they will produce different result: 11938 * 11939 * `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'` 11940 * 11941 * `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'` 11942 * 11943 * `isMatch` will try to match both formatting and stand-alone units interchangeably. 11944 * 11945 * 2. Any sequence of the identical letters is a pattern, unless it is escaped by 11946 * the single quote characters (see below). 11947 * If the sequence is longer than listed in table: 11948 * - for numerical units (`yyyyyyyy`) `isMatch` will try to match a number 11949 * as wide as the sequence 11950 * - for text units (`MMMMMMMM`) `isMatch` will try to match the widest variation of the unit. 11951 * These variations are marked with "2" in the last column of the table. 11952 * 11953 * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales. 11954 * These tokens represent the shortest form of the quarter. 11955 * 11956 * 4. The main difference between `y` and `u` patterns are B.C. years: 11957 * 11958 * | Year | `y` | `u` | 11959 * |------|-----|-----| 11960 * | AC 1 | 1 | 1 | 11961 * | BC 1 | 1 | 0 | 11962 * | BC 2 | 2 | -1 | 11963 * 11964 * Also `yy` will try to guess the century of two digit year by proximity with `referenceDate`: 11965 * 11966 * `isMatch('50', 'yy') //=> true` 11967 * 11968 * `isMatch('75', 'yy') //=> true` 11969 * 11970 * while `uu` will use the year as is: 11971 * 11972 * `isMatch('50', 'uu') //=> true` 11973 * 11974 * `isMatch('75', 'uu') //=> true` 11975 * 11976 * The same difference is true for local and ISO week-numbering years (`Y` and `R`), 11977 * except local week-numbering years are dependent on `options.weekStartsOn` 11978 * and `options.firstWeekContainsDate` (compare [setISOWeekYear](https://date-fns.org/docs/setISOWeekYear) 11979 * and [setWeekYear](https://date-fns.org/docs/setWeekYear)). 11980 * 11981 * 5. These patterns are not in the Unicode Technical Standard #35: 11982 * - `i`: ISO day of week 11983 * - `I`: ISO week of year 11984 * - `R`: ISO week-numbering year 11985 * - `o`: ordinal number modifier 11986 * - `P`: long localized date 11987 * - `p`: long localized time 11988 * 11989 * 6. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years. 11990 * You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 11991 * 11992 * 7. `D` and `DD` tokens represent days of the year but they are often confused with days of the month. 11993 * You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 11994 * 11995 * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based 11996 * on the given locale. 11997 * 11998 * using `en-US` locale: `P` => `MM/dd/yyyy` 11999 * using `en-US` locale: `p` => `hh:mm a` 12000 * using `pt-BR` locale: `P` => `dd/MM/yyyy` 12001 * using `pt-BR` locale: `p` => `HH:mm` 12002 * 12003 * Values will be checked in the descending order of its unit's priority. 12004 * Units of an equal priority overwrite each other in the order of appearance. 12005 * 12006 * If no values of higher priority are matched (e.g. when matching string 'January 1st' without a year), 12007 * the values will be taken from today's using `new Date()` date which works as a context of parsing. 12008 * 12009 * The result may vary by locale. 12010 * 12011 * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned. 12012 * 12013 * @param dateStr - The date string to verify 12014 * @param format - The string of tokens 12015 * @param options - An object with options. 12016 * see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12017 * see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12018 * 12019 * @returns Is format string a match for date string? 12020 * 12021 * @throws `options.locale` must contain `match` property 12022 * @throws use `yyyy` instead of `YYYY` for formatting years; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12023 * @throws use `yy` instead of `YY` for formatting years; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12024 * @throws use `d` instead of `D` for formatting days of the month; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12025 * @throws use `dd` instead of `DD` for formatting days of the month; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 12026 * @throws format string contains an unescaped latin alphabet character 12027 * 12028 * @example 12029 * // Match 11 February 2014 from middle-endian format: 12030 * const result = isMatch('02/11/2014', 'MM/dd/yyyy') 12031 * //=> true 12032 * 12033 * @example 12034 * // Match 28th of February in Esperanto locale in the context of 2010 year: 12035 * import eo from 'date-fns/locale/eo' 12036 * const result = isMatch('28-a de februaro', "do 'de' MMMM", { 12037 * locale: eo 12038 * }) 12039 * //=> true 12040 */
12041function isMatch(dateStr, formatStr, options) { 12042 return (0, _index.isValid)( 12043 (0, _index2.parse)(dateStr, formatStr, new Date(), options), 12044 ); 12045} 12046 12047 12048/***/ }), 12049 12050/***/ 542649: 12051/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12052 12053"use strict"; 12054 12055exports.isMonday = isMonday; 12056var _index = __webpack_require__(807799); 12057 12058/** 12059 * The {@link isMonday} function options. 12060 */ 12061 12062/** 12063 * @name isMonday 12064 * @category Weekday Helpers 12065 * @summary Is the given date Monday? 12066 * 12067 * @description 12068 * Is the given date Monday? 12069 * 12070 * @param date - The date to check 12071 * @param options - An object with options 12072 * 12073 * @returns The date is Monday 12074 * 12075 * @example 12076 * // Is 22 September 2014 Monday? 12077 * const result = isMonday(new Date(2014, 8, 22)) 12078 * //=> true 12079 */ 12080function isMonday(date, options) { 12081 return (0, _index.toDate)(date, options?.in).getDay() === 1; 12082} 12083 12084 12085/***/ }), 12086 12087/***/ 800999: 12088/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12089 12090"use strict"; 12091 12092exports.isPast = isPast; 12093var _index = __webpack_require__(807799); 12094 12095/** 12096 * @name isPast 12097 * @category Common Helpers 12098 * @summary Is the given date in the past? 12099 * @pure false 12100 * 12101 * @description 12102 * Is the given date in the past? 12103 * 12104 * @param date - The date to check 12105 * 12106 * @returns The date is in the past 12107 * 12108 * @example 12109 * // If today is 6 October 2014, is 2 July 2014 in the past? 12110 * const result = isPast(new Date(2014, 6, 2)) 12111 * //=> true 12112 */ 12113function isPast(date) { 12114 return +(0, _index.toDate)(date) < Date.now(); 12115} 12116 12117 12118/***/ }), 12119 12120/***/ 373958: 12121/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12122 12123"use strict"; 12124 12125exports.isSameDay = isSameDay; 12126var _index = __webpack_require__(947561); 12127var _index2 = __webpack_require__(731010); 12128 12129/** 12130 * The {@link isSameDay} function options. 12131 */ 12132 12133/** 12134 * @name isSameDay 12135 * @category Day Helpers 12136 * @summary Are the given dates in the same day (and year and month)? 12137 * 12138 * @description 12139 * Are the given dates in the same day (and year and month)? 12140 * 12141 * @param laterDate - The first date to check 12142 * @param earlierDate - The second date to check 12143 * @param options - An object with options 12144 * 12145 * @returns The dates are in the same day (and year and month) 12146 * 12147 * @example 12148 * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day? 12149 * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0)) 12150 * //=> true 12151 * 12152 * @example 12153 * // Are 4 September and 4 October in the same day? 12154 * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4)) 12155 * //=> false 12156 * 12157 * @example 12158 * // Are 4 September, 2014 and 4 September, 2015 in the same day? 12159 * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4)) 12160 * //=> false 12161 */ 12162function isSameDay(laterDate, earlierDate, options) { 12163 const [dateLeft_, dateRight_] = (0, _index.normalizeDates)( 12164 options?.in, 12165 laterDate, 12166 earlierDate, 12167 ); 12168 return ( 12169 +(0, _index2.startOfDay)(dateLeft_) === +(0, _index2.startOfDay)(dateRight_) 12170 ); 12171} 12172 12173 12174/***/ }), 12175 12176/***/ 461908: 12177/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12178 12179"use strict"; 12180 12181exports.isSameHour = isSameHour; 12182var _index = __webpack_require__(947561); 12183var _index2 = __webpack_require__(233849); 12184 12185/** 12186 * The {@link isSameHour} function options. 12187 */ 12188 12189/** 12190 * @name isSameHour 12191 * @category Hour Helpers 12192 * @summary Are the given dates in the same hour (and same day)? 12193 * 12194 * @description 12195 * Are the given dates in the same hour (and same day)? 12196 * 12197 * @param dateLeft - The first date to check 12198 * @param dateRight - The second date to check 12199 * @param options - An object with options 12200 * 12201 * @returns The dates are in the same hour (and same day) 12202 * 12203 * @example 12204 * // Are 4 September 2014 06:00:00 and 4 September 06:30:00 in the same hour? 12205 * const result = isSameHour(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 6, 30)) 12206 * //=> true 12207 * 12208 * @example 12209 * // Are 4 September 2014 06:00:00 and 5 September 06:00:00 in the same hour? 12210 * const result = isSameHour(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 5, 6, 0)) 12211 * //=> false 12212 */ 12213function isSameHour(dateLeft, dateRight, options) {
12214 const [dateLeft_, dateRight_] = (0, _index.normalizeDates)( 12215 options?.in, 12216 dateLeft, 12217 dateRight, 12218 ); 12219 return ( 12220 +(0, _index2.startOfHour)(dateLeft_) === 12221 +(0, _index2.startOfHour)(dateRight_) 12222 ); 12223} 12224 12225 12226/***/ }), 12227 12228/***/ 389706: 12229/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12230 12231"use strict"; 12232 12233exports.isSameISOWeek = isSameISOWeek; 12234var _index = __webpack_require__(463373); 12235 12236/** 12237 * The {@link isSameISOWeek} function options. 12238 */ 12239 12240/** 12241 * @name isSameISOWeek 12242 * @category ISO Week Helpers 12243 * @summary Are the given dates in the same ISO week (and year)? 12244 * 12245 * @description 12246 * Are the given dates in the same ISO week (and year)? 12247 * 12248 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 12249 * 12250 * @param laterDate - The first date to check 12251 * @param earlierDate - The second date to check 12252 * @param options - An object with options 12253 * 12254 * @returns The dates are in the same ISO week (and year) 12255 * 12256 * @example 12257 * // Are 1 September 2014 and 7 September 2014 in the same ISO week? 12258 * const result = isSameISOWeek(new Date(2014, 8, 1), new Date(2014, 8, 7)) 12259 * //=> true 12260 * 12261 * @example 12262 * // Are 1 September 2014 and 1 September 2015 in the same ISO week? 12263 * const result = isSameISOWeek(new Date(2014, 8, 1), new Date(2015, 8, 1)) 12264 * //=> false 12265 */ 12266function isSameISOWeek(laterDate, earlierDate, options) { 12267 return (0, _index.isSameWeek)(laterDate, earlierDate, { 12268 ...options, 12269 weekStartsOn: 1, 12270 }); 12271} 12272 12273 12274/***/ }), 12275 12276/***/ 860928: 12277/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12278 12279"use strict"; 12280 12281exports.isSameISOWeekYear = isSameISOWeekYear; 12282var _index = __webpack_require__(116666); 12283 12284var _index2 = __webpack_require__(947561); 12285 12286/** 12287 * The {@link isSameISOWeekYear} function options. 12288 */ 12289 12290/** 12291 * @name isSameISOWeekYear 12292 * @category ISO Week-Numbering Year Helpers 12293 * @summary Are the given dates in the same ISO week-numbering year? 12294 * 12295 * @description 12296 * Are the given dates in the same ISO week-numbering year? 12297 * 12298 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 12299 * 12300 * @param laterDate - The first date to check 12301 * @param earlierDate - The second date to check 12302 * @param options - An object with options 12303 * 12304 * @returns The dates are in the same ISO week-numbering year 12305 * 12306 * @example 12307 * // Are 29 December 2003 and 2 January 2005 in the same ISO week-numbering year? 12308 * const result = isSameISOWeekYear(new Date(2003, 11, 29), new Date(2005, 0, 2)) 12309 * //=> true 12310 */ 12311function isSameISOWeekYear(laterDate, earlierDate, options) { 12312 const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)( 12313 options?.in, 12314 laterDate, 12315 earlierDate, 12316 ); 12317 return ( 12318 +(0, _index.startOfISOWeekYear)(laterDate_) === 12319 +(0, _index.startOfISOWeekYear)(earlierDate_) 12320 ); 12321} 12322 12323 12324/***/ }), 12325 12326/***/ 32648: 12327/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12328 12329"use strict"; 12330 12331exports.isSameMinute = isSameMinute; 12332var _index = __webpack_require__(537104); 12333 12334/** 12335 * @name isSameMinute 12336 * @category Minute Helpers 12337 * @summary Are the given dates in the same minute (and hour and day)? 12338 * 12339 * @description 12340 * Are the given dates in the same minute (and hour and day)? 12341 * 12342 * @param laterDate - The first date to check 12343 * @param earlierDate - The second date to check 12344 * 12345 * @returns The dates are in the same minute (and hour and day) 12346 * 12347 * @example 12348 * // Are 4 September 2014 06:30:00 and 4 September 2014 06:30:15 in the same minute? 12349 * const result = isSameMinute( 12350 * new Date(2014, 8, 4, 6, 30), 12351 * new Date(2014, 8, 4, 6, 30, 15) 12352 * ) 12353 * //=> true 12354 * 12355 * @example 12356 * // Are 4 September 2014 06:30:00 and 5 September 2014 06:30:00 in the same minute? 12357 * const result = isSameMinute( 12358 * new Date(2014, 8, 4, 6, 30), 12359 * new Date(2014, 8, 5, 6, 30) 12360 * ) 12361 * //=> false 12362 */ 12363function isSameMinute(laterDate, earlierDate) { 12364 return ( 12365 +(0, _index.startOfMinute)(laterDate) === 12366 +(0, _index.startOfMinute)(earlierDate) 12367 ); 12368} 12369 12370 12371/***/ }), 12372 12373/***/ 458331: 12374/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12375 12376"use strict"; 12377 12378exports.isSameMonth = isSameMonth; 12379var _index = __webpack_require__(947561); 12380 12381/** 12382 * The {@link isSameMonth} function options. 12383 */ 12384 12385/** 12386 * @name isSameMonth 12387 * @category Month Helpers 12388 * @summary Are the given dates in the same month (and year)? 12389 * 12390 * @description 12391 * Are the given dates in the same month (and year)? 12392 * 12393 * @param laterDate - The first date to check 12394 * @param earlierDate - The second date to check 12395 * @param options - An object with options 12396 * 12397 * @returns The dates are in the same month (and year) 12398 * 12399 * @example 12400 * // Are 2 September 2014 and 25 September 2014 in the same month? 12401 * const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25)) 12402 * //=> true 12403 * 12404 * @example 12405 * // Are 2 September 2014 and 25 September 2015 in the same month? 12406 * const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25)) 12407 * //=> false 12408 */ 12409function isSameMonth(laterDate, earlierDate, options) {
12410 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 12411 options?.in, 12412 laterDate, 12413 earlierDate, 12414 ); 12415 return ( 12416 laterDate_.getFullYear() === earlierDate_.getFullYear() && 12417 laterDate_.getMonth() === earlierDate_.getMonth() 12418 ); 12419} 12420 12421 12422/***/ }), 12423 12424/***/ 637184: 12425/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12426 12427"use strict"; 12428 12429exports.isSameQuarter = isSameQuarter; 12430var _index = __webpack_require__(947561); 12431var _index2 = __webpack_require__(927907); 12432 12433/** 12434 * The {@link isSameQuarter} function options. 12435 */ 12436 12437/** 12438 * @name isSameQuarter 12439 * @category Quarter Helpers 12440 * @summary Are the given dates in the same quarter (and year)? 12441 * 12442 * @description 12443 * Are the given dates in the same quarter (and year)? 12444 * 12445 * @param laterDate - The first date to check 12446 * @param earlierDate - The second date to check 12447 * @param options - An object with options 12448 * 12449 * @returns The dates are in the same quarter (and year) 12450 * 12451 * @example 12452 * // Are 1 January 2014 and 8 March 2014 in the same quarter? 12453 * const result = isSameQuarter(new Date(2014, 0, 1), new Date(2014, 2, 8)) 12454 * //=> true 12455 * 12456 * @example 12457 * // Are 1 January 2014 and 1 January 2015 in the same quarter? 12458 * const result = isSameQuarter(new Date(2014, 0, 1), new Date(2015, 0, 1)) 12459 * //=> false 12460 */ 12461function isSameQuarter(laterDate, earlierDate, options) { 12462 const [dateLeft_, dateRight_] = (0, _index.normalizeDates)( 12463 options?.in, 12464 laterDate, 12465 earlierDate, 12466 ); 12467 return ( 12468 +(0, _index2.startOfQuarter)(dateLeft_) === 12469 +(0, _index2.startOfQuarter)(dateRight_) 12470 ); 12471} 12472 12473 12474/***/ }), 12475 12476/***/ 516248: 12477/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12478 12479"use strict"; 12480 12481exports.isSameSecond = isSameSecond; 12482var _index = __webpack_require__(42247); 12483 12484/** 12485 * @name isSameSecond 12486 * @category Second Helpers 12487 * @summary Are the given dates in the same second (and hour and day)? 12488 * 12489 * @description 12490 * Are the given dates in the same second (and hour and day)? 12491 * 12492 * @param laterDate - The first date to check 12493 * @param earlierDate - The second date to check 12494 * 12495 * @returns The dates are in the same second (and hour and day) 12496 * 12497 * @example 12498 * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second? 12499 * const result = isSameSecond( 12500 * new Date(2014, 8, 4, 6, 30, 15), 12501 * new Date(2014, 8, 4, 6, 30, 15, 500) 12502 * ) 12503 * //=> true 12504 * 12505 * @example 12506 * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second? 12507 * const result = isSameSecond( 12508 * new Date(2014, 8, 4, 6, 0, 15), 12509 * new Date(2014, 8, 4, 6, 1, 15) 12510 * ) 12511 * //=> false 12512 * 12513 * @example 12514 * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second? 12515 * const result = isSameSecond( 12516 * new Date(2014, 8, 4, 6, 0, 15), 12517 * new Date(2014, 8, 5, 6, 0, 15) 12518 * ) 12519 * //=> false 12520 */ 12521function isSameSecond(laterDate, earlierDate) { 12522 return ( 12523 +(0, _index.startOfSecond)(laterDate) === 12524 +(0, _index.startOfSecond)(earlierDate) 12525 ); 12526} 12527 12528 12529/***/ }), 12530 12531/***/ 463373: 12532/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12533 12534"use strict"; 12535 12536exports.isSameWeek = isSameWeek; 12537var _index = __webpack_require__(947561); 12538var _index2 = __webpack_require__(517805); 12539 12540/** 12541 * The {@link isSameWeek} function options. 12542 */ 12543 12544/** 12545 * @name isSameWeek 12546 * @category Week Helpers 12547 * @summary Are the given dates in the same week (and month and year)? 12548 * 12549 * @description 12550 * Are the given dates in the same week (and month and year)? 12551 * 12552 * @param laterDate - The first date to check 12553 * @param earlierDate - The second date to check 12554 * @param options - An object with options 12555 * 12556 * @returns The dates are in the same week (and month and year) 12557 * 12558 * @example 12559 * // Are 31 August 2014 and 4 September 2014 in the same week? 12560 * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4)) 12561 * //=> true 12562 * 12563 * @example 12564 * // If week starts with Monday, 12565 * // are 31 August 2014 and 4 September 2014 in the same week? 12566 * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4), { 12567 * weekStartsOn: 1 12568 * }) 12569 * //=> false 12570 * 12571 * @example 12572 * // Are 1 January 2014 and 1 January 2015 in the same week? 12573 * const result = isSameWeek(new Date(2014, 0, 1), new Date(2015, 0, 1)) 12574 * //=> false 12575 */ 12576function isSameWeek(laterDate, earlierDate, options) {
12577 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 12578 options?.in, 12579 laterDate, 12580 earlierDate, 12581 ); 12582 return ( 12583 +(0, _index2.startOfWeek)(laterDate_, options) === 12584 +(0, _index2.startOfWeek)(earlierDate_, options) 12585 ); 12586} 12587 12588 12589/***/ }), 12590 12591/***/ 777751: 12592/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12593 12594"use strict"; 12595 12596exports.isSameYear = isSameYear; 12597var _index = __webpack_require__(947561); 12598 12599/** 12600 * The {@link isSameYear} function options. 12601 */ 12602 12603/** 12604 * @name isSameYear 12605 * @category Year Helpers 12606 * @summary Are the given dates in the same year? 12607 * 12608 * @description 12609 * Are the given dates in the same year? 12610 * 12611 * @param laterDate - The first date to check 12612 * @param earlierDate - The second date to check 12613 * @param options - An object with options 12614 * 12615 * @returns The dates are in the same year 12616 * 12617 * @example 12618 * // Are 2 September 2014 and 25 September 2014 in the same year? 12619 * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25)) 12620 * //=> true 12621 */ 12622function isSameYear(laterDate, earlierDate, options) { 12623 const [laterDate_, earlierDate_] = (0, _index.normalizeDates)( 12624 options?.in, 12625 laterDate, 12626 earlierDate, 12627 ); 12628 return laterDate_.getFullYear() === earlierDate_.getFullYear(); 12629} 12630 12631 12632/***/ }), 12633 12634/***/ 852642: 12635/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12636 12637"use strict"; 12638 12639exports.isSaturday = isSaturday; 12640var _index = __webpack_require__(807799); 12641 12642/** 12643 * The {@link isSaturday} function options. 12644 */ 12645 12646/** 12647 * @name isSaturday 12648 * @category Weekday Helpers 12649 * @summary Is the given date Saturday? 12650 * 12651 * @description 12652 * Is the given date Saturday? 12653 * 12654 * @param date - The date to check 12655 * @param options - An object with options 12656 * 12657 * @returns The date is Saturday 12658 * 12659 * @example 12660 * // Is 27 September 2014 Saturday? 12661 * const result = isSaturday(new Date(2014, 8, 27)) 12662 * //=> true 12663 */ 12664function isSaturday(date, options) { 12665 return (0, _index.toDate)(date, options?.in).getDay() === 6; 12666} 12667 12668 12669/***/ }), 12670 12671/***/ 843239: 12672/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12673 12674"use strict"; 12675 12676exports.isSunday = isSunday; 12677var _index = __webpack_require__(807799); 12678 12679/** 12680 * The {@link isSunday} function options. 12681 */ 12682 12683/** 12684 * @name isSunday 12685 * @category Weekday Helpers 12686 * @summary Is the given date Sunday? 12687 * 12688 * @description 12689 * Is the given date Sunday? 12690 * 12691 * @param date - The date to check 12692 * @param options - The options object 12693 * 12694 * @returns The date is Sunday 12695 * 12696 * @example 12697 * // Is 21 September 2014 Sunday? 12698 * const result = isSunday(new Date(2014, 8, 21)) 12699 * //=> true 12700 */ 12701function isSunday(date, options) { 12702 return (0, _index.toDate)(date, options?.in).getDay() === 0; 12703} 12704 12705 12706/***/ }), 12707 12708/***/ 527719: 12709/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12710 12711"use strict"; 12712 12713exports.isThisHour = isThisHour; 12714var _index = __webpack_require__(560533); 12715var _index2 = __webpack_require__(461908); 12716var _index3 = __webpack_require__(807799); 12717 12718/** 12719 * The {@link isThisHour} function options. 12720 */ 12721 12722/** 12723 * @name isThisHour 12724 * @category Hour Helpers 12725 * @summary Is the given date in the same hour as the current date? 12726 * @pure false 12727 * 12728 * @description 12729 * Is the given date in the same hour as the current date? 12730 * 12731 * @param date - The date to check 12732 * @param options - An object with options 12733 * 12734 * @returns The date is in this hour 12735 * 12736 * @example 12737 * // If now is 25 September 2014 18:30:15.500, 12738 * // is 25 September 2014 18:00:00 in this hour? 12739 * const result = isThisHour(new Date(2014, 8, 25, 18)) 12740 * //=> true 12741 */ 12742function isThisHour(date, options) { 12743 return (0, _index2.isSameHour)( 12744 (0, _index3.toDate)(date, options?.in), 12745 (0, _index.constructNow)(options?.in || date), 12746 ); 12747} 12748 12749 12750/***/ }), 12751 12752/***/ 452027: 12753/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12754 12755"use strict"; 12756 12757exports.isThisISOWeek = isThisISOWeek; 12758var _index = __webpack_require__(658612); 12759var _index2 = __webpack_require__(560533); 12760var _index3 = __webpack_require__(389706); 12761 12762/** 12763 * The {@link isThisISOWeek} function options. 12764 */ 12765 12766/** 12767 * @name isThisISOWeek 12768 * @category ISO Week Helpers 12769 * @summary Is the given date in the same ISO week as the current date? 12770 * @pure false 12771 * 12772 * @description 12773 * Is the given date in the same ISO week as the current date? 12774 * 12775 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 12776 * 12777 * @param date - The date to check 12778 * @param options - An object with options 12779 * 12780 * @returns The date is in this ISO week 12781 * 12782 * @example 12783 * // If today is 25 September 2014, is 22 September 2014 in this ISO week? 12784 * const result = isThisISOWeek(new Date(2014, 8, 22)) 12785 * //=> true 12786 */ 12787function isThisISOWeek(date, options) { 12788 return (0, _index3.isSameISOWeek)( 12789 (0, _index.constructFrom)(options?.in || date, date), 12790 (0, _index2.constructNow)(options?.in || date), 12791 ); 12792} 12793 12794 12795/***/ }), 12796 12797/***/ 978989: 12798/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12799 12800"use strict"; 12801 12802exports.isThisMinute = isThisMinute; 12803var _index = __webpack_require__(560533); 12804var _index2 = __webpack_require__(32648); 12805 12806/** 12807 * @name isThisMinute 12808 * @category Minute Helpers 12809 * @summary Is the given date in the same minute as the current date? 12810 * @pure false 12811 * 12812 * @description 12813 * Is the given date in the same minute as the current date? 12814 * 12815 * @param date - The date to check 12816 * 12817 * @returns The date is in this minute 12818 * 12819 * @example 12820 * // If now is 25 September 2014 18:30:15.500, 12821 * // is 25 September 2014 18:30:00 in this minute? 12822 * const result = isThisMinute(new Date(2014, 8, 25, 18, 30)) 12823 * //=> true 12824 */ 12825 12826function isThisMinute(date) { 12827 return (0, _index2.isSameMinute)(date, (0, _index.constructNow)(date)); 12828} 12829 12830 12831/***/ }), 12832 12833/***/ 575812: 12834/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12835 12836"use strict"; 12837 12838exports.isThisMonth = isThisMonth; 12839var _index = __webpack_require__(658612); 12840var _index2 = __webpack_require__(560533); 12841var _index3 = __webpack_require__(458331); 12842 12843/** 12844 * The {@link isThisMonth} function options. 12845 */ 12846 12847/** 12848 * @name isThisMonth 12849 * @category Month Helpers 12850 * @summary Is the given date in the same month as the current date? 12851 * @pure false 12852 * 12853 * @description 12854 * Is the given date in the same month as the current date? 12855 * 12856 * @param date - The date to check 12857 * @param options - An object with options 12858 * 12859 * @returns The date is in this month 12860 * 12861 * @example 12862 * // If today is 25 September 2014, is 15 September 2014 in this month? 12863 * const result = isThisMonth(new Date(2014, 8, 15)) 12864 * //=> true 12865 */ 12866function isThisMonth(date, options) { 12867 return (0, _index3.isSameMonth)( 12868 (0, _index.constructFrom)(options?.in || date, date), 12869 (0, _index2.constructNow)(options?.in || date), 12870 ); 12871} 12872 12873 12874/***/ }), 12875 12876/***/ 350274: 12877/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12878 12879"use strict"; 12880 12881exports.isThisQuarter = isThisQuarter; 12882var _index = __webpack_require__(658612); 12883var _index2 = __webpack_require__(560533); 12884var _index3 = __webpack_require__(637184); 12885 12886/** 12887 * The {@link isThisQuarter} function options. 12888 */ 12889 12890/** 12891 * @name isThisQuarter 12892 * @category Quarter Helpers 12893 * @summary Is the given date in the same quarter as the current date? 12894 * @pure false 12895 * 12896 * @description 12897 * Is the given date in the same quarter as the current date? 12898 * 12899 * @param date - The date to check 12900 * @param options - An object with options 12901 * 12902 * @returns The date is in this quarter 12903 * 12904 * @example 12905 * // If today is 25 September 2014, is 2 July 2014 in this quarter? 12906 * const result = isThisQuarter(new Date(2014, 6, 2)) 12907 * //=> true 12908 */ 12909function isThisQuarter(date, options) { 12910 return (0, _index3.isSameQuarter)( 12911 (0, _index.constructFrom)(options?.in || date, date), 12912 (0, _index2.constructNow)(options?.in || date), 12913 ); 12914} 12915 12916 12917/***/ }), 12918 12919/***/ 383826: 12920/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12921 12922"use strict"; 12923 12924exports.isThisSecond = isThisSecond; 12925var _index = __webpack_require__(560533); 12926var _index2 = __webpack_require__(516248); 12927 12928/** 12929 * @name isThisSecond 12930 * @category Second Helpers 12931 * @summary Is the given date in the same second as the current date? 12932 * @pure false 12933 * 12934 * @description 12935 * Is the given date in the same second as the current date? 12936 * 12937 * @param date - The date to check 12938 * 12939 * @returns The date is in this second 12940 * 12941 * @example 12942 * // If now is 25 September 2014 18:30:15.500, 12943 * // is 25 September 2014 18:30:15.000 in this second? 12944 * const result = isThisSecond(new Date(2014, 8, 25, 18, 30, 15)) 12945 * //=> true 12946 */ 12947function isThisSecond(date) { 12948 return (0, _index2.isSameSecond)(date, (0, _index.constructNow)(date)); 12949} 12950 12951 12952/***/ }), 12953 12954/***/ 870987: 12955/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12956 12957"use strict"; 12958 12959exports.isThisWeek = isThisWeek; 12960var _index = __webpack_require__(658612); 12961var _index2 = __webpack_require__(560533); 12962var _index3 = __webpack_require__(463373); 12963 12964/** 12965 * The {@link isThisWeek} function options. 12966 */ 12967 12968/** 12969 * @name isThisWeek 12970 * @category Week Helpers 12971 * @summary Is the given date in the same week as the current date? 12972 * @pure false 12973 * 12974 * @description 12975 * Is the given date in the same week as the current date? 12976 * 12977 * @param date - The date to check 12978 * @param options - The object with options 12979 * 12980 * @returns The date is in this week 12981 * 12982 * @example 12983 * // If today is 25 September 2014, is 21 September 2014 in this week? 12984 * const result = isThisWeek(new Date(2014, 8, 21)) 12985 * //=> true 12986 * 12987 * @example 12988 * // If today is 25 September 2014 and week starts with Monday 12989 * // is 21 September 2014 in this week? 12990 * const result = isThisWeek(new Date(2014, 8, 21), { weekStartsOn: 1 }) 12991 * //=> false 12992 */ 12993function isThisWeek(date, options) { 12994 return (0, _index3.isSameWeek)( 12995 (0, _index.constructFrom)(options?.in || date, date), 12996 (0, _index2.constructNow)(options?.in || date), 12997 options, 12998 ); 12999} 13000 13001 13002/***/ }), 13003 13004/***/ 500251: 13005/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13006 13007"use strict"; 13008 13009exports.isThisYear = isThisYear; 13010var _index = __webpack_require__(658612); 13011var _index2 = __webpack_require__(560533); 13012var _index3 = __webpack_require__(777751); 13013 13014/** 13015 * The {@link isThisYear} function options. 13016 */ 13017 13018/** 13019 * @name isThisYear 13020 * @category Year Helpers 13021 * @summary Is the given date in the same year as the current date? 13022 * @pure false 13023 * 13024 * @description 13025 * Is the given date in the same year as the current date? 13026 * 13027 * @param date - The date to check 13028 * @param options - An object with options 13029 * 13030 * @returns The date is in this year 13031 * 13032 * @example 13033 * // If today is 25 September 2014, is 2 July 2014 in this year? 13034 * const result = isThisYear(new Date(2014, 6, 2)) 13035 * //=> true 13036 */ 13037function isThisYear(date, options) { 13038 return (0, _index3.isSameYear)( 13039 (0, _index.constructFrom)(options?.in || date, date), 13040 (0, _index2.constructNow)(options?.in || date), 13041 ); 13042} 13043 13044 13045/***/ }), 13046 13047/***/ 608529: 13048/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13049 13050"use strict"; 13051 13052exports.isThursday = isThursday; 13053var _index = __webpack_require__(807799); 13054 13055/** 13056 * The {@link isThursday} function options. 13057 */ 13058 13059/** 13060 * @name isThursday 13061 * @category Weekday Helpers 13062 * @summary Is the given date Thursday? 13063 * 13064 * @description 13065 * Is the given date Thursday? 13066 * 13067 * @param date - The date to check 13068 * @param options - An object with options 13069 * 13070 * @returns The date is Thursday 13071 * 13072 * @example 13073 * // Is 25 September 2014 Thursday? 13074 * const result = isThursday(new Date(2014, 8, 25)) 13075 * //=> true 13076 */ 13077function isThursday(date, options) { 13078 return (0, _index.toDate)(date, options?.in).getDay() === 4; 13079} 13080 13081 13082/***/ }), 13083 13084/***/ 390689: 13085/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13086 13087"use strict"; 13088 13089exports.isToday = isToday; 13090var _index = __webpack_require__(658612); 13091var _index2 = __webpack_require__(560533); 13092var _index3 = __webpack_require__(373958); 13093 13094/** 13095 * The {@link isToday} function options. 13096 */ 13097 13098/** 13099 * @name isToday 13100 * @category Day Helpers 13101 * @summary Is the given date today? 13102 * @pure false 13103 * 13104 * @description 13105 * Is the given date today? 13106 * 13107 * @param date - The date to check 13108 * @param options - An object with options 13109 * 13110 * @returns The date is today 13111 * 13112 * @example 13113 * // If today is 6 October 2014, is 6 October 14:00:00 today? 13114 * const result = isToday(new Date(2014, 9, 6, 14, 0)) 13115 * //=> true 13116 */ 13117function isToday(date, options) { 13118 return (0, _index3.isSameDay)( 13119 (0, _index.constructFrom)(options?.in || date, date), 13120 (0, _index2.constructNow)(options?.in || date), 13121 ); 13122} 13123 13124 13125/***/ }), 13126 13127/***/ 718721: 13128/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13129 13130"use strict"; 13131 13132exports.isTomorrow = isTomorrow; 13133var _index = __webpack_require__(519746); 13134var _index2 = __webpack_require__(560533); 13135var _index3 = __webpack_require__(373958); 13136 13137/** 13138 * The {@link isTomorrow} function options. 13139 */ 13140 13141/** 13142 * @name isTomorrow 13143 * @category Day Helpers 13144 * @summary Is the given date tomorrow? 13145 * @pure false 13146 * 13147 * @description 13148 * Is the given date tomorrow? 13149 * 13150 * @param date - The date to check 13151 * @param options - An object with options 13152 * 13153 * @returns The date is tomorrow 13154 * 13155 * @example 13156 * // If today is 6 October 2014, is 7 October 14:00:00 tomorrow? 13157 * const result = isTomorrow(new Date(2014, 9, 7, 14, 0)) 13158 * //=> true 13159 */ 13160function isTomorrow(date, options) { 13161 return (0, _index3.isSameDay)( 13162 date, 13163 (0, _index.addDays)((0, _index2.constructNow)(options?.in || date), 1), 13164 options, 13165 ); 13166} 13167 13168 13169/***/ }), 13170 13171/***/ 166787: 13172/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13173 13174"use strict"; 13175 13176exports.isTuesday = isTuesday; 13177var _index = __webpack_require__(807799); 13178 13179/** 13180 * The {@link isTuesday} function options. 13181 */ 13182 13183/** 13184 * @name isTuesday 13185 * @category Weekday Helpers 13186 * @summary Is the given date Tuesday? 13187 * 13188 * @description 13189 * Is the given date Tuesday? 13190 * 13191 * @param date - The date to check 13192 * @param options - An object with options 13193 * 13194 * @returns The date is Tuesday 13195 * 13196 * @example 13197 * // Is 23 September 2014 Tuesday? 13198 * const result = isTuesday(new Date(2014, 8, 23)) 13199 * //=> true 13200 */ 13201function isTuesday(date, options) { 13202 return (0, _index.toDate)(date, options?.in).getDay() === 2; 13203} 13204 13205 13206/***/ }), 13207 13208/***/ 533209: 13209/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13210 13211"use strict"; 13212 13213exports.isValid = isValid; 13214var _index = __webpack_require__(348233); 13215var _index2 = __webpack_require__(807799); 13216 13217/** 13218 * @name isValid 13219 * @category Common Helpers 13220 * @summary Is the given date valid? 13221 * 13222 * @description 13223 * Returns false if argument is Invalid Date and true otherwise. 13224 * Argument is converted to Date using `toDate`. See [toDate](https://date-fns.org/docs/toDate) 13225 * Invalid Date is a Date, whose time value is NaN. 13226 * 13227 * Time value of Date: http://es5.github.io/#x15.9.1.1 13228 * 13229 * @param date - The date to check 13230 * 13231 * @returns The date is valid 13232 * 13233 * @example 13234 * // For the valid date: 13235 * const result = isValid(new Date(2014, 1, 31)) 13236 * //=> true 13237 * 13238 * @example 13239 * // For the value, convertible into a date: 13240 * const result = isValid(1393804800000) 13241 * //=> true 13242 * 13243 * @example 13244 * // For the invalid date: 13245 * const result = isValid(new Date('')) 13246 * //=> false 13247 */ 13248function isValid(date) { 13249 return !(
13250 (!(0, _index.isDate)(date) && typeof date !== "number") || 13251 isNaN(+(0, _index2.toDate)(date)) 13252 ); 13253} 13254 13255 13256/***/ }), 13257 13258/***/ 735098: 13259/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13260 13261"use strict"; 13262 13263exports.isWednesday = isWednesday; 13264var _index = __webpack_require__(807799); 13265 13266/** 13267 * The {@link isWednesday} function options. 13268 */ 13269 13270/** 13271 * @name isWednesday 13272 * @category Weekday Helpers 13273 * @summary Is the given date Wednesday? 13274 * 13275 * @description 13276 * Is the given date Wednesday? 13277 * 13278 * @param date - The date to check 13279 * @param options - An object with options 13280 * 13281 * @returns The date is Wednesday 13282 * 13283 * @example 13284 * // Is 24 September 2014 Wednesday? 13285 * const result = isWednesday(new Date(2014, 8, 24)) 13286 * //=> true 13287 */ 13288function isWednesday(date, options) { 13289 return (0, _index.toDate)(date, options?.in).getDay() === 3; 13290} 13291 13292 13293/***/ }), 13294 13295/***/ 356804: 13296/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13297 13298"use strict"; 13299 13300exports.isWeekend = isWeekend; 13301var _index = __webpack_require__(807799); 13302 13303/** 13304 * The {@link isWeekend} function options. 13305 */ 13306 13307/** 13308 * @name isWeekend 13309 * @category Weekday Helpers 13310 * @summary Does the given date fall on a weekend? 13311 * 13312 * @description 13313 * Does the given date fall on a weekend? A weekend is either Saturday (`6`) or Sunday (`0`). 13314 * 13315 * @param date - The date to check 13316 * @param options - An object with options 13317 * 13318 * @returns The date falls on a weekend 13319 * 13320 * @example 13321 * // Does 5 October 2014 fall on a weekend? 13322 * const result = isWeekend(new Date(2014, 9, 5)) 13323 * //=> true 13324 */ 13325function isWeekend(date, options) { 13326 const day = (0, _index.toDate)(date, options?.in).getDay(); 13327 return day === 0 || day === 6; 13328} 13329 13330 13331/***/ }), 13332 13333/***/ 769816: 13334/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13335 13336"use strict"; 13337 13338exports.isWithinInterval = isWithinInterval; 13339var _index = __webpack_require__(807799); 13340 13341/** 13342 * The {@link isWithinInterval} function options. 13343 */ 13344 13345/** 13346 * @name isWithinInterval 13347 * @category Interval Helpers 13348 * @summary Is the given date within the interval? 13349 * 13350 * @description 13351 * Is the given date within the interval? (Including start and end.) 13352 * 13353 * @param date - The date to check 13354 * @param interval - The interval to check 13355 * @param options - An object with options 13356 * 13357 * @returns The date is within the interval 13358 * 13359 * @example 13360 * // For the date within the interval: 13361 * isWithinInterval(new Date(2014, 0, 3), { 13362 * start: new Date(2014, 0, 1), 13363 * end: new Date(2014, 0, 7) 13364 * }) 13365 * // => true 13366 * 13367 * @example 13368 * // For the date outside of the interval: 13369 * isWithinInterval(new Date(2014, 0, 10), { 13370 * start: new Date(2014, 0, 1), 13371 * end: new Date(2014, 0, 7) 13372 * }) 13373 * // => false 13374 * 13375 * @example 13376 * // For date equal to the interval start: 13377 * isWithinInterval(date, { start, end: date }) 13378 * // => true 13379 * 13380 * @example 13381 * // For date equal to the interval end: 13382 * isWithinInterval(date, { start: date, end }) 13383 * // => true 13384 */ 13385function isWithinInterval(date, interval, options) { 13386 const time = +(0, _index.toDate)(date, options?.in); 13387 const [startTime, endTime] = [ 13388 +(0, _index.toDate)(interval.start, options?.in), 13389 +(0, _index.toDate)(interval.end, options?.in), 13390 ].sort((a, b) => a - b); 13391 13392 return time >= startTime && time <= endTime; 13393} 13394 13395 13396/***/ }), 13397 13398/***/ 115706: 13399/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13400 13401"use strict"; 13402 13403exports.isYesterday = isYesterday; 13404var _index = __webpack_require__(658612); 13405var _index2 = __webpack_require__(560533); 13406var _index3 = __webpack_require__(373958); 13407var _index4 = __webpack_require__(678293); 13408 13409/** 13410 * The {@link isYesterday} function options. 13411 */ 13412 13413/** 13414 * @name isYesterday 13415 * @category Day Helpers 13416 * @summary Is the given date yesterday? 13417 * @pure false 13418 * 13419 * @description 13420 * Is the given date yesterday? 13421 * 13422 * @param date - The date to check 13423 * @param options - An object with options 13424 * 13425 * @returns The date is yesterday 13426 * 13427 * @example 13428 * // If today is 6 October 2014, is 5 October 14:00:00 yesterday? 13429 * const result = isYesterday(new Date(2014, 9, 5, 14, 0)) 13430 * //=> true 13431 */ 13432function isYesterday(date, options) { 13433 return (0, _index3.isSameDay)( 13434 (0, _index.constructFrom)(options?.in || date, date), 13435 (0, _index4.subDays)((0, _index2.constructNow)(options?.in || date), 1), 13436 ); 13437} 13438 13439 13440/***/ }), 13441 13442/***/ 520549: 13443/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13444 13445"use strict"; 13446 13447exports.lastDayOfDecade = lastDayOfDecade; 13448var _index = __webpack_require__(807799); 13449 13450/** 13451 * The {@link lastDayOfDecade} function options. 13452 */ 13453 13454/** 13455 * @name lastDayOfDecade 13456 * @category Decade Helpers 13457 * @summary Return the last day of a decade for the given date. 13458 * 13459 * @description 13460 * Return the last day of a decade for the given date. 13461 * 13462 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc). 13463 * @typeParam ResultDate - The result `Date` type; inferred from arguments or specified by context. 13464 * 13465 * @param date - The original date 13466 * @param options - The options 13467 * 13468 * @returns The last day of a decade 13469 * 13470 * @example 13471 * // The last day of a decade for 21 December 2012 21:12:00: 13472 * const result = lastDayOfDecade(new Date(2012, 11, 21, 21, 12, 00)) 13473 * //=> Wed Dec 31 2019 00:00:00 13474 */ 13475function lastDayOfDecade(date, options) { 13476 const _date = (0, _index.toDate)(date, options?.in); 13477 const year = _date.getFullYear(); 13478 const decade = 9 + Math.floor(year / 10) * 10; 13479 _date.setFullYear(decade + 1, 0, 0); 13480 _date.setHours(0, 0, 0, 0); 13481 return (0, _index.toDate)(_date, options?.in); 13482} 13483 13484 13485/***/ }), 13486 13487/***/ 865149: 13488/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13489 13490"use strict"; 13491 13492exports.lastDayOfISOWeek = lastDayOfISOWeek; 13493var _index = __webpack_require__(485601); 13494 13495/** 13496 * The {@link lastDayOfISOWeek} function options. 13497 */ 13498 13499/** 13500 * @name lastDayOfISOWeek 13501 * @category ISO Week Helpers 13502 * @summary Return the last day of an ISO week for the given date. 13503 * 13504 * @description 13505 * Return the last day of an ISO week for the given date. 13506 * The result will be in the local timezone. 13507 * 13508 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 13509 * 13510 * @typeParam DateType - The Date type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [UTCDate](https://github.com/date-fns/utc). 13511 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13512 * 13513 * @param date - The original date 13514 * @param options - An object with options 13515 * 13516 * @returns The last day of an ISO week 13517 * 13518 * @example 13519 * // The last day of an ISO week for 2 September 2014 11:55:00: 13520 * const result = lastDayOfISOWeek(new Date(2014, 8, 2, 11, 55, 0)) 13521 * //=> Sun Sep 07 2014 00:00:00 13522 */ 13523function lastDayOfISOWeek(date, options) { 13524 return (0, _index.lastDayOfWeek)(date, { ...options, weekStartsOn: 1 }); 13525} 13526 13527 13528/***/ }), 13529 13530/***/ 263256: 13531/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13532 13533"use strict"; 13534 13535exports.lastDayOfISOWeekYear = lastDayOfISOWeekYear; 13536var _index = __webpack_require__(658612); 13537var _index2 = __webpack_require__(196914); 13538var _index3 = __webpack_require__(266795); 13539 13540/** 13541 * The {@link lastDayOfISOWeekYear} function options. 13542 */ 13543 13544/** 13545 * @name lastDayOfISOWeekYear 13546 * @category ISO Week-Numbering Year Helpers 13547 * @summary Return the last day of an ISO week-numbering year for the given date. 13548 * 13549 * @description 13550 * Return the last day of an ISO week-numbering year, 13551 * which always starts 3 days before the year's first Thursday. 13552 * The result will be in the local timezone. 13553 * 13554 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date 13555 * 13556 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 13557 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13558 * 13559 * @param date - The original date 13560 * @param options - An object with options 13561 * 13562 * @returns The end of an ISO week-numbering year 13563 * 13564 * @example 13565 * // The last day of an ISO week-numbering year for 2 July 2005: 13566 * const result = lastDayOfISOWeekYear(new Date(2005, 6, 2)) 13567 * //=> Sun Jan 01 2006 00:00:00 13568 */ 13569function lastDayOfISOWeekYear(date, options) { 13570 const year = (0, _index2.getISOWeekYear)(date, options); 13571 const fourthOfJanuary = (0, _index.constructFrom)(options?.in || date, 0); 13572 fourthOfJanuary.setFullYear(year + 1, 0, 4); 13573 fourthOfJanuary.setHours(0, 0, 0, 0); 13574 13575 const date_ = (0, _index3.startOfISOWeek)(fourthOfJanuary, options); 13576 date_.setDate(date_.getDate() - 1); 13577 return date_; 13578} 13579 13580 13581/***/ }), 13582 13583/***/ 251596: 13584/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13585 13586"use strict"; 13587 13588exports.lastDayOfMonth = lastDayOfMonth; 13589var _index = __webpack_require__(807799); 13590 13591/** 13592 * The {@link lastDayOfMonth} function options. 13593 */ 13594 13595/** 13596 * @name lastDayOfMonth 13597 * @category Month Helpers 13598 * @summary Return the last day of a month for the given date. 13599 * 13600 * @description 13601 * Return the last day of a month for the given date. 13602 * The result will be in the local timezone. 13603 * 13604 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 13605 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13606 * 13607 * @param date - The original date 13608 * @param options - An object with options 13609 * 13610 * @returns The last day of a month 13611 * 13612 * @example 13613 * // The last day of a month for 2 September 2014 11:55:00: 13614 * const result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0)) 13615 * //=> Tue Sep 30 2014 00:00:00 13616 */ 13617function lastDayOfMonth(date, options) { 13618 const _date = (0, _index.toDate)(date, options?.in);
13619 const month = _date.getMonth(); 13620 _date.setFullYear(_date.getFullYear(), month + 1, 0); 13621 _date.setHours(0, 0, 0, 0); 13622 return (0, _index.toDate)(_date, options?.in); 13623} 13624 13625 13626/***/ }), 13627 13628/***/ 118050: 13629/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13630 13631"use strict"; 13632 13633exports.lastDayOfQuarter = lastDayOfQuarter; 13634var _index = __webpack_require__(807799); 13635 13636/** 13637 * The {@link lastDayOfQuarter} function options. 13638 */ 13639 13640/** 13641 * @name lastDayOfQuarter 13642 * @category Quarter Helpers 13643 * @summary Return the last day of a year quarter for the given date. 13644 * 13645 * @description 13646 * Return the last day of a year quarter for the given date. 13647 * The result will be in the local timezone. 13648 * 13649 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 13650 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13651 * 13652 * @param date - The original date 13653 * @param options - The options 13654 * 13655 * @returns The last day of a quarter 13656 * 13657 * @example 13658 * // The last day of a quarter for 2 September 2014 11:55:00: 13659 * const result = lastDayOfQuarter(new Date(2014, 8, 2, 11, 55, 0)) 13660 * //=> Tue Sep 30 2014 00:00:00 13661 */ 13662function lastDayOfQuarter(date, options) { 13663 const date_ = (0, _index.toDate)(date, options?.in); 13664 const currentMonth = date_.getMonth();
13665 const month = currentMonth - (currentMonth % 3) + 3; 13666 date_.setMonth(month, 0); 13667 date_.setHours(0, 0, 0, 0); 13668 return date_; 13669} 13670 13671 13672/***/ }), 13673 13674/***/ 485601: 13675/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13676 13677"use strict"; 13678 13679exports.lastDayOfWeek = lastDayOfWeek; 13680var _index = __webpack_require__(983074); 13681var _index2 = __webpack_require__(807799); 13682 13683/** 13684 * The {@link lastDayOfWeek} function options. 13685 */ 13686 13687/** 13688 * @name lastDayOfWeek 13689 * @category Week Helpers 13690 * @summary Return the last day of a week for the given date. 13691 * 13692 * @description 13693 * Return the last day of a week for the given date. 13694 * The result will be in the local timezone unless a context is specified. 13695 * 13696 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 13697 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13698 * 13699 * @param date - The original date 13700 * @param options - An object with options 13701 * 13702 * @returns The last day of a week 13703 */ 13704function lastDayOfWeek(date, options) { 13705 const defaultOptions = (0, _index.getDefaultOptions)(); 13706 const weekStartsOn = 13707 options?.weekStartsOn ?? 13708 options?.locale?.options?.weekStartsOn ?? 13709 defaultOptions.weekStartsOn ?? 13710 defaultOptions.locale?.options?.weekStartsOn ?? 13711 0; 13712 13713 const _date = (0, _index2.toDate)(date, options?.in); 13714 const day = _date.getDay(); 13715 const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn); 13716 13717 _date.setHours(0, 0, 0, 0); 13718 _date.setDate(_date.getDate() + diff); 13719 13720 return _date; 13721} 13722 13723 13724/***/ }), 13725 13726/***/ 426347: 13727/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13728 13729"use strict"; 13730 13731exports.lastDayOfYear = lastDayOfYear; 13732var _index = __webpack_require__(807799); 13733 13734/** 13735 * The {@link lastDayOfYear} function options. 13736 */ 13737 13738/** 13739 * @name lastDayOfYear 13740 * @category Year Helpers 13741 * @summary Return the last day of a year for the given date. 13742 * 13743 * @description 13744 * Return the last day of a year for the given date. 13745 * The result will be in the local timezone. 13746 * 13747 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 13748 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 13749 * 13750 * @param date - The original date 13751 * @param options - An object with options 13752 * 13753 * @returns The last day of a year 13754 * 13755 * @example 13756 * // The last day of a year for 2 September 2014 11:55:00: 13757 * const result = lastDayOfYear(new Date(2014, 8, 2, 11, 55, 00)) 13758 * //=> Wed Dec 31 2014 00:00:00 13759 */ 13760function lastDayOfYear(date, options) { 13761 const date_ = (0, _index.toDate)(date, options?.in); 13762 const year = date_.getFullYear(); 13763 date_.setFullYear(year + 1, 0, 0); 13764 date_.setHours(0, 0, 0, 0); 13765 return date_; 13766} 13767 13768 13769/***/ }), 13770 13771/***/ 692266: 13772/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 13773 13774"use strict"; 13775 13776exports.lightFormat = lightFormat; 13777Object.defineProperty(exports, "lightFormatters", ({ 13778 enumerable: true, 13779 get: function () { 13780 return _index.lightFormatters; 13781 }, 13782})); 13783var _index = __webpack_require__(387179); 13784var _index2 = __webpack_require__(533209); 13785var _index3 = __webpack_require__(807799); 13786 13787// Rexports of internal for libraries to use. 13788// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874 13789 13790// This RegExp consists of three parts separated by `|`: 13791// - (\w)\1* matches any sequences of the same letter 13792// - '' matches two quote characters in a row 13793// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('), 13794// except a single quote symbol, which ends the sequence. 13795// Two quote characters do not end the sequence. 13796// If there is no matching single quote 13797// then the sequence will continue until the end of the string. 13798// - . matches any single character unmatched by previous parts of the RegExps 13799const formattingTokensRegExp = /(\w)\1*|''|'(''|[^'])+('|$)|./g; 13800 13801const escapedStringRegExp = /^'([^]*?)'?$/; 13802const doubleQuoteRegExp = /''/g; 13803const unescapedLatinCharacterRegExp = /[a-zA-Z]/; 13804 13805/** 13806 * @private 13807 */ 13808 13809/** 13810 * @name lightFormat 13811 * @category Common Helpers 13812 * @summary Format the date. 13813 * 13814 * @description 13815 * Return the formatted date string in the given format. Unlike `format`, 13816 * `lightFormat` doesn't use locales and outputs date using the most popular tokens. 13817 * 13818 * > â ï¸ Please note that the `lightFormat` tokens differ from Moment.js and other libraries. 13819 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md 13820 * 13821 * The characters wrapped between two single quotes characters (') are escaped. 13822 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote. 13823 * 13824 * Format of the string is based on Unicode Technical Standard #35: 13825 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table 13826 * 13827 * Accepted patterns: 13828 * | Unit | Pattern | Result examples | 13829 * |---------------------------------|---------|-----------------------------------| 13830 * | AM, PM | a..aaa | AM, PM | 13831 * | | aaaa | a.m., p.m. | 13832 * | | aaaaa | a, p | 13833 * | Calendar year | y | 44, 1, 1900, 2017 | 13834 * | | yy | 44, 01, 00, 17 | 13835 * | | yyy | 044, 001, 000, 017 | 13836 * | | yyyy | 0044, 0001, 1900, 2017 | 13837 * | Month (formatting) | M | 1, 2, ..., 12 | 13838 * | | MM | 01, 02, ..., 12 | 13839 * | Day of month | d | 1, 2, ..., 31 | 13840 * | | dd | 01, 02, ..., 31 | 13841 * | Hour [1-12] | h | 1, 2, ..., 11, 12 | 13842 * | | hh | 01, 02, ..., 11, 12 | 13843 * | Hour [0-23] | H | 0, 1, 2, ..., 23 | 13844 * | | HH | 00, 01, 02, ..., 23 | 13845 * | Minute | m | 0, 1, ..., 59 | 13846 * | | mm | 00, 01, ..., 59 | 13847 * | Second | s | 0, 1, ..., 59 | 13848 * | | ss | 00, 01, ..., 59 | 13849 * | Fraction of second | S | 0, 1, ..., 9 | 13850 * | | SS | 00, 01, ..., 99 | 13851 * | | SSS | 000, 001, ..., 999 | 13852 * | | SSSS | ... | 13853 * 13854 * @param date - The original date 13855 * @param format - The string of tokens 13856 * 13857 * @returns The formatted date string 13858 *
13859 * @throws `Invalid time value` if the date is invalid 13860 * @throws format string contains an unescaped latin alphabet character 13861 * 13862 * @example 13863 * const result = lightFormat(new Date(2014, 1, 11), 'yyyy-MM-dd') 13864 * //=> '2014-02-11' 13865 */ 13866function lightFormat(date, formatStr) { 13867 const date_ = (0, _index3.toDate)(date); 13868 13869 if (!(0, _index2.isValid)(date_)) { 13870 throw new RangeError("Invalid time value"); 13871 } 13872 13873 const tokens = formatStr.match(formattingTokensRegExp); 13874 13875 // The only case when formattingTokensRegExp doesn't match the string is when it's empty 13876 if (!tokens) return ""; 13877 13878 const result = tokens 13879 .map((substring) => { 13880 // Replace two single quote characters with one single quote character 13881 if (substring === "''") { 13882 return "'"; 13883 } 13884 13885 const firstCharacter = substring[0]; 13886 if (firstCharacter === "'") { 13887 return cleanEscapedString(substring); 13888 } 13889 13890 const formatter = _index.lightFormatters[firstCharacter]; 13891 if (formatter) { 13892 return formatter(date_, substring); 13893 } 13894 13895 if (firstCharacter.match(unescapedLatinCharacterRegExp)) { 13896 throw new RangeError( 13897 "Format string contains an unescaped latin alphabet character `" + 13898 firstCharacter + 13899 "`", 13900 ); 13901 } 13902 13903 return substring; 13904 }) 13905 .join(""); 13906 13907 return result; 13908} 13909 13910function cleanEscapedString(input) { 13911 const matches = input.match(escapedStringRegExp); 13912 if (!matches) return input; 13913 return matches[1].replace(doubleQuoteRegExp, "'"); 13914} 13915 13916 13917/***/ }), 13918 13919/***/ 537264: 13920/***/ (function(__unused_webpack_module, exports) { 13921 13922"use strict"; 13923 13924exports.buildFormatLongFn = buildFormatLongFn; 13925 13926function buildFormatLongFn(args) { 13927 return (options = {}) => { 13928 // TODO: Remove String() 13929 const width = options.width ? String(options.width) : args.defaultWidth; 13930 const format = args.formats[width] || args.formats[args.defaultWidth]; 13931 return format; 13932 }; 13933} 13934 13935 13936/***/ }), 13937 13938/***/ 964647: 13939/***/ (function(__unused_webpack_module, exports) { 13940 13941"use strict"; 13942 13943exports.buildLocalizeFn = buildLocalizeFn; 13944 13945/** 13946 * The localize function argument callback which allows to convert raw value to 13947 * the actual type. 13948 * 13949 * @param value - The value to convert 13950 * 13951 * @returns The converted value 13952 */ 13953 13954/** 13955 * The map of localized values for each width. 13956 */ 13957 13958/** 13959 * The index type of the locale unit value. It types conversion of units of 13960 * values that don't start at 0 (i.e. quarters). 13961 */ 13962 13963/** 13964 * Converts the unit value to the tuple of values. 13965 */ 13966 13967/** 13968 * The tuple of localized era values. The first element represents BC, 13969 * the second element represents AD. 13970 */ 13971 13972/** 13973 * The tuple of localized quarter values. The first element represents Q1. 13974 */ 13975 13976/** 13977 * The tuple of localized day values. The first element represents Sunday. 13978 */ 13979 13980/** 13981 * The tuple of localized month values. The first element represents January. 13982 */ 13983 13984function buildLocalizeFn(args) { 13985 return (value, options) => { 13986 const context = options?.context ? String(options.context) : "standalone"; 13987 13988 let valuesArray; 13989 if (context === "formatting" && args.formattingValues) { 13990 const defaultWidth = args.defaultFormattingWidth || args.defaultWidth; 13991 const width = options?.width ? String(options.width) : defaultWidth; 13992 13993 valuesArray = 13994 args.formattingValues[width] || args.formattingValues[defaultWidth]; 13995 } else { 13996 const defaultWidth = args.defaultWidth; 13997 const width = options?.width ? String(options.width) : args.defaultWidth; 13998 13999 valuesArray = args.values[width] || args.values[defaultWidth]; 14000 } 14001 const index = args.argumentCallback ? args.argumentCallback(value) : value; 14002 14003 // @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it! 14004 return valuesArray[index]; 14005 }; 14006} 14007 14008 14009/***/ }), 14010 14011/***/ 549548: 14012/***/ (function(__unused_webpack_module, exports) { 14013 14014"use strict"; 14015 14016exports.buildMatchFn = buildMatchFn; 14017 14018function buildMatchFn(args) { 14019 return (string, options = {}) => { 14020 const width = options.width; 14021 14022 const matchPattern = 14023 (width && args.matchPatterns[width]) || 14024 args.matchPatterns[args.defaultMatchWidth]; 14025 const matchResult = string.match(matchPattern); 14026 14027 if (!matchResult) { 14028 return null; 14029 } 14030 const matchedString = matchResult[0]; 14031 14032 const parsePatterns = 14033 (width && args.parsePatterns[width]) || 14034 args.parsePatterns[args.defaultParseWidth]; 14035
vendor: 5,521 bytes, lines 14036-14308
14036 const key = Array.isArray(parsePatterns) 14037 ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) 14038 : // [TODO] -- I challenge you to fix the type 14039 findKey(parsePatterns, (pattern) => pattern.test(matchedString)); 14040 14041 let value; 14042 14043 value = args.valueCallback ? args.valueCallback(key) : key; 14044 value = options.valueCallback 14045 ? // [TODO] -- I challenge you to fix the type 14046 options.valueCallback(value) 14047 : value; 14048 14049 const rest = string.slice(matchedString.length); 14050 14051 return { value, rest }; 14052 }; 14053} 14054 14055function findKey(object, predicate) { 14056 for (const key in object) { 14057 if ( 14058 Object.prototype.hasOwnProperty.call(object, key) && 14059 predicate(object[key]) 14060 ) { 14061 return key; 14062 } 14063 } 14064 return undefined; 14065} 14066 14067function findIndex(array, predicate) { 14068 for (let key = 0; key < array.length; key++) { 14069 if (predicate(array[key])) { 14070 return key; 14071 } 14072 } 14073 return undefined; 14074} 14075 14076 14077/***/ }), 14078 14079/***/ 223094: 14080/***/ (function(__unused_webpack_module, exports) { 14081 14082"use strict"; 14083 14084exports.buildMatchPatternFn = buildMatchPatternFn; 14085 14086function buildMatchPatternFn(args) { 14087 return (string, options = {}) => { 14088 const matchResult = string.match(args.matchPattern); 14089 if (!matchResult) return null; 14090 const matchedString = matchResult[0]; 14091 14092 const parseResult = string.match(args.parsePattern); 14093 if (!parseResult) return null; 14094 let value = args.valueCallback 14095 ? args.valueCallback(parseResult[0]) 14096 : parseResult[0]; 14097 14098 // [TODO] I challenge you to fix the type 14099 value = options.valueCallback ? options.valueCallback(value) : value; 14100 14101 const rest = string.slice(matchedString.length); 14102 14103 return { value, rest }; 14104 }; 14105} 14106 14107 14108/***/ }), 14109 14110/***/ 810824: 14111/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 14112 14113"use strict"; 14114 14115exports.enUS = void 0; 14116var _index = __webpack_require__(509310); 14117var _index2 = __webpack_require__(144868); 14118var _index3 = __webpack_require__(566959); 14119var _index4 = __webpack_require__(618119); 14120var _index5 = __webpack_require__(950993); 14121 14122/** 14123 * @category Locales 14124 * @summary English locale (United States). 14125 * @language English 14126 * @iso-639-2 eng 14127 * @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp) 14128 * @author Lesha Koss [@leshakoss](https://github.com/leshakoss) 14129 */ 14130const enUS = (exports.enUS = { 14131 code: "en-US", 14132 formatDistance: _index.formatDistance, 14133 formatLong: _index2.formatLong, 14134 formatRelative: _index3.formatRelative, 14135 localize: _index4.localize, 14136 match: _index5.match, 14137 options: { 14138 weekStartsOn: 0 /* Sunday */, 14139 firstWeekContainsDate: 1, 14140 }, 14141}); 14142 14143 14144/***/ }), 14145 14146/***/ 509310: 14147/***/ (function(__unused_webpack_module, exports) { 14148 14149"use strict"; 14150 14151exports.formatDistance = void 0; 14152 14153const formatDistanceLocale = { 14154 lessThanXSeconds: { 14155 one: "less than a second", 14156 other: "less than {{count}} seconds", 14157 }, 14158 14159 xSeconds: { 14160 one: "1 second", 14161 other: "{{count}} seconds", 14162 }, 14163 14164 halfAMinute: "half a minute", 14165 14166 lessThanXMinutes: { 14167 one: "less than a minute", 14168 other: "less than {{count}} minutes", 14169 }, 14170 14171 xMinutes: { 14172 one: "1 minute", 14173 other: "{{count}} minutes", 14174 }, 14175 14176 aboutXHours: { 14177 one: "about 1 hour", 14178 other: "about {{count}} hours", 14179 }, 14180 14181 xHours: { 14182 one: "1 hour", 14183 other: "{{count}} hours", 14184 }, 14185 14186 xDays: { 14187 one: "1 day", 14188 other: "{{count}} days", 14189 }, 14190 14191 aboutXWeeks: { 14192 one: "about 1 week", 14193 other: "about {{count}} weeks", 14194 }, 14195 14196 xWeeks: { 14197 one: "1 week", 14198 other: "{{count}} weeks", 14199 }, 14200 14201 aboutXMonths: { 14202 one: "about 1 month", 14203 other: "about {{count}} months", 14204 }, 14205 14206 xMonths: { 14207 one: "1 month", 14208 other: "{{count}} months", 14209 }, 14210 14211 aboutXYears: { 14212 one: "about 1 year", 14213 other: "about {{count}} years", 14214 }, 14215 14216 xYears: { 14217 one: "1 year", 14218 other: "{{count}} years", 14219 }, 14220 14221 overXYears: { 14222 one: "over 1 year", 14223 other: "over {{count}} years", 14224 }, 14225 14226 almostXYears: { 14227 one: "almost 1 year", 14228 other: "almost {{count}} years", 14229 }, 14230}; 14231 14232const formatDistance = (token, count, options) => { 14233 let result; 14234 14235 const tokenValue = formatDistanceLocale[token]; 14236 if (typeof tokenValue === "string") { 14237 result = tokenValue; 14238 } else if (count === 1) { 14239 result = tokenValue.one; 14240 } else { 14241 result = tokenValue.other.replace("{{count}}", count.toString()); 14242 } 14243 14244 if (options?.addSuffix) { 14245 if (options.comparison && options.comparison > 0) { 14246 return "in " + result; 14247 } else { 14248 return result + " ago"; 14249 } 14250 } 14251 14252 return result; 14253}; 14254exports.formatDistance = formatDistance; 14255 14256 14257/***/ }), 14258 14259/***/ 144868: 14260/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 14261 14262"use strict"; 14263 14264exports.formatLong = void 0; 14265var _index = __webpack_require__(537264); 14266 14267const dateFormats = { 14268 full: "EEEE, MMMM do, y", 14269 long: "MMMM do, y", 14270 medium: "MMM d, y", 14271 short: "MM/dd/yyyy", 14272}; 14273 14274const timeFormats = { 14275 full: "h:mm:ss a zzzz", 14276 long: "h:mm:ss a z", 14277 medium: "h:mm:ss a", 14278 short: "h:mm a", 14279}; 14280 14281const dateTimeFormats = { 14282 full: "{{date}} 'at' {{time}}", 14283 long: "{{date}} 'at' {{time}}", 14284 medium: "{{date}}, {{time}}", 14285 short: "{{date}}, {{time}}", 14286}; 14287 14288const formatLong = (exports.formatLong = { 14289 date: (0, _index.buildFormatLongFn)({ 14290 formats: dateFormats, 14291 defaultWidth: "full", 14292 }), 14293 14294 time: (0, _index.buildFormatLongFn)({ 14295 formats: timeFormats, 14296 defaultWidth: "full", 14297 }), 14298 14299 dateTime: (0, _index.buildFormatLongFn)({ 14300 formats: dateTimeFormats, 14301 defaultWidth: "full", 14302 }), 14303}); 14304 14305 14306/***/ }), 14307 14308/***/ 566959:
vendor: 9,031 bytes, lines 14309-14712
14309/***/ (function(__unused_webpack_module, exports) { 14310 14311"use strict"; 14312 14313exports.formatRelative = void 0; 14314 14315const formatRelativeLocale = { 14316 lastWeek: "'last' eeee 'at' p", 14317 yesterday: "'yesterday at' p", 14318 today: "'today at' p", 14319 tomorrow: "'tomorrow at' p", 14320 nextWeek: "eeee 'at' p", 14321 other: "P", 14322}; 14323 14324const formatRelative = (token, _date, _baseDate, _options) => 14325 formatRelativeLocale[token]; 14326exports.formatRelative = formatRelative; 14327 14328 14329/***/ }), 14330 14331/***/ 618119: 14332/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 14333 14334"use strict"; 14335 14336exports.localize = void 0; 14337var _index = __webpack_require__(964647); 14338 14339const eraValues = { 14340 narrow: ["B", "A"], 14341 abbreviated: ["BC", "AD"], 14342 wide: ["Before Christ", "Anno Domini"], 14343}; 14344 14345const quarterValues = { 14346 narrow: ["1", "2", "3", "4"], 14347 abbreviated: ["Q1", "Q2", "Q3", "Q4"], 14348 wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"], 14349}; 14350 14351// Note: in English, the names of days of the week and months are capitalized. 14352// If you are making a new locale based on this one, check if the same is true for the language you're working on. 14353// Generally, formatted dates should look like they are in the middle of a sentence, 14354// e.g. in Spanish language the weekdays and months should be in the lowercase. 14355const monthValues = { 14356 narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"], 14357 abbreviated: [ 14358 "Jan", 14359 "Feb", 14360 "Mar", 14361 "Apr", 14362 "May", 14363 "Jun", 14364 "Jul", 14365 "Aug", 14366 "Sep", 14367 "Oct", 14368 "Nov", 14369 "Dec", 14370 ], 14371 14372 wide: [ 14373 "January", 14374 "February", 14375 "March", 14376 "April", 14377 "May", 14378 "June", 14379 "July", 14380 "August", 14381 "September", 14382 "October", 14383 "November", 14384 "December", 14385 ], 14386}; 14387 14388const dayValues = { 14389 narrow: ["S", "M", "T", "W", "T", "F", "S"], 14390 short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], 14391 abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], 14392 wide: [ 14393 "Sunday", 14394 "Monday", 14395 "Tuesday", 14396 "Wednesday", 14397 "Thursday", 14398 "Friday", 14399 "Saturday", 14400 ], 14401}; 14402 14403const dayPeriodValues = { 14404 narrow: { 14405 am: "a", 14406 pm: "p", 14407 midnight: "mi", 14408 noon: "n", 14409 morning: "morning", 14410 afternoon: "afternoon", 14411 evening: "evening", 14412 night: "night", 14413 }, 14414 abbreviated: { 14415 am: "AM", 14416 pm: "PM", 14417 midnight: "midnight", 14418 noon: "noon", 14419 morning: "morning", 14420 afternoon: "afternoon", 14421 evening: "evening", 14422 night: "night", 14423 }, 14424 wide: { 14425 am: "a.m.", 14426 pm: "p.m.", 14427 midnight: "midnight", 14428 noon: "noon", 14429 morning: "morning", 14430 afternoon: "afternoon", 14431 evening: "evening", 14432 night: "night", 14433 }, 14434}; 14435 14436const formattingDayPeriodValues = { 14437 narrow: { 14438 am: "a", 14439 pm: "p", 14440 midnight: "mi", 14441 noon: "n", 14442 morning: "in the morning", 14443 afternoon: "in the afternoon", 14444 evening: "in the evening", 14445 night: "at night", 14446 }, 14447 abbreviated: { 14448 am: "AM", 14449 pm: "PM", 14450 midnight: "midnight", 14451 noon: "noon", 14452 morning: "in the morning", 14453 afternoon: "in the afternoon", 14454 evening: "in the evening", 14455 night: "at night", 14456 }, 14457 wide: { 14458 am: "a.m.", 14459 pm: "p.m.", 14460 midnight: "midnight", 14461 noon: "noon", 14462 morning: "in the morning", 14463 afternoon: "in the afternoon", 14464 evening: "in the evening", 14465 night: "at night", 14466 }, 14467}; 14468 14469const ordinalNumber = (dirtyNumber, _options) => { 14470 const number = Number(dirtyNumber); 14471 14472 // If ordinal numbers depend on context, for example, 14473 // if they are different for different grammatical genders, 14474 // use `options.unit`. 14475 // 14476 // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear', 14477 // 'day', 'hour', 'minute', 'second'. 14478 14479 const rem100 = number % 100; 14480 if (rem100 > 20 || rem100 < 10) { 14481 switch (rem100 % 10) { 14482 case 1: 14483 return number + "st"; 14484 case 2: 14485 return number + "nd"; 14486 case 3: 14487 return number + "rd"; 14488 } 14489 } 14490 return number + "th"; 14491}; 14492 14493const localize = (exports.localize = { 14494 ordinalNumber, 14495 14496 era: (0, _index.buildLocalizeFn)({ 14497 values: eraValues, 14498 defaultWidth: "wide", 14499 }), 14500 14501 quarter: (0, _index.buildLocalizeFn)({ 14502 values: quarterValues, 14503 defaultWidth: "wide", 14504 argumentCallback: (quarter) => quarter - 1, 14505 }), 14506 14507 month: (0, _index.buildLocalizeFn)({ 14508 values: monthValues, 14509 defaultWidth: "wide", 14510 }), 14511 14512 day: (0, _index.buildLocalizeFn)({ 14513 values: dayValues, 14514 defaultWidth: "wide", 14515 }), 14516 14517 dayPeriod: (0, _index.buildLocalizeFn)({ 14518 values: dayPeriodValues, 14519 defaultWidth: "wide", 14520 formattingValues: formattingDayPeriodValues, 14521 defaultFormattingWidth: "wide", 14522 }), 14523}); 14524 14525 14526/***/ }), 14527 14528/***/ 950993: 14529/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 14530 14531"use strict"; 14532 14533exports.match = void 0; 14534 14535var _index = __webpack_require__(549548); 14536var _index2 = __webpack_require__(223094); 14537 14538const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i; 14539const parseOrdinalNumberPattern = /\d+/i; 14540 14541const matchEraPatterns = { 14542 narrow: /^(b|a)/i, 14543 abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i, 14544 wide: /^(before christ|before common era|anno domini|common era)/i, 14545}; 14546const parseEraPatterns = { 14547 any: [/^b/i, /^(a|c)/i], 14548}; 14549 14550const matchQuarterPatterns = { 14551 narrow: /^[1234]/i, 14552 abbreviated: /^q[1234]/i, 14553 wide: /^[1234](th|st|nd|rd)? quarter/i, 14554}; 14555const parseQuarterPatterns = { 14556 any: [/1/i, /2/i, /3/i, /4/i], 14557}; 14558 14559const matchMonthPatterns = { 14560 narrow: /^[jfmasond]/i, 14561 abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i, 14562 wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i, 14563}; 14564const parseMonthPatterns = { 14565 narrow: [ 14566 /^j/i, 14567 /^f/i, 14568 /^m/i, 14569 /^a/i, 14570 /^m/i, 14571 /^j/i, 14572 /^j/i, 14573 /^a/i, 14574 /^s/i, 14575 /^o/i, 14576 /^n/i, 14577 /^d/i, 14578 ], 14579 14580 any: [ 14581 /^ja/i, 14582 /^f/i, 14583 /^mar/i, 14584 /^ap/i, 14585 /^may/i, 14586 /^jun/i, 14587 /^jul/i, 14588 /^au/i, 14589 /^s/i, 14590 /^o/i, 14591 /^n/i, 14592 /^d/i, 14593 ], 14594}; 14595 14596const matchDayPatterns = { 14597 narrow: /^[smtwf]/i, 14598 short: /^(su|mo|tu|we|th|fr|sa)/i, 14599 abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i, 14600 wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i, 14601}; 14602const parseDayPatterns = { 14603 narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i], 14604 any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i], 14605}; 14606 14607const matchDayPeriodPatterns = { 14608 narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i, 14609 any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i, 14610}; 14611const parseDayPeriodPatterns = { 14612 any: { 14613 am: /^a/i, 14614 pm: /^p/i, 14615 midnight: /^mi/i, 14616 noon: /^no/i, 14617 morning: /morning/i, 14618 afternoon: /afternoon/i, 14619 evening: /evening/i, 14620 night: /night/i, 14621 }, 14622}; 14623 14624const match = (exports.match = { 14625 ordinalNumber: (0, _index2.buildMatchPatternFn)({ 14626 matchPattern: matchOrdinalNumberPattern, 14627 parsePattern: parseOrdinalNumberPattern, 14628 valueCallback: (value) => parseInt(value, 10), 14629 }), 14630 14631 era: (0, _index.buildMatchFn)({ 14632 matchPatterns: matchEraPatterns, 14633 defaultMatchWidth: "wide", 14634 parsePatterns: parseEraPatterns, 14635 defaultParseWidth: "any", 14636 }), 14637 14638 quarter: (0, _index.buildMatchFn)({ 14639 matchPatterns: matchQuarterPatterns, 14640 defaultMatchWidth: "wide", 14641 parsePatterns: parseQuarterPatterns, 14642 defaultParseWidth: "any", 14643 valueCallback: (index) => index + 1, 14644 }), 14645 14646 month: (0, _index.buildMatchFn)({ 14647 matchPatterns: matchMonthPatterns, 14648 defaultMatchWidth: "wide", 14649 parsePatterns: parseMonthPatterns, 14650 defaultParseWidth: "any", 14651 }), 14652 14653 day: (0, _index.buildMatchFn)({ 14654 matchPatterns: matchDayPatterns, 14655 defaultMatchWidth: "wide", 14656 parsePatterns: parseDayPatterns, 14657 defaultParseWidth: "any", 14658 }), 14659 14660 dayPeriod: (0, _index.buildMatchFn)({ 14661 matchPatterns: matchDayPeriodPatterns, 14662 defaultMatchWidth: "any", 14663 parsePatterns: parseDayPeriodPatterns, 14664 defaultParseWidth: "any", 14665 }), 14666}); 14667 14668 14669/***/ }), 14670 14671/***/ 418809: 14672/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 14673 14674"use strict"; 14675 14676exports.max = max; 14677var _index = __webpack_require__(658612); 14678var _index2 = __webpack_require__(807799); 14679 14680/** 14681 * The {@link max} function options. 14682 */ 14683 14684/** 14685 * @name max 14686 * @category Common Helpers 14687 * @summary Return the latest of the given dates. 14688 * 14689 * @description 14690 * Return the latest of the given dates. 14691 * 14692 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc). 14693 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments. 14694 * 14695 * @param dates - The dates to compare 14696 * 14697 * @returns The latest of the dates 14698 * 14699 * @example 14700 * // Which of these dates is the latest? 14701 * const result = max([ 14702 * new Date(1989, 6, 10), 14703 * new Date(1987, 1, 11), 14704 * new Date(1995, 6, 2), 14705 * new Date(1990, 0, 1) 14706 * ]) 14707 * //=> Sun Jul 02 1995 00:00:00 14708 */ 14709function max(dates, options) { 14710 let result; 14711 let context = options?.in; 14712
14713 dates.forEach((date) => { 14714 // Use the first date object as the context function 14715 if (!context && typeof date === "object") 14716 context = _index.constructFrom.bind(null, date); 14717 14718 const date_ = (0, _index2.toDate)(date, context); 14719 if (!result || result < date_ || isNaN(+date_)) result = date_; 14720 }); 14721 14722 return (0, _index.constructFrom)(context, result || NaN); 14723} 14724 14725 14726/***/ }), 14727 14728/***/ 304835: 14729/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14730 14731"use strict"; 14732 14733// EXPORTS 14734__webpack_require__.d(__webpack_exports__, { 14735 b: function() { return /* binding */ h; } 14736}); 14737 14738// UNUSED EXPORTS: default 14739 14740// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/external/preact/dist/preact.js 14741var preact = __webpack_require__(257703); 14742// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/UIElement/UIElement.js 14743var UIElement = __webpack_require__(346545); 14744// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/SecuredFields/SFP/SecuredFieldsProvider.js + 43 modules 14745var SecuredFieldsProvider = __webpack_require__(260626); 14746// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/_virtual/index.js + 3 modules 14747var _virtual = __webpack_require__(630931); 14748// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/Icon/Icon.js 14749var Icon = __webpack_require__(264047); 14750;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/Alert/Alert.js 14751function r({children:r,classNames:s=[],type:c="error",icon:o}){return (0,preact/* createElement */.az)("div",{className:(0,_virtual/* default */.Z)("adyen-checkout__alert-message",`adyen-checkout__alert-message--${c}`,s)},o&&(0,preact/* createElement */.az)(Icon/* default */.Z,{className:"adyen-checkout__alert-message__icon",type:o}),r)} 14752//# sourceMappingURL=Alert.js.map 14753 14754// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/core/Context/CoreProvider.js 14755var CoreProvider = __webpack_require__(901087); 14756;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/components/GiftcardResult.js 14757function GiftcardResult_t({amount:t,balance:c,transactionLimit:n,status:l,makePayment:_,showPayButton:u,payButton:r}){const{i18n:s}=(0,CoreProvider/* useCoreContext */.m)(),i=t.value>n?.value?n:t,o=c?.value-i?.value;return (0,preact/* createElement */.az)("div",{className:"adyen-checkout__giftcard-result"},(0,preact/* createElement */.az)("ul",{className:"adyen-checkout__giftcard-result__balance"},(0,preact/* createElement */.az)("li",{className:"adyen-checkout__giftcard-result__balance__item"},(0,preact/* createElement */.az)("span",{className:"adyen-checkout__giftcard-result__balance__title"},s.get("giftcardBalance")),(0,preact/* createElement */.az)("span",{className:"adyen-checkout__giftcard-result__balance__value adyen-checkout__giftcard-result__balance__value--amount"},s.amount(c.value,c.currency))),n&&n.value&&(0,preact/* createElement */.az)("li",{className:"adyen-checkout__giftcard-result__balance__item"},(0,preact/* createElement */.az)("span",{className:"adyen-checkout__giftcard-result__balance__title adyen-checkout__giftcard-result__balance__title--transactionLimit"},s.get("giftcardTransactionLimit",{values:{amount:s.amount(n.value,n.currency)}})))),u&&r({amount:i,status:l,onClick:_}),(0,preact/* createElement */.az)("p",{className:"adyen-checkout__giftcard-result__remaining-balance"},s.get("partialPayment.remainingBalance",{values:{amount:s.amount(o,c.currency)}})))} 14758//# sourceMappingURL=GiftcardResult.js.map 14759 14760// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/SecuredFields/lib/constants.js 14761var constants = __webpack_require__(493556); 14762// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Card/components/CardInput/components/DataSfSpan.js 14763var DataSfSpan = __webpack_require__(880516); 14764// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/FormFields/Field/Field.js 14765var Field = __webpack_require__(31450); 14766// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Card/components/CardInput/components/FieldLabelAlternative.js 14767var FieldLabelAlternative = __webpack_require__(333098); 14768;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/components/GiftcardNumberField.js 14769const d=({i18n:d,classNameModifiers:o,sfpState:c,getCardErrorMessage:s,focusedElement:i,setFocusOn:m})=>(0,preact/* createElement */.az)(Field/* default */.Z,{label:d.get("giftcard.cardNumber.label"),classNameModifiers:["number",...o],errorMessage:s(c),focused:"encryptedCardNumber"===i,onFocusField:()=>m("encryptedCardNumber"),dir:"ltr",name:"encryptedCardNumber",contextVisibleToScreenReader:!1,useLabelElement:!1,renderAlternativeToLabel:FieldLabelAlternative/* alternativeLabelContent */._},(0,preact/* createElement */.az)(DataSfSpan/* default */.Z,{encryptedFieldType:"encryptedCardNumber","data-info":'{"length":"15-32", "maskInterval":4}',className:(0,_virtual/* default */.Z)({"adyen-checkout__input":!0,"adyen-checkout__input--large":!0,"adyen-checkout__card__cardNumber__input":!0,"adyen-checkout__input--error":s(c),"adyen-checkout__input--focus":"encryptedCardNumber"===i})})); 14770//# sourceMappingURL=GiftcardNumberField.js.map 14771 14772;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/components/GiftcardPinField.js 14773const c=({i18n:c,classNameModifiers:d,sfpState:a,focusedElement:i,setFocusOn:s,label:p=c.get("creditCard.pin.label")})=>(0,preact/* createElement */.az)(Field/* default */.Z,{label:p,classNameModifiers:["pin",...d],errorMessage:a.errors.encryptedSecurityCode&&c.get(a.errors.encryptedSecurityCode),focused:"encryptedSecurityCode"===i,onFocusField:()=>s("encryptedSecurityCode"),dir:"ltr",name:"encryptedSecurityCode",contextVisibleToScreenReader:!1,useLabelElement:!1,renderAlternativeToLabel:FieldLabelAlternative/* alternativeLabelContent */._},(0,preact/* createElement */.az)(DataSfSpan/* default */.Z,{encryptedFieldType:"encryptedSecurityCode","data-info":'{"length":"3-10", "maskInterval": 0}',className:(0,_virtual/* default */.Z)({"adyen-checkout__input":!0,"adyen-checkout__input--large":!0,"adyen-checkout__card__cvc__input":!0,"adyen-checkout__input--error":a.errors.encryptedSecurityCode,"adyen-checkout__input--focus":"encryptedSecurityCode"===i})})); 14774//# sourceMappingURL=GiftcardPinField.js.map 14775 14776;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/components/GiftcardFields.js 14777const i=i=>{const{setRootNode:s,pinRequired:a}=i;return (0,preact/* createElement */.az)("div",{ref:s,className:"adyen-checkout__field-wrapper"},(0,preact/* createElement */.az)(d,{...i,classNameModifiers:a?["70"]:["100"]}),a&&(0,preact/* createElement */.az)(c,{...i,classNameModifiers:["30"]}
14777))}; 14778//# sourceMappingURL=GiftcardFields.js.map 14779 14780;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/components/GiftcardComponent.js 14781function u(t,e,r){return e in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}class GiftcardComponent_c extends preact/* Component */.wA{setStatus(t){this.setState({status:t})}render(t,{focusedElement:i,balance:u,transactionLimit:c}){const{i18n:l}=(0,CoreProvider/* useCoreContext */.m)(),p=c?.value<u?.value?c:u,d=p?.value>=this.props.amount?.value;if(p&&d)return (0,preact/* createElement */.az)(GiftcardResult_t,{amount:this.props.amount,balance:u,transactionLimit:c,makePayment:t.makePayment,status:this.state.status,showPayButton:this.props.showPayButton,payButton:this.props.payButton});const h=t=>{if(t.errors.encryptedCardNumber)return l.get(t.errors.encryptedCardNumber);switch(this.state.status){case"no-balance":return l.get("error.giftcard.no-balance");case"card-error":return l.get("error.giftcard.card-error");case"currency-error":return l.get("error.giftcard.currency-error");default:return null}};return (0,preact/* createElement */.az)("div",{className:"adyen-checkout__giftcard"},"error"===this.state.status&&(0,preact/* createElement */.az)(r,{icon:"cross"},l.get("error.message.unknown")),(0,preact/* createElement */.az)(SecuredFieldsProvider/* default */.Z,{...this.props,ref:t=>{this.sfp=t},onChange:this.onChange,onFocus:this.handleFocus,type:constants/* GIFT_CARD */.cx,render:({setRootNode:t,setFocusOn:e},r)=>this.props.fieldsLayoutComponent({i18n:l,pinRequired:this.props.pinRequired,focusedElement:i,getCardErrorMessage:h,setRootNode:t,setFocusOn:e,sfpState:r})}),this.props.showPayButton&&this.props.payButton({status:this.state.status,onClick:this.props.makeBalanceCheck,label:l.get("applyGiftcard")}))}constructor(...t){super(...t),u(this,"state",{status:"ready",data:{},balance:null,transactionLimit:null,focusedElement:!1,isValid:!1}),u(this,"sfp",void 0),u(this,"onChange",(t=>{this.props.onChange({data:t.data,isValid:t.isSfpValid})})),u(this,"showValidation",(()=>{this.sfp.showValidation()})),u(this,"handleFocus",(t=>{this.setState({focusedElement:t.currentFocusObject});!0===t.focus?this.props.onFocus(t):this.props.onBlur(t)})),u(this,"setBalance",(({balance:t,transactionLimit:e})=>{this.setState({balance:t,transactionLimit:e})}))}}u(GiftcardComponent_c,"defaultProps",{pinRequired:!0,expiryDateRequired:!1,onChange:()=>{},onFocus:()=>{},onBlur:()=>{},fieldsLayoutComponent:i}); 14782//# sourceMappingURL=GiftcardComponent.js.map 14783 14784// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/internal/PayButton/PayButton.js + 1 modules 14785var PayButton = __webpack_require__(871847); 14786// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/core/Errors/AdyenCheckoutError.js 14787var AdyenCheckoutError = __webpack_require__(811134); 14788// EXTERNAL MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/tx-variants.js 14789var tx_variants = __webpack_require__(360762); 14790;// CONCATENATED MODULE: ./node_modules/@adyen/adyen-web/dist/es/components/Giftcard/Giftcard.js 14791function a(t,e,r){return e in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}class h extends UIElement/* UIElement */.u{formatProps(t){return{...t?.configuration,...t}}formatData(){return{paymentMethod:{type:this.constructor.type,brand:this.props.brand,encryptedCardNumber:this.state.data?.encryptedCardNumber,encryptedSecurityCode:this.state.data?.encryptedSecurityCode}}}get isValid(){return!!this.state.isValid}get icon(){return this.props.brandsConfiguration[this.props.brand]?.icon||this.props.icon||this.resources.getImage()(this.props.brand)}get displayName(){return this.props.brandsConfiguration[this.props.brand]?.name||this.props.name}balanceCheck(){return this.onBalanceCheck()}submit(){if(!this.isValid)return this.showValidation(),!1;this.balanceCheck()}makeSubmitCall(){super.submit()}render(){return (0,preact/* createElement */.az)(CoreProvider/* CoreProvider */.k,{i18n:this.props.i18n,loadingContext:this.props.loadingContext,resources:this.resources},(0,preact/* createElement */.az)(GiftcardComponent_c,{ref:t=>{this.componentRef=t},...this.props,handleKeyPress:this.handleKeyPress,showPayButton:this.props.showPayButton,onChange:this.setState,makeBalanceCheck:()=>this.onBalanceCheck(),makePayment:()=>this.makeSubmitCall(),payButton:this.payButton}))}constructor(...e){super(...e),a(this,"handleBalanceCheck",(t=>this.props.onBalanceCheck?new Promise(((e,r)=>{this.props.onBalanceCheck(e,r,t)})):this.props.session?this.props.session.checkBalance(t):void 0)),a(this,"onOrderRequest",(t=>this.props.onOrderRequest?new Promise(((e,r)=>
14791{this.props.onOrderRequest(e,r,t)})):this.props.session?this.props.session.createOrder():void 0)),a(this,"onBalanceCheck",(()=>{if(!(this.props.session||this.props.onBalanceCheck))return super.submit();this.setStatus("loading"),this.handleBalanceCheck(this.formatData()).then((({balance:t,transactionLimit:e={}})=>{if(!t)throw new Error("card-error");if(t?.currency!==this.props.amount?.currency)throw new Error("currency-error");if(t?.value<=0)throw new Error("no-balance");return this.props.amount.value>t.value||this.props.amount.value>e.value?this.props.order?this.makeSubmitCall():this.onOrderRequest(this.data).then((t=>(this.setState({order:{orderData:t.orderData,pspReference:t.pspReference}}),this.makeSubmitCall()))):this.handleOnRequiringConfirmation(t,e)})).catch((t=>{this.setStatus(t?.message||"error"),this.props.onError&&(t instanceof AdyenCheckoutError/* default */.ZP?this.handleError(t):this.handleError(new AdyenCheckoutError/* default */.ZP("ERROR",t)))}))})),a(this,"handleOnRequiringConfirmation",((t,e)=>{if(this.componentRef.setBalance({balance:t,transactionLimit:e}),this.setStatus("ready"),!this.props.showPayButton){if(!this.props.onRequiringConfirmation)throw new AdyenCheckoutError/* default */.ZP("IMPLEMENTATION_ERROR","onRequiringConfirmation must be provided");return new Promise(((t,e)=>{this.props.onRequiringConfirmation(t,e)})).then((()=>this.makeSubmitCall())).catch((()=>{}))}})),a(this,"payButton",(e=>(0,preact/* createElement */.az)(PayButton/* default */.Z,e)))}}a(h,"type",tx_variants/* TxVariants */.C.giftcard),a(h,"defaultProps",{brandsConfiguration:{}}); 14792//# sourceMappingURL=Giftcard.js.map 14793 14794 14795/***/ }), 14796 14797/***/ 215671: 14798/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14799 14800"use strict"; 14801/* harmony export */ __webpack_require__.d(__webpack_exports__, { 14802/* harmony export */ Z: function() { return /* binding */ _classCallCheck; } 14803/* harmony export */ }); 14804function _classCallCheck(a, n) { 14805 if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); 14806} 14807 14808 14809/***/ }), 14810 14811/***/ 143144: 14812/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14813 14814"use strict"; 14815/* harmony export */ __webpack_require__.d(__webpack_exports__, { 14816/* harmony export */ Z: function() { return /* binding */ _createClass; } 14817/* harmony export */ }); 14818/* harmony import */ var _toPropertyKey_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(383997); 14819 14820function _defineProperties(e, r) { 14821 for (var t = 0; t < r.length; t++) { 14822 var o = r[t]; 14823 o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, (0,_toPropertyKey_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(o.key), o); 14824 } 14825} 14826function _createClass(e, r, t) { 14827 return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { 14828 writable: !1 14829 }), e; 14830} 14831 14832 14833/***/ }), 14834 14835/***/ 661120: 14836/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14837 14838"use strict"; 14839/* harmony export */ __webpack_require__.d(__webpack_exports__, { 14840/* harmony export */ Z: function() { return /* binding */ _getPrototypeOf; } 14841/* harmony export */ }); 14842function _getPrototypeOf(t) { 14843 return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { 14844 return t.__proto__ || Object.getPrototypeOf(t); 14845 }, _getPrototypeOf(t); 14846} 14847 14848 14849/***/ }), 14850 14851/***/ 360136: 14852/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14853 14854"use strict"; 14855/* harmony export */ __webpack_require__.d(__webpack_exports__, { 14856/* harmony export */ Z: function() { return /* binding */ _inherits; } 14857/* harmony export */ }); 14858/* harmony import */ var _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(589611); 14859 14860function _inherits(t, e) { 14861 if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); 14862 t.prototype = Object.create(e && e.prototype, { 14863 constructor: { 14864 value: t, 14865 writable: !0, 14866 configurable: !0 14867 } 14868 }), Object.defineProperty(t, "prototype", { 14869 writable: !1 14870 }), e && (0,_setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(t, e); 14871} 14872 14873 14874/***/ }), 14875 14876/***/ 182963: 14877/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14878 14879"use strict"; 14880/* harmony export */ __webpack_require__.d(__webpack_exports__, { 14881/* harmony export */ Z: function() { return /* binding */ _possibleConstructorReturn; } 14882/* harmony export */ }); 14883/* harmony import */ var _typeof_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(671002); 14884/* harmony import */ var _assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(497326); 14885 14886 14887function _possibleConstructorReturn(t, e) { 14888 if (e && ("object" == (0,_typeof_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(e) || "function" == typeof e)) return e; 14889 if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); 14890 return (0,_assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(t); 14891} 14892 14893 14894/***/ }), 14895 14896/***/ 35440: 14897/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 14898 14899"use strict"; 14900 14901// EXPORTS 14902__webpack_require__.d(__webpack_exports__, { 14903 Z: function() { return /* binding */ _toArray; } 14904}); 14905 14906;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 14907function _arrayWithHoles(r) { 14908 if (Array.isArray(r)) return r; 14909} 14910 14911;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js 14912function _iterableToArray(r) { 14913 if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); 14914} 14915 14916;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 14917function _arrayLikeToArray(r, a) { 14918 (null == a || a > r.length) && (a = r.length); 14919 for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; 14920 return n; 14921} 14922 14923;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 14924 14925function _unsupportedIterableToArray(r, a) { 14926 if (r) { 14927 if ("string" == typeof r) return _arrayLikeToArray(r, a); 14928 var t = {}.toString.call(r).slice(8, -1); 14929 return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; 14930 } 14931} 14932 14933;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 14934function _nonIterableRest() {
14935 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 14936} 14937 14938;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toArray.js 14939 14940 14941 14942 14943function _toArray(r) { 14944 return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); 14945} 14946 14947 14948/***/ }) 14949 14950}]);
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.