@purpur/library 9.9.0 → 9.10.0

package/dist/date-field-DVp_RMNm.mjs

@@ -0,0 +1,1595 @@
+import { jsxs as V, jsx as C } from "react/jsx-runtime";
+import { forwardRef as pe, useState as K, useEffect as Z, useRef as B, useId as U, useLayoutEffect as J } from "react";
+import { T as ye } from "./text-field-D0e-cRbG.mjs";
+import { V as be } from "./visually-hidden-BYFkJEp1.mjs";
+import { c as me } from "./bind-CU-R61T-.mjs";
+import { g as ne, t as M, c as k, m as xe, b as ge, d as Te, f as De, s as X, h as se, i as _e, j as ke, a as oe, k as ae, e as Pe, l as S, n as Me, w as ee, o as Oe, p as Ye, q as Ee } from "./format-CWOXI-dC.mjs";
+function He() {
+  return Object.assign({}, ne());
+}
+function Ie(n, e) {
+  const r = M(n, e?.in).getDay();
+  return r === 0 ? 7 : r;
+}
+function ve(n, e) {
+  const r = qe(e) ? new e(0) : k(e, 0);
+  return r.setFullYear(n.getFullYear(), n.getMonth(), n.getDate()), r.setHours(
+    n.getHours(),
+    n.getMinutes(),
+    n.getSeconds(),
+    n.getMilliseconds()
+  ), r;
+}
+function qe(n) {
+  return typeof n == "function" && n.prototype?.constructor === n;
+}
+const Re = 10;
+class ie {
+  subPriority = 0;
+  validate(e, r) {
+    return !0;
+  }
+}
+class Le extends ie {
+  constructor(e, r, t, s, o) {
+    super(), this.value = e, this.validateValue = r, this.setValue = t, this.priority = s, o && (this.subPriority = o);
+  }
+  validate(e, r) {
+    return this.validateValue(e, this.value, r);
+  }
+  set(e, r, t) {
+    return this.setValue(e, r, this.value, t);
+  }
+}
+class Ne extends ie {
+  priority = Re;
+  subPriority = -1;
+  constructor(e, r) {
+    super(), this.context = e || ((t) => k(r, t));
+  }
+  set(e, r) {
+    return r.timestampIsSet ? e : k(e, ve(e, this.context));
+  }
+}
+class i {
+  run(e, r, t, s) {
+    const o = this.parse(e, r, t, s);
+    return o ? {
+      setter: new Le(
+        o.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: o.rest
+    } : null;
+  }
+  validate(e, r, t) {
+    return !0;
+  }
+}
+class Ce extends i {
+  priority = 140;
+  parse(e, r, t) {
+    switch (r) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return t.era(e, { width: "abbreviated" }) || t.era(e, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return t.era(e, { width: "narrow" });
+      default:
+        return t.era(e, { width: "wide" }) || t.era(e, { width: "abbreviated" }) || t.era(e, { width: "narrow" });
+    }
+  }
+  set(e, r, t) {
+    return r.era = t, e.setFullYear(t, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+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
+}, 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 w(n, e) {
+  return n && {
+    value: e(n.value),
+    rest: n.rest
+  };
+}
+function u(n, e) {
+  const r = e.match(n);
+  return r ? {
+    value: parseInt(r[0], 10),
+    rest: e.slice(r[0].length)
+  } : null;
+}
+function D(n, e) {
+  const r = e.match(n);
+  if (!r)
+    return null;
+  if (r[0] === "Z")
+    return {
+      value: 0,
+      rest: e.slice(1)
+    };
+  const t = r[1] === "+" ? 1 : -1, s = r[2] ? parseInt(r[2], 10) : 0, o = r[3] ? parseInt(r[3], 10) : 0, l = r[5] ? parseInt(r[5], 10) : 0;
+  return {
+    value: t * (s * xe + o * ge + l * Te),
+    rest: e.slice(r[0].length)
+  };
+}
+function ce(n) {
+  return u(f.anyDigitsSigned, n);
+}
+function d(n, e) {
+  switch (n) {
+    case 1:
+      return u(f.singleDigit, e);
+    case 2:
+      return u(f.twoDigits, e);
+    case 3:
+      return u(f.threeDigits, e);
+    case 4:
+      return u(f.fourDigits, e);
+    default:
+      return u(new RegExp("^\\d{1," + n + "}"), e);
+  }
+}
+function Q(n, e) {
+  switch (n) {
+    case 1:
+      return u(f.singleDigitSigned, e);
+    case 2:
+      return u(f.twoDigitsSigned, e);
+    case 3:
+      return u(f.threeDigitsSigned, e);
+    case 4:
+      return u(f.fourDigitsSigned, e);
+    default:
+      return u(new RegExp("^-?\\d{1," + n + "}"), e);
+  }
+}
+function $(n) {
+  switch (n) {
+    case "morning":
+      return 4;
+    case "evening":
+      return 17;
+    case "pm":
+    case "noon":
+    case "afternoon":
+      return 12;
+    default:
+      return 0;
+  }
+}
+function ue(n, e) {
+  const r = e > 0, t = r ? e : 1 - e;
+  let s;
+  if (t <= 50)
+    s = n || 100;
+  else {
+    const o = t + 50, l = Math.trunc(o / 100) * 100, b = n >= o % 100;
+    s = n + l - (b ? 100 : 0);
+  }
+  return r ? s : 1 - s;
+}
+function le(n) {
+  return n % 400 === 0 || n % 4 === 0 && n % 100 !== 0;
+}
+class Qe extends i {
+  priority = 130;
+  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+  parse(e, r, t) {
+    const s = (o) => ({
+      year: o,
+      isTwoDigitYear: r === "yy"
+    });
+    switch (r) {
+      case "y":
+        return w(d(4, e), s);
+      case "yo":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "year"
+          }),
+          s
+        );
+      default:
+        return w(d(r.length, e), s);
+    }
+  }
+  validate(e, r) {
+    return r.isTwoDigitYear || r.year > 0;
+  }
+  set(e, r, t) {
+    const s = e.getFullYear();
+    if (t.isTwoDigitYear) {
+      const l = ue(
+        t.year,
+        s
+      );
+      return e.setFullYear(l, 0, 1), e.setHours(0, 0, 0, 0), e;
+    }
+    const o = !("era" in r) || r.era === 1 ? t.year : 1 - t.year;
+    return e.setFullYear(o, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class Fe extends i {
+  priority = 130;
+  parse(e, r, t) {
+    const s = (o) => ({
+      year: o,
+      isTwoDigitYear: r === "YY"
+    });
+    switch (r) {
+      case "Y":
+        return w(d(4, e), s);
+      case "Yo":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "year"
+          }),
+          s
+        );
+      default:
+        return w(d(r.length, e), s);
+    }
+  }
+  validate(e, r) {
+    return r.isTwoDigitYear || r.year > 0;
+  }
+  set(e, r, t, s) {
+    const o = De(e, s);
+    if (t.isTwoDigitYear) {
+      const b = ue(
+        t.year,
+        o
+      );
+      return e.setFullYear(
+        b,
+        0,
+        s.firstWeekContainsDate
+      ), e.setHours(0, 0, 0, 0), X(e, s);
+    }
+    const l = !("era" in r) || r.era === 1 ? t.year : 1 - t.year;
+    return e.setFullYear(l, 0, s.firstWeekContainsDate), e.setHours(0, 0, 0, 0), X(e, s);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+class We extends i {
+  priority = 130;
+  parse(e, r) {
+    return Q(r === "R" ? 4 : r.length, e);
+  }
+  set(e, r, t) {
+    const s = k(e, 0);
+    return s.setFullYear(t, 0, 4), s.setHours(0, 0, 0, 0), se(s);
+  }
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Be extends i {
+  priority = 130;
+  parse(e, r) {
+    return Q(r === "u" ? 4 : r.length, e);
+  }
+  set(e, r, t) {
+    return e.setFullYear(t, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+class Ae extends i {
+  priority = 120;
+  parse(e, r, t) {
+    switch (r) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return d(r.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return t.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return t.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return t.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.quarter(e, {
+          width: "wide",
+          context: "formatting"
+        }) || t.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 4;
+  }
+  set(e, r, t) {
+    return e.setMonth((t - 1) * 3, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Ge extends i {
+  priority = 120;
+  parse(e, r, t) {
+    switch (r) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return d(r.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return t.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return t.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return t.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return t.quarter(e, {
+          width: "wide",
+          context: "standalone"
+        }) || t.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 4;
+  }
+  set(e, r, t) {
+    return e.setMonth((t - 1) * 3, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Xe extends i {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+  priority = 110;
+  parse(e, r, t) {
+    const s = (o) => o - 1;
+    switch (r) {
+      // 1, 2, ..., 12
+      case "M":
+        return w(
+          u(f.month, e),
+          s
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return w(d(2, e), s);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "month"
+          }),
+          s
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return t.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.month(e, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return t.month(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.month(e, { width: "wide", context: "formatting" }) || t.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.month(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 11;
+  }
+  set(e, r, t) {
+    return e.setMonth(t, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class $e extends i {
+  priority = 110;
+  parse(e, r, t) {
+    const s = (o) => o - 1;
+    switch (r) {
+      // 1, 2, ..., 12
+      case "L":
+        return w(
+          u(f.month, e),
+          s
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return w(d(2, e), s);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "month"
+          }),
+          s
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return t.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.month(e, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return t.month(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return t.month(e, { width: "wide", context: "standalone" }) || t.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.month(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 11;
+  }
+  set(e, r, t) {
+    return e.setMonth(t, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+function ze(n, e, r) {
+  const t = M(n, r?.in), s = _e(t, r) - e;
+  return t.setDate(t.getDate() - s * 7), M(t, r?.in);
+}
+class je extends i {
+  priority = 100;
+  parse(e, r, t) {
+    switch (r) {
+      case "w":
+        return u(f.week, e);
+      case "wo":
+        return t.ordinalNumber(e, { unit: "week" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 53;
+  }
+  set(e, r, t, s) {
+    return X(ze(e, t, s), s);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+function Ve(n, e, r) {
+  const t = M(n, r?.in), s = ke(t, r) - e;
+  return t.setDate(t.getDate() - s * 7), t;
+}
+class Ke extends i {
+  priority = 100;
+  parse(e, r, t) {
+    switch (r) {
+      case "I":
+        return u(f.week, e);
+      case "Io":
+        return t.ordinalNumber(e, { unit: "week" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 53;
+  }
+  set(e, r, t) {
+    return se(Ve(e, t));
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+const Ze = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Ue = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class Je extends i {
+  priority = 90;
+  subPriority = 1;
+  parse(e, r, t) {
+    switch (r) {
+      case "d":
+        return u(f.date, e);
+      case "do":
+        return t.ordinalNumber(e, { unit: "date" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    const t = e.getFullYear(), s = le(t), o = e.getMonth();
+    return s ? r >= 1 && r <= Ue[o] : r >= 1 && r <= Ze[o];
+  }
+  set(e, r, t) {
+    return e.setDate(t), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Se extends i {
+  priority = 90;
+  subpriority = 1;
+  parse(e, r, t) {
+    switch (r) {
+      case "D":
+      case "DD":
+        return u(f.dayOfYear, e);
+      case "Do":
+        return t.ordinalNumber(e, { unit: "date" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    const t = e.getFullYear();
+    return le(t) ? r >= 1 && r <= 366 : r >= 1 && r <= 365;
+  }
+  set(e, r, t) {
+    return e.setMonth(0, t), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+function z(n, e, r) {
+  const t = ne(), s = r?.weekStartsOn ?? r?.locale?.options?.weekStartsOn ?? t.weekStartsOn ?? t.locale?.options?.weekStartsOn ?? 0, o = M(n, r?.in), l = o.getDay(), H = (e % 7 + 7) % 7, y = 7 - s, P = e < 0 || e > 6 ? e - (l + y) % 7 : (H + y) % 7 - (l + y) % 7;
+  return oe(o, P, r);
+}
+class et extends i {
+  priority = 90;
+  parse(e, r, t) {
+    switch (r) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return t.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      default:
+        return t.day(e, { width: "wide", context: "formatting" }) || t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 6;
+  }
+  set(e, r, t, s) {
+    return e = z(e, t, s), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+class tt extends i {
+  priority = 90;
+  parse(e, r, t, s) {
+    const o = (l) => {
+      const b = Math.floor((l - 1) / 7) * 7;
+      return (l + s.weekStartsOn + 6) % 7 + b;
+    };
+    switch (r) {
+      // 3
+      case "e":
+      case "ee":
+        return w(d(r.length, e), o);
+      // 3rd
+      case "eo":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "day"
+          }),
+          o
+        );
+      // Tue
+      case "eee":
+        return t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return t.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      default:
+        return t.day(e, { width: "wide", context: "formatting" }) || t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 6;
+  }
+  set(e, r, t, s) {
+    return e = z(e, t, s), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class rt extends i {
+  priority = 90;
+  parse(e, r, t, s) {
+    const o = (l) => {
+      const b = Math.floor((l - 1) / 7) * 7;
+      return (l + s.weekStartsOn + 6) % 7 + b;
+    };
+    switch (r) {
+      // 3
+      case "c":
+      case "cc":
+        return w(d(r.length, e), o);
+      // 3rd
+      case "co":
+        return w(
+          t.ordinalNumber(e, {
+            unit: "day"
+          }),
+          o
+        );
+      // Tue
+      case "ccc":
+        return t.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.day(e, { width: "short", context: "standalone" }) || t.day(e, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return t.day(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return t.day(e, { width: "short", context: "standalone" }) || t.day(e, { width: "narrow", context: "standalone" });
+      default:
+        return t.day(e, { width: "wide", context: "standalone" }) || t.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.day(e, { width: "short", context: "standalone" }) || t.day(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 6;
+  }
+  set(e, r, t, s) {
+    return e = z(e, t, s), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "e",
+    "t",
+    "T"
+  ];
+}
+function nt(n, e, r) {
+  const t = M(n, r?.in), s = Ie(t, r), o = e - s;
+  return oe(t, o, r);
+}
+class st extends i {
+  priority = 90;
+  parse(e, r, t) {
+    const s = (o) => o === 0 ? 7 : o;
+    switch (r) {
+      // 2
+      case "i":
+      case "ii":
+        return d(r.length, e);
+      // 2nd
+      case "io":
+        return t.ordinalNumber(e, { unit: "day" });
+      // Tue
+      case "iii":
+        return w(
+          t.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      // T
+      case "iiiii":
+        return w(
+          t.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      // Tu
+      case "iiiiii":
+        return w(
+          t.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+      default:
+        return w(
+          t.day(e, {
+            width: "wide",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || t.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          s
+        );
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 7;
+  }
+  set(e, r, t) {
+    return e = nt(e, t), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class ot extends i {
+  priority = 80;
+  parse(e, r, t) {
+    switch (r) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, r, t) {
+    return e.setHours($(t), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}
+class at extends i {
+  priority = 80;
+  parse(e, r, t) {
+    switch (r) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, r, t) {
+    return e.setHours($(t), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}
+class it extends i {
+  priority = 80;
+  parse(e, r, t) {
+    switch (r) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, r, t) {
+    return e.setHours($(t), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+class ct extends i {
+  priority = 70;
+  parse(e, r, t) {
+    switch (r) {
+      case "h":
+        return u(f.hour12h, e);
+      case "ho":
+        return t.ordinalNumber(e, { unit: "hour" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 12;
+  }
+  set(e, r, t) {
+    const s = e.getHours() >= 12;
+    return s && t < 12 ? e.setHours(t + 12, 0, 0, 0) : !s && t === 12 ? e.setHours(0, 0, 0, 0) : e.setHours(t, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+class ut extends i {
+  priority = 70;
+  parse(e, r, t) {
+    switch (r) {
+      case "H":
+        return u(f.hour23h, e);
+      case "Ho":
+        return t.ordinalNumber(e, { unit: "hour" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 23;
+  }
+  set(e, r, t) {
+    return e.setHours(t, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+class lt extends i {
+  priority = 70;
+  parse(e, r, t) {
+    switch (r) {
+      case "K":
+        return u(f.hour11h, e);
+      case "Ko":
+        return t.ordinalNumber(e, { unit: "hour" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 11;
+  }
+  set(e, r, t) {
+    return e.getHours() >= 12 && t < 12 ? e.setHours(t + 12, 0, 0, 0) : e.setHours(t, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+class dt extends i {
+  priority = 70;
+  parse(e, r, t) {
+    switch (r) {
+      case "k":
+        return u(f.hour24h, e);
+      case "ko":
+        return t.ordinalNumber(e, { unit: "hour" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 24;
+  }
+  set(e, r, t) {
+    const s = t <= 24 ? t % 24 : t;
+    return e.setHours(s, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+class ft extends i {
+  priority = 60;
+  parse(e, r, t) {
+    switch (r) {
+      case "m":
+        return u(f.minute, e);
+      case "mo":
+        return t.ordinalNumber(e, { unit: "minute" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 59;
+  }
+  set(e, r, t) {
+    return e.setMinutes(t, 0, 0), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class wt extends i {
+  priority = 50;
+  parse(e, r, t) {
+    switch (r) {
+      case "s":
+        return u(f.second, e);
+      case "so":
+        return t.ordinalNumber(e, { unit: "second" });
+      default:
+        return d(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 59;
+  }
+  set(e, r, t) {
+    return e.setSeconds(t, 0), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class ht extends i {
+  priority = 30;
+  parse(e, r) {
+    const t = (s) => Math.trunc(s * Math.pow(10, -r.length + 3));
+    return w(d(r.length, e), t);
+  }
+  set(e, r, t) {
+    return e.setMilliseconds(t), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class pt extends i {
+  priority = 10;
+  parse(e, r) {
+    switch (r) {
+      case "X":
+        return D(
+          T.basicOptionalMinutes,
+          e
+        );
+      case "XX":
+        return D(T.basic, e);
+      case "XXXX":
+        return D(
+          T.basicOptionalSeconds,
+          e
+        );
+      case "XXXXX":
+        return D(
+          T.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return D(T.extended, e);
+    }
+  }
+  set(e, r, t) {
+    return r.timestampIsSet ? e : k(
+      e,
+      e.getTime() - ae(e) - t
+    );
+  }
+  incompatibleTokens = ["t", "T", "x"];
+}
+class yt extends i {
+  priority = 10;
+  parse(e, r) {
+    switch (r) {
+      case "x":
+        return D(
+          T.basicOptionalMinutes,
+          e
+        );
+      case "xx":
+        return D(T.basic, e);
+      case "xxxx":
+        return D(
+          T.basicOptionalSeconds,
+          e
+        );
+      case "xxxxx":
+        return D(
+          T.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return D(T.extended, e);
+    }
+  }
+  set(e, r, t) {
+    return r.timestampIsSet ? e : k(
+      e,
+      e.getTime() - ae(e) - t
+    );
+  }
+  incompatibleTokens = ["t", "T", "X"];
+}
+class bt extends i {
+  priority = 40;
+  parse(e) {
+    return ce(e);
+  }
+  set(e, r, t) {
+    return [k(e, t * 1e3), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+class mt extends i {
+  priority = 20;
+  parse(e) {
+    return ce(e);
+  }
+  set(e, r, t) {
+    return [k(e, t), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+const xt = {
+  G: new Ce(),
+  y: new Qe(),
+  Y: new Fe(),
+  R: new We(),
+  u: new Be(),
+  Q: new Ae(),
+  q: new Ge(),
+  M: new Xe(),
+  L: new $e(),
+  w: new je(),
+  I: new Ke(),
+  d: new Je(),
+  D: new Se(),
+  E: new et(),
+  e: new tt(),
+  c: new rt(),
+  i: new st(),
+  a: new ot(),
+  b: new at(),
+  B: new it(),
+  h: new ct(),
+  H: new ut(),
+  K: new lt(),
+  k: new dt(),
+  m: new ft(),
+  s: new wt(),
+  S: new ht(),
+  X: new pt(),
+  x: new yt(),
+  t: new bt(),
+  T: new mt()
+}, gt = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, Tt = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, Dt = /^'([^]*?)'?$/, _t = /''/g, kt = /\S/, Pt = /[a-zA-Z]/;
+function Mt(n, e, r, t) {
+  const s = () => k(r, NaN), o = He(), l = o.locale ?? Pe, b = o.firstWeekContainsDate ?? o.locale?.options?.firstWeekContainsDate ?? 1, H = o.weekStartsOn ?? o.locale?.options?.weekStartsOn ?? 0, y = {
+    firstWeekContainsDate: b,
+    weekStartsOn: H,
+    locale: l
+  }, P = [new Ne(t?.in, r)], R = e.match(Tt).map((a) => {
+    const c = a[0];
+    if (c in S) {
+      const m = S[c];
+      return m(a, l.formatLong);
+    }
+    return a;
+  }).join("").match(gt), I = [];
+  for (let a of R) {
+    Me(a) && ee(a, e, n), Oe(a) && ee(a, e, n);
+    const c = a[0], m = xt[c];
+    if (m) {
+      const { incompatibleTokens: N } = m;
+      if (Array.isArray(N)) {
+        const O = I.find(
+          (v) => N.includes(v.token) || v.token === c
+        );
+        if (O)
+          throw new RangeError(
+            `The format string mustn't contain \`${O.fullToken}\` and \`${a}\` at the same time`
+          );
+      } else if (m.incompatibleTokens === "*" && I.length > 0)
+        throw new RangeError(
+          `The format string mustn't contain \`${a}\` and any other token at the same time`
+        );
+      I.push({ token: c, fullToken: a });
+      const _ = m.run(
+        n,
+        a,
+        l.match,
+        y
+      );
+      if (!_)
+        return s();
+      P.push(_.setter), n = _.rest;
+    } else {
+      if (c.match(Pt))
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + c + "`"
+        );
+      if (a === "''" ? a = "'" : c === "'" && (a = Ot(a)), n.indexOf(a) === 0)
+        n = n.slice(a.length);
+      else
+        return s();
+    }
+  }
+  if (n.length > 0 && kt.test(n))
+    return s();
+  const F = P.map((a) => a.priority).sort((a, c) => c - a).filter((a, c, m) => m.indexOf(a) === c).map(
+    (a) => P.filter((c) => c.priority === a).sort((c, m) => m.subPriority - c.subPriority)
+  ).map((a) => a[0]);
+  let h = M(r, t?.in);
+  if (isNaN(+h)) return s();
+  const L = {};
+  for (const a of F) {
+    if (!a.validate(h, y))
+      return s();
+    const c = a.set(h, L, y);
+    Array.isArray(c) ? (h = c[0], Object.assign(L, c[1])) : h = c;
+  }
+  return h;
+}
+function Ot(n) {
+  return n.match(Dt)[1].replace(_t, "'");
+}
+const Yt = {
+  "purpur-date-field": "_purpur-date-field_6j24v_1",
+  "purpur-date-field__overlay": "_purpur-date-field__overlay_6j24v_4",
+  "purpur-date-field__start-adornment": "_purpur-date-field__start-adornment_6j24v_14"
+}, Et = (n) => Mt(n, "yyyy-MM-dd", /* @__PURE__ */ new Date()), te = (n) => n ? Ye(n, "yyyy-MM-dd") : "", Ht = (...n) => {
+  const e = n.filter(Boolean);
+  return e.length <= 1 ? e[0] || null : (r) => {
+    for (const t of e)
+      typeof t == "function" ? t(r) : t && (t.current = r);
+  };
+}, A = me.bind(Yt), G = "purpur-date-field", re = 10, It = {
+  yearChar: "Y",
+  monthChar: "M",
+  dayChar: "D"
+}, vt = (n) => {
+  const e = n ?? It;
+  return `${e.yearChar.repeat(4)}-${e.monthChar.repeat(2)}-${e.dayChar.repeat(2)}`;
+}, qt = (n, e) => {
+  let r = n;
+  return e.length > 4 && n >= 4 && (r += 1), e.length > 7 && n >= 6 && (r += 1), Math.min(r, e.length);
+}, Rt = pe(
+  ({
+    value: n,
+    label: e,
+    onChange: r,
+    startAdornment: t,
+    helperText: s,
+    formatLabel: o,
+    dateChars: l,
+    ...b
+  }, H) => {
+    const [y, P] = K(te(n)), R = vt(l);
+    Z(() => {
+      P(n ? te(n) : "");
+    }, [n]);
+    const [I, F] = K({}), h = B(null), L = Ht(H, h), a = U(), c = U(), m = s ? `${a}-helper-text` : void 0, N = [c, m, b["aria-describedby"]].filter(Boolean).join(" ") || void 0, _ = B(null), O = B(null), v = () => {
+      if (h.current) {
+        const p = window.document.querySelector(
+          `label[for="${h.current.id}"]`
+        ), x = p ? p.offsetHeight + 4 : 0, Y = window.getComputedStyle(h.current);
+        F({
+          position: "absolute",
+          top: h.current.offsetTop + x,
+          left: h.current.offsetLeft,
+          padding: Y.padding,
+          width: h.current.offsetWidth,
+          height: h.current.offsetHeight
+        });
+      }
+    };
+    J(() => {
+      v();
+    }, [y, e, h]), Z(() => {
+      if (!h.current) return;
+      const p = new ResizeObserver(() => {
+        v();
+      });
+      return p.observe(h.current), () => p.disconnect();
+    }, []), J(() => {
+      _.current !== null && h.current && (h.current.setSelectionRange(_.current, _.current), _.current = null);
+    }, [y]);
+    const de = (p) => {
+      if (p.length === 0 && r?.(void 0), p.length !== re)
+        return;
+      const x = Et(p);
+      Ee(x) && r?.(x);
+    }, fe = (p) => {
+      const x = p.currentTarget.selectionStart ?? 0;
+      O.current = y.slice(0, x).replace(/\D/g, "").length;
+    }, we = (p) => {
+      const x = p.target.value, Y = p.target.selectionStart ?? 0, q = y.replace(/\D/g, ""), g = x.replace(/\D/g, "");
+      let E = "";
+      g.length > 0 && (E += g.slice(0, 4)), g.length > 4 && (E += "-" + g.slice(4, 6)), g.length > 6 && (E += "-" + g.slice(6, 8));
+      let W;
+      const j = O.current;
+      j !== null && g.length > q.length ? W = Math.min(j + (g.length - q.length), g.length) : W = Math.min(
+        x.slice(0, Y).replace(/\D/g, "").length,
+        g.length
+      ), O.current = null, _.current = qt(W, E), P(E), de(E);
+    }, he = () => R.split("").map((x, Y) => {
+      const q = y[Y];
+      return /* @__PURE__ */ C(
+        "span",
+        {
+          style: {
+            color: q ? "transparent" : "var(--purpur-color-text-medium)"
+          },
+          children: q || x
+        },
+        Y
+      );
+    });
+    return /* @__PURE__ */ V("div", { className: A(G), children: [
+      /* @__PURE__ */ V(be, { id: c, children: [
+        o,
+        ": ",
+        R
+      ] }),
+      /* @__PURE__ */ C(
+        ye,
+        {
+          ...b,
+          id: a,
+          helperText: s,
+          startAdornment: t && /* @__PURE__ */ C("span", { className: A(`${G}__start-adornment`), children: t }),
+          ref: L,
+          value: y,
+          onChange: we,
+          onKeyDown: fe,
+          type: "text",
+          maxLength: re,
+          inputMode: "numeric",
+          label: e,
+          "aria-describedby": N
+        }
+      ),
+      /* @__PURE__ */ C("div", { role: "presentation", style: I, className: A(`${G}__overlay`), children: he() })
+    ] });
+  }
+);
+Rt.displayName = "DateField";
+export {
+  Rt as D
+};
+//# sourceMappingURL=date-field-DVp_RMNm.mjs.map