@tricoteuses/assemblee 1.10.5 → 2.0.0

package/lib/parse-Ccs6wcUg.js

@@ -0,0 +1,2512 @@
+var ne = Object.defineProperty;
+var re = (r, a, e) => a in r ? ne(r, a, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[a] = e;
+var i = (r, a, e) => re(r, typeof a != "symbol" ? a + "" : a, e);
+const ae = {
+  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"
+  }
+}, se = (r, a, e) => {
+  let t;
+  const n = ae[r];
+  return typeof n == "string" ? t = n : a === 1 ? t = n.one : t = n.other.replace("{{count}}", a.toString()), e?.addSuffix ? e.comparison && e.comparison > 0 ? "in " + t : t + " ago" : t;
+};
+function Y(r) {
+  return (a = {}) => {
+    const e = a.width ? String(a.width) : r.defaultWidth;
+    return r.formats[e] || r.formats[r.defaultWidth];
+  };
+}
+const ie = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+}, oe = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+}, ue = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+}, ce = {
+  date: Y({
+    formats: ie,
+    defaultWidth: "full"
+  }),
+  time: Y({
+    formats: oe,
+    defaultWidth: "full"
+  }),
+  dateTime: Y({
+    formats: ue,
+    defaultWidth: "full"
+  })
+}, de = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+}, le = (r, a, e, t) => de[r];
+function x(r) {
+  return (a, e) => {
+    const t = e?.context ? String(e.context) : "standalone";
+    let n;
+    if (t === "formatting" && r.formattingValues) {
+      const o = r.defaultFormattingWidth || r.defaultWidth, d = e?.width ? String(e.width) : o;
+      n = r.formattingValues[d] || r.formattingValues[o];
+    } else {
+      const o = r.defaultWidth, d = e?.width ? String(e.width) : r.defaultWidth;
+      n = r.values[d] || r.values[o];
+    }
+    const s = r.argumentCallback ? r.argumentCallback(a) : a;
+    return n[s];
+  };
+}
+const me = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+}, he = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+}, fe = {
+  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"
+  ]
+}, we = {
+  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"
+  ]
+}, ye = {
+  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"
+  }
+}, be = {
+  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"
+  }
+}, pe = (r, a) => {
+  const e = Number(r), t = e % 100;
+  if (t > 20 || t < 10)
+    switch (t % 10) {
+      case 1:
+        return e + "st";
+      case 2:
+        return e + "nd";
+      case 3:
+        return e + "rd";
+    }
+  return e + "th";
+}, ge = {
+  ordinalNumber: pe,
+  era: x({
+    values: me,
+    defaultWidth: "wide"
+  }),
+  quarter: x({
+    values: he,
+    defaultWidth: "wide",
+    argumentCallback: (r) => r - 1
+  }),
+  month: x({
+    values: fe,
+    defaultWidth: "wide"
+  }),
+  day: x({
+    values: we,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: x({
+    values: ye,
+    defaultWidth: "wide",
+    formattingValues: be,
+    defaultFormattingWidth: "wide"
+  })
+};
+function M(r) {
+  return (a, e = {}) => {
+    const t = e.width, n = t && r.matchPatterns[t] || r.matchPatterns[r.defaultMatchWidth], s = a.match(n);
+    if (!s)
+      return null;
+    const o = s[0], d = t && r.parsePatterns[t] || r.parsePatterns[r.defaultParseWidth], b = Array.isArray(d) ? xe(d, (_) => _.test(o)) : (
+      // [TODO] -- I challenge you to fix the type
+      Pe(d, (_) => _.test(o))
+    );
+    let p;
+    p = r.valueCallback ? r.valueCallback(b) : b, p = e.valueCallback ? (
+      // [TODO] -- I challenge you to fix the type
+      e.valueCallback(p)
+    ) : p;
+    const D = a.slice(o.length);
+    return { value: p, rest: D };
+  };
+}
+function Pe(r, a) {
+  for (const e in r)
+    if (Object.prototype.hasOwnProperty.call(r, e) && a(r[e]))
+      return e;
+}
+function xe(r, a) {
+  for (let e = 0; e < r.length; e++)
+    if (a(r[e]))
+      return e;
+}
+function J(r) {
+  return (a, e = {}) => {
+    const t = a.match(r.matchPattern);
+    if (!t) return null;
+    const n = t[0], s = a.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 d = a.slice(n.length);
+    return { value: o, rest: d };
+  };
+}
+const Me = /^(\d+)(th|st|nd|rd)?/i, ke = /\d+/i, ve = {
+  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
+}, Te = {
+  any: [/^b/i, /^(a|c)/i]
+}, De = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+}, We = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, Ye = {
+  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
+}, Oe = {
+  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
+  ]
+}, _e = {
+  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
+}, Ce = {
+  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]
+}, He = {
+  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
+}, Ee = {
+  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
+  }
+}, qe = {
+  ordinalNumber: J({
+    matchPattern: Me,
+    parsePattern: ke,
+    valueCallback: (r) => parseInt(r, 10)
+  }),
+  era: M({
+    matchPatterns: ve,
+    defaultMatchWidth: "wide",
+    parsePatterns: Te,
+    defaultParseWidth: "any"
+  }),
+  quarter: M({
+    matchPatterns: De,
+    defaultMatchWidth: "wide",
+    parsePatterns: We,
+    defaultParseWidth: "any",
+    valueCallback: (r) => r + 1
+  }),
+  month: M({
+    matchPatterns: Ye,
+    defaultMatchWidth: "wide",
+    parsePatterns: Oe,
+    defaultParseWidth: "any"
+  }),
+  day: M({
+    matchPatterns: _e,
+    defaultMatchWidth: "wide",
+    parsePatterns: Ce,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: M({
+    matchPatterns: He,
+    defaultMatchWidth: "any",
+    parsePatterns: Ee,
+    defaultParseWidth: "any"
+  })
+}, Ne = {
+  code: "en-US",
+  formatDistance: se,
+  formatLong: ce,
+  formatRelative: le,
+  localize: ge,
+  match: qe,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+let Fe = {};
+function C() {
+  return Fe;
+}
+const z = 6048e5, Dn = 864e5, Ie = 6e4, je = 36e5, Le = 1e3, $ = Symbol.for("constructDateFrom");
+function y(r, a) {
+  return typeof r == "function" ? r(a) : r && typeof r == "object" && $ in r ? r[$](a) : r instanceof Date ? new r.constructor(a) : new Date(a);
+}
+function g(r, a) {
+  return y(a || r, r);
+}
+function V(r) {
+  const a = g(r), e = new Date(
+    Date.UTC(
+      a.getFullYear(),
+      a.getMonth(),
+      a.getDate(),
+      a.getHours(),
+      a.getMinutes(),
+      a.getSeconds(),
+      a.getMilliseconds()
+    )
+  );
+  return e.setUTCFullYear(a.getFullYear()), +r - +e;
+}
+function T(r, a) {
+  const e = C(), t = a?.weekStartsOn ?? a?.locale?.options?.weekStartsOn ?? e.weekStartsOn ?? e.locale?.options?.weekStartsOn ?? 0, n = g(r, a?.in), s = n.getDay(), o = (s < t ? 7 : 0) + s - t;
+  return n.setDate(n.getDate() - o), n.setHours(0, 0, 0, 0), n;
+}
+function O(r, a) {
+  return T(r, { ...a, weekStartsOn: 1 });
+}
+function Re(r, a) {
+  const e = g(r, a?.in), t = e.getFullYear(), n = y(e, 0);
+  n.setFullYear(t + 1, 0, 4), n.setHours(0, 0, 0, 0);
+  const s = O(n), o = y(e, 0);
+  o.setFullYear(t, 0, 4), o.setHours(0, 0, 0, 0);
+  const d = O(o);
+  return e.getTime() >= s.getTime() ? t + 1 : e.getTime() >= d.getTime() ? t : t - 1;
+}
+function $e(r, a) {
+  const e = Re(r, a), t = y(r, 0);
+  return t.setFullYear(e, 0, 4), t.setHours(0, 0, 0, 0), O(t);
+}
+function Qe(r, a) {
+  const e = g(r, a?.in), t = +O(e) - +$e(e);
+  return Math.round(t / z) + 1;
+}
+function B(r, a) {
+  const e = g(r, a?.in), t = e.getFullYear(), n = C(), s = a?.firstWeekContainsDate ?? a?.locale?.options?.firstWeekContainsDate ?? n.firstWeekContainsDate ?? n.locale?.options?.firstWeekContainsDate ?? 1, o = y(a?.in || r, 0);
+  o.setFullYear(t + 1, 0, s), o.setHours(0, 0, 0, 0);
+  const d = T(o, a), b = y(a?.in || r, 0);
+  b.setFullYear(t, 0, s), b.setHours(0, 0, 0, 0);
+  const p = T(b, a);
+  return +e >= +d ? t + 1 : +e >= +p ? t : t - 1;
+}
+function Ae(r, a) {
+  const e = C(), t = a?.firstWeekContainsDate ?? a?.locale?.options?.firstWeekContainsDate ?? e.firstWeekContainsDate ?? e.locale?.options?.firstWeekContainsDate ?? 1, n = B(r, a), s = y(a?.in || r, 0);
+  return s.setFullYear(n, 0, t), s.setHours(0, 0, 0, 0), T(s, a);
+}
+function Xe(r, a) {
+  const e = g(r, a?.in), t = +T(e, a) - +Ae(e, a);
+  return Math.round(t / z) + 1;
+}
+function Wn(r, a) {
+  const e = r < 0 ? "-" : "", t = Math.abs(r).toString().padStart(a, "0");
+  return e + t;
+}
+const Q = (r, a) => {
+  switch (r) {
+    case "P":
+      return a.date({ width: "short" });
+    case "PP":
+      return a.date({ width: "medium" });
+    case "PPP":
+      return a.date({ width: "long" });
+    case "PPPP":
+    default:
+      return a.date({ width: "full" });
+  }
+}, G = (r, a) => {
+  switch (r) {
+    case "p":
+      return a.time({ width: "short" });
+    case "pp":
+      return a.time({ width: "medium" });
+    case "ppp":
+      return a.time({ width: "long" });
+    case "pppp":
+    default:
+      return a.time({ width: "full" });
+  }
+}, Je = (r, a) => {
+  const e = r.match(/(P+)(p+)?/) || [], t = e[1], n = e[2];
+  if (!n)
+    return Q(r, a);
+  let s;
+  switch (t) {
+    case "P":
+      s = a.dateTime({ width: "short" });
+      break;
+    case "PP":
+      s = a.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      s = a.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      s = a.dateTime({ width: "full" });
+      break;
+  }
+  return s.replace("{{date}}", Q(t, a)).replace("{{time}}", G(n, a));
+}, A = {
+  p: G,
+  P: Je
+}, ze = /^D+$/, Ve = /^Y+$/, Be = ["D", "DD", "YY", "YYYY"];
+function Ge(r) {
+  return ze.test(r);
+}
+function Ze(r) {
+  return Ve.test(r);
+}
+function X(r, a, e) {
+  const t = Ke(r, a, e);
+  if (console.warn(t), Be.includes(r)) throw new RangeError(t);
+}
+function Ke(r, a, e) {
+  const t = r[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${r.toLowerCase()}\` instead of \`${r}\` (in \`${a}\`) for formatting ${t} to the input \`${e}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+const Ue = {
+  lessThanXSeconds: {
+    one: "moins d’une seconde",
+    other: "moins de {{count}} secondes"
+  },
+  xSeconds: {
+    one: "1 seconde",
+    other: "{{count}} secondes"
+  },
+  halfAMinute: "30 secondes",
+  lessThanXMinutes: {
+    one: "moins d’une minute",
+    other: "moins de {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "environ 1 heure",
+    other: "environ {{count}} heures"
+  },
+  xHours: {
+    one: "1 heure",
+    other: "{{count}} heures"
+  },
+  xDays: {
+    one: "1 jour",
+    other: "{{count}} jours"
+  },
+  aboutXWeeks: {
+    one: "environ 1 semaine",
+    other: "environ {{count}} semaines"
+  },
+  xWeeks: {
+    one: "1 semaine",
+    other: "{{count}} semaines"
+  },
+  aboutXMonths: {
+    one: "environ 1 mois",
+    other: "environ {{count}} mois"
+  },
+  xMonths: {
+    one: "1 mois",
+    other: "{{count}} mois"
+  },
+  aboutXYears: {
+    one: "environ 1 an",
+    other: "environ {{count}} ans"
+  },
+  xYears: {
+    one: "1 an",
+    other: "{{count}} ans"
+  },
+  overXYears: {
+    one: "plus d’un an",
+    other: "plus de {{count}} ans"
+  },
+  almostXYears: {
+    one: "presqu’un an",
+    other: "presque {{count}} ans"
+  }
+}, Se = (r, a, e) => {
+  let t;
+  const n = Ue[r];
+  return typeof n == "string" ? t = n : a === 1 ? t = n.one : t = n.other.replace("{{count}}", String(a)), e?.addSuffix ? e.comparison && e.comparison > 0 ? "dans " + t : "il y a " + t : t;
+}, et = {
+  full: "EEEE d MMMM y",
+  long: "d MMMM y",
+  medium: "d MMM y",
+  short: "dd/MM/y"
+}, tt = {
+  full: "HH:mm:ss zzzz",
+  long: "HH:mm:ss z",
+  medium: "HH:mm:ss",
+  short: "HH:mm"
+}, nt = {
+  full: "{{date}} 'à' {{time}}",
+  long: "{{date}} 'à' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+}, rt = {
+  date: Y({
+    formats: et,
+    defaultWidth: "full"
+  }),
+  time: Y({
+    formats: tt,
+    defaultWidth: "full"
+  }),
+  dateTime: Y({
+    formats: nt,
+    defaultWidth: "full"
+  })
+}, at = {
+  lastWeek: "eeee 'dernier à' p",
+  yesterday: "'hier à' p",
+  today: "'aujourd’hui à' p",
+  tomorrow: "'demain à' p'",
+  nextWeek: "eeee 'prochain à' p",
+  other: "P"
+}, st = (r, a, e, t) => at[r], it = {
+  narrow: ["av. J.-C", "ap. J.-C"],
+  abbreviated: ["av. J.-C", "ap. J.-C"],
+  wide: ["avant Jésus-Christ", "après Jésus-Christ"]
+}, ot = {
+  narrow: ["T1", "T2", "T3", "T4"],
+  abbreviated: ["1er trim.", "2ème trim.", "3ème trim.", "4ème trim."],
+  wide: ["1er trimestre", "2ème trimestre", "3ème trimestre", "4ème trimestre"]
+}, ut = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "janv.",
+    "févr.",
+    "mars",
+    "avr.",
+    "mai",
+    "juin",
+    "juil.",
+    "août",
+    "sept.",
+    "oct.",
+    "nov.",
+    "déc."
+  ],
+  wide: [
+    "janvier",
+    "février",
+    "mars",
+    "avril",
+    "mai",
+    "juin",
+    "juillet",
+    "août",
+    "septembre",
+    "octobre",
+    "novembre",
+    "décembre"
+  ]
+}, ct = {
+  narrow: ["D", "L", "M", "M", "J", "V", "S"],
+  short: ["di", "lu", "ma", "me", "je", "ve", "sa"],
+  abbreviated: ["dim.", "lun.", "mar.", "mer.", "jeu.", "ven.", "sam."],
+  wide: [
+    "dimanche",
+    "lundi",
+    "mardi",
+    "mercredi",
+    "jeudi",
+    "vendredi",
+    "samedi"
+  ]
+}, dt = {
+  narrow: {
+    am: "AM",
+    pm: "PM",
+    midnight: "minuit",
+    noon: "midi",
+    morning: "mat.",
+    afternoon: "ap.m.",
+    evening: "soir",
+    night: "mat."
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "minuit",
+    noon: "midi",
+    morning: "matin",
+    afternoon: "après-midi",
+    evening: "soir",
+    night: "matin"
+  },
+  wide: {
+    am: "AM",
+    pm: "PM",
+    midnight: "minuit",
+    noon: "midi",
+    morning: "du matin",
+    afternoon: "de l’après-midi",
+    evening: "du soir",
+    night: "du matin"
+  }
+}, lt = (r, a) => {
+  const e = Number(r), t = a?.unit;
+  if (e === 0) return "0";
+  const n = ["year", "week", "hour", "minute", "second"];
+  let s;
+  return e === 1 ? s = t && n.includes(t) ? "ère" : "er" : s = "ème", e + s;
+}, mt = ["MMM", "MMMM"], ht = {
+  preprocessor: (r, a) => r.getDate() === 1 || !a.some(
+    (t) => t.isToken && mt.includes(t.value)
+  ) ? a : a.map(
+    (t) => t.isToken && t.value === "do" ? { isToken: !0, value: "d" } : t
+  ),
+  ordinalNumber: lt,
+  era: x({
+    values: it,
+    defaultWidth: "wide"
+  }),
+  quarter: x({
+    values: ot,
+    defaultWidth: "wide",
+    argumentCallback: (r) => r - 1
+  }),
+  month: x({
+    values: ut,
+    defaultWidth: "wide"
+  }),
+  day: x({
+    values: ct,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: x({
+    values: dt,
+    defaultWidth: "wide"
+  })
+}, ft = /^(\d+)(ième|ère|ème|er|e)?/i, wt = /\d+/i, yt = {
+  narrow: /^(av\.J\.C|ap\.J\.C|ap\.J\.-C)/i,
+  abbreviated: /^(av\.J\.-C|av\.J-C|apr\.J\.-C|apr\.J-C|ap\.J-C)/i,
+  wide: /^(avant Jésus-Christ|après Jésus-Christ)/i
+}, bt = {
+  any: [/^av/i, /^ap/i]
+}, pt = {
+  narrow: /^T?[1234]/i,
+  abbreviated: /^[1234](er|ème|e)? trim\.?/i,
+  wide: /^[1234](er|ème|e)? trimestre/i
+}, gt = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, Pt = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(janv|févr|mars|avr|mai|juin|juill|juil|août|sept|oct|nov|déc)\.?/i,
+  wide: /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i
+}, xt = {
+  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,
+    /^av/i,
+    /^ma/i,
+    /^juin/i,
+    /^juil/i,
+    /^ao/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+}, Mt = {
+  narrow: /^[lmjvsd]/i,
+  short: /^(di|lu|ma|me|je|ve|sa)/i,
+  abbreviated: /^(dim|lun|mar|mer|jeu|ven|sam)\.?/i,
+  wide: /^(dimanche|lundi|mardi|mercredi|jeudi|vendredi|samedi)/i
+}, kt = {
+  narrow: [/^d/i, /^l/i, /^m/i, /^m/i, /^j/i, /^v/i, /^s/i],
+  any: [/^di/i, /^lu/i, /^ma/i, /^me/i, /^je/i, /^ve/i, /^sa/i]
+}, vt = {
+  narrow: /^(a|p|minuit|midi|mat\.?|ap\.?m\.?|soir|nuit)/i,
+  any: /^([ap]\.?\s?m\.?|du matin|de l'après[-\s]midi|du soir|de la nuit)/i
+}, Tt = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^min/i,
+    noon: /^mid/i,
+    morning: /mat/i,
+    afternoon: /ap/i,
+    evening: /soir/i,
+    night: /nuit/i
+  }
+}, Dt = {
+  ordinalNumber: J({
+    matchPattern: ft,
+    parsePattern: wt,
+    valueCallback: (r) => parseInt(r)
+  }),
+  era: M({
+    matchPatterns: yt,
+    defaultMatchWidth: "wide",
+    parsePatterns: bt,
+    defaultParseWidth: "any"
+  }),
+  quarter: M({
+    matchPatterns: pt,
+    defaultMatchWidth: "wide",
+    parsePatterns: gt,
+    defaultParseWidth: "any",
+    valueCallback: (r) => r + 1
+  }),
+  month: M({
+    matchPatterns: Pt,
+    defaultMatchWidth: "wide",
+    parsePatterns: xt,
+    defaultParseWidth: "any"
+  }),
+  day: M({
+    matchPatterns: Mt,
+    defaultMatchWidth: "wide",
+    parsePatterns: kt,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: M({
+    matchPatterns: vt,
+    defaultMatchWidth: "any",
+    parsePatterns: Tt,
+    defaultParseWidth: "any"
+  })
+}, Yn = {
+  code: "fr",
+  formatDistance: Se,
+  formatLong: rt,
+  formatRelative: st,
+  localize: ht,
+  match: Dt,
+  options: {
+    weekStartsOn: 1,
+    firstWeekContainsDate: 4
+  }
+};
+function Wt() {
+  return Object.assign({}, C());
+}
+function Yt(r, a) {
+  const e = Ot(a) ? new a(0) : y(a, 0);
+  return e.setFullYear(r.getFullYear(), r.getMonth(), r.getDate()), e.setHours(
+    r.getHours(),
+    r.getMinutes(),
+    r.getSeconds(),
+    r.getMilliseconds()
+  ), e;
+}
+function Ot(r) {
+  return typeof r == "function" && r.prototype?.constructor === r;
+}
+const _t = 10;
+class Z {
+  constructor() {
+    i(this, "subPriority", 0);
+  }
+  validate(a, e) {
+    return !0;
+  }
+}
+class Ct extends Z {
+  constructor(a, e, t, n, s) {
+    super(), this.value = a, this.validateValue = e, this.setValue = t, this.priority = n, s && (this.subPriority = s);
+  }
+  validate(a, e) {
+    return this.validateValue(a, this.value, e);
+  }
+  set(a, e, t) {
+    return this.setValue(a, e, this.value, t);
+  }
+}
+class Ht extends Z {
+  constructor(e, t) {
+    super();
+    i(this, "priority", _t);
+    i(this, "subPriority", -1);
+    this.context = e || ((n) => y(t, n));
+  }
+  set(e, t) {
+    return t.timestampIsSet ? e : y(e, Yt(e, this.context));
+  }
+}
+class c {
+  run(a, e, t, n) {
+    const s = this.parse(a, e, t, n);
+    return s ? {
+      setter: new Ct(
+        s.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: s.rest
+    } : null;
+  }
+  validate(a, e, t) {
+    return !0;
+  }
+}
+class Et extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 140);
+    i(this, "incompatibleTokens", ["R", "u", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return n.era(e, { width: "abbreviated" }) || n.era(e, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return n.era(e, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return n.era(e, { width: "wide" }) || n.era(e, { width: "abbreviated" }) || n.era(e, { width: "narrow" });
+    }
+  }
+  set(e, t, n) {
+    return t.era = n, e.setFullYear(n, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+const f = {
+  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
+}, k = {
+  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 w(r, a) {
+  return r && {
+    value: a(r.value),
+    rest: r.rest
+  };
+}
+function l(r, a) {
+  const e = a.match(r);
+  return e ? {
+    value: parseInt(e[0], 10),
+    rest: a.slice(e[0].length)
+  } : null;
+}
+function v(r, a) {
+  const e = a.match(r);
+  if (!e)
+    return null;
+  if (e[0] === "Z")
+    return {
+      value: 0,
+      rest: a.slice(1)
+    };
+  const t = e[1] === "+" ? 1 : -1, n = 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: t * (n * je + s * Ie + o * Le),
+    rest: a.slice(e[0].length)
+  };
+}
+function K(r) {
+  return l(f.anyDigitsSigned, r);
+}
+function h(r, a) {
+  switch (r) {
+    case 1:
+      return l(f.singleDigit, a);
+    case 2:
+      return l(f.twoDigits, a);
+    case 3:
+      return l(f.threeDigits, a);
+    case 4:
+      return l(f.fourDigits, a);
+    default:
+      return l(new RegExp("^\\d{1," + r + "}"), a);
+  }
+}
+function H(r, a) {
+  switch (r) {
+    case 1:
+      return l(f.singleDigitSigned, a);
+    case 2:
+      return l(f.twoDigitsSigned, a);
+    case 3:
+      return l(f.threeDigitsSigned, a);
+    case 4:
+      return l(f.fourDigitsSigned, a);
+    default:
+      return l(new RegExp("^-?\\d{1," + r + "}"), a);
+  }
+}
+function N(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 U(r, a) {
+  const e = a > 0, t = e ? a : 1 - a;
+  let n;
+  if (t <= 50)
+    n = r || 100;
+  else {
+    const s = t + 50, o = Math.trunc(s / 100) * 100, d = r >= s % 100;
+    n = r + o - (d ? 100 : 0);
+  }
+  return e ? n : 1 - n;
+}
+function S(r) {
+  return r % 400 === 0 || r % 4 === 0 && r % 100 !== 0;
+}
+class qt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 130);
+    i(this, "incompatibleTokens", ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(e, t, n) {
+    const s = (o) => ({
+      year: o,
+      isTwoDigitYear: t === "yy"
+    });
+    switch (t) {
+      case "y":
+        return w(h(4, e), s);
+      case "yo":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "year"
+          }),
+          s
+        );
+      default:
+        return w(h(t.length, e), s);
+    }
+  }
+  validate(e, t) {
+    return t.isTwoDigitYear || t.year > 0;
+  }
+  set(e, t, n) {
+    const s = e.getFullYear();
+    if (n.isTwoDigitYear) {
+      const d = U(
+        n.year,
+        s
+      );
+      return e.setFullYear(d, 0, 1), e.setHours(0, 0, 0, 0), e;
+    }
+    const o = !("era" in t) || t.era === 1 ? n.year : 1 - n.year;
+    return e.setFullYear(o, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Nt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 130);
+    i(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    const s = (o) => ({
+      year: o,
+      isTwoDigitYear: t === "YY"
+    });
+    switch (t) {
+      case "Y":
+        return w(h(4, e), s);
+      case "Yo":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "year"
+          }),
+          s
+        );
+      default:
+        return w(h(t.length, e), s);
+    }
+  }
+  validate(e, t) {
+    return t.isTwoDigitYear || t.year > 0;
+  }
+  set(e, t, n, s) {
+    const o = B(e, s);
+    if (n.isTwoDigitYear) {
+      const b = U(
+        n.year,
+        o
+      );
+      return e.setFullYear(
+        b,
+        0,
+        s.firstWeekContainsDate
+      ), e.setHours(0, 0, 0, 0), T(e, s);
+    }
+    const d = !("era" in t) || t.era === 1 ? n.year : 1 - n.year;
+    return e.setFullYear(d, 0, s.firstWeekContainsDate), e.setHours(0, 0, 0, 0), T(e, s);
+  }
+}
+class Ft extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 130);
+    i(this, "incompatibleTokens", [
+      "G",
+      "y",
+      "Y",
+      "u",
+      "Q",
+      "q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t) {
+    return H(t === "R" ? 4 : t.length, e);
+  }
+  set(e, t, n) {
+    const s = y(e, 0);
+    return s.setFullYear(n, 0, 4), s.setHours(0, 0, 0, 0), O(s);
+  }
+}
+class It extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 130);
+    i(this, "incompatibleTokens", ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"]);
+  }
+  parse(e, t) {
+    return H(t === "u" ? 4 : t.length, e);
+  }
+  set(e, t, n) {
+    return e.setFullYear(n, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class jt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 120);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return h(t.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return n.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return n.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return n.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return n.quarter(e, {
+          width: "wide",
+          context: "formatting"
+        }) || n.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 4;
+  }
+  set(e, t, n) {
+    return e.setMonth((n - 1) * 3, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Lt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 120);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return h(t.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return n.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return n.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return n.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return n.quarter(e, {
+          width: "wide",
+          context: "standalone"
+        }) || n.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 4;
+  }
+  set(e, t, n) {
+    return e.setMonth((n - 1) * 3, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Rt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "L",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+    i(this, "priority", 110);
+  }
+  parse(e, t, n) {
+    const s = (o) => o - 1;
+    switch (t) {
+      // 1, 2, ..., 12
+      case "M":
+        return w(
+          l(f.month, e),
+          s
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return w(h(2, e), s);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "month"
+          }),
+          s
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return n.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.month(e, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return n.month(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return n.month(e, { width: "wide", context: "formatting" }) || n.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.month(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, n) {
+    return e.setMonth(n, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class $t extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 110);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    const s = (o) => o - 1;
+    switch (t) {
+      // 1, 2, ..., 12
+      case "L":
+        return w(
+          l(f.month, e),
+          s
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return w(h(2, e), s);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "month"
+          }),
+          s
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return n.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.month(e, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return n.month(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return n.month(e, { width: "wide", context: "standalone" }) || n.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.month(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, n) {
+    return e.setMonth(n, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+function Qt(r, a, e) {
+  const t = g(r, e?.in), n = Xe(t, e) - a;
+  return t.setDate(t.getDate() - n * 7), g(t, e?.in);
+}
+class At extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 100);
+    i(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "i",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "w":
+        return l(f.week, e);
+      case "wo":
+        return n.ordinalNumber(e, { unit: "week" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 53;
+  }
+  set(e, t, n, s) {
+    return T(Qt(e, n, s), s);
+  }
+}
+function Xt(r, a, e) {
+  const t = g(r, e?.in), n = Qe(t, e) - a;
+  return t.setDate(t.getDate() - n * 7), t;
+}
+class Jt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 100);
+    i(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "I":
+        return l(f.week, e);
+      case "Io":
+        return n.ordinalNumber(e, { unit: "week" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 53;
+  }
+  set(e, t, n) {
+    return O(Xt(e, n));
+  }
+}
+const zt = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Vt = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class Bt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "subPriority", 1);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "d":
+        return l(f.date, e);
+      case "do":
+        return n.ordinalNumber(e, { unit: "date" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    const n = e.getFullYear(), s = S(n), o = e.getMonth();
+    return s ? t >= 1 && t <= Vt[o] : t >= 1 && t <= zt[o];
+  }
+  set(e, t, n) {
+    return e.setDate(n), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Gt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "subpriority", 1);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "E",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "D":
+      case "DD":
+        return l(f.dayOfYear, e);
+      case "Do":
+        return n.ordinalNumber(e, { unit: "date" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    const n = e.getFullYear();
+    return S(n) ? t >= 1 && t <= 366 : t >= 1 && t <= 365;
+  }
+  set(e, t, n) {
+    return e.setMonth(0, n), e.setHours(0, 0, 0, 0), e;
+  }
+}
+function ee(r, a, e) {
+  const t = g(r, e?.in);
+  return isNaN(a) ? y(e?.in || r, NaN) : (a && t.setDate(t.getDate() + a), t);
+}
+function F(r, a, e) {
+  const t = C(), n = e?.weekStartsOn ?? e?.locale?.options?.weekStartsOn ?? t.weekStartsOn ?? t.locale?.options?.weekStartsOn ?? 0, s = g(r, e?.in), o = s.getDay(), b = (a % 7 + 7) % 7, p = 7 - n, D = a < 0 || a > 6 ? a - (o + p) % 7 : (b + p) % 7 - (o + p) % 7;
+  return ee(s, D, e);
+}
+class Zt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return n.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return n.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "EEEE":
+      default:
+        return n.day(e, { width: "wide", context: "formatting" }) || n.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, n, s) {
+    return e = F(e, n, s), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Kt extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n, s) {
+    const o = (d) => {
+      const b = Math.floor((d - 1) / 7) * 7;
+      return (d + s.weekStartsOn + 6) % 7 + b;
+    };
+    switch (t) {
+      // 3
+      case "e":
+      case "ee":
+        return w(h(t.length, e), o);
+      // 3rd
+      case "eo":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "day"
+          }),
+          o
+        );
+      // Tue
+      case "eee":
+        return n.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return n.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+      // Tuesday
+      case "eeee":
+      default:
+        return n.day(e, { width: "wide", context: "formatting" }) || n.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.day(e, { width: "short", context: "formatting" }) || n.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, n, s) {
+    return e = F(e, n, s), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Ut extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "incompatibleTokens", [
+      "y",
+      "R",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "I",
+      "d",
+      "D",
+      "E",
+      "i",
+      "e",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n, s) {
+    const o = (d) => {
+      const b = Math.floor((d - 1) / 7) * 7;
+      return (d + s.weekStartsOn + 6) % 7 + b;
+    };
+    switch (t) {
+      // 3
+      case "c":
+      case "cc":
+        return w(h(t.length, e), o);
+      // 3rd
+      case "co":
+        return w(
+          n.ordinalNumber(e, {
+            unit: "day"
+          }),
+          o
+        );
+      // Tue
+      case "ccc":
+        return n.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.day(e, { width: "short", context: "standalone" }) || n.day(e, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return n.day(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return n.day(e, { width: "short", context: "standalone" }) || n.day(e, { width: "narrow", context: "standalone" });
+      // Tuesday
+      case "cccc":
+      default:
+        return n.day(e, { width: "wide", context: "standalone" }) || n.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || n.day(e, { width: "short", context: "standalone" }) || n.day(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, n, s) {
+    return e = F(e, n, s), e.setHours(0, 0, 0, 0), e;
+  }
+}
+function St(r, a) {
+  const e = g(r, a?.in).getDay();
+  return e === 0 ? 7 : e;
+}
+function en(r, a, e) {
+  const t = g(r, e?.in), n = St(t, e), s = a - n;
+  return ee(t, s, e);
+}
+class tn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "incompatibleTokens", [
+      "y",
+      "Y",
+      "u",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "d",
+      "D",
+      "E",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(e, t, n) {
+    const s = (o) => o === 0 ? 7 : o;
+    switch (t) {
+      // 2
+      case "i":
+      case "ii":
+        return h(t.length, e);
+      // 2nd
+      case "io":
+        return n.ordinalNumber(e, { unit: "day" });
+      // Tue
+      case "iii":
+        return w(
+          n.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      // T
+      case "iiiii":
+        return w(
+          n.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      // Tu
+      case "iiiiii":
+        return w(
+          n.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      // Tuesday
+      case "iiii":
+      default:
+        return w(
+          n.day(e, {
+            width: "wide",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || n.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 7;
+  }
+  set(e, t, n) {
+    return e = en(e, n), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class nn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 80);
+    i(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return n.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, n) {
+    return e.setHours(N(n), 0, 0, 0), e;
+  }
+}
+class rn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 80);
+    i(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return n.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, n) {
+    return e.setHours(N(n), 0, 0, 0), e;
+  }
+}
+class an extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 80);
+    i(this, "incompatibleTokens", ["a", "b", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return n.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || n.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, n) {
+    return e.setHours(N(n), 0, 0, 0), e;
+  }
+}
+class sn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 70);
+    i(this, "incompatibleTokens", ["H", "K", "k", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "h":
+        return l(f.hour12h, e);
+      case "ho":
+        return n.ordinalNumber(e, { unit: "hour" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 12;
+  }
+  set(e, t, n) {
+    const s = e.getHours() >= 12;
+    return s && n < 12 ? e.setHours(n + 12, 0, 0, 0) : !s && n === 12 ? e.setHours(0, 0, 0, 0) : e.setHours(n, 0, 0, 0), e;
+  }
+}
+class on extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 70);
+    i(this, "incompatibleTokens", ["a", "b", "h", "K", "k", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "H":
+        return l(f.hour23h, e);
+      case "Ho":
+        return n.ordinalNumber(e, { unit: "hour" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 23;
+  }
+  set(e, t, n) {
+    return e.setHours(n, 0, 0, 0), e;
+  }
+}
+class un extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 70);
+    i(this, "incompatibleTokens", ["h", "H", "k", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "K":
+        return l(f.hour11h, e);
+      case "Ko":
+        return n.ordinalNumber(e, { unit: "hour" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, n) {
+    return e.getHours() >= 12 && n < 12 ? e.setHours(n + 12, 0, 0, 0) : e.setHours(n, 0, 0, 0), e;
+  }
+}
+class cn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 70);
+    i(this, "incompatibleTokens", ["a", "b", "h", "H", "K", "t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "k":
+        return l(f.hour24h, e);
+      case "ko":
+        return n.ordinalNumber(e, { unit: "hour" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 24;
+  }
+  set(e, t, n) {
+    const s = n <= 24 ? n % 24 : n;
+    return e.setHours(s, 0, 0, 0), e;
+  }
+}
+class dn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 60);
+    i(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "m":
+        return l(f.minute, e);
+      case "mo":
+        return n.ordinalNumber(e, { unit: "minute" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 59;
+  }
+  set(e, t, n) {
+    return e.setMinutes(n, 0, 0), e;
+  }
+}
+class ln extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 50);
+    i(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(e, t, n) {
+    switch (t) {
+      case "s":
+        return l(f.second, e);
+      case "so":
+        return n.ordinalNumber(e, { unit: "second" });
+      default:
+        return h(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 59;
+  }
+  set(e, t, n) {
+    return e.setSeconds(n, 0), e;
+  }
+}
+class mn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 30);
+    i(this, "incompatibleTokens", ["t", "T"]);
+  }
+  parse(e, t) {
+    const n = (s) => Math.trunc(s * Math.pow(10, -t.length + 3));
+    return w(h(t.length, e), n);
+  }
+  set(e, t, n) {
+    return e.setMilliseconds(n), e;
+  }
+}
+class hn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 10);
+    i(this, "incompatibleTokens", ["t", "T", "x"]);
+  }
+  parse(e, t) {
+    switch (t) {
+      case "X":
+        return v(
+          k.basicOptionalMinutes,
+          e
+        );
+      case "XX":
+        return v(k.basic, e);
+      case "XXXX":
+        return v(
+          k.basicOptionalSeconds,
+          e
+        );
+      case "XXXXX":
+        return v(
+          k.extendedOptionalSeconds,
+          e
+        );
+      case "XXX":
+      default:
+        return v(k.extended, e);
+    }
+  }
+  set(e, t, n) {
+    return t.timestampIsSet ? e : y(
+      e,
+      e.getTime() - V(e) - n
+    );
+  }
+}
+class fn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 10);
+    i(this, "incompatibleTokens", ["t", "T", "X"]);
+  }
+  parse(e, t) {
+    switch (t) {
+      case "x":
+        return v(
+          k.basicOptionalMinutes,
+          e
+        );
+      case "xx":
+        return v(k.basic, e);
+      case "xxxx":
+        return v(
+          k.basicOptionalSeconds,
+          e
+        );
+      case "xxxxx":
+        return v(
+          k.extendedOptionalSeconds,
+          e
+        );
+      case "xxx":
+      default:
+        return v(k.extended, e);
+    }
+  }
+  set(e, t, n) {
+    return t.timestampIsSet ? e : y(
+      e,
+      e.getTime() - V(e) - n
+    );
+  }
+}
+class wn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 40);
+    i(this, "incompatibleTokens", "*");
+  }
+  parse(e) {
+    return K(e);
+  }
+  set(e, t, n) {
+    return [y(e, n * 1e3), { timestampIsSet: !0 }];
+  }
+}
+class yn extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 20);
+    i(this, "incompatibleTokens", "*");
+  }
+  parse(e) {
+    return K(e);
+  }
+  set(e, t, n) {
+    return [y(e, n), { timestampIsSet: !0 }];
+  }
+}
+const bn = {
+  G: new Et(),
+  y: new qt(),
+  Y: new Nt(),
+  R: new Ft(),
+  u: new It(),
+  Q: new jt(),
+  q: new Lt(),
+  M: new Rt(),
+  L: new $t(),
+  w: new At(),
+  I: new Jt(),
+  d: new Bt(),
+  D: new Gt(),
+  E: new Zt(),
+  e: new Kt(),
+  c: new Ut(),
+  i: new tn(),
+  a: new nn(),
+  b: new rn(),
+  B: new an(),
+  h: new sn(),
+  H: new on(),
+  K: new un(),
+  k: new cn(),
+  m: new dn(),
+  s: new ln(),
+  S: new mn(),
+  X: new hn(),
+  x: new fn(),
+  t: new wn(),
+  T: new yn()
+}, pn = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, gn = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, Pn = /^'([^]*?)'?$/, xn = /''/g, Mn = /\S/, kn = /[a-zA-Z]/;
+function On(r, a, e, t) {
+  const n = () => y(t?.in || e, NaN), s = Wt(), o = t?.locale ?? s.locale ?? Ne, d = t?.firstWeekContainsDate ?? t?.locale?.options?.firstWeekContainsDate ?? s.firstWeekContainsDate ?? s.locale?.options?.firstWeekContainsDate ?? 1, b = t?.weekStartsOn ?? t?.locale?.options?.weekStartsOn ?? s.weekStartsOn ?? s.locale?.options?.weekStartsOn ?? 0;
+  if (!a)
+    return r ? n() : g(e, t?.in);
+  const p = {
+    firstWeekContainsDate: d,
+    weekStartsOn: b,
+    locale: o
+  }, D = [new Ht(t?.in, e)], _ = a.match(gn).map((u) => {
+    const m = u[0];
+    if (m in A) {
+      const P = A[m];
+      return P(u, o.formatLong);
+    }
+    return u;
+  }).join("").match(pn), E = [];
+  for (let u of _) {
+    !t?.useAdditionalWeekYearTokens && Ze(u) && X(u, a, r), !t?.useAdditionalDayOfYearTokens && Ge(u) && X(u, a, r);
+    const m = u[0], P = bn[m];
+    if (P) {
+      const { incompatibleTokens: j } = P;
+      if (Array.isArray(j)) {
+        const L = E.find(
+          (R) => j.includes(R.token) || R.token === m
+        );
+        if (L)
+          throw new RangeError(
+            `The format string mustn't contain \`${L.fullToken}\` and \`${u}\` at the same time`
+          );
+      } else if (P.incompatibleTokens === "*" && E.length > 0)
+        throw new RangeError(
+          `The format string mustn't contain \`${u}\` and any other token at the same time`
+        );
+      E.push({ token: m, fullToken: u });
+      const q = P.run(
+        r,
+        u,
+        o.match,
+        p
+      );
+      if (!q)
+        return n();
+      D.push(q.setter), r = q.rest;
+    } else {
+      if (m.match(kn))
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + m + "`"
+        );
+      if (u === "''" ? u = "'" : m === "'" && (u = vn(u)), r.indexOf(u) === 0)
+        r = r.slice(u.length);
+      else
+        return n();
+    }
+  }
+  if (r.length > 0 && Mn.test(r))
+    return n();
+  const te = D.map((u) => u.priority).sort((u, m) => m - u).filter((u, m, P) => P.indexOf(u) === m).map(
+    (u) => D.filter((m) => m.priority === u).sort((m, P) => P.subPriority - m.subPriority)
+  ).map((u) => u[0]);
+  let W = g(e, t?.in);
+  if (isNaN(+W)) return n();
+  const I = {};
+  for (const u of te) {
+    if (!u.validate(W, p))
+      return n();
+    const m = u.set(W, I, p);
+    Array.isArray(m) ? (W = m[0], Object.assign(I, m[1])) : W = m;
+  }
+  return W;
+}
+function vn(r) {
+  return r.match(Pn)[1].replace(xn, "'");
+}
+export {
+  Wn as a,
+  Qe as b,
+  y as c,
+  Xe as d,
+  Re as e,
+  B as f,
+  V as g,
+  C as h,
+  Ne as i,
+  Ze as j,
+  Ge as k,
+  A as l,
+  Dn as m,
+  je as n,
+  Ie as o,
+  On as p,
+  Yn as q,
+  g as t,
+  X as w
+};