@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-date-fns-CdFbeoHV.js

@@ -0,0 +1,2989 @@
+function i(r) {
+  const t = Object.prototype.toString.call(r);
+  return r instanceof Date || typeof r == "object" && t === "[object Date]" ? new r.constructor(+r) : typeof r == "number" || t === "[object Number]" || typeof r == "string" || t === "[object String]" ? new Date(r) : /* @__PURE__ */ new Date(NaN);
+}
+function d(r, t) {
+  return r instanceof Date ? new r.constructor(t) : new Date(t);
+}
+function Q(r, t) {
+  const e = i(r);
+  return isNaN(t) ? d(r, NaN) : (t && e.setDate(e.getDate() + t), e);
+}
+function R(r, t) {
+  const e = i(r);
+  if (isNaN(t)) return d(r, NaN);
+  if (!t)
+    return e;
+  const n = e.getDate(), a = d(r, e.getTime());
+  a.setMonth(e.getMonth() + t + 1, 0);
+  const s = a.getDate();
+  return n >= s ? a : (e.setFullYear(
+    a.getFullYear(),
+    a.getMonth(),
+    n
+  ), e);
+}
+function Mn(r, t) {
+  const {
+    years: e = 0,
+    months: n = 0,
+    weeks: a = 0,
+    days: s = 0,
+    hours: o = 0,
+    minutes: u = 0,
+    seconds: h = 0
+  } = t, g = i(r), w = n || e ? R(g, n + e * 12) : g, m = s || a ? Q(w, s + a * 7) : w, O = u + o * 60, q = (h + O * 60) * 1e3;
+  return d(r, m.getTime() + q);
+}
+function yt(r, t) {
+  const e = +i(r);
+  return d(r, e + t);
+}
+const rt = 6048e5, gt = 864e5, bt = 6e4, at = 36e5, pt = 1e3;
+function Dn(r, t) {
+  return yt(r, t * at);
+}
+let xt = {};
+function v() {
+  return xt;
+}
+function _(r, t) {
+  const e = v(), n = t?.weekStartsOn ?? t?.locale?.options?.weekStartsOn ?? e.weekStartsOn ?? e.locale?.options?.weekStartsOn ?? 0, a = i(r), s = a.getDay(), o = (s < n ? 7 : 0) + s - n;
+  return a.setDate(a.getDate() - o), a.setHours(0, 0, 0, 0), a;
+}
+function H(r) {
+  return _(r, { weekStartsOn: 1 });
+}
+function st(r) {
+  const t = i(r), e = t.getFullYear(), n = d(r, 0);
+  n.setFullYear(e + 1, 0, 4), n.setHours(0, 0, 0, 0);
+  const a = H(n), s = d(r, 0);
+  s.setFullYear(e, 0, 4), s.setHours(0, 0, 0, 0);
+  const o = H(s);
+  return t.getTime() >= a.getTime() ? e + 1 : t.getTime() >= o.getTime() ? e : e - 1;
+}
+function Z(r) {
+  const t = i(r);
+  return t.setHours(0, 0, 0, 0), t;
+}
+function C(r) {
+  const t = i(r), e = new Date(
+    Date.UTC(
+      t.getFullYear(),
+      t.getMonth(),
+      t.getDate(),
+      t.getHours(),
+      t.getMinutes(),
+      t.getSeconds(),
+      t.getMilliseconds()
+    )
+  );
+  return e.setUTCFullYear(t.getFullYear()), +r - +e;
+}
+function Mt(r, t) {
+  const e = Z(r), n = Z(t), a = +e - C(e), s = +n - C(n);
+  return Math.round((a - s) / gt);
+}
+function Dt(r) {
+  const t = st(r), e = d(r, 0);
+  return e.setFullYear(t, 0, 4), e.setHours(0, 0, 0, 0), H(e);
+}
+function Tt(r, t) {
+  const e = t * 3;
+  return R(r, e);
+}
+function kt(r, t) {
+  return R(r, t * 12);
+}
+function U(r, t) {
+  const e = i(r), n = i(t), a = e.getTime() - n.getTime();
+  return a < 0 ? -1 : a > 0 ? 1 : a;
+}
+function Pt(r) {
+  return r instanceof Date || typeof r == "object" && Object.prototype.toString.call(r) === "[object Date]";
+}
+function Ot(r) {
+  if (!Pt(r) && typeof r != "number")
+    return !1;
+  const t = i(r);
+  return !isNaN(Number(t));
+}
+function Tn(r) {
+  const t = i(r);
+  return Math.trunc(t.getMonth() / 3) + 1;
+}
+function Yt(r, t) {
+  const e = i(r), n = i(t);
+  return e.getFullYear() - n.getFullYear();
+}
+function kn(r, t) {
+  const e = i(r), n = i(t), a = U(e, n), s = Math.abs(Yt(e, n));
+  e.setFullYear(1584), n.setFullYear(1584);
+  const o = U(e, n) === -a, u = a * (s - +o);
+  return u === 0 ? 0 : u;
+}
+function Pn(r, t) {
+  const e = i(r.start), n = i(r.end);
+  let a = +e > +n;
+  const s = a ? +e : +n, o = a ? n : e;
+  o.setHours(0, 0, 0, 0);
+  let u = 1;
+  const h = [];
+  for (; +o <= s; )
+    h.push(i(o)), o.setDate(o.getDate() + u), o.setHours(0, 0, 0, 0);
+  return a ? h.reverse() : h;
+}
+function E(r) {
+  const t = i(r), e = t.getMonth(), n = e - e % 3;
+  return t.setMonth(n, 1), t.setHours(0, 0, 0, 0), t;
+}
+function On(r, t) {
+  const e = i(r.start), n = i(r.end);
+  let a = +e > +n;
+  const s = a ? +E(e) : +E(n);
+  let o = E(a ? n : e), u = 1;
+  const h = [];
+  for (; +o <= s; )
+    h.push(i(o)), o = Tt(o, u);
+  return a ? h.reverse() : h;
+}
+function Yn(r) {
+  const t = i(r);
+  return t.setDate(1), t.setHours(0, 0, 0, 0), t;
+}
+function _n(r) {
+  const t = i(r), e = t.getFullYear();
+  return t.setFullYear(e + 1, 0, 0), t.setHours(23, 59, 59, 999), t;
+}
+function _t(r) {
+  const t = i(r), e = d(r, 0);
+  return e.setFullYear(t.getFullYear(), 0, 1), e.setHours(0, 0, 0, 0), e;
+}
+function Wn(r, t) {
+  const e = v(), n = t?.weekStartsOn ?? t?.locale?.options?.weekStartsOn ?? e.weekStartsOn ?? e.locale?.options?.weekStartsOn ?? 0, a = i(r), s = a.getDay(), o = (s < n ? -7 : 0) + 6 - (s - n);
+  return a.setDate(a.getDate() + o), a.setHours(23, 59, 59, 999), a;
+}
+function vn(r) {
+  const t = i(r), e = t.getMonth(), n = e - e % 3 + 3;
+  return t.setMonth(n, 0), t.setHours(23, 59, 59, 999), t;
+}
+const Wt = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds"
+  },
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds"
+  },
+  halfAMinute: "half a minute",
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours"
+  },
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours"
+  },
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days"
+  },
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks"
+  },
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months"
+  },
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months"
+  },
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years"
+  },
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years"
+  },
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years"
+  },
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years"
+  }
+}, vt = (r, t, e) => {
+  let n;
+  const a = Wt[r];
+  return typeof a == "string" ? n = a : t === 1 ? n = a.one : n = a.other.replace("{{count}}", t.toString()), e?.addSuffix ? e.comparison && e.comparison > 0 ? "in " + n : n + " ago" : n;
+};
+function X(r) {
+  return (t = {}) => {
+    const e = t.width ? String(t.width) : r.defaultWidth;
+    return r.formats[e] || r.formats[r.defaultWidth];
+  };
+}
+const Nt = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+}, Et = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+}, Ht = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+}, qt = {
+  date: X({
+    formats: Nt,
+    defaultWidth: "full"
+  }),
+  time: X({
+    formats: Et,
+    defaultWidth: "full"
+  }),
+  dateTime: X({
+    formats: Ht,
+    defaultWidth: "full"
+  })
+}, Ft = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+}, Lt = (r, t, e, n) => Ft[r];
+function F(r) {
+  return (t, e) => {
+    const n = e?.context ? String(e.context) : "standalone";
+    let a;
+    if (n === "formatting" && r.formattingValues) {
+      const o = r.defaultFormattingWidth || r.defaultWidth, u = e?.width ? String(e.width) : o;
+      a = r.formattingValues[u] || r.formattingValues[o];
+    } else {
+      const o = r.defaultWidth, u = e?.width ? String(e.width) : r.defaultWidth;
+      a = r.values[u] || r.values[o];
+    }
+    const s = r.argumentCallback ? r.argumentCallback(t) : t;
+    return a[s];
+  };
+}
+const Ct = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+}, It = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+}, Qt = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  wide: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ]
+}, Rt = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ]
+}, At = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+}, Xt = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+}, Bt = (r, t) => {
+  const e = Number(r), n = e % 100;
+  if (n > 20 || n < 10)
+    switch (n % 10) {
+      case 1:
+        return e + "st";
+      case 2:
+        return e + "nd";
+      case 3:
+        return e + "rd";
+    }
+  return e + "th";
+}, Gt = {
+  ordinalNumber: Bt,
+  era: F({
+    values: Ct,
+    defaultWidth: "wide"
+  }),
+  quarter: F({
+    values: It,
+    defaultWidth: "wide",
+    argumentCallback: (r) => r - 1
+  }),
+  month: F({
+    values: Qt,
+    defaultWidth: "wide"
+  }),
+  day: F({
+    values: Rt,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: F({
+    values: At,
+    defaultWidth: "wide",
+    formattingValues: Xt,
+    defaultFormattingWidth: "wide"
+  })
+};
+function L(r) {
+  return (t, e = {}) => {
+    const n = e.width, a = n && r.matchPatterns[n] || r.matchPatterns[r.defaultMatchWidth], s = t.match(a);
+    if (!s)
+      return null;
+    const o = s[0], u = n && r.parsePatterns[n] || r.parsePatterns[r.defaultParseWidth], h = Array.isArray(u) ? $t(u, (m) => m.test(o)) : (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
+      jt(u, (m) => m.test(o))
+    );
+    let g;
+    g = r.valueCallback ? r.valueCallback(h) : h, g = e.valueCallback ? (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
+      e.valueCallback(g)
+    ) : g;
+    const w = t.slice(o.length);
+    return { value: g, rest: w };
+  };
+}
+function jt(r, t) {
+  for (const e in r)
+    if (Object.prototype.hasOwnProperty.call(r, e) && t(r[e]))
+      return e;
+}
+function $t(r, t) {
+  for (let e = 0; e < r.length; e++)
+    if (t(r[e]))
+      return e;
+}
+function Vt(r) {
+  return (t, e = {}) => {
+    const n = t.match(r.matchPattern);
+    if (!n) return null;
+    const a = n[0], s = t.match(r.parsePattern);
+    if (!s) return null;
+    let o = r.valueCallback ? r.valueCallback(s[0]) : s[0];
+    o = e.valueCallback ? e.valueCallback(o) : o;
+    const u = t.slice(a.length);
+    return { value: o, rest: u };
+  };
+}
+const zt = /^(\d+)(th|st|nd|rd)?/i, Jt = /\d+/i, Kt = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+}, Zt = {
+  any: [/^b/i, /^(a|c)/i]
+}, Ut = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+}, St = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, te = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+}, ee = {
+  narrow: [
+    /^j/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^ja/i,
+    /^f/i,
+    /^mar/i,
+    /^ap/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^au/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+}, ne = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+}, re = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+}, ae = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+}, se = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+}, oe = {
+  ordinalNumber: Vt({
+    matchPattern: zt,
+    parsePattern: Jt,
+    valueCallback: (r) => parseInt(r, 10)
+  }),
+  era: L({
+    matchPatterns: Kt,
+    defaultMatchWidth: "wide",
+    parsePatterns: Zt,
+    defaultParseWidth: "any"
+  }),
+  quarter: L({
+    matchPatterns: Ut,
+    defaultMatchWidth: "wide",
+    parsePatterns: St,
+    defaultParseWidth: "any",
+    valueCallback: (r) => r + 1
+  }),
+  month: L({
+    matchPatterns: te,
+    defaultMatchWidth: "wide",
+    parsePatterns: ee,
+    defaultParseWidth: "any"
+  }),
+  day: L({
+    matchPatterns: ne,
+    defaultMatchWidth: "wide",
+    parsePatterns: re,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: L({
+    matchPatterns: ae,
+    defaultMatchWidth: "any",
+    parsePatterns: se,
+    defaultParseWidth: "any"
+  })
+}, ot = {
+  code: "en-US",
+  formatDistance: vt,
+  formatLong: qt,
+  formatRelative: Lt,
+  localize: Gt,
+  match: oe,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+function ie(r) {
+  const t = i(r);
+  return Mt(t, _t(t)) + 1;
+}
+function it(r) {
+  const t = i(r), e = +H(t) - +Dt(t);
+  return Math.round(e / rt) + 1;
+}
+function j(r, t) {
+  const e = i(r), n = e.getFullYear(), a = v(), s = t?.firstWeekContainsDate ?? t?.locale?.options?.firstWeekContainsDate ?? a.firstWeekContainsDate ?? a.locale?.options?.firstWeekContainsDate ?? 1, o = d(r, 0);
+  o.setFullYear(n + 1, 0, s), o.setHours(0, 0, 0, 0);
+  const u = _(o, t), h = d(r, 0);
+  h.setFullYear(n, 0, s), h.setHours(0, 0, 0, 0);
+  const g = _(h, t);
+  return e.getTime() >= u.getTime() ? n + 1 : e.getTime() >= g.getTime() ? n : n - 1;
+}
+function ue(r, t) {
+  const e = v(), n = t?.firstWeekContainsDate ?? t?.locale?.options?.firstWeekContainsDate ?? e.firstWeekContainsDate ?? e.locale?.options?.firstWeekContainsDate ?? 1, a = j(r, t), s = d(r, 0);
+  return s.setFullYear(a, 0, n), s.setHours(0, 0, 0, 0), _(s, t);
+}
+function ut(r, t) {
+  const e = i(r), n = +_(e, t) - +ue(e, t);
+  return Math.round(n / rt) + 1;
+}
+function f(r, t) {
+  const e = r < 0 ? "-" : "", n = Math.abs(r).toString().padStart(t, "0");
+  return e + n;
+}
+const Y = {
+  // Year
+  y(r, t) {
+    const e = r.getFullYear(), n = e > 0 ? e : 1 - e;
+    return f(t === "yy" ? n % 100 : n, t.length);
+  },
+  // Month
+  M(r, t) {
+    const e = r.getMonth();
+    return t === "M" ? String(e + 1) : f(e + 1, 2);
+  },
+  // Day of the month
+  d(r, t) {
+    return f(r.getDate(), t.length);
+  },
+  // AM or PM
+  a(r, t) {
+    const e = r.getHours() / 12 >= 1 ? "pm" : "am";
+    switch (t) {
+      case "a":
+      case "aa":
+        return e.toUpperCase();
+      case "aaa":
+        return e;
+      case "aaaaa":
+        return e[0];
+      case "aaaa":
+      default:
+        return e === "am" ? "a.m." : "p.m.";
+    }
+  },
+  // Hour [1-12]
+  h(r, t) {
+    return f(r.getHours() % 12 || 12, t.length);
+  },
+  // Hour [0-23]
+  H(r, t) {
+    return f(r.getHours(), t.length);
+  },
+  // Minute
+  m(r, t) {
+    return f(r.getMinutes(), t.length);
+  },
+  // Second
+  s(r, t) {
+    return f(r.getSeconds(), t.length);
+  },
+  // Fraction of second
+  S(r, t) {
+    const e = t.length, n = r.getMilliseconds(), a = Math.trunc(
+      n * Math.pow(10, e - 3)
+    );
+    return f(a, t.length);
+  }
+}, N = {
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night"
+}, S = {
+  // Era
+  G: function(r, t, e) {
+    const n = r.getFullYear() > 0 ? 1 : 0;
+    switch (t) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return e.era(n, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return e.era(n, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return e.era(n, { width: "wide" });
+    }
+  },
+  // Year
+  y: function(r, t, e) {
+    if (t === "yo") {
+      const n = r.getFullYear(), a = n > 0 ? n : 1 - n;
+      return e.ordinalNumber(a, { unit: "year" });
+    }
+    return Y.y(r, t);
+  },
+  // Local week-numbering year
+  Y: function(r, t, e, n) {
+    const a = j(r, n), s = a > 0 ? a : 1 - a;
+    if (t === "YY") {
+      const o = s % 100;
+      return f(o, 2);
+    }
+    return t === "Yo" ? e.ordinalNumber(s, { unit: "year" }) : f(s, t.length);
+  },
+  // ISO week-numbering year
+  R: function(r, t) {
+    const e = st(r);
+    return f(e, t.length);
+  },
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function(r, t) {
+    const e = r.getFullYear();
+    return f(e, t.length);
+  },
+  // Quarter
+  Q: function(r, t, e) {
+    const n = Math.ceil((r.getMonth() + 1) / 3);
+    switch (t) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(n);
+      // 01, 02, 03, 04
+      case "QQ":
+        return f(n, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return e.ordinalNumber(n, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return e.quarter(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return e.quarter(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return e.quarter(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Stand-alone quarter
+  q: function(r, t, e) {
+    const n = Math.ceil((r.getMonth() + 1) / 3);
+    switch (t) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(n);
+      // 01, 02, 03, 04
+      case "qq":
+        return f(n, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return e.ordinalNumber(n, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return e.quarter(n, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return e.quarter(n, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return e.quarter(n, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  // Month
+  M: function(r, t, e) {
+    const n = r.getMonth();
+    switch (t) {
+      case "M":
+      case "MM":
+        return Y.M(r, t);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return e.ordinalNumber(n + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return e.month(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return e.month(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return e.month(n, { width: "wide", context: "formatting" });
+    }
+  },
+  // Stand-alone month
+  L: function(r, t, e) {
+    const n = r.getMonth();
+    switch (t) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(n + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return f(n + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return e.ordinalNumber(n + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return e.month(n, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return e.month(n, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return e.month(n, { width: "wide", context: "standalone" });
+    }
+  },
+  // Local week of year
+  w: function(r, t, e, n) {
+    const a = ut(r, n);
+    return t === "wo" ? e.ordinalNumber(a, { unit: "week" }) : f(a, t.length);
+  },
+  // ISO week of year
+  I: function(r, t, e) {
+    const n = it(r);
+    return t === "Io" ? e.ordinalNumber(n, { unit: "week" }) : f(n, t.length);
+  },
+  // Day of the month
+  d: function(r, t, e) {
+    return t === "do" ? e.ordinalNumber(r.getDate(), { unit: "date" }) : Y.d(r, t);
+  },
+  // Day of year
+  D: function(r, t, e) {
+    const n = ie(r);
+    return t === "Do" ? e.ordinalNumber(n, { unit: "dayOfYear" }) : f(n, t.length);
+  },
+  // Day of week
+  E: function(r, t, e) {
+    const n = r.getDay();
+    switch (t) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return e.day(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "EEEEE":
+        return e.day(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return e.day(n, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return e.day(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Local day of week
+  e: function(r, t, e, n) {
+    const a = r.getDay(), s = (a - n.weekStartsOn + 8) % 7 || 7;
+    switch (t) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(s);
+      // Padded numerical value
+      case "ee":
+        return f(s, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return e.ordinalNumber(s, { unit: "day" });
+      case "eee":
+        return e.day(a, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "eeeee":
+        return e.day(a, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return e.day(a, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return e.day(a, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Stand-alone local day of week
+  c: function(r, t, e, n) {
+    const a = r.getDay(), s = (a - n.weekStartsOn + 8) % 7 || 7;
+    switch (t) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(s);
+      // Padded numerical value
+      case "cc":
+        return f(s, t.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return e.ordinalNumber(s, { unit: "day" });
+      case "ccc":
+        return e.day(a, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // T
+      case "ccccc":
+        return e.day(a, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return e.day(a, {
+          width: "short",
+          context: "standalone"
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return e.day(a, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  // ISO day of week
+  i: function(r, t, e) {
+    const n = r.getDay(), a = n === 0 ? 7 : n;
+    switch (t) {
+      // 2
+      case "i":
+        return String(a);
+      // 02
+      case "ii":
+        return f(a, t.length);
+      // 2nd
+      case "io":
+        return e.ordinalNumber(a, { unit: "day" });
+      // Tue
+      case "iii":
+        return e.day(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "iiiii":
+        return e.day(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "iiiiii":
+        return e.day(n, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return e.day(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // AM or PM
+  a: function(r, t, e) {
+    const a = r.getHours() / 12 >= 1 ? "pm" : "am";
+    switch (t) {
+      case "a":
+      case "aa":
+        return e.dayPeriod(a, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "aaa":
+        return e.dayPeriod(a, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "aaaaa":
+        return e.dayPeriod(a, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return e.dayPeriod(a, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // AM, PM, midnight, noon
+  b: function(r, t, e) {
+    const n = r.getHours();
+    let a;
+    switch (n === 12 ? a = N.noon : n === 0 ? a = N.midnight : a = n / 12 >= 1 ? "pm" : "am", t) {
+      case "b":
+      case "bb":
+        return e.dayPeriod(a, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "bbb":
+        return e.dayPeriod(a, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "bbbbb":
+        return e.dayPeriod(a, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return e.dayPeriod(a, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // in the morning, in the afternoon, in the evening, at night
+  B: function(r, t, e) {
+    const n = r.getHours();
+    let a;
+    switch (n >= 17 ? a = N.evening : n >= 12 ? a = N.afternoon : n >= 4 ? a = N.morning : a = N.night, t) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return e.dayPeriod(a, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return e.dayPeriod(a, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return e.dayPeriod(a, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Hour [1-12]
+  h: function(r, t, e) {
+    if (t === "ho") {
+      let n = r.getHours() % 12;
+      return n === 0 && (n = 12), e.ordinalNumber(n, { unit: "hour" });
+    }
+    return Y.h(r, t);
+  },
+  // Hour [0-23]
+  H: function(r, t, e) {
+    return t === "Ho" ? e.ordinalNumber(r.getHours(), { unit: "hour" }) : Y.H(r, t);
+  },
+  // Hour [0-11]
+  K: function(r, t, e) {
+    const n = r.getHours() % 12;
+    return t === "Ko" ? e.ordinalNumber(n, { unit: "hour" }) : f(n, t.length);
+  },
+  // Hour [1-24]
+  k: function(r, t, e) {
+    let n = r.getHours();
+    return n === 0 && (n = 24), t === "ko" ? e.ordinalNumber(n, { unit: "hour" }) : f(n, t.length);
+  },
+  // Minute
+  m: function(r, t, e) {
+    return t === "mo" ? e.ordinalNumber(r.getMinutes(), { unit: "minute" }) : Y.m(r, t);
+  },
+  // Second
+  s: function(r, t, e) {
+    return t === "so" ? e.ordinalNumber(r.getSeconds(), { unit: "second" }) : Y.s(r, t);
+  },
+  // Fraction of second
+  S: function(r, t) {
+    return Y.S(r, t);
+  },
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function(r, t, e) {
+    const n = r.getTimezoneOffset();
+    if (n === 0)
+      return "Z";
+    switch (t) {
+      // Hours and optional minutes
+      case "X":
+        return et(n);
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX":
+        return W(n);
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX":
+      // Hours and minutes with `:` delimiter
+      default:
+        return W(n, ":");
+    }
+  },
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function(r, t, e) {
+    const n = r.getTimezoneOffset();
+    switch (t) {
+      // Hours and optional minutes
+      case "x":
+        return et(n);
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx":
+        return W(n);
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx":
+      // Hours and minutes with `:` delimiter
+      default:
+        return W(n, ":");
+    }
+  },
+  // Timezone (GMT)
+  O: function(r, t, e) {
+    const n = r.getTimezoneOffset();
+    switch (t) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + tt(n, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + W(n, ":");
+    }
+  },
+  // Timezone (specific non-location)
+  z: function(r, t, e) {
+    const n = r.getTimezoneOffset();
+    switch (t) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + tt(n, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + W(n, ":");
+    }
+  },
+  // Seconds timestamp
+  t: function(r, t, e) {
+    const n = Math.trunc(r.getTime() / 1e3);
+    return f(n, t.length);
+  },
+  // Milliseconds timestamp
+  T: function(r, t, e) {
+    const n = r.getTime();
+    return f(n, t.length);
+  }
+};
+function tt(r, t = "") {
+  const e = r > 0 ? "-" : "+", n = Math.abs(r), a = Math.trunc(n / 60), s = n % 60;
+  return s === 0 ? e + String(a) : e + String(a) + t + f(s, 2);
+}
+function et(r, t) {
+  return r % 60 === 0 ? (r > 0 ? "-" : "+") + f(Math.abs(r) / 60, 2) : W(r, t);
+}
+function W(r, t = "") {
+  const e = r > 0 ? "-" : "+", n = Math.abs(r), a = f(Math.trunc(n / 60), 2), s = f(n % 60, 2);
+  return e + a + t + s;
+}
+const nt = (r, t) => {
+  switch (r) {
+    case "P":
+      return t.date({ width: "short" });
+    case "PP":
+      return t.date({ width: "medium" });
+    case "PPP":
+      return t.date({ width: "long" });
+    case "PPPP":
+    default:
+      return t.date({ width: "full" });
+  }
+}, ct = (r, t) => {
+  switch (r) {
+    case "p":
+      return t.time({ width: "short" });
+    case "pp":
+      return t.time({ width: "medium" });
+    case "ppp":
+      return t.time({ width: "long" });
+    case "pppp":
+    default:
+      return t.time({ width: "full" });
+  }
+}, ce = (r, t) => {
+  const e = r.match(/(P+)(p+)?/) || [], n = e[1], a = e[2];
+  if (!a)
+    return nt(r, t);
+  let s;
+  switch (n) {
+    case "P":
+      s = t.dateTime({ width: "short" });
+      break;
+    case "PP":
+      s = t.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      s = t.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      s = t.dateTime({ width: "full" });
+      break;
+  }
+  return s.replace("{{date}}", nt(n, t)).replace("{{time}}", ct(a, t));
+}, B = {
+  p: ct,
+  P: ce
+}, de = /^D+$/, le = /^Y+$/, fe = ["D", "DD", "YY", "YYYY"];
+function dt(r) {
+  return de.test(r);
+}
+function lt(r) {
+  return le.test(r);
+}
+function G(r, t, e) {
+  const n = he(r, t, e);
+  if (console.warn(n), fe.includes(r)) throw new RangeError(n);
+}
+function he(r, t, e) {
+  const n = r[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${r.toLowerCase()}\` instead of \`${r}\` (in \`${t}\`) for formatting ${n} to the input \`${e}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+const me = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, we = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, ye = /^'([^]*?)'?$/, ge = /''/g, be = /[a-zA-Z]/;
+function Nn(r, t, e) {
+  const n = v(), a = e?.locale ?? n.locale ?? ot, s = e?.firstWeekContainsDate ?? e?.locale?.options?.firstWeekContainsDate ?? n.firstWeekContainsDate ?? n.locale?.options?.firstWeekContainsDate ?? 1, o = e?.weekStartsOn ?? e?.locale?.options?.weekStartsOn ?? n.weekStartsOn ?? n.locale?.options?.weekStartsOn ?? 0, u = i(r);
+  if (!Ot(u))
+    throw new RangeError("Invalid time value");
+  let h = t.match(we).map((w) => {
+    const m = w[0];
+    if (m === "p" || m === "P") {
+      const O = B[m];
+      return O(w, a.formatLong);
+    }
+    return w;
+  }).join("").match(me).map((w) => {
+    if (w === "''")
+      return { isToken: !1, value: "'" };
+    const m = w[0];
+    if (m === "'")
+      return { isToken: !1, value: pe(w) };
+    if (S[m])
+      return { isToken: !0, value: w };
+    if (m.match(be))
+      throw new RangeError(
+        "Format string contains an unescaped latin alphabet character `" + m + "`"
+      );
+    return { isToken: !1, value: w };
+  });
+  a.localize.preprocessor && (h = a.localize.preprocessor(u, h));
+  const g = {
+    firstWeekContainsDate: s,
+    weekStartsOn: o,
+    locale: a
+  };
+  return h.map((w) => {
+    if (!w.isToken) return w.value;
+    const m = w.value;
+    (!e?.useAdditionalWeekYearTokens && lt(m) || !e?.useAdditionalDayOfYearTokens && dt(m)) && G(m, t, String(r));
+    const O = S[m[0]];
+    return O(u, m, a.localize, g);
+  }).join("");
+}
+function pe(r) {
+  const t = r.match(ye);
+  return t ? t[1].replace(ge, "'") : r;
+}
+function En(r) {
+  return i(r).getDay();
+}
+function xe(r) {
+  const t = i(r), e = t.getFullYear(), n = t.getMonth(), a = d(r, 0);
+  return a.setFullYear(e, n + 1, 0), a.setHours(0, 0, 0, 0), a.getDate();
+}
+function Me() {
+  return Object.assign({}, v());
+}
+function Hn(r) {
+  return i(r).getHours();
+}
+function De(r) {
+  let e = i(r).getDay();
+  return e === 0 && (e = 7), e;
+}
+function qn(r) {
+  return i(r).getMinutes();
+}
+function Fn(r) {
+  return i(r).getMonth();
+}
+function Ln(r) {
+  return i(r).getSeconds();
+}
+function Cn(r) {
+  return i(r).getFullYear();
+}
+function In(r, t) {
+  const e = i(r), n = i(t);
+  return e.getTime() > n.getTime();
+}
+function Qn(r, t) {
+  const e = i(r), n = i(t);
+  return +e < +n;
+}
+function Rn(r, t) {
+  const e = i(r), n = i(t);
+  return +e == +n;
+}
+function Te(r, t) {
+  const e = t instanceof Date ? d(t, 0) : new t(0);
+  return e.setFullYear(
+    r.getFullYear(),
+    r.getMonth(),
+    r.getDate()
+  ), e.setHours(
+    r.getHours(),
+    r.getMinutes(),
+    r.getSeconds(),
+    r.getMilliseconds()
+  ), e;
+}
+const ke = 10;
+class ft {
+  subPriority = 0;
+  validate(t, e) {
+    return !0;
+  }
+}
+class Pe extends ft {
+  constructor(t, e, n, a, s) {
+    super(), this.value = t, this.validateValue = e, this.setValue = n, this.priority = a, s && (this.subPriority = s);
+  }
+  validate(t, e) {
+    return this.validateValue(t, this.value, e);
+  }
+  set(t, e, n) {
+    return this.setValue(t, e, this.value, n);
+  }
+}
+class Oe extends ft {
+  priority = ke;
+  subPriority = -1;
+  set(t, e) {
+    return e.timestampIsSet ? t : d(t, Te(t, Date));
+  }
+}
+class l {
+  run(t, e, n, a) {
+    const s = this.parse(t, e, n, a);
+    return s ? {
+      setter: new Pe(
+        s.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: s.rest
+    } : null;
+  }
+  validate(t, e, n) {
+    return !0;
+  }
+}
+class Ye extends l {
+  priority = 140;
+  parse(t, e, n) {
+    switch (e) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return n.era(t, { width: "abbreviated" }) || n.era(t, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return n.era(t, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return n.era(t, { width: "wide" }) || n.era(t, { width: "abbreviated" }) || n.era(t, { width: "narrow" });
+    }
+  }
+  set(t, e, n) {
+    return e.era = n, t.setFullYear(n, 0, 1), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+const x = {
+  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
+}, T = {
+  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 M(r, t) {
+  return r && {
+    value: t(r.value),
+    rest: r.rest
+  };
+}
+function y(r, t) {
+  const e = t.match(r);
+  return e ? {
+    value: parseInt(e[0], 10),
+    rest: t.slice(e[0].length)
+  } : null;
+}
+function k(r, t) {
+  const e = t.match(r);
+  if (!e)
+    return null;
+  if (e[0] === "Z")
+    return {
+      value: 0,
+      rest: t.slice(1)
+    };
+  const n = e[1] === "+" ? 1 : -1, a = e[2] ? parseInt(e[2], 10) : 0, s = e[3] ? parseInt(e[3], 10) : 0, o = e[5] ? parseInt(e[5], 10) : 0;
+  return {
+    value: n * (a * at + s * bt + o * pt),
+    rest: t.slice(e[0].length)
+  };
+}
+function ht(r) {
+  return y(x.anyDigitsSigned, r);
+}
+function p(r, t) {
+  switch (r) {
+    case 1:
+      return y(x.singleDigit, t);
+    case 2:
+      return y(x.twoDigits, t);
+    case 3:
+      return y(x.threeDigits, t);
+    case 4:
+      return y(x.fourDigits, t);
+    default:
+      return y(new RegExp("^\\d{1," + r + "}"), t);
+  }
+}
+function I(r, t) {
+  switch (r) {
+    case 1:
+      return y(x.singleDigitSigned, t);
+    case 2:
+      return y(x.twoDigitsSigned, t);
+    case 3:
+      return y(x.threeDigitsSigned, t);
+    case 4:
+      return y(x.fourDigitsSigned, t);
+    default:
+      return y(new RegExp("^-?\\d{1," + r + "}"), t);
+  }
+}
+function $(r) {
+  switch (r) {
+    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 mt(r, t) {
+  const e = t > 0, n = e ? t : 1 - t;
+  let a;
+  if (n <= 50)
+    a = r || 100;
+  else {
+    const s = n + 50, o = Math.trunc(s / 100) * 100, u = r >= s % 100;
+    a = r + o - (u ? 100 : 0);
+  }
+  return e ? a : 1 - a;
+}
+function wt(r) {
+  return r % 400 === 0 || r % 4 === 0 && r % 100 !== 0;
+}
+class _e extends l {
+  priority = 130;
+  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+  parse(t, e, n) {
+    const a = (s) => ({
+      year: s,
+      isTwoDigitYear: e === "yy"
+    });
+    switch (e) {
+      case "y":
+        return M(p(4, t), a);
+      case "yo":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "year"
+          }),
+          a
+        );
+      default:
+        return M(p(e.length, t), a);
+    }
+  }
+  validate(t, e) {
+    return e.isTwoDigitYear || e.year > 0;
+  }
+  set(t, e, n) {
+    const a = t.getFullYear();
+    if (n.isTwoDigitYear) {
+      const o = mt(
+        n.year,
+        a
+      );
+      return t.setFullYear(o, 0, 1), t.setHours(0, 0, 0, 0), t;
+    }
+    const s = !("era" in e) || e.era === 1 ? n.year : 1 - n.year;
+    return t.setFullYear(s, 0, 1), t.setHours(0, 0, 0, 0), t;
+  }
+}
+class We extends l {
+  priority = 130;
+  parse(t, e, n) {
+    const a = (s) => ({
+      year: s,
+      isTwoDigitYear: e === "YY"
+    });
+    switch (e) {
+      case "Y":
+        return M(p(4, t), a);
+      case "Yo":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "year"
+          }),
+          a
+        );
+      default:
+        return M(p(e.length, t), a);
+    }
+  }
+  validate(t, e) {
+    return e.isTwoDigitYear || e.year > 0;
+  }
+  set(t, e, n, a) {
+    const s = j(t, a);
+    if (n.isTwoDigitYear) {
+      const u = mt(
+        n.year,
+        s
+      );
+      return t.setFullYear(
+        u,
+        0,
+        a.firstWeekContainsDate
+      ), t.setHours(0, 0, 0, 0), _(t, a);
+    }
+    const o = !("era" in e) || e.era === 1 ? n.year : 1 - n.year;
+    return t.setFullYear(o, 0, a.firstWeekContainsDate), t.setHours(0, 0, 0, 0), _(t, a);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+class ve extends l {
+  priority = 130;
+  parse(t, e) {
+    return I(e === "R" ? 4 : e.length, t);
+  }
+  set(t, e, n) {
+    const a = d(t, 0);
+    return a.setFullYear(n, 0, 4), a.setHours(0, 0, 0, 0), H(a);
+  }
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Ne extends l {
+  priority = 130;
+  parse(t, e) {
+    return I(e === "u" ? 4 : e.length, t);
+  }
+  set(t, e, n) {
+    return t.setFullYear(n, 0, 1), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+class Ee extends l {
+  priority = 120;
+  parse(t, e, n) {
+    switch (e) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return p(e.length, t);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return n.ordinalNumber(t, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return n.quarter(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.quarter(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return n.quarter(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return n.quarter(t, {
+          width: "wide",
+          context: "formatting"
+        }) || n.quarter(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.quarter(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 4;
+  }
+  set(t, e, n) {
+    return t.setMonth((n - 1) * 3, 1), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class He extends l {
+  priority = 120;
+  parse(t, e, n) {
+    switch (e) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return p(e.length, t);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return n.ordinalNumber(t, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return n.quarter(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.quarter(t, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return n.quarter(t, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return n.quarter(t, {
+          width: "wide",
+          context: "standalone"
+        }) || n.quarter(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.quarter(t, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 4;
+  }
+  set(t, e, n) {
+    return t.setMonth((n - 1) * 3, 1), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class qe extends l {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+  priority = 110;
+  parse(t, e, n) {
+    const a = (s) => s - 1;
+    switch (e) {
+      // 1, 2, ..., 12
+      case "M":
+        return M(
+          y(x.month, t),
+          a
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return M(p(2, t), a);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "month"
+          }),
+          a
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return n.month(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.month(t, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return n.month(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return n.month(t, { width: "wide", context: "formatting" }) || n.month(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.month(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 11;
+  }
+  set(t, e, n) {
+    return t.setMonth(n, 1), t.setHours(0, 0, 0, 0), t;
+  }
+}
+class Fe extends l {
+  priority = 110;
+  parse(t, e, n) {
+    const a = (s) => s - 1;
+    switch (e) {
+      // 1, 2, ..., 12
+      case "L":
+        return M(
+          y(x.month, t),
+          a
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return M(p(2, t), a);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "month"
+          }),
+          a
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return n.month(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.month(t, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return n.month(t, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return n.month(t, { width: "wide", context: "standalone" }) || n.month(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.month(t, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 11;
+  }
+  set(t, e, n) {
+    return t.setMonth(n, 1), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+function Le(r, t, e) {
+  const n = i(r), a = ut(n, e) - t;
+  return n.setDate(n.getDate() - a * 7), n;
+}
+class Ce extends l {
+  priority = 100;
+  parse(t, e, n) {
+    switch (e) {
+      case "w":
+        return y(x.week, t);
+      case "wo":
+        return n.ordinalNumber(t, { unit: "week" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 53;
+  }
+  set(t, e, n, a) {
+    return _(Le(t, n, a), a);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+function Ie(r, t) {
+  const e = i(r), n = it(e) - t;
+  return e.setDate(e.getDate() - n * 7), e;
+}
+class Qe extends l {
+  priority = 100;
+  parse(t, e, n) {
+    switch (e) {
+      case "I":
+        return y(x.week, t);
+      case "Io":
+        return n.ordinalNumber(t, { unit: "week" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 53;
+  }
+  set(t, e, n) {
+    return H(Ie(t, n));
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+const Re = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Ae = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class Xe extends l {
+  priority = 90;
+  subPriority = 1;
+  parse(t, e, n) {
+    switch (e) {
+      case "d":
+        return y(x.date, t);
+      case "do":
+        return n.ordinalNumber(t, { unit: "date" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    const n = t.getFullYear(), a = wt(n), s = t.getMonth();
+    return a ? e >= 1 && e <= Ae[s] : e >= 1 && e <= Re[s];
+  }
+  set(t, e, n) {
+    return t.setDate(n), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Be extends l {
+  priority = 90;
+  subpriority = 1;
+  parse(t, e, n) {
+    switch (e) {
+      case "D":
+      case "DD":
+        return y(x.dayOfYear, t);
+      case "Do":
+        return n.ordinalNumber(t, { unit: "date" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    const n = t.getFullYear();
+    return wt(n) ? e >= 1 && e <= 366 : e >= 1 && e <= 365;
+  }
+  set(t, e, n) {
+    return t.setMonth(0, n), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+function V(r, t, e) {
+  const n = v(), a = e?.weekStartsOn ?? e?.locale?.options?.weekStartsOn ?? n.weekStartsOn ?? n.locale?.options?.weekStartsOn ?? 0, s = i(r), o = s.getDay(), h = (t % 7 + 7) % 7, g = 7 - a, w = t < 0 || t > 6 ? t - (o + g) % 7 : (h + g) % 7 - (o + g) % 7;
+  return Q(s, w);
+}
+class Ge extends l {
+  priority = 90;
+  parse(t, e, n) {
+    switch (e) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return n.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return n.day(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "EEEE":
+      default:
+        return n.day(t, { width: "wide", context: "formatting" }) || n.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 6;
+  }
+  set(t, e, n, a) {
+    return t = V(t, n, a), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+class je extends l {
+  priority = 90;
+  parse(t, e, n, a) {
+    const s = (o) => {
+      const u = Math.floor((o - 1) / 7) * 7;
+      return (o + a.weekStartsOn + 6) % 7 + u;
+    };
+    switch (e) {
+      // 3
+      case "e":
+      case "ee":
+        return M(p(e.length, t), s);
+      // 3rd
+      case "eo":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "day"
+          }),
+          s
+        );
+      // Tue
+      case "eee":
+        return n.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return n.day(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "eeee":
+      default:
+        return n.day(t, { width: "wide", context: "formatting" }) || n.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 6;
+  }
+  set(t, e, n, a) {
+    return t = V(t, n, a), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class $e extends l {
+  priority = 90;
+  parse(t, e, n, a) {
+    const s = (o) => {
+      const u = Math.floor((o - 1) / 7) * 7;
+      return (o + a.weekStartsOn + 6) % 7 + u;
+    };
+    switch (e) {
+      // 3
+      case "c":
+      case "cc":
+        return M(p(e.length, t), s);
+      // 3rd
+      case "co":
+        return M(
+          n.ordinalNumber(t, {
+            unit: "day"
+          }),
+          s
+        );
+      // Tue
+      case "ccc":
+        return n.day(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return n.day(t, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
+      // Tuesday
+      case "cccc":
+      default:
+        return n.day(t, { width: "wide", context: "standalone" }) || n.day(t, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 6;
+  }
+  set(t, e, n, a) {
+    return t = V(t, n, a), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "e",
+    "t",
+    "T"
+  ];
+}
+function Ve(r, t) {
+  const e = i(r), n = De(e), a = t - n;
+  return Q(e, a);
+}
+class ze extends l {
+  priority = 90;
+  parse(t, e, n) {
+    const a = (s) => s === 0 ? 7 : s;
+    switch (e) {
+      // 2
+      case "i":
+      case "ii":
+        return p(e.length, t);
+      // 2nd
+      case "io":
+        return n.ordinalNumber(t, { unit: "day" });
+      // Tue
+      case "iii":
+        return M(
+          n.day(t, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          a
+        );
+      // T
+      case "iiiii":
+        return M(
+          n.day(t, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          a
+        );
+      // Tu
+      case "iiiiii":
+        return M(
+          n.day(t, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          a
+        );
+      // Tuesday
+      case "iiii":
+      default:
+        return M(
+          n.day(t, {
+            width: "wide",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(t, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          a
+        );
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 7;
+  }
+  set(t, e, n) {
+    return t = Ve(t, n), t.setHours(0, 0, 0, 0), t;
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Je extends l {
+  priority = 80;
+  parse(t, e, n) {
+    switch (e) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return n.dayPeriod(t, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(t, e, n) {
+    return t.setHours($(n), 0, 0, 0), t;
+  }
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}
+class Ke extends l {
+  priority = 80;
+  parse(t, e, n) {
+    switch (e) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return n.dayPeriod(t, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(t, e, n) {
+    return t.setHours($(n), 0, 0, 0), t;
+  }
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}
+class Ze extends l {
+  priority = 80;
+  parse(t, e, n) {
+    switch (e) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return n.dayPeriod(t, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(t, e, n) {
+    return t.setHours($(n), 0, 0, 0), t;
+  }
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+class Ue extends l {
+  priority = 70;
+  parse(t, e, n) {
+    switch (e) {
+      case "h":
+        return y(x.hour12h, t);
+      case "ho":
+        return n.ordinalNumber(t, { unit: "hour" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 12;
+  }
+  set(t, e, n) {
+    const a = t.getHours() >= 12;
+    return a && n < 12 ? t.setHours(n + 12, 0, 0, 0) : !a && n === 12 ? t.setHours(0, 0, 0, 0) : t.setHours(n, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+class Se extends l {
+  priority = 70;
+  parse(t, e, n) {
+    switch (e) {
+      case "H":
+        return y(x.hour23h, t);
+      case "Ho":
+        return n.ordinalNumber(t, { unit: "hour" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 23;
+  }
+  set(t, e, n) {
+    return t.setHours(n, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+class tn extends l {
+  priority = 70;
+  parse(t, e, n) {
+    switch (e) {
+      case "K":
+        return y(x.hour11h, t);
+      case "Ko":
+        return n.ordinalNumber(t, { unit: "hour" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 11;
+  }
+  set(t, e, n) {
+    return t.getHours() >= 12 && n < 12 ? t.setHours(n + 12, 0, 0, 0) : t.setHours(n, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+class en extends l {
+  priority = 70;
+  parse(t, e, n) {
+    switch (e) {
+      case "k":
+        return y(x.hour24h, t);
+      case "ko":
+        return n.ordinalNumber(t, { unit: "hour" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 1 && e <= 24;
+  }
+  set(t, e, n) {
+    const a = n <= 24 ? n % 24 : n;
+    return t.setHours(a, 0, 0, 0), t;
+  }
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+class nn extends l {
+  priority = 60;
+  parse(t, e, n) {
+    switch (e) {
+      case "m":
+        return y(x.minute, t);
+      case "mo":
+        return n.ordinalNumber(t, { unit: "minute" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 59;
+  }
+  set(t, e, n) {
+    return t.setMinutes(n, 0, 0), t;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class rn extends l {
+  priority = 50;
+  parse(t, e, n) {
+    switch (e) {
+      case "s":
+        return y(x.second, t);
+      case "so":
+        return n.ordinalNumber(t, { unit: "second" });
+      default:
+        return p(e.length, t);
+    }
+  }
+  validate(t, e) {
+    return e >= 0 && e <= 59;
+  }
+  set(t, e, n) {
+    return t.setSeconds(n, 0), t;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class an extends l {
+  priority = 30;
+  parse(t, e) {
+    const n = (a) => Math.trunc(a * Math.pow(10, -e.length + 3));
+    return M(p(e.length, t), n);
+  }
+  set(t, e, n) {
+    return t.setMilliseconds(n), t;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class sn extends l {
+  priority = 10;
+  parse(t, e) {
+    switch (e) {
+      case "X":
+        return k(
+          T.basicOptionalMinutes,
+          t
+        );
+      case "XX":
+        return k(T.basic, t);
+      case "XXXX":
+        return k(
+          T.basicOptionalSeconds,
+          t
+        );
+      case "XXXXX":
+        return k(
+          T.extendedOptionalSeconds,
+          t
+        );
+      case "XXX":
+      default:
+        return k(T.extended, t);
+    }
+  }
+  set(t, e, n) {
+    return e.timestampIsSet ? t : d(
+      t,
+      t.getTime() - C(t) - n
+    );
+  }
+  incompatibleTokens = ["t", "T", "x"];
+}
+class on extends l {
+  priority = 10;
+  parse(t, e) {
+    switch (e) {
+      case "x":
+        return k(
+          T.basicOptionalMinutes,
+          t
+        );
+      case "xx":
+        return k(T.basic, t);
+      case "xxxx":
+        return k(
+          T.basicOptionalSeconds,
+          t
+        );
+      case "xxxxx":
+        return k(
+          T.extendedOptionalSeconds,
+          t
+        );
+      case "xxx":
+      default:
+        return k(T.extended, t);
+    }
+  }
+  set(t, e, n) {
+    return e.timestampIsSet ? t : d(
+      t,
+      t.getTime() - C(t) - n
+    );
+  }
+  incompatibleTokens = ["t", "T", "X"];
+}
+class un extends l {
+  priority = 40;
+  parse(t) {
+    return ht(t);
+  }
+  set(t, e, n) {
+    return [d(t, n * 1e3), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+class cn extends l {
+  priority = 20;
+  parse(t) {
+    return ht(t);
+  }
+  set(t, e, n) {
+    return [d(t, n), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+const dn = {
+  G: new Ye(),
+  y: new _e(),
+  Y: new We(),
+  R: new ve(),
+  u: new Ne(),
+  Q: new Ee(),
+  q: new He(),
+  M: new qe(),
+  L: new Fe(),
+  w: new Ce(),
+  I: new Qe(),
+  d: new Xe(),
+  D: new Be(),
+  E: new Ge(),
+  e: new je(),
+  c: new $e(),
+  i: new ze(),
+  a: new Je(),
+  b: new Ke(),
+  B: new Ze(),
+  h: new Ue(),
+  H: new Se(),
+  K: new tn(),
+  k: new en(),
+  m: new nn(),
+  s: new rn(),
+  S: new an(),
+  X: new sn(),
+  x: new on(),
+  t: new un(),
+  T: new cn()
+}, ln = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, fn = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, hn = /^'([^]*?)'?$/, mn = /''/g, wn = /\S/, yn = /[a-zA-Z]/;
+function An(r, t, e, n) {
+  const a = Me(), s = n?.locale ?? a.locale ?? ot, o = n?.firstWeekContainsDate ?? n?.locale?.options?.firstWeekContainsDate ?? a.firstWeekContainsDate ?? a.locale?.options?.firstWeekContainsDate ?? 1, u = n?.weekStartsOn ?? n?.locale?.options?.weekStartsOn ?? a.weekStartsOn ?? a.locale?.options?.weekStartsOn ?? 0;
+  if (t === "")
+    return r === "" ? i(e) : d(e, NaN);
+  const h = {
+    firstWeekContainsDate: o,
+    weekStartsOn: u,
+    locale: s
+  }, g = [new Oe()], w = t.match(fn).map((c) => {
+    const b = c[0];
+    if (b in B) {
+      const D = B[b];
+      return D(c, s.formatLong);
+    }
+    return c;
+  }).join("").match(ln), m = [];
+  for (let c of w) {
+    !n?.useAdditionalWeekYearTokens && lt(c) && G(c, t, r), !n?.useAdditionalDayOfYearTokens && dt(c) && G(c, t, r);
+    const b = c[0], D = dn[b];
+    if (D) {
+      const { incompatibleTokens: z } = D;
+      if (Array.isArray(z)) {
+        const J = m.find(
+          (K) => z.includes(K.token) || K.token === b
+        );
+        if (J)
+          throw new RangeError(
+            `The format string mustn't contain \`${J.fullToken}\` and \`${c}\` at the same time`
+          );
+      } else if (D.incompatibleTokens === "*" && m.length > 0)
+        throw new RangeError(
+          `The format string mustn't contain \`${c}\` and any other token at the same time`
+        );
+      m.push({ token: b, fullToken: c });
+      const A = D.run(
+        r,
+        c,
+        s.match,
+        h
+      );
+      if (!A)
+        return d(e, NaN);
+      g.push(A.setter), r = A.rest;
+    } else {
+      if (b.match(yn))
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + b + "`"
+        );
+      if (c === "''" ? c = "'" : b === "'" && (c = gn(c)), r.indexOf(c) === 0)
+        r = r.slice(c.length);
+      else
+        return d(e, NaN);
+    }
+  }
+  if (r.length > 0 && wn.test(r))
+    return d(e, NaN);
+  const O = g.map((c) => c.priority).sort((c, b) => b - c).filter((c, b, D) => D.indexOf(c) === b).map(
+    (c) => g.filter((b) => b.priority === c).sort((b, D) => D.subPriority - b.subPriority)
+  ).map((c) => c[0]);
+  let P = i(e);
+  if (isNaN(P.getTime()))
+    return d(e, NaN);
+  const q = {};
+  for (const c of O) {
+    if (!c.validate(P, h))
+      return d(e, NaN);
+    const b = c.set(P, q, h);
+    Array.isArray(b) ? (P = b[0], Object.assign(q, b[1])) : P = b;
+  }
+  return d(e, P);
+}
+function gn(r) {
+  return r.match(hn)[1].replace(mn, "'");
+}
+function Xn(r, t) {
+  const e = E(r), n = E(t);
+  return +e == +n;
+}
+function bn(r, t) {
+  return Q(r, -t);
+}
+function pn(r, t) {
+  const e = i(r), n = e.getFullYear(), a = e.getDate(), s = d(r, 0);
+  s.setFullYear(n, t, 15), s.setHours(0, 0, 0, 0);
+  const o = xe(s);
+  return e.setMonth(t, Math.min(a, o)), e;
+}
+function Bn(r, t) {
+  let e = i(r);
+  return isNaN(+e) ? d(r, NaN) : (t.year != null && e.setFullYear(t.year), t.month != null && (e = pn(e, t.month)), t.date != null && e.setDate(t.date), t.hours != null && e.setHours(t.hours), t.minutes != null && e.setMinutes(t.minutes), t.seconds != null && e.setSeconds(t.seconds), t.milliseconds != null && e.setMilliseconds(t.milliseconds), e);
+}
+function Gn(r, t) {
+  const e = i(r);
+  return e.setHours(t), e;
+}
+function jn(r, t) {
+  const e = i(r);
+  return e.setMilliseconds(t), e;
+}
+function $n(r, t) {
+  const e = i(r);
+  return e.setMinutes(t), e;
+}
+function Vn(r, t) {
+  const e = i(r);
+  return e.setSeconds(t), e;
+}
+function zn(r, t) {
+  const e = i(r);
+  return isNaN(+e) ? d(r, NaN) : (e.setFullYear(t), e);
+}
+function xn(r, t) {
+  return R(r, -t);
+}
+function Jn(r, t) {
+  const {
+    years: e = 0,
+    months: n = 0,
+    weeks: a = 0,
+    days: s = 0,
+    hours: o = 0,
+    minutes: u = 0,
+    seconds: h = 0
+  } = t, g = xn(r, n + e * 12), w = bn(g, s + a * 7), m = u + o * 60, P = (h + m * 60) * 1e3;
+  return d(r, w.getTime() - P);
+}
+function Kn(r, t) {
+  return kt(r, -t);
+}
+export {
+  R as A,
+  Yn as B,
+  jn as C,
+  Gn as D,
+  $n as E,
+  Vn as F,
+  pn as G,
+  Tn as H,
+  xn as I,
+  Q as J,
+  ut as K,
+  it as L,
+  Jn as M,
+  Pt as N,
+  kt as O,
+  Kn as P,
+  kn as Q,
+  Fn as a,
+  Ln as b,
+  qn as c,
+  Hn as d,
+  Qn as e,
+  Nn as f,
+  Cn as g,
+  Rn as h,
+  In as i,
+  Mt as j,
+  Pn as k,
+  En as l,
+  Dn as m,
+  zn as n,
+  Ot as o,
+  _ as p,
+  Wn as q,
+  An as r,
+  Bn as s,
+  _t as t,
+  Xn as u,
+  On as v,
+  _n as w,
+  E as x,
+  vn as y,
+  Mn as z
+};