@bigbinary/neeto-atoms 1.0.37 → 1.0.39

package/dist/DatePicker-CCN3b1oz.js

@@ -1,3166 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { forwardRef, useId, useRef, useState, useCallback, useEffect } from 'react';
-import { g as getDefaultOptions$1, t as toDate, c as constructFrom, m as millisecondsInHour, b as millisecondsInMinute, d as millisecondsInSecond, e as getWeekYear, s as startOfWeek, f as startOfISOWeek, h as getWeek, i as getISOWeek, j as addDays, k as getTimezoneOffsetInMilliseconds, l as enUS, n as longFormatters, o as isProtectedWeekYearToken, w as warnOrThrowProtectedError, p as isProtectedDayOfYearToken, q as format, C as Calendar$1 } from './Calendar-CjOBwDbx.js';
-import { Popover, PopoverAnchor, PopoverContent } from './primitives/Popover.js';
-import { Field, FieldLabel, FieldContent, FieldError, FieldDescription } from './primitives/Field.js';
-import { c as cn } from './utils-BJnb9o5c.js';
-import { Button } from './primitives/Button.js';
-import { d as dateToTimeValue, T as TimePickerPanel } from './TimePickerPanel-DAhz3B2d.js';
-import { c as createLucideIcon } from './createLucideIcon-C8ycilSN.js';
-import { X } from './x-_o2T3n6D.js';
-
-/**
- * @license lucide-react v0.577.0 - ISC
- *
- * This source code is licensed under the ISC license.
- * See the LICENSE file in the root directory of this source tree.
- */
-
-
-const __iconNode = [
-  ["path", { d: "M8 2v4", key: "1cmpym" }],
-  ["path", { d: "M16 2v4", key: "4m81vk" }],
-  ["rect", { width: "18", height: "18", x: "3", y: "4", rx: "2", key: "1hopcy" }],
-  ["path", { d: "M3 10h18", key: "8toen8" }]
-];
-const Calendar = createLucideIcon("calendar", __iconNode);
-
-/**
- * @name getDefaultOptions
- * @category Common Helpers
- * @summary Get default options.
- * @pure false
- *
- * @description
- * Returns an object that contains defaults for
- * `options.locale`, `options.weekStartsOn` and `options.firstWeekContainsDate`
- * arguments for all functions.
- *
- * You can change these with [setDefaultOptions](https://date-fns.org/docs/setDefaultOptions).
- *
- * @returns The default options
- *
- * @example
- * const result = getDefaultOptions()
- * //=> {}
- *
- * @example
- * setDefaultOptions({ weekStarsOn: 1, firstWeekContainsDate: 4 })
- * const result = getDefaultOptions()
- * //=> { weekStarsOn: 1, firstWeekContainsDate: 4 }
- */
-function getDefaultOptions() {
-  return Object.assign({}, getDefaultOptions$1());
-}
-
-/**
- * The {@link getISODay} function options.
- */
-
-/**
- * @name getISODay
- * @category Weekday Helpers
- * @summary Get the day of the ISO week of the given date.
- *
- * @description
- * Get the day of the ISO week of the given date,
- * which is 7 for Sunday, 1 for Monday etc.
- *
- * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
- *
- * @param date - The given date
- * @param options - An object with options
- *
- * @returns The day of ISO week
- *
- * @example
- * // Which day of the ISO week is 26 February 2012?
- * const result = getISODay(new Date(2012, 1, 26))
- * //=> 7
- */
-function getISODay(date, options) {
-  const day = toDate(date, options?.in).getDay();
-  return day === 0 ? 7 : day;
-}
-
-/**
- * @name transpose
- * @category Generic Helpers
- * @summary Transpose the date to the given constructor.
- *
- * @description
- * The function transposes the date to the given constructor. It helps you
- * to transpose the date in the system time zone to say `UTCDate` or any other
- * date extension.
- *
- * @typeParam InputDate - The input `Date` type derived from the passed argument.
- * @typeParam ResultDate - The result `Date` type derived from the passed constructor.
- *
- * @param date - The date to use values from
- * @param constructor - The date constructor to use
- *
- * @returns Date transposed to the given constructor
- *
- * @example
- * // Create July 10, 2022 00:00 in locale time zone
- * const date = new Date(2022, 6, 10)
- * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
- *
- * @example
- * // Transpose the date to July 10, 2022 00:00 in UTC
- * transpose(date, UTCDate)
- * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
- */
-function transpose(date, constructor) {
-  const date_ = isConstructor(constructor)
-    ? new constructor(0)
-    : constructFrom(constructor, 0);
-  date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
-  date_.setHours(
-    date.getHours(),
-    date.getMinutes(),
-    date.getSeconds(),
-    date.getMilliseconds(),
-  );
-  return date_;
-}
-
-function isConstructor(constructor) {
-  return (
-    typeof constructor === "function" &&
-    constructor.prototype?.constructor === constructor
-  );
-}
-
-const TIMEZONE_UNIT_PRIORITY = 10;
-
-class Setter {
-  subPriority = 0;
-
-  validate(_utcDate, _options) {
-    return true;
-  }
-}
-
-class ValueSetter extends Setter {
-  constructor(
-    value,
-
-    validateValue,
-
-    setValue,
-
-    priority,
-    subPriority,
-  ) {
-    super();
-    this.value = value;
-    this.validateValue = validateValue;
-    this.setValue = setValue;
-    this.priority = priority;
-    if (subPriority) {
-      this.subPriority = subPriority;
-    }
-  }
-
-  validate(date, options) {
-    return this.validateValue(date, this.value, options);
-  }
-
-  set(date, flags, options) {
-    return this.setValue(date, flags, this.value, options);
-  }
-}
-
-class DateTimezoneSetter extends Setter {
-  priority = TIMEZONE_UNIT_PRIORITY;
-  subPriority = -1;
-
-  constructor(context, reference) {
-    super();
-    this.context = context || ((date) => constructFrom(reference, date));
-  }
-
-  set(date, flags) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(date, transpose(date, this.context));
-  }
-}
-
-class Parser {
-  run(dateString, token, match, options) {
-    const result = this.parse(dateString, token, match, options);
-    if (!result) {
-      return null;
-    }
-
-    return {
-      setter: new ValueSetter(
-        result.value,
-        this.validate,
-        this.set,
-        this.priority,
-        this.subPriority,
-      ),
-      rest: result.rest,
-    };
-  }
-
-  validate(_utcDate, _value, _options) {
-    return true;
-  }
-}
-
-class EraParser extends Parser {
-  priority = 140;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      // AD, BC
-      case "G":
-      case "GG":
-      case "GGG":
-        return (
-          match.era(dateString, { width: "abbreviated" }) ||
-          match.era(dateString, { width: "narrow" })
-        );
-
-      // A, B
-      case "GGGGG":
-        return match.era(dateString, { width: "narrow" });
-      // Anno Domini, Before Christ
-      case "GGGG":
-      default:
-        return (
-          match.era(dateString, { width: "wide" }) ||
-          match.era(dateString, { width: "abbreviated" }) ||
-          match.era(dateString, { width: "narrow" })
-        );
-    }
-  }
-
-  set(date, flags, value) {
-    flags.era = value;
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["R", "u", "t", "T"];
-}
-
-const numericPatterns = {
-  month: /^(1[0-2]|0?\d)/, // 0 to 12
-  date: /^(3[0-1]|[0-2]?\d)/, // 0 to 31
-  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
-  week: /^(5[0-3]|[0-4]?\d)/, // 0 to 53
-  hour23h: /^(2[0-3]|[0-1]?\d)/, // 0 to 23
-  hour24h: /^(2[0-4]|[0-1]?\d)/, // 0 to 24
-  hour11h: /^(1[0-1]|0?\d)/, // 0 to 11
-  hour12h: /^(1[0-2]|0?\d)/, // 0 to 12
-  minute: /^[0-5]?\d/, // 0 to 59
-  second: /^[0-5]?\d/, // 0 to 59
-
-  singleDigit: /^\d/, // 0 to 9
-  twoDigits: /^\d{1,2}/, // 0 to 99
-  threeDigits: /^\d{1,3}/, // 0 to 999
-  fourDigits: /^\d{1,4}/, // 0 to 9999
-
-  anyDigitsSigned: /^-?\d+/,
-  singleDigitSigned: /^-?\d/, // 0 to 9, -0 to -9
-  twoDigitsSigned: /^-?\d{1,2}/, // 0 to 99, -0 to -99
-  threeDigitsSigned: /^-?\d{1,3}/, // 0 to 999, -0 to -999
-  fourDigitsSigned: /^-?\d{1,4}/, // 0 to 9999, -0 to -9999
-};
-
-const timezonePatterns = {
-  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
-  basic: /^([+-])(\d{2})(\d{2})|Z/,
-  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
-  extended: /^([+-])(\d{2}):(\d{2})|Z/,
-  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/,
-};
-
-function mapValue(parseFnResult, mapFn) {
-  if (!parseFnResult) {
-    return parseFnResult;
-  }
-
-  return {
-    value: mapFn(parseFnResult.value),
-    rest: parseFnResult.rest,
-  };
-}
-
-function parseNumericPattern(pattern, dateString) {
-  const matchResult = dateString.match(pattern);
-
-  if (!matchResult) {
-    return null;
-  }
-
-  return {
-    value: parseInt(matchResult[0], 10),
-    rest: dateString.slice(matchResult[0].length),
-  };
-}
-
-function parseTimezonePattern(pattern, dateString) {
-  const matchResult = dateString.match(pattern);
-
-  if (!matchResult) {
-    return null;
-  }
-
-  // Input is 'Z'
-  if (matchResult[0] === "Z") {
-    return {
-      value: 0,
-      rest: dateString.slice(1),
-    };
-  }
-
-  const sign = matchResult[1] === "+" ? 1 : -1;
-  const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
-  const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
-  const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
-
-  return {
-    value:
-      sign *
-      (hours * millisecondsInHour +
-        minutes * millisecondsInMinute +
-        seconds * millisecondsInSecond),
-    rest: dateString.slice(matchResult[0].length),
-  };
-}
-
-function parseAnyDigitsSigned(dateString) {
-  return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
-}
-
-function parseNDigits(n, dateString) {
-  switch (n) {
-    case 1:
-      return parseNumericPattern(numericPatterns.singleDigit, dateString);
-    case 2:
-      return parseNumericPattern(numericPatterns.twoDigits, dateString);
-    case 3:
-      return parseNumericPattern(numericPatterns.threeDigits, dateString);
-    case 4:
-      return parseNumericPattern(numericPatterns.fourDigits, dateString);
-    default:
-      return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
-  }
-}
-
-function parseNDigitsSigned(n, dateString) {
-  switch (n) {
-    case 1:
-      return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
-    case 2:
-      return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
-    case 3:
-      return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
-    case 4:
-      return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
-    default:
-      return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
-  }
-}
-
-function dayPeriodEnumToHours(dayPeriod) {
-  switch (dayPeriod) {
-    case "morning":
-      return 4;
-    case "evening":
-      return 17;
-    case "pm":
-    case "noon":
-    case "afternoon":
-      return 12;
-    case "am":
-    case "midnight":
-    case "night":
-    default:
-      return 0;
-  }
-}
-
-function normalizeTwoDigitYear(twoDigitYear, currentYear) {
-  const isCommonEra = currentYear > 0;
-  // Absolute number of the current year:
-  // 1 -> 1 AC
-  // 0 -> 1 BC
-  // -1 -> 2 BC
-  const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
-
-  let result;
-  if (absCurrentYear <= 50) {
-    result = twoDigitYear || 100;
-  } else {
-    const rangeEnd = absCurrentYear + 50;
-    const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
-    const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
-    result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
-  }
-
-  return isCommonEra ? result : 1 - result;
-}
-
-function isLeapYearIndex(year) {
-  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
-}
-
-// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
-// | Year     |     y | yy |   yyy |  yyyy | yyyyy |
-// |----------|-------|----|-------|-------|-------|
-// | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
-// | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
-// | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
-// | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
-// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
-class YearParser extends Parser {
-  priority = 130;
-  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
-
-  parse(dateString, token, match) {
-    const valueCallback = (year) => ({
-      year,
-      isTwoDigitYear: token === "yy",
-    });
-
-    switch (token) {
-      case "y":
-        return mapValue(parseNDigits(4, dateString), valueCallback);
-      case "yo":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "year",
-          }),
-          valueCallback,
-        );
-      default:
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-    }
-  }
-
-  validate(_date, value) {
-    return value.isTwoDigitYear || value.year > 0;
-  }
-
-  set(date, flags, value) {
-    const currentYear = date.getFullYear();
-
-    if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear,
-      );
-      date.setFullYear(normalizedTwoDigitYear, 0, 1);
-      date.setHours(0, 0, 0, 0);
-      return date;
-    }
-
-    const year =
-      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
-    date.setFullYear(year, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-
-// Local week-numbering year
-class LocalWeekYearParser extends Parser {
-  priority = 130;
-
-  parse(dateString, token, match) {
-    const valueCallback = (year) => ({
-      year,
-      isTwoDigitYear: token === "YY",
-    });
-
-    switch (token) {
-      case "Y":
-        return mapValue(parseNDigits(4, dateString), valueCallback);
-      case "Yo":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "year",
-          }),
-          valueCallback,
-        );
-      default:
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-    }
-  }
-
-  validate(_date, value) {
-    return value.isTwoDigitYear || value.year > 0;
-  }
-
-  set(date, flags, value, options) {
-    const currentYear = getWeekYear(date, options);
-
-    if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear,
-      );
-      date.setFullYear(
-        normalizedTwoDigitYear,
-        0,
-        options.firstWeekContainsDate,
-      );
-      date.setHours(0, 0, 0, 0);
-      return startOfWeek(date, options);
-    }
-
-    const year =
-      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
-    date.setFullYear(year, 0, options.firstWeekContainsDate);
-    date.setHours(0, 0, 0, 0);
-    return startOfWeek(date, options);
-  }
-
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "Q",
-    "q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "i",
-    "t",
-    "T",
-  ];
-}
-
-// ISO week-numbering year
-class ISOWeekYearParser extends Parser {
-  priority = 130;
-
-  parse(dateString, token) {
-    if (token === "R") {
-      return parseNDigitsSigned(4, dateString);
-    }
-
-    return parseNDigitsSigned(token.length, dateString);
-  }
-
-  set(date, _flags, value) {
-    const firstWeekOfYear = constructFrom(date, 0);
-    firstWeekOfYear.setFullYear(value, 0, 4);
-    firstWeekOfYear.setHours(0, 0, 0, 0);
-    return startOfISOWeek(firstWeekOfYear);
-  }
-
-  incompatibleTokens = [
-    "G",
-    "y",
-    "Y",
-    "u",
-    "Q",
-    "q",
-    "M",
-    "L",
-    "w",
-    "d",
-    "D",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-class ExtendedYearParser extends Parser {
-  priority = 130;
-
-  parse(dateString, token) {
-    if (token === "u") {
-      return parseNDigitsSigned(4, dateString);
-    }
-
-    return parseNDigitsSigned(token.length, dateString);
-  }
-
-  set(date, _flags, value) {
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
-}
-
-class QuarterParser extends Parser {
-  priority = 120;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      // 1, 2, 3, 4
-      case "Q":
-      case "QQ": // 01, 02, 03, 04
-        return parseNDigits(token.length, dateString);
-      // 1st, 2nd, 3rd, 4th
-      case "Qo":
-        return match.ordinalNumber(dateString, { unit: "quarter" });
-      // Q1, Q2, Q3, Q4
-      case "QQQ":
-        return (
-          match.quarter(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.quarter(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-
-      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
-      case "QQQQQ":
-        return match.quarter(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      // 1st quarter, 2nd quarter, ...
-      case "QQQQ":
-      default:
-        return (
-          match.quarter(dateString, {
-            width: "wide",
-            context: "formatting",
-          }) ||
-          match.quarter(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.quarter(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 4;
-  }
-
-  set(date, _flags, value) {
-    date.setMonth((value - 1) * 3, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "M",
-    "L",
-    "w",
-    "I",
-    "d",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-class StandAloneQuarterParser extends Parser {
-  priority = 120;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      // 1, 2, 3, 4
-      case "q":
-      case "qq": // 01, 02, 03, 04
-        return parseNDigits(token.length, dateString);
-      // 1st, 2nd, 3rd, 4th
-      case "qo":
-        return match.ordinalNumber(dateString, { unit: "quarter" });
-      // Q1, Q2, Q3, Q4
-      case "qqq":
-        return (
-          match.quarter(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.quarter(dateString, {
-            width: "narrow",
-            context: "standalone",
-          })
-        );
-
-      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
-      case "qqqqq":
-        return match.quarter(dateString, {
-          width: "narrow",
-          context: "standalone",
-        });
-      // 1st quarter, 2nd quarter, ...
-      case "qqqq":
-      default:
-        return (
-          match.quarter(dateString, {
-            width: "wide",
-            context: "standalone",
-          }) ||
-          match.quarter(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.quarter(dateString, {
-            width: "narrow",
-            context: "standalone",
-          })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 4;
-  }
-
-  set(date, _flags, value) {
-    date.setMonth((value - 1) * 3, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "I",
-    "d",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-class MonthParser extends Parser {
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "L",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-
-  priority = 110;
-
-  parse(dateString, token, match) {
-    const valueCallback = (value) => value - 1;
-
-    switch (token) {
-      // 1, 2, ..., 12
-      case "M":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback,
-        );
-      // 01, 02, ..., 12
-      case "MM":
-        return mapValue(parseNDigits(2, dateString), valueCallback);
-      // 1st, 2nd, ..., 12th
-      case "Mo":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "month",
-          }),
-          valueCallback,
-        );
-      // Jan, Feb, ..., Dec
-      case "MMM":
-        return (
-          match.month(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "formatting" })
-        );
-
-      // J, F, ..., D
-      case "MMMMM":
-        return match.month(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      // January, February, ..., December
-      case "MMMM":
-      default:
-        return (
-          match.month(dateString, { width: "wide", context: "formatting" }) ||
-          match.month(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "formatting" })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-
-  set(date, _flags, value) {
-    date.setMonth(value, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-
-class StandAloneMonthParser extends Parser {
-  priority = 110;
-
-  parse(dateString, token, match) {
-    const valueCallback = (value) => value - 1;
-
-    switch (token) {
-      // 1, 2, ..., 12
-      case "L":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback,
-        );
-      // 01, 02, ..., 12
-      case "LL":
-        return mapValue(parseNDigits(2, dateString), valueCallback);
-      // 1st, 2nd, ..., 12th
-      case "Lo":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "month",
-          }),
-          valueCallback,
-        );
-      // Jan, Feb, ..., Dec
-      case "LLL":
-        return (
-          match.month(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "standalone" })
-        );
-
-      // J, F, ..., D
-      case "LLLLL":
-        return match.month(dateString, {
-          width: "narrow",
-          context: "standalone",
-        });
-      // January, February, ..., December
-      case "LLLL":
-      default:
-        return (
-          match.month(dateString, { width: "wide", context: "standalone" }) ||
-          match.month(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "standalone" })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-
-  set(date, _flags, value) {
-    date.setMonth(value, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "M",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-/**
- * The {@link setWeek} function options.
- */
-
-/**
- * @name setWeek
- * @category Week Helpers
- * @summary Set the local week to the given date.
- *
- * @description
- * Set the local week to the given date, saving the weekday number.
- * The exact calculation depends on the values of
- * `options.weekStartsOn` (which is the index of the first day of the week)
- * and `options.firstWeekContainsDate` (which is the day of January, which is always in
- * the first week of the week-numbering year)
- *
- * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
- *
- * @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).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param date - The date to be changed
- * @param week - The week of the new date
- * @param options - An object with options
- *
- * @returns The new date with the local week set
- *
- * @example
- * // Set the 1st week to 2 January 2005 with default options:
- * const result = setWeek(new Date(2005, 0, 2), 1)
- * //=> Sun Dec 26 2004 00:00:00
- *
- * @example
- * // Set the 1st week to 2 January 2005,
- * // if Monday is the first day of the week,
- * // and the first week of the year always contains 4 January:
- * const result = setWeek(new Date(2005, 0, 2), 1, {
- *   weekStartsOn: 1,
- *   firstWeekContainsDate: 4
- * })
- * //=> Sun Jan 4 2004 00:00:00
- */
-function setWeek(date, week, options) {
-  const date_ = toDate(date, options?.in);
-  const diff = getWeek(date_, options) - week;
-  date_.setDate(date_.getDate() - diff * 7);
-  return toDate(date_, options?.in);
-}
-
-// Local week of year
-class LocalWeekParser extends Parser {
-  priority = 100;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "w":
-        return parseNumericPattern(numericPatterns.week, dateString);
-      case "wo":
-        return match.ordinalNumber(dateString, { unit: "week" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 53;
-  }
-
-  set(date, _flags, value, options) {
-    return startOfWeek(setWeek(date, value, options), options);
-  }
-
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "i",
-    "t",
-    "T",
-  ];
-}
-
-/**
- * The {@link setISOWeek} function options.
- */
-
-/**
- * @name setISOWeek
- * @category ISO Week Helpers
- * @summary Set the ISO week to the given date.
- *
- * @description
- * Set the ISO week to the given date, saving the weekday number.
- *
- * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
- *
- * @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).
- * @typeParam ResultDate - The `Date` type of the context function.
- *
- * @param date - The date to be changed
- * @param week - The ISO week of the new date
- * @param options - An object with options
- *
- * @returns The new date with the ISO week set
- *
- * @example
- * // Set the 53rd ISO week to 7 August 2004:
- * const result = setISOWeek(new Date(2004, 7, 7), 53)
- * //=> Sat Jan 01 2005 00:00:00
- */
-function setISOWeek(date, week, options) {
-  const _date = toDate(date, options?.in);
-  const diff = getISOWeek(_date, options) - week;
-  _date.setDate(_date.getDate() - diff * 7);
-  return _date;
-}
-
-// ISO week of year
-class ISOWeekParser extends Parser {
-  priority = 100;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "I":
-        return parseNumericPattern(numericPatterns.week, dateString);
-      case "Io":
-        return match.ordinalNumber(dateString, { unit: "week" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 53;
-  }
-
-  set(date, _flags, value) {
-    return startOfISOWeek(setISOWeek(date, value));
-  }
-
-  incompatibleTokens = [
-    "y",
-    "Y",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "d",
-    "D",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DAYS_IN_MONTH_LEAP_YEAR = [
-  31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
-];
-
-// Day of the month
-class DateParser extends Parser {
-  priority = 90;
-  subPriority = 1;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "d":
-        return parseNumericPattern(numericPatterns.date, dateString);
-      case "do":
-        return match.ordinalNumber(dateString, { unit: "date" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(date, value) {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex(year);
-    const month = date.getMonth();
-    if (isLeapYear) {
-      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
-    } else {
-      return value >= 1 && value <= DAYS_IN_MONTH[month];
-    }
-  }
-
-  set(date, _flags, value) {
-    date.setDate(value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-class DayOfYearParser extends Parser {
-  priority = 90;
-
-  subpriority = 1;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "D":
-      case "DD":
-        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
-      case "Do":
-        return match.ordinalNumber(dateString, { unit: "date" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(date, value) {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex(year);
-    if (isLeapYear) {
-      return value >= 1 && value <= 366;
-    } else {
-      return value >= 1 && value <= 365;
-    }
-  }
-
-  set(date, _flags, value) {
-    date.setMonth(0, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "I",
-    "d",
-    "E",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-/**
- * The {@link setDay} function options.
- */
-
-/**
- * @name setDay
- * @category Weekday Helpers
- * @summary Set the day of the week to the given date.
- *
- * @description
- * Set the day of the week to the given date.
- *
- * @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).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param date - The date to be changed
- * @param day - The day of the week of the new date
- * @param options - An object with options.
- *
- * @returns The new date with the day of the week set
- *
- * @example
- * // Set week day to Sunday, with the default weekStartsOn of Sunday:
- * const result = setDay(new Date(2014, 8, 1), 0)
- * //=> Sun Aug 31 2014 00:00:00
- *
- * @example
- * // Set week day to Sunday, with a weekStartsOn of Monday:
- * const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
- * //=> Sun Sep 07 2014 00:00:00
- */
-function setDay(date, day, options) {
-  const defaultOptions = getDefaultOptions$1();
-  const weekStartsOn =
-    options?.weekStartsOn ??
-    options?.locale?.options?.weekStartsOn ??
-    defaultOptions.weekStartsOn ??
-    defaultOptions.locale?.options?.weekStartsOn ??
-    0;
-
-  const date_ = toDate(date, options?.in);
-  const currentDay = date_.getDay();
-
-  const remainder = day % 7;
-  const dayIndex = (remainder + 7) % 7;
-
-  const delta = 7 - weekStartsOn;
-  const diff =
-    day < 0 || day > 6
-      ? day - ((currentDay + delta) % 7)
-      : ((dayIndex + delta) % 7) - ((currentDay + delta) % 7);
-  return addDays(date_, diff, options);
-}
-
-// Day of week
-class DayParser extends Parser {
-  priority = 90;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      // Tue
-      case "E":
-      case "EE":
-      case "EEE":
-        return (
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-
-      // T
-      case "EEEEE":
-        return match.day(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      // Tu
-      case "EEEEEE":
-        return (
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-
-      // Tuesday
-      case "EEEE":
-      default:
-        return (
-          match.day(dateString, { width: "wide", context: "formatting" }) ||
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
-}
-
-// Local day of week
-class LocalDayParser extends Parser {
-  priority = 90;
-  parse(dateString, token, match, options) {
-    const valueCallback = (value) => {
-      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
-      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
-      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
-    };
-
-    switch (token) {
-      // 3
-      case "e":
-      case "ee": // 03
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-      // 3rd
-      case "eo":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "day",
-          }),
-          valueCallback,
-        );
-      // Tue
-      case "eee":
-        return (
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-
-      // T
-      case "eeeee":
-        return match.day(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      // Tu
-      case "eeeeee":
-        return (
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-
-      // Tuesday
-      case "eeee":
-      default:
-        return (
-          match.day(dateString, { width: "wide", context: "formatting" }) ||
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "E",
-    "i",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-// Stand-alone local day of week
-class StandAloneLocalDayParser extends Parser {
-  priority = 90;
-
-  parse(dateString, token, match, options) {
-    const valueCallback = (value) => {
-      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
-      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
-      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
-    };
-
-    switch (token) {
-      // 3
-      case "c":
-      case "cc": // 03
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-      // 3rd
-      case "co":
-        return mapValue(
-          match.ordinalNumber(dateString, {
-            unit: "day",
-          }),
-          valueCallback,
-        );
-      // Tue
-      case "ccc":
-        return (
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
-        );
-
-      // T
-      case "ccccc":
-        return match.day(dateString, {
-          width: "narrow",
-          context: "standalone",
-        });
-      // Tu
-      case "cccccc":
-        return (
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
-        );
-
-      // Tuesday
-      case "cccc":
-      default:
-        return (
-          match.day(dateString, { width: "wide", context: "standalone" }) ||
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "E",
-    "i",
-    "e",
-    "t",
-    "T",
-  ];
-}
-
-/**
- * The {@link setISODay} function options.
- */
-
-/**
- * @name setISODay
- * @category Weekday Helpers
- * @summary Set the day of the ISO week to the given date.
- *
- * @description
- * Set the day of the ISO week to the given date.
- * ISO week starts with Monday.
- * 7 is the index of Sunday, 1 is the index of Monday, etc.
- *
- * @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).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param date - The date to be changed
- * @param day - The day of the ISO week of the new date
- * @param options - An object with options
- *
- * @returns The new date with the day of the ISO week set
- *
- * @example
- * // Set Sunday to 1 September 2014:
- * const result = setISODay(new Date(2014, 8, 1), 7)
- * //=> Sun Sep 07 2014 00:00:00
- */
-function setISODay(date, day, options) {
-  const date_ = toDate(date, options?.in);
-  const currentDay = getISODay(date_, options);
-  const diff = day - currentDay;
-  return addDays(date_, diff, options);
-}
-
-// ISO day of week
-class ISODayParser extends Parser {
-  priority = 90;
-
-  parse(dateString, token, match) {
-    const valueCallback = (value) => {
-      if (value === 0) {
-        return 7;
-      }
-      return value;
-    };
-
-    switch (token) {
-      // 2
-      case "i":
-      case "ii": // 02
-        return parseNDigits(token.length, dateString);
-      // 2nd
-      case "io":
-        return match.ordinalNumber(dateString, { unit: "day" });
-      // Tue
-      case "iii":
-        return mapValue(
-          match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-            match.day(dateString, {
-              width: "short",
-              context: "formatting",
-            }) ||
-            match.day(dateString, {
-              width: "narrow",
-              context: "formatting",
-            }),
-          valueCallback,
-        );
-      // T
-      case "iiiii":
-        return mapValue(
-          match.day(dateString, {
-            width: "narrow",
-            context: "formatting",
-          }),
-          valueCallback,
-        );
-      // Tu
-      case "iiiiii":
-        return mapValue(
-          match.day(dateString, {
-            width: "short",
-            context: "formatting",
-          }) ||
-            match.day(dateString, {
-              width: "narrow",
-              context: "formatting",
-            }),
-          valueCallback,
-        );
-      // Tuesday
-      case "iiii":
-      default:
-        return mapValue(
-          match.day(dateString, {
-            width: "wide",
-            context: "formatting",
-          }) ||
-            match.day(dateString, {
-              width: "abbreviated",
-              context: "formatting",
-            }) ||
-            match.day(dateString, {
-              width: "short",
-              context: "formatting",
-            }) ||
-            match.day(dateString, {
-              width: "narrow",
-              context: "formatting",
-            }),
-          valueCallback,
-        );
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 7;
-  }
-
-  set(date, _flags, value) {
-    date = setISODay(date, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = [
-    "y",
-    "Y",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "d",
-    "D",
-    "E",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
-}
-
-class AMPMParser extends Parser {
-  priority = 80;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "a":
-      case "aa":
-      case "aaa":
-        return (
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-
-      case "aaaaa":
-        return match.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      case "aaaa":
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: "wide",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-    }
-  }
-
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
-}
-
-class AMPMMidnightParser extends Parser {
-  priority = 80;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "b":
-      case "bb":
-      case "bbb":
-        return (
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-
-      case "bbbbb":
-        return match.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      case "bbbb":
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: "wide",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-    }
-  }
-
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
-}
-
-// in the morning, in the afternoon, in the evening, at night
-class DayPeriodParser extends Parser {
-  priority = 80;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "B":
-      case "BB":
-      case "BBB":
-        return (
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-
-      case "BBBBB":
-        return match.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting",
-        });
-      case "BBBB":
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: "wide",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.dayPeriod(dateString, {
-            width: "narrow",
-            context: "formatting",
-          })
-        );
-    }
-  }
-
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["a", "b", "t", "T"];
-}
-
-class Hour1to12Parser extends Parser {
-  priority = 70;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "h":
-        return parseNumericPattern(numericPatterns.hour12h, dateString);
-      case "ho":
-        return match.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 12;
-  }
-
-  set(date, _flags, value) {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else if (!isPM && value === 12) {
-      date.setHours(0, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-
-  incompatibleTokens = ["H", "K", "k", "t", "T"];
-}
-
-class Hour0to23Parser extends Parser {
-  priority = 70;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "H":
-        return parseNumericPattern(numericPatterns.hour23h, dateString);
-      case "Ho":
-        return match.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 23;
-  }
-
-  set(date, _flags, value) {
-    date.setHours(value, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
-}
-
-class Hour0To11Parser extends Parser {
-  priority = 70;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "K":
-        return parseNumericPattern(numericPatterns.hour11h, dateString);
-      case "Ko":
-        return match.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-
-  set(date, _flags, value) {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-
-  incompatibleTokens = ["h", "H", "k", "t", "T"];
-}
-
-class Hour1To24Parser extends Parser {
-  priority = 70;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "k":
-        return parseNumericPattern(numericPatterns.hour24h, dateString);
-      case "ko":
-        return match.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 1 && value <= 24;
-  }
-
-  set(date, _flags, value) {
-    const hours = value <= 24 ? value % 24 : value;
-    date.setHours(hours, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
-}
-
-class MinuteParser extends Parser {
-  priority = 60;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "m":
-        return parseNumericPattern(numericPatterns.minute, dateString);
-      case "mo":
-        return match.ordinalNumber(dateString, { unit: "minute" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 59;
-  }
-
-  set(date, _flags, value) {
-    date.setMinutes(value, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["t", "T"];
-}
-
-class SecondParser extends Parser {
-  priority = 50;
-
-  parse(dateString, token, match) {
-    switch (token) {
-      case "s":
-        return parseNumericPattern(numericPatterns.second, dateString);
-      case "so":
-        return match.ordinalNumber(dateString, { unit: "second" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  validate(_date, value) {
-    return value >= 0 && value <= 59;
-  }
-
-  set(date, _flags, value) {
-    date.setSeconds(value, 0);
-    return date;
-  }
-
-  incompatibleTokens = ["t", "T"];
-}
-
-class FractionOfSecondParser extends Parser {
-  priority = 30;
-
-  parse(dateString, token) {
-    const valueCallback = (value) =>
-      Math.trunc(value * Math.pow(10, -token.length + 3));
-    return mapValue(parseNDigits(token.length, dateString), valueCallback);
-  }
-
-  set(date, _flags, value) {
-    date.setMilliseconds(value);
-    return date;
-  }
-
-  incompatibleTokens = ["t", "T"];
-}
-
-// Timezone (ISO-8601. +00:00 is `'Z'`)
-class ISOTimezoneWithZParser extends Parser {
-  priority = 10;
-
-  parse(dateString, token) {
-    switch (token) {
-      case "X":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalMinutes,
-          dateString,
-        );
-      case "XX":
-        return parseTimezonePattern(timezonePatterns.basic, dateString);
-      case "XXXX":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalSeconds,
-          dateString,
-        );
-      case "XXXXX":
-        return parseTimezonePattern(
-          timezonePatterns.extendedOptionalSeconds,
-          dateString,
-        );
-      case "XXX":
-      default:
-        return parseTimezonePattern(timezonePatterns.extended, dateString);
-    }
-  }
-
-  set(date, flags, value) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(
-      date,
-      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value,
-    );
-  }
-
-  incompatibleTokens = ["t", "T", "x"];
-}
-
-// Timezone (ISO-8601)
-class ISOTimezoneParser extends Parser {
-  priority = 10;
-
-  parse(dateString, token) {
-    switch (token) {
-      case "x":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalMinutes,
-          dateString,
-        );
-      case "xx":
-        return parseTimezonePattern(timezonePatterns.basic, dateString);
-      case "xxxx":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalSeconds,
-          dateString,
-        );
-      case "xxxxx":
-        return parseTimezonePattern(
-          timezonePatterns.extendedOptionalSeconds,
-          dateString,
-        );
-      case "xxx":
-      default:
-        return parseTimezonePattern(timezonePatterns.extended, dateString);
-    }
-  }
-
-  set(date, flags, value) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(
-      date,
-      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value,
-    );
-  }
-
-  incompatibleTokens = ["t", "T", "X"];
-}
-
-class TimestampSecondsParser extends Parser {
-  priority = 40;
-
-  parse(dateString) {
-    return parseAnyDigitsSigned(dateString);
-  }
-
-  set(date, _flags, value) {
-    return [constructFrom(date, value * 1000), { timestampIsSet: true }];
-  }
-
-  incompatibleTokens = "*";
-}
-
-class TimestampMillisecondsParser extends Parser {
-  priority = 20;
-
-  parse(dateString) {
-    return parseAnyDigitsSigned(dateString);
-  }
-
-  set(date, _flags, value) {
-    return [constructFrom(date, value), { timestampIsSet: true }];
-  }
-
-  incompatibleTokens = "*";
-}
-
-/*
- * |     | Unit                           |     | Unit                           |
- * |-----|--------------------------------|-----|--------------------------------|
- * |  a  | AM, PM                         |  A* | Milliseconds in day            |
- * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
- * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
- * |  d  | Day of month                   |  D  | Day of year                    |
- * |  e  | Local day of week              |  E  | Day of week                    |
- * |  f  |                                |  F* | Day of week in month           |
- * |  g* | Modified Julian day            |  G  | Era                            |
- * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
- * |  i! | ISO day of week                |  I! | ISO week of year               |
- * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
- * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
- * |  l* | (deprecated)                   |  L  | Stand-alone month              |
- * |  m  | Minute                         |  M  | Month                          |
- * |  n  |                                |  N  |                                |
- * |  o! | Ordinal number modifier        |  O* | Timezone (GMT)                 |
- * |  p  |                                |  P  |                                |
- * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
- * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
- * |  s  | Second                         |  S  | Fraction of second             |
- * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
- * |  u  | Extended year                  |  U* | Cyclic year                    |
- * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
- * |  w  | Local week of year             |  W* | Week of month                  |
- * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
- * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
- * |  z* | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
- *
- * Letters marked by * are not implemented but reserved by Unicode standard.
- *
- * Letters marked by ! are non-standard, but implemented by date-fns:
- * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
- * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
- *   i.e. 7 for Sunday, 1 for Monday, etc.
- * - `I` is ISO week of year, as opposed to `w` which is local week of year.
- * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
- *   `R` is supposed to be used in conjunction with `I` and `i`
- *   for universal ISO week-numbering date, whereas
- *   `Y` is supposed to be used in conjunction with `w` and `e`
- *   for week-numbering date specific to the locale.
- */
-const parsers = {
-  G: new EraParser(),
-  y: new YearParser(),
-  Y: new LocalWeekYearParser(),
-  R: new ISOWeekYearParser(),
-  u: new ExtendedYearParser(),
-  Q: new QuarterParser(),
-  q: new StandAloneQuarterParser(),
-  M: new MonthParser(),
-  L: new StandAloneMonthParser(),
-  w: new LocalWeekParser(),
-  I: new ISOWeekParser(),
-  d: new DateParser(),
-  D: new DayOfYearParser(),
-  E: new DayParser(),
-  e: new LocalDayParser(),
-  c: new StandAloneLocalDayParser(),
-  i: new ISODayParser(),
-  a: new AMPMParser(),
-  b: new AMPMMidnightParser(),
-  B: new DayPeriodParser(),
-  h: new Hour1to12Parser(),
-  H: new Hour0to23Parser(),
-  K: new Hour0To11Parser(),
-  k: new Hour1To24Parser(),
-  m: new MinuteParser(),
-  s: new SecondParser(),
-  S: new FractionOfSecondParser(),
-  X: new ISOTimezoneWithZParser(),
-  x: new ISOTimezoneParser(),
-  t: new TimestampSecondsParser(),
-  T: new TimestampMillisecondsParser(),
-};
-
-/**
- * The {@link parse} function options.
- */
-
-// This RegExp consists of three parts separated by `|`:
-// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
-//   (one of the certain letters followed by `o`)
-// - (\w)\1* matches any sequences of the same letter
-// - '' matches two quote characters in a row
-// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
-//   except a single quote symbol, which ends the sequence.
-//   Two quote characters do not end the sequence.
-//   If there is no matching single quote
-//   then the sequence will continue until the end of the string.
-// - . matches any single character unmatched by previous parts of the RegExps
-const formattingTokensRegExp =
-  /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
-
-// This RegExp catches symbols escaped by quotes, and also
-// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
-const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
-
-const escapedStringRegExp = /^'([^]*?)'?$/;
-const doubleQuoteRegExp = /''/g;
-
-const notWhitespaceRegExp = /\S/;
-const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
-
-/**
- * @name parse
- * @category Common Helpers
- * @summary Parse the date.
- *
- * @description
- * Return the date parsed from string using the given format string.
- *
- * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
- * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
- *
- * The characters in the format string wrapped between two single quotes characters (') are escaped.
- * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
- *
- * Format of the format string is based on Unicode Technical Standard #35:
- * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
- * with a few additions (see note 5 below the table).
- *
- * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited
- * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception:
- *
- * ```javascript
- * parse('23 AM', 'HH a', new Date())
- * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time
- * ```
- *
- * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true
- *
- * Accepted format string patterns:
- * | Unit                            |Prior| Pattern | Result examples                   | Notes |
- * |---------------------------------|-----|---------|-----------------------------------|-------|
- * | Era                             | 140 | G..GGG  | AD, BC                            |       |
- * |                                 |     | GGGG    | Anno Domini, Before Christ        | 2     |
- * |                                 |     | GGGGG   | A, B                              |       |
- * | Calendar year                   | 130 | y       | 44, 1, 1900, 2017, 9999           | 4     |
- * |                                 |     | yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
- * |                                 |     | yy      | 44, 01, 00, 17                    | 4     |
- * |                                 |     | yyy     | 044, 001, 123, 999                | 4     |
- * |                                 |     | yyyy    | 0044, 0001, 1900, 2017            | 4     |
- * |                                 |     | yyyyy   | ...                               | 2,4   |
- * | Local week-numbering year       | 130 | Y       | 44, 1, 1900, 2017, 9000           | 4     |
- * |                                 |     | Yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
- * |                                 |     | YY      | 44, 01, 00, 17                    | 4,6   |
- * |                                 |     | YYY     | 044, 001, 123, 999                | 4     |
- * |                                 |     | YYYY    | 0044, 0001, 1900, 2017            | 4,6   |
- * |                                 |     | YYYYY   | ...                               | 2,4   |
- * | ISO week-numbering year         | 130 | R       | -43, 1, 1900, 2017, 9999, -9999   | 4,5   |
- * |                                 |     | RR      | -43, 01, 00, 17                   | 4,5   |
- * |                                 |     | RRR     | -043, 001, 123, 999, -999         | 4,5   |
- * |                                 |     | RRRR    | -0043, 0001, 2017, 9999, -9999    | 4,5   |
- * |                                 |     | RRRRR   | ...                               | 2,4,5 |
- * | Extended year                   | 130 | u       | -43, 1, 1900, 2017, 9999, -999    | 4     |
- * |                                 |     | uu      | -43, 01, 99, -99                  | 4     |
- * |                                 |     | uuu     | -043, 001, 123, 999, -999         | 4     |
- * |                                 |     | uuuu    | -0043, 0001, 2017, 9999, -9999    | 4     |
- * |                                 |     | uuuuu   | ...                               | 2,4   |
- * | Quarter (formatting)            | 120 | Q       | 1, 2, 3, 4                        |       |
- * |                                 |     | Qo      | 1st, 2nd, 3rd, 4th                | 5     |
- * |                                 |     | QQ      | 01, 02, 03, 04                    |       |
- * |                                 |     | QQQ     | Q1, Q2, Q3, Q4                    |       |
- * |                                 |     | QQQQ    | 1st quarter, 2nd quarter, ...     | 2     |
- * |                                 |     | QQQQQ   | 1, 2, 3, 4                        | 4     |
- * | Quarter (stand-alone)           | 120 | q       | 1, 2, 3, 4                        |       |
- * |                                 |     | qo      | 1st, 2nd, 3rd, 4th                | 5     |
- * |                                 |     | qq      | 01, 02, 03, 04                    |       |
- * |                                 |     | qqq     | Q1, Q2, Q3, Q4                    |       |
- * |                                 |     | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
- * |                                 |     | qqqqq   | 1, 2, 3, 4                        | 3     |
- * | Month (formatting)              | 110 | M       | 1, 2, ..., 12                     |       |
- * |                                 |     | Mo      | 1st, 2nd, ..., 12th               | 5     |
- * |                                 |     | MM      | 01, 02, ..., 12                   |       |
- * |                                 |     | MMM     | Jan, Feb, ..., Dec                |       |
- * |                                 |     | MMMM    | January, February, ..., December  | 2     |
- * |                                 |     | MMMMM   | J, F, ..., D                      |       |
- * | Month (stand-alone)             | 110 | L       | 1, 2, ..., 12                     |       |
- * |                                 |     | Lo      | 1st, 2nd, ..., 12th               | 5     |
- * |                                 |     | LL      | 01, 02, ..., 12                   |       |
- * |                                 |     | LLL     | Jan, Feb, ..., Dec                |       |
- * |                                 |     | LLLL    | January, February, ..., December  | 2     |
- * |                                 |     | LLLLL   | J, F, ..., D                      |       |
- * | Local week of year              | 100 | w       | 1, 2, ..., 53                     |       |
- * |                                 |     | wo      | 1st, 2nd, ..., 53th               | 5     |
- * |                                 |     | ww      | 01, 02, ..., 53                   |       |
- * | ISO week of year                | 100 | I       | 1, 2, ..., 53                     | 5     |
- * |                                 |     | Io      | 1st, 2nd, ..., 53th               | 5     |
- * |                                 |     | II      | 01, 02, ..., 53                   | 5     |
- * | Day of month                    |  90 | d       | 1, 2, ..., 31                     |       |
- * |                                 |     | do      | 1st, 2nd, ..., 31st               | 5     |
- * |                                 |     | dd      | 01, 02, ..., 31                   |       |
- * | Day of year                     |  90 | D       | 1, 2, ..., 365, 366               | 7     |
- * |                                 |     | Do      | 1st, 2nd, ..., 365th, 366th       | 5     |
- * |                                 |     | DD      | 01, 02, ..., 365, 366             | 7     |
- * |                                 |     | DDD     | 001, 002, ..., 365, 366           |       |
- * |                                 |     | DDDD    | ...                               | 2     |
- * | Day of week (formatting)        |  90 | E..EEE  | Mon, Tue, Wed, ..., Sun           |       |
- * |                                 |     | EEEE    | Monday, Tuesday, ..., Sunday      | 2     |
- * |                                 |     | EEEEE   | M, T, W, T, F, S, S               |       |
- * |                                 |     | EEEEEE  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
- * | ISO day of week (formatting)    |  90 | i       | 1, 2, 3, ..., 7                   | 5     |
- * |                                 |     | io      | 1st, 2nd, ..., 7th                | 5     |
- * |                                 |     | ii      | 01, 02, ..., 07                   | 5     |
- * |                                 |     | iii     | Mon, Tue, Wed, ..., Sun           | 5     |
- * |                                 |     | iiii    | Monday, Tuesday, ..., Sunday      | 2,5   |
- * |                                 |     | iiiii   | M, T, W, T, F, S, S               | 5     |
- * |                                 |     | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 5     |
- * | Local day of week (formatting)  |  90 | e       | 2, 3, 4, ..., 1                   |       |
- * |                                 |     | eo      | 2nd, 3rd, ..., 1st                | 5     |
- * |                                 |     | ee      | 02, 03, ..., 01                   |       |
- * |                                 |     | eee     | Mon, Tue, Wed, ..., Sun           |       |
- * |                                 |     | eeee    | Monday, Tuesday, ..., Sunday      | 2     |
- * |                                 |     | eeeee   | M, T, W, T, F, S, S               |       |
- * |                                 |     | eeeeee  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
- * | Local day of week (stand-alone) |  90 | c       | 2, 3, 4, ..., 1                   |       |
- * |                                 |     | co      | 2nd, 3rd, ..., 1st                | 5     |
- * |                                 |     | cc      | 02, 03, ..., 01                   |       |
- * |                                 |     | ccc     | Mon, Tue, Wed, ..., Sun           |       |
- * |                                 |     | cccc    | Monday, Tuesday, ..., Sunday      | 2     |
- * |                                 |     | ccccc   | M, T, W, T, F, S, S               |       |
- * |                                 |     | cccccc  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
- * | AM, PM                          |  80 | a..aaa  | AM, PM                            |       |
- * |                                 |     | aaaa    | a.m., p.m.                        | 2     |
- * |                                 |     | aaaaa   | a, p                              |       |
- * | AM, PM, noon, midnight          |  80 | b..bbb  | AM, PM, noon, midnight            |       |
- * |                                 |     | bbbb    | a.m., p.m., noon, midnight        | 2     |
- * |                                 |     | bbbbb   | a, p, n, mi                       |       |
- * | Flexible day period             |  80 | B..BBB  | at night, in the morning, ...     |       |
- * |                                 |     | BBBB    | at night, in the morning, ...     | 2     |
- * |                                 |     | BBBBB   | at night, in the morning, ...     |       |
- * | Hour [1-12]                     |  70 | h       | 1, 2, ..., 11, 12                 |       |
- * |                                 |     | ho      | 1st, 2nd, ..., 11th, 12th         | 5     |
- * |                                 |     | hh      | 01, 02, ..., 11, 12               |       |
- * | Hour [0-23]                     |  70 | H       | 0, 1, 2, ..., 23                  |       |
- * |                                 |     | Ho      | 0th, 1st, 2nd, ..., 23rd          | 5     |
- * |                                 |     | HH      | 00, 01, 02, ..., 23               |       |
- * | Hour [0-11]                     |  70 | K       | 1, 2, ..., 11, 0                  |       |
- * |                                 |     | Ko      | 1st, 2nd, ..., 11th, 0th          | 5     |
- * |                                 |     | KK      | 01, 02, ..., 11, 00               |       |
- * | Hour [1-24]                     |  70 | k       | 24, 1, 2, ..., 23                 |       |
- * |                                 |     | ko      | 24th, 1st, 2nd, ..., 23rd         | 5     |
- * |                                 |     | kk      | 24, 01, 02, ..., 23               |       |
- * | Minute                          |  60 | m       | 0, 1, ..., 59                     |       |
- * |                                 |     | mo      | 0th, 1st, ..., 59th               | 5     |
- * |                                 |     | mm      | 00, 01, ..., 59                   |       |
- * | Second                          |  50 | s       | 0, 1, ..., 59                     |       |
- * |                                 |     | so      | 0th, 1st, ..., 59th               | 5     |
- * |                                 |     | ss      | 00, 01, ..., 59                   |       |
- * | Seconds timestamp               |  40 | t       | 512969520                         |       |
- * |                                 |     | tt      | ...                               | 2     |
- * | Fraction of second              |  30 | S       | 0, 1, ..., 9                      |       |
- * |                                 |     | SS      | 00, 01, ..., 99                   |       |
- * |                                 |     | SSS     | 000, 001, ..., 999                |       |
- * |                                 |     | SSSS    | ...                               | 2     |
- * | Milliseconds timestamp          |  20 | T       | 512969520900                      |       |
- * |                                 |     | TT      | ...                               | 2     |
- * | Timezone (ISO-8601 w/ Z)        |  10 | X       | -08, +0530, Z                     |       |
- * |                                 |     | XX      | -0800, +0530, Z                   |       |
- * |                                 |     | XXX     | -08:00, +05:30, Z                 |       |
- * |                                 |     | XXXX    | -0800, +0530, Z, +123456          | 2     |
- * |                                 |     | XXXXX   | -08:00, +05:30, Z, +12:34:56      |       |
- * | Timezone (ISO-8601 w/o Z)       |  10 | x       | -08, +0530, +00                   |       |
- * |                                 |     | xx      | -0800, +0530, +0000               |       |
- * |                                 |     | xxx     | -08:00, +05:30, +00:00            | 2     |
- * |                                 |     | xxxx    | -0800, +0530, +0000, +123456      |       |
- * |                                 |     | xxxxx   | -08:00, +05:30, +00:00, +12:34:56 |       |
- * | Long localized date             |  NA | P       | 05/29/1453                        | 5,8   |
- * |                                 |     | PP      | May 29, 1453                      |       |
- * |                                 |     | PPP     | May 29th, 1453                    |       |
- * |                                 |     | PPPP    | Sunday, May 29th, 1453            | 2,5,8 |
- * | Long localized time             |  NA | p       | 12:00 AM                          | 5,8   |
- * |                                 |     | pp      | 12:00:00 AM                       |       |
- * | Combination of date and time    |  NA | Pp      | 05/29/1453, 12:00 AM              |       |
- * |                                 |     | PPpp    | May 29, 1453, 12:00:00 AM         |       |
- * |                                 |     | PPPpp   | May 29th, 1453 at ...             |       |
- * |                                 |     | PPPPpp  | Sunday, May 29th, 1453 at ...     | 2,5,8 |
- * Notes:
- * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
- *    are the same as "stand-alone" units, but are different in some languages.
- *    "Formatting" units are declined according to the rules of the language
- *    in the context of a date. "Stand-alone" units are always nominative singular.
- *    In `format` function, they will produce different result:
- *
- *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
- *
- *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
- *
- *    `parse` will try to match both formatting and stand-alone units interchangeably.
- *
- * 2. Any sequence of the identical letters is a pattern, unless it is escaped by
- *    the single quote characters (see below).
- *    If the sequence is longer than listed in table:
- *    - for numerical units (`yyyyyyyy`) `parse` will try to match a number
- *      as wide as the sequence
- *    - for text units (`MMMMMMMM`) `parse` will try to match the widest variation of the unit.
- *      These variations are marked with "2" in the last column of the table.
- *
- * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
- *    These tokens represent the shortest form of the quarter.
- *
- * 4. The main difference between `y` and `u` patterns are B.C. years:
- *
- *    | Year | `y` | `u` |
- *    |------|-----|-----|
- *    | AC 1 |   1 |   1 |
- *    | BC 1 |   1 |   0 |
- *    | BC 2 |   2 |  -1 |
- *
- *    Also `yy` will try to guess the century of two digit year by proximity with `referenceDate`:
- *
- *    `parse('50', 'yy', new Date(2018, 0, 1)) //=> Sat Jan 01 2050 00:00:00`
- *
- *    `parse('75', 'yy', new Date(2018, 0, 1)) //=> Wed Jan 01 1975 00:00:00`
- *
- *    while `uu` will just assign the year as is:
- *
- *    `parse('50', 'uu', new Date(2018, 0, 1)) //=> Sat Jan 01 0050 00:00:00`
- *
- *    `parse('75', 'uu', new Date(2018, 0, 1)) //=> Tue Jan 01 0075 00:00:00`
- *
- *    The same difference is true for local and ISO week-numbering years (`Y` and `R`),
- *    except local week-numbering years are dependent on `options.weekStartsOn`
- *    and `options.firstWeekContainsDate` (compare [setISOWeekYear](https://date-fns.org/docs/setISOWeekYear)
- *    and [setWeekYear](https://date-fns.org/docs/setWeekYear)).
- *
- * 5. These patterns are not in the Unicode Technical Standard #35:
- *    - `i`: ISO day of week
- *    - `I`: ISO week of year
- *    - `R`: ISO week-numbering year
- *    - `o`: ordinal number modifier
- *    - `P`: long localized date
- *    - `p`: long localized time
- *
- * 6. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
- *    You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
- *
- * 7. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
- *    You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
- *
- * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based
- *    on the given locale.
- *
- *    using `en-US` locale: `P` => `MM/dd/yyyy`
- *    using `en-US` locale: `p` => `hh:mm a`
- *    using `pt-BR` locale: `P` => `dd/MM/yyyy`
- *    using `pt-BR` locale: `p` => `HH:mm`
- *
- * Values will be assigned to the date in the descending order of its unit's priority.
- * Units of an equal priority overwrite each other in the order of appearance.
- *
- * If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),
- * the values will be taken from 3rd argument `referenceDate` which works as a context of parsing.
- *
- * `referenceDate` must be passed for correct work of the function.
- * If you're not sure which `referenceDate` to supply, create a new instance of Date:
- * `parse('02/11/2014', 'MM/dd/yyyy', new Date())`
- * In this case parsing will be done in the context of the current date.
- * If `referenceDate` is `Invalid Date` or a value not convertible to valid `Date`,
- * then `Invalid Date` will be returned.
- *
- * The result may vary by locale.
- *
- * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned.
- *
- * If parsing failed, `Invalid Date` will be returned.
- * Invalid Date is a Date, whose time value is NaN.
- * Time value of Date: http://es5.github.io/#x15.9.1.1
- *
- * @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).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param dateStr - The string to parse
- * @param formatStr - The string of tokens
- * @param referenceDate - defines values missing from the parsed dateString
- * @param options - An object with options.
- *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
- *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
- *
- * @returns The parsed date
- *
- * @throws `options.locale` must contain `match` property
- * @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
- * @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
- * @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
- * @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
- * @throws format string contains an unescaped latin alphabet character
- *
- * @example
- * // Parse 11 February 2014 from middle-endian format:
- * var result = parse('02/11/2014', 'MM/dd/yyyy', new Date())
- * //=> Tue Feb 11 2014 00:00:00
- *
- * @example
- * // Parse 28th of February in Esperanto locale in the context of 2010 year:
- * import eo from 'date-fns/locale/eo'
- * var result = parse('28-a de februaro', "do 'de' MMMM", new Date(2010, 0, 1), {
- *   locale: eo
- * })
- * //=> Sun Feb 28 2010 00:00:00
- */
-function parse(dateStr, formatStr, referenceDate, options) {
-  const invalidDate = () => constructFrom(referenceDate, NaN);
-  const defaultOptions = getDefaultOptions();
-  const locale = defaultOptions.locale ?? enUS;
-
-  const firstWeekContainsDate =
-    defaultOptions.firstWeekContainsDate ??
-    defaultOptions.locale?.options?.firstWeekContainsDate ??
-    1;
-
-  const weekStartsOn =
-    defaultOptions.weekStartsOn ??
-    defaultOptions.locale?.options?.weekStartsOn ??
-    0;
-
-  if (!formatStr)
-    return dateStr ? invalidDate() : toDate(referenceDate, options?.in);
-
-  const subFnOptions = {
-    firstWeekContainsDate,
-    weekStartsOn,
-    locale,
-  };
-
-  // If timezone isn't specified, it will try to use the context or
-  // the reference date and fallback to the system time zone.
-  const setters = [new DateTimezoneSetter(options?.in, referenceDate)];
-
-  const tokens = formatStr
-    .match(longFormattingTokensRegExp)
-    .map((substring) => {
-      const firstCharacter = substring[0];
-      if (firstCharacter in longFormatters) {
-        const longFormatter = longFormatters[firstCharacter];
-        return longFormatter(substring, locale.formatLong);
-      }
-      return substring;
-    })
-    .join("")
-    .match(formattingTokensRegExp);
-
-  const usedTokens = [];
-
-  for (let token of tokens) {
-    if (
-      isProtectedWeekYearToken(token)
-    ) {
-      warnOrThrowProtectedError(token, formatStr, dateStr);
-    }
-    if (
-      isProtectedDayOfYearToken(token)
-    ) {
-      warnOrThrowProtectedError(token, formatStr, dateStr);
-    }
-
-    const firstCharacter = token[0];
-    const parser = parsers[firstCharacter];
-    if (parser) {
-      const { incompatibleTokens } = parser;
-      if (Array.isArray(incompatibleTokens)) {
-        const incompatibleToken = usedTokens.find(
-          (usedToken) =>
-            incompatibleTokens.includes(usedToken.token) ||
-            usedToken.token === firstCharacter,
-        );
-        if (incompatibleToken) {
-          throw new RangeError(
-            `The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`,
-          );
-        }
-      } else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
-        throw new RangeError(
-          `The format string mustn't contain \`${token}\` and any other token at the same time`,
-        );
-      }
-
-      usedTokens.push({ token: firstCharacter, fullToken: token });
-
-      const parseResult = parser.run(
-        dateStr,
-        token,
-        locale.match,
-        subFnOptions,
-      );
-
-      if (!parseResult) {
-        return invalidDate();
-      }
-
-      setters.push(parseResult.setter);
-
-      dateStr = parseResult.rest;
-    } else {
-      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
-        throw new RangeError(
-          "Format string contains an unescaped latin alphabet character `" +
-            firstCharacter +
-            "`",
-        );
-      }
-
-      // Replace two single quote characters with one single quote character
-      if (token === "''") {
-        token = "'";
-      } else if (firstCharacter === "'") {
-        token = cleanEscapedString(token);
-      }
-
-      // Cut token from string, or, if string doesn't match the token, return Invalid Date
-      if (dateStr.indexOf(token) === 0) {
-        dateStr = dateStr.slice(token.length);
-      } else {
-        return invalidDate();
-      }
-    }
-  }
-
-  // Check if the remaining input contains something other than whitespace
-  if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
-    return invalidDate();
-  }
-
-  const uniquePrioritySetters = setters
-    .map((setter) => setter.priority)
-    .sort((a, b) => b - a)
-    .filter((priority, index, array) => array.indexOf(priority) === index)
-    .map((priority) =>
-      setters
-        .filter((setter) => setter.priority === priority)
-        .sort((a, b) => b.subPriority - a.subPriority),
-    )
-    .map((setterArray) => setterArray[0]);
-
-  let date = toDate(referenceDate, options?.in);
-
-  if (isNaN(+date)) return invalidDate();
-
-  const flags = {};
-  for (const setter of uniquePrioritySetters) {
-    if (!setter.validate(date, subFnOptions)) {
-      return invalidDate();
-    }
-
-    const result = setter.set(date, flags, subFnOptions);
-    // Result is tuple (date, flags)
-    if (Array.isArray(result)) {
-      date = result[0];
-      Object.assign(flags, result[1]);
-      // Result is date
-    } else {
-      date = result;
-    }
-  }
-
-  return date;
-}
-
-function cleanEscapedString(input) {
-  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
-}
-
-const DEFAULT_DATE_FORMAT = "dd/MM/yyyy";
-const DEFAULT_TIME_FORMAT = "HH:mm:ss";
-const SIZE_CONFIG = {
-  small: { trigger: "h-7 text-xs", icon: "size-3.5" },
-  medium: { trigger: "h-8 text-sm", icon: "size-4" },
-  large: { trigger: "h-10 text-sm", icon: "size-4" }
-};
-
-const toNativeDate = (value) => {
-  if (value == null) return null;
-  if (value instanceof Date) return value;
-  if (typeof value.toDate === "function") {
-    return value.toDate();
-  }
-  if (typeof value === "string") {
-    const parsed = new Date(value);
-    if (!isNaN(parsed.getTime())) return parsed;
-  }
-  return null;
-};
-const coerceDateValue = (value, type) => {
-  if (value == null) return null;
-  if (type === "range" && Array.isArray(value)) {
-    return [toNativeDate(value[0]), toNativeDate(value[1])];
-  }
-  return toNativeDate(value);
-};
-const normalizeDateFormat = (fmt) => fmt.replace(/YYYY/g, "yyyy").replace(/YY/g, "yy").replace(/DD/g, "dd").replace(/\bD\b/g, "d");
-const formatDate = (date, formatStr) => {
-  if (!date) return "";
-  try {
-    return format(date, normalizeDateFormat(formatStr));
-  } catch {
-    return "";
-  }
-};
-const parseDate = (str, formatStr) => {
-  if (!str) return null;
-  try {
-    const parsed = parse(str, normalizeDateFormat(formatStr), /* @__PURE__ */ new Date());
-    if (!isNaN(parsed.getTime())) return parsed;
-  } catch {
-  }
-  const flexibleFormats = [
-    "dd/MM/yyyy",
-    "MM/dd/yyyy",
-    "yyyy-MM-dd",
-    "dd-MM-yyyy",
-    "dd/MM/yyyy HH:mm:ss",
-    "dd/MM/yyyy HH:mm"
-  ];
-  for (const fmt of flexibleFormats) {
-    if (fmt === formatStr) continue;
-    try {
-      const parsed = parse(str, fmt, /* @__PURE__ */ new Date());
-      if (!isNaN(parsed.getTime())) return parsed;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-};
-const applyTimeToDate = (date, time) => {
-  const result = new Date(date);
-  result.setHours(time.hours, time.minutes, time.seconds ?? 0, 0);
-  return result;
-};
-const getDisplayFormat = (dateFormat, timeFormat, showTime) => showTime ? `${dateFormat} ${timeFormat}` : dateFormat;
-
-const TIMEZONE_OPTIONS = [
-  { label: "Local", value: "" },
-  { label: "UTC", value: "utc" }
-];
-const TimezoneSelect = ({
-  value,
-  onChange,
-  className
-}) => /* @__PURE__ */ jsxs("div", { className: cn("flex items-center gap-1.5 text-sm", className), children: [
-  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: "Timezone" }),
-  /* @__PURE__ */ jsx(
-    "select",
-    {
-      value: value ?? "",
-      onChange: (e) => onChange(e.target.value || void 0),
-      className: cn(
-        "rounded-md border border-input bg-background px-2 py-0.5 text-xs",
-        "focus:outline-none focus:ring-1 focus:ring-ring"
-      ),
-      "aria-label": "Select timezone",
-      children: TIMEZONE_OPTIONS.map((opt) => /* @__PURE__ */ jsx("option", { value: opt.value, children: opt.label }, opt.value))
-    }
-  )
-] });
-TimezoneSelect.displayName = "TimezoneSelect";
-
-const DatePickerFooter = ({
-  showTime,
-  needConfirm,
-  timezone,
-  onTimezoneChange,
-  onNow,
-  onOk,
-  className
-}) => {
-  const showOkButton = showTime || needConfirm;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: cn(
-        "flex items-center border-t border-border px-3 py-2",
-        className
-      ),
-      children: [
-        /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "sm", onClick: onNow, className: "text-xs", children: "Now" }),
-        /* @__PURE__ */ jsx("div", { className: "flex-1" }),
-        onTimezoneChange && /* @__PURE__ */ jsx(
-          TimezoneSelect,
-          {
-            value: timezone,
-            onChange: onTimezoneChange,
-            className: "me-2"
-          }
-        ),
-        showOkButton && /* @__PURE__ */ jsx(Button, { size: "sm", onClick: onOk, className: "text-xs", children: "OK" })
-      ]
-    }
-  );
-};
-DatePickerFooter.displayName = "DatePickerFooter";
-
-const DatePicker = forwardRef(
-  ({
-    value,
-    defaultValue,
-    onChange,
-    type = "date",
-    dateFormat = DEFAULT_DATE_FORMAT,
-    timeFormat = DEFAULT_TIME_FORMAT,
-    showTime = false,
-    timePickerFormat = "24",
-    showSeconds = false,
-    minDate,
-    maxDate,
-    placeholder,
-    label,
-    error,
-    helpText,
-    size = "medium",
-    disabled = false,
-    allowClear = true,
-    required = false,
-    timezone,
-    onTimezoneChange,
-    onOk,
-    needConfirm = false,
-    onOpenChange,
-    className,
-    labelProps
-  }, ref) => {
-    const generatedId = useId();
-    const errorId = `error_${generatedId}`;
-    const helpTextId = `helpText_${generatedId}`;
-    const containerRef = useRef(null);
-    const popoverContentId = useRef(
-      `datepicker-popover-${generatedId}`
-    ).current;
-    const [open, setOpen] = useState(false);
-    const [internalValue, setInternalValue] = useState(coerceDateValue(defaultValue, type) ?? null);
-    const currentValue = value !== void 0 ? coerceDateValue(value, type) : internalValue;
-    const [calendarMonth, setCalendarMonth] = useState(
-      (type === "date" ? value ?? defaultValue : null) ?? /* @__PURE__ */ new Date()
-    );
-    const [rangeSelectionStep, setRangeSelectionStep] = useState(
-      "from"
-    );
-    const [pendingDate, setPendingDate] = useState(null);
-    const [pendingTime, setPendingTime] = useState({
-      hours: 0,
-      minutes: 0,
-      seconds: 0
-    });
-    const displayFormat = getDisplayFormat(dateFormat, timeFormat, showTime);
-    const sizeConfig = SIZE_CONFIG[size];
-    const defaultPlaceholder = showTime ? `${dateFormat.toUpperCase()} ${timeFormat}` : dateFormat.toUpperCase();
-    const getDisplayText = useCallback(() => {
-      if (type === "range") {
-        const rangeValue = currentValue;
-        if (!rangeValue || !rangeValue[0] && !rangeValue[1]) return "";
-        const from = rangeValue[0] ? formatDate(rangeValue[0], displayFormat) : "";
-        const to = rangeValue[1] ? formatDate(rangeValue[1], displayFormat) : "";
-        return `${from} - ${to}`;
-      }
-      return formatDate(currentValue, displayFormat);
-    }, [currentValue, displayFormat, type]);
-    const [inputText, setInputText] = useState(() => getDisplayText());
-    useEffect(() => {
-      setInputText(getDisplayText());
-    }, [getDisplayText]);
-    const closePopover = useCallback(() => {
-      setOpen(false);
-      onOpenChange?.(false);
-      setInputText(getDisplayText());
-    }, [onOpenChange, getDisplayText]);
-    const openPopover = useCallback(() => {
-      setOpen(true);
-      onOpenChange?.(true);
-      setRangeSelectionStep("from");
-      const dateVal = type === "date" ? currentValue : null;
-      if (dateVal) {
-        setCalendarMonth(dateVal);
-        setPendingDate(dateVal);
-        setPendingTime(dateToTimeValue(dateVal));
-      } else {
-        setPendingDate(null);
-        setPendingTime({ hours: 0, minutes: 0, seconds: 0 });
-      }
-    }, [type, currentValue, onOpenChange]);
-    useEffect(() => {
-      if (!open) return;
-      const handlePointerDown = (e) => {
-        const target = e.target;
-        if (containerRef.current?.contains(target)) return;
-        const popoverEl = document.getElementById(popoverContentId);
-        if (popoverEl?.contains(target)) return;
-        closePopover();
-      };
-      document.addEventListener("pointerdown", handlePointerDown);
-      return () => document.removeEventListener("pointerdown", handlePointerDown);
-    }, [open, closePopover]);
-    const commitValue = (date) => {
-      setInternalValue(date);
-      if (date === null) {
-        onChange?.(null, "");
-        setInputText("");
-      } else if (Array.isArray(date)) {
-        const formatted = [
-          formatDate(date[0], displayFormat),
-          formatDate(date[1], displayFormat)
-        ];
-        onChange?.(date, formatted);
-        setInputText(`${formatted[0]} - ${formatted[1]}`);
-      } else {
-        const formatted = formatDate(date, displayFormat);
-        onChange?.(date, formatted);
-        setInputText(formatted);
-      }
-    };
-    const handleDateSelect = (selected) => {
-      if (!selected) return;
-      setCalendarMonth(selected);
-      if (showTime || needConfirm) {
-        setPendingDate(selected);
-      } else {
-        commitValue(selected);
-        setOpen(false);
-        onOpenChange?.(false);
-      }
-    };
-    const handleRangeSelect = (range) => {
-      if (!range) return;
-      const from = range.from ?? null;
-      const to = range.to ?? null;
-      if (rangeSelectionStep === "from") {
-        setInternalValue([from, null]);
-        setRangeSelectionStep("to");
-      } else {
-        if (from && to) {
-          if (showTime || needConfirm) {
-            setPendingDate(from);
-          } else {
-            commitValue([from, to]);
-            setOpen(false);
-            onOpenChange?.(false);
-          }
-        } else if (from) {
-          setInternalValue([from, null]);
-        }
-        setRangeSelectionStep("from");
-      }
-    };
-    const handleTimeChange = (time) => {
-      setPendingTime(time);
-    };
-    const handleNow = () => {
-      const now = /* @__PURE__ */ new Date();
-      if (showTime || needConfirm) {
-        setPendingDate(now);
-        setPendingTime(dateToTimeValue(now));
-      } else {
-        commitValue(now);
-        setOpen(false);
-        onOpenChange?.(false);
-      }
-    };
-    const handleOk = () => {
-      if (pendingDate) {
-        const finalDate = showTime ? applyTimeToDate(pendingDate, pendingTime) : pendingDate;
-        commitValue(finalDate);
-        onOk?.(finalDate);
-      }
-      setOpen(false);
-      onOpenChange?.(false);
-    };
-    const handleClear = (e) => {
-      e.stopPropagation();
-      e.preventDefault();
-      commitValue(null);
-    };
-    const handleInputChange = (e) => {
-      const text = e.target.value;
-      setInputText(text);
-      if (type === "range") return;
-      const parsed = parseDate(text, displayFormat);
-      if (parsed) {
-        setCalendarMonth(parsed);
-        if (showTime || needConfirm) {
-          setPendingDate(parsed);
-          setPendingTime(dateToTimeValue(parsed));
-        } else {
-          setInternalValue(parsed);
-        }
-      }
-    };
-    const handleInputKeyDown = (e) => {
-      if (e.key === "Enter" && type !== "range") {
-        const parsed = parseDate(inputText, displayFormat);
-        if (parsed) {
-          commitValue(parsed);
-        }
-        setOpen(false);
-        onOpenChange?.(false);
-      } else if (e.key === "Escape") {
-        closePopover();
-      }
-    };
-    const handleInputFocus = () => {
-      if (!open) openPopover();
-    };
-    const hasField = !!(label || error || helpText);
-    const showFooter = showTime || needConfirm || !!onTimezoneChange;
-    const ariaDescribedBy = [error ? errorId : null, helpText ? helpTextId : null].filter(Boolean).join(" ") || void 0;
-    const calendarDisabled = useCallback(
-      (date) => {
-        if (minDate && date < new Date(minDate.setHours(0, 0, 0, 0)))
-          return true;
-        if (maxDate && date > new Date(maxDate.setHours(23, 59, 59, 999)))
-          return true;
-        return false;
-      },
-      [minDate, maxDate]
-    );
-    const calendarSelected = useCallback(() => {
-      if (showTime || needConfirm) return pendingDate ?? void 0;
-      return currentValue ?? void 0;
-    }, [showTime, needConfirm, pendingDate, currentValue]);
-    const triggerContent = /* @__PURE__ */ jsxs(Popover, { open, children: [
-      /* @__PURE__ */ jsx(PopoverAnchor, { asChild: true, children: /* @__PURE__ */ jsxs(
-        "div",
-        {
-          ref: containerRef,
-          className: cn(
-            "relative flex w-full items-center gap-2 rounded-md border border-input bg-background pe-8 ps-3",
-            "focus-within:ring-2 focus-within:ring-ring focus-within:ring-offset-2",
-            disabled && "cursor-not-allowed opacity-50",
-            !!error && "border-destructive ring-destructive/20 ring-3",
-            sizeConfig.trigger,
-            !hasField && className
-          ),
-          children: [
-            /* @__PURE__ */ jsx(
-              Calendar,
-              {
-                className: cn("shrink-0 text-muted-foreground", sizeConfig.icon)
-              }
-            ),
-            /* @__PURE__ */ jsx(
-              "input",
-              {
-                type: "text",
-                disabled,
-                "aria-label": label || "Pick a date",
-                "aria-describedby": ariaDescribedBy,
-                "aria-invalid": !!error || void 0,
-                placeholder: placeholder ?? defaultPlaceholder,
-                value: inputText,
-                onChange: handleInputChange,
-                onKeyDown: handleInputKeyDown,
-                onFocus: handleInputFocus,
-                className: cn(
-                  "min-w-0 flex-1 bg-transparent outline-none placeholder:text-muted-foreground",
-                  "disabled:cursor-not-allowed",
-                  sizeConfig.trigger.split(" ").find((c) => c.startsWith("text-"))
-                )
-              }
-            ),
-            timezone && /* @__PURE__ */ jsx("span", { className: "shrink-0 rounded bg-muted px-1.5 py-0.5 text-xs text-muted-foreground", children: timezone.toUpperCase() }),
-            allowClear && /* @__PURE__ */ jsx(
-              "button",
-              {
-                type: "button",
-                onPointerDown: (e) => e.preventDefault(),
-                onClick: handleClear,
-                className: cn(
-                  "absolute inset-y-0 end-2 flex items-center text-muted-foreground hover:text-foreground focus:outline-none",
-                  !(inputText && !disabled) && "invisible"
-                ),
-                "aria-label": "Clear date",
-                tabIndex: -1,
-                children: /* @__PURE__ */ jsx(X, { className: sizeConfig.icon })
-              }
-            )
-          ]
-        }
-      ) }),
-      open && /* @__PURE__ */ jsxs(
-        PopoverContent,
-        {
-          id: popoverContentId,
-          className: "w-auto p-0",
-          align: "start",
-          onOpenAutoFocus: (e) => e.preventDefault(),
-          onCloseAutoFocus: (e) => e.preventDefault(),
-          onPointerDownOutside: (e) => e.preventDefault(),
-          onInteractOutside: (e) => e.preventDefault(),
-          children: [
-            /* @__PURE__ */ jsxs("div", { className: cn("flex", showTime && "flex-row"), children: [
-              type === "date" ? /* @__PURE__ */ jsx(
-                Calendar$1,
-                {
-                  mode: "single",
-                  captionLayout: "dropdown",
-                  month: calendarMonth,
-                  onMonthChange: setCalendarMonth,
-                  selected: calendarSelected(),
-                  onSelect: handleDateSelect,
-                  disabled: calendarDisabled,
-                  ...minDate && { fromDate: minDate },
-                  ...maxDate && { toDate: maxDate }
-                }
-              ) : /* @__PURE__ */ jsx(
-                Calendar$1,
-                {
-                  mode: "range",
-                  numberOfMonths: 2,
-                  captionLayout: "dropdown",
-                  month: calendarMonth,
-                  onMonthChange: setCalendarMonth,
-                  selected: currentValue ? {
-                    from: currentValue[0] ?? void 0,
-                    to: currentValue[1] ?? void 0
-                  } : void 0,
-                  onSelect: handleRangeSelect,
-                  disabled: calendarDisabled,
-                  ...minDate && { fromDate: minDate },
-                  ...maxDate && { toDate: maxDate }
-                }
-              ),
-              showTime && /* @__PURE__ */ jsx("div", { className: "border-inline-start border-border", children: /* @__PURE__ */ jsx(
-                TimePickerPanel,
-                {
-                  value: pendingTime,
-                  onChange: handleTimeChange,
-                  format: timePickerFormat,
-                  showSeconds,
-                  disabled
-                }
-              ) })
-            ] }),
-            showFooter && /* @__PURE__ */ jsx(
-              DatePickerFooter,
-              {
-                showTime,
-                needConfirm,
-                timezone,
-                onTimezoneChange,
-                onNow: handleNow,
-                onOk: handleOk
-              }
-            )
-          ]
-        }
-      )
-    ] });
-    if (!hasField) {
-      return /* @__PURE__ */ jsx("div", { ref, className, children: triggerContent });
-    }
-    return /* @__PURE__ */ jsxs(
-      Field,
-      {
-        ref,
-        "data-disabled": disabled || void 0,
-        "data-invalid": !!error || void 0,
-        className,
-        children: [
-          label && /* @__PURE__ */ jsxs(
-            FieldLabel,
-            {
-              ...labelProps,
-              children: [
-                label,
-                required && /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "text-destructive", children: "*" })
-              ]
-            }
-          ),
-          /* @__PURE__ */ jsxs(FieldContent, { children: [
-            triggerContent,
-            !!error && /* @__PURE__ */ jsx(FieldError, { id: errorId, children: error }),
-            helpText && /* @__PURE__ */ jsx(FieldDescription, { id: helpTextId, children: helpText })
-          ] })
-        ]
-      }
-    );
-  }
-);
-DatePicker.displayName = "DatePicker";
-
-export { DatePicker as D };
-//# sourceMappingURL=DatePicker-CCN3b1oz.js.map