@adyen/bento-vue2 1.102.0 → 1.103.0

package/dist/chunks/use-date-input-formatter.DXwvH7B0.js

@@ -0,0 +1,1629 @@
+import { C as U, y as I, l as J } from "./calendar.BoFWdxN7.js";
+import { computed as C } from "vue";
+import { t as x, c as p, s as L, g as E, u as S, r as ee, v as te, k as Q, j as re } from "./en-US.BR6y7foR.js";
+import { s as T } from "./startOfWeek.muMEhS7U.js";
+const A = U.MONDAY, se = A, kt = (s) => ({
+  resolvedFirstDayOfWeek: C(() => s.value ?? se ?? A)
+});
+function k(s, e) {
+  return T(s, { ...e, weekStartsOn: 1 });
+}
+function ne(s, e) {
+  const t = x(s, e?.in), r = t.getFullYear(), n = p(t, 0);
+  n.setFullYear(r + 1, 0, 4), n.setHours(0, 0, 0, 0);
+  const a = k(n), o = p(t, 0);
+  o.setFullYear(r, 0, 4), o.setHours(0, 0, 0, 0);
+  const u = k(o);
+  return t.getTime() >= a.getTime() ? r + 1 : t.getTime() >= u.getTime() ? r : r - 1;
+}
+function ae(s, e) {
+  const t = ne(s, e), r = p(s, 0);
+  return r.setFullYear(t, 0, 4), r.setHours(0, 0, 0, 0), k(r);
+}
+function oe(s, e) {
+  const t = x(s, e?.in), r = +k(t) - +ae(t);
+  return Math.round(r / L) + 1;
+}
+function B(s, e) {
+  const t = x(s, e?.in), r = t.getFullYear(), n = E(), a = e?.firstWeekContainsDate ?? e?.locale?.options?.firstWeekContainsDate ?? n.firstWeekContainsDate ?? n.locale?.options?.firstWeekContainsDate ?? 1, o = p(e?.in || s, 0);
+  o.setFullYear(r + 1, 0, a), o.setHours(0, 0, 0, 0);
+  const u = T(o, e), y = p(e?.in || s, 0);
+  y.setFullYear(r, 0, a), y.setHours(0, 0, 0, 0);
+  const m = T(y, e);
+  return +t >= +u ? r + 1 : +t >= +m ? r : r - 1;
+}
+function ie(s, e) {
+  const t = E(), r = e?.firstWeekContainsDate ?? e?.locale?.options?.firstWeekContainsDate ?? t.firstWeekContainsDate ?? t.locale?.options?.firstWeekContainsDate ?? 1, n = B(s, e), a = p(e?.in || s, 0);
+  return a.setFullYear(n, 0, r), a.setHours(0, 0, 0, 0), T(a, e);
+}
+function ce(s, e) {
+  const t = x(s, e?.in), r = +T(t, e) - +ie(t, e);
+  return Math.round(r / L) + 1;
+}
+const $ = (s, e) => {
+  switch (s) {
+    case "P":
+      return e.date({ width: "short" });
+    case "PP":
+      return e.date({ width: "medium" });
+    case "PPP":
+      return e.date({ width: "long" });
+    default:
+      return e.date({ width: "full" });
+  }
+}, G = (s, e) => {
+  switch (s) {
+    case "p":
+      return e.time({ width: "short" });
+    case "pp":
+      return e.time({ width: "medium" });
+    case "ppp":
+      return e.time({ width: "long" });
+    default:
+      return e.time({ width: "full" });
+  }
+}, ue = (s, e) => {
+  const t = s.match(/(P+)(p+)?/) || [], r = t[1], n = t[2];
+  if (!n)
+    return $(s, e);
+  let a;
+  switch (r) {
+    case "P":
+      a = e.dateTime({ width: "short" });
+      break;
+    case "PP":
+      a = e.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      a = e.dateTime({ width: "long" });
+      break;
+    default:
+      a = e.dateTime({ width: "full" });
+      break;
+  }
+  return a.replace("{{date}}", $(r, e)).replace("{{time}}", G(n, e));
+}, R = {
+  p: G,
+  P: ue
+}, le = /^D+$/, de = /^Y+$/, fe = ["D", "DD", "YY", "YYYY"];
+function we(s) {
+  return le.test(s);
+}
+function he(s) {
+  return de.test(s);
+}
+function v(s, e, t) {
+  const r = ye(s, e, t);
+  if (console.warn(r), fe.includes(s)) throw new RangeError(r);
+}
+function ye(s, e, t) {
+  const r = s[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${s.toLowerCase()}\` instead of \`${s}\` (in \`${e}\`) for formatting ${r} to the input \`${t}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+function pe() {
+  return Object.assign({}, E());
+}
+function me(s, e) {
+  const t = x(s, e?.in).getDay();
+  return t === 0 ? 7 : t;
+}
+function xe(s, e) {
+  const t = be(e) ? new e(0) : p(e, 0);
+  return t.setFullYear(s.getFullYear(), s.getMonth(), s.getDate()), t.setHours(
+    s.getHours(),
+    s.getMinutes(),
+    s.getSeconds(),
+    s.getMilliseconds()
+  ), t;
+}
+function be(s) {
+  return typeof s == "function" && s.prototype?.constructor === s;
+}
+const De = 10;
+class X {
+  subPriority = 0;
+  validate(e, t) {
+    return !0;
+  }
+}
+class Ye extends X {
+  constructor(e, t, r, n, a) {
+    super(), this.value = e, this.validateValue = t, this.setValue = r, this.priority = n, a && (this.subPriority = a);
+  }
+  validate(e, t) {
+    return this.validateValue(e, this.value, t);
+  }
+  set(e, t, r) {
+    return this.setValue(e, t, this.value, r);
+  }
+}
+class Te extends X {
+  priority = De;
+  subPriority = -1;
+  constructor(e, t) {
+    super(), this.context = e || ((r) => p(t, r));
+  }
+  set(e, t) {
+    return t.timestampIsSet ? e : p(e, xe(e, this.context));
+  }
+}
+class c {
+  run(e, t, r, n) {
+    const a = this.parse(e, t, r, n);
+    return a ? {
+      setter: new Ye(
+        a.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: a.rest
+    } : null;
+  }
+  validate(e, t, r) {
+    return !0;
+  }
+}
+class ge extends c {
+  priority = 140;
+  parse(e, t, r) {
+    switch (t) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return r.era(e, { width: "abbreviated" }) || r.era(e, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return r.era(e, { width: "narrow" });
+      default:
+        return r.era(e, { width: "wide" }) || r.era(e, { width: "abbreviated" }) || r.era(e, { width: "narrow" });
+    }
+  }
+  set(e, t, r) {
+    return t.era = r, e.setFullYear(r, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+const w = {
+  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
+}, D = {
+  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 h(s, e) {
+  return s && {
+    value: e(s.value),
+    rest: s.rest
+  };
+}
+function l(s, e) {
+  const t = e.match(s);
+  return t ? {
+    value: parseInt(t[0], 10),
+    rest: e.slice(t[0].length)
+  } : null;
+}
+function Y(s, e) {
+  const t = e.match(s);
+  if (!t)
+    return null;
+  if (t[0] === "Z")
+    return {
+      value: 0,
+      rest: e.slice(1)
+    };
+  const r = t[1] === "+" ? 1 : -1, n = t[2] ? parseInt(t[2], 10) : 0, a = t[3] ? parseInt(t[3], 10) : 0, o = t[5] ? parseInt(t[5], 10) : 0;
+  return {
+    value: r * (n * S + a * ee + o * te),
+    rest: e.slice(t[0].length)
+  };
+}
+function K(s) {
+  return l(w.anyDigitsSigned, s);
+}
+function f(s, e) {
+  switch (s) {
+    case 1:
+      return l(w.singleDigit, e);
+    case 2:
+      return l(w.twoDigits, e);
+    case 3:
+      return l(w.threeDigits, e);
+    case 4:
+      return l(w.fourDigits, e);
+    default:
+      return l(new RegExp("^\\d{1," + s + "}"), e);
+  }
+}
+function P(s, e) {
+  switch (s) {
+    case 1:
+      return l(w.singleDigitSigned, e);
+    case 2:
+      return l(w.twoDigitsSigned, e);
+    case 3:
+      return l(w.threeDigitsSigned, e);
+    case 4:
+      return l(w.fourDigitsSigned, e);
+    default:
+      return l(new RegExp("^-?\\d{1," + s + "}"), e);
+  }
+}
+function H(s) {
+  switch (s) {
+    case "morning":
+      return 4;
+    case "evening":
+      return 17;
+    case "pm":
+    case "noon":
+    case "afternoon":
+      return 12;
+    default:
+      return 0;
+  }
+}
+function z(s, e) {
+  const t = e > 0, r = t ? e : 1 - e;
+  let n;
+  if (r <= 50)
+    n = s || 100;
+  else {
+    const a = r + 50, o = Math.trunc(a / 100) * 100, u = s >= a % 100;
+    n = s + o - (u ? 100 : 0);
+  }
+  return t ? n : 1 - n;
+}
+function V(s) {
+  return s % 400 === 0 || s % 4 === 0 && s % 100 !== 0;
+}
+class Me extends c {
+  priority = 130;
+  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+  parse(e, t, r) {
+    const n = (a) => ({
+      year: a,
+      isTwoDigitYear: t === "yy"
+    });
+    switch (t) {
+      case "y":
+        return h(f(4, e), n);
+      case "yo":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "year"
+          }),
+          n
+        );
+      default:
+        return h(f(t.length, e), n);
+    }
+  }
+  validate(e, t) {
+    return t.isTwoDigitYear || t.year > 0;
+  }
+  set(e, t, r) {
+    const n = e.getFullYear();
+    if (r.isTwoDigitYear) {
+      const o = z(
+        r.year,
+        n
+      );
+      return e.setFullYear(o, 0, 1), e.setHours(0, 0, 0, 0), e;
+    }
+    const a = !("era" in t) || t.era === 1 ? r.year : 1 - r.year;
+    return e.setFullYear(a, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class ke extends c {
+  priority = 130;
+  parse(e, t, r) {
+    const n = (a) => ({
+      year: a,
+      isTwoDigitYear: t === "YY"
+    });
+    switch (t) {
+      case "Y":
+        return h(f(4, e), n);
+      case "Yo":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "year"
+          }),
+          n
+        );
+      default:
+        return h(f(t.length, e), n);
+    }
+  }
+  validate(e, t) {
+    return t.isTwoDigitYear || t.year > 0;
+  }
+  set(e, t, r, n) {
+    const a = B(e, n);
+    if (r.isTwoDigitYear) {
+      const u = z(
+        r.year,
+        a
+      );
+      return e.setFullYear(
+        u,
+        0,
+        n.firstWeekContainsDate
+      ), e.setHours(0, 0, 0, 0), T(e, n);
+    }
+    const o = !("era" in t) || t.era === 1 ? r.year : 1 - r.year;
+    return e.setFullYear(o, 0, n.firstWeekContainsDate), e.setHours(0, 0, 0, 0), T(e, n);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+class Pe extends c {
+  priority = 130;
+  parse(e, t) {
+    return P(t === "R" ? 4 : t.length, e);
+  }
+  set(e, t, r) {
+    const n = p(e, 0);
+    return n.setFullYear(r, 0, 4), n.setHours(0, 0, 0, 0), k(n);
+  }
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class _e extends c {
+  priority = 130;
+  parse(e, t) {
+    return P(t === "u" ? 4 : t.length, e);
+  }
+  set(e, t, r) {
+    return e.setFullYear(r, 0, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+class Oe extends c {
+  priority = 120;
+  parse(e, t, r) {
+    switch (t) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return f(t.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return r.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return r.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return r.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.quarter(e, {
+          width: "wide",
+          context: "formatting"
+        }) || r.quarter(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.quarter(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 4;
+  }
+  set(e, t, r) {
+    return e.setMonth((r - 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 Ie extends c {
+  priority = 120;
+  parse(e, t, r) {
+    switch (t) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return f(t.length, e);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return r.ordinalNumber(e, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return r.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return r.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return r.quarter(e, {
+          width: "wide",
+          context: "standalone"
+        }) || r.quarter(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.quarter(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 4;
+  }
+  set(e, t, r) {
+    return e.setMonth((r - 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 Ee extends c {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+  priority = 110;
+  parse(e, t, r) {
+    const n = (a) => a - 1;
+    switch (t) {
+      // 1, 2, ..., 12
+      case "M":
+        return h(
+          l(w.month, e),
+          n
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return h(f(2, e), n);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "month"
+          }),
+          n
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return r.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.month(e, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return r.month(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.month(e, { width: "wide", context: "formatting" }) || r.month(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.month(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, r) {
+    return e.setMonth(r, 1), e.setHours(0, 0, 0, 0), e;
+  }
+}
+class He extends c {
+  priority = 110;
+  parse(e, t, r) {
+    const n = (a) => a - 1;
+    switch (t) {
+      // 1, 2, ..., 12
+      case "L":
+        return h(
+          l(w.month, e),
+          n
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return h(f(2, e), n);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "month"
+          }),
+          n
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return r.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.month(e, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return r.month(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return r.month(e, { width: "wide", context: "standalone" }) || r.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.month(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, r) {
+    return e.setMonth(r, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+function Fe(s, e, t) {
+  const r = x(s, t?.in), n = ce(r, t) - e;
+  return r.setDate(r.getDate() - n * 7), x(r, t?.in);
+}
+class We extends c {
+  priority = 100;
+  parse(e, t, r) {
+    switch (t) {
+      case "w":
+        return l(w.week, e);
+      case "wo":
+        return r.ordinalNumber(e, { unit: "week" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 53;
+  }
+  set(e, t, r, n) {
+    return T(Fe(e, r, n), n);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+function qe(s, e, t) {
+  const r = x(s, t?.in), n = oe(r, t) - e;
+  return r.setDate(r.getDate() - n * 7), r;
+}
+class Ne extends c {
+  priority = 100;
+  parse(e, t, r) {
+    switch (t) {
+      case "I":
+        return l(w.week, e);
+      case "Io":
+        return r.ordinalNumber(e, { unit: "week" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 53;
+  }
+  set(e, t, r) {
+    return k(qe(e, r));
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+const $e = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Re = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class ve extends c {
+  priority = 90;
+  subPriority = 1;
+  parse(e, t, r) {
+    switch (t) {
+      case "d":
+        return l(w.date, e);
+      case "do":
+        return r.ordinalNumber(e, { unit: "date" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    const r = e.getFullYear(), n = V(r), a = e.getMonth();
+    return n ? t >= 1 && t <= Re[a] : t >= 1 && t <= $e[a];
+  }
+  set(e, t, r) {
+    return e.setDate(r), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Ce extends c {
+  priority = 90;
+  subpriority = 1;
+  parse(e, t, r) {
+    switch (t) {
+      case "D":
+      case "DD":
+        return l(w.dayOfYear, e);
+      case "Do":
+        return r.ordinalNumber(e, { unit: "date" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    const r = e.getFullYear();
+    return V(r) ? t >= 1 && t <= 366 : t >= 1 && t <= 365;
+  }
+  set(e, t, r) {
+    return e.setMonth(0, r), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Le extends c {
+  priority = 90;
+  parse(e, t, r) {
+    switch (t) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return r.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return r.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+      default:
+        return r.day(e, { width: "wide", context: "formatting" }) || r.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, r, n) {
+    return e = I(e, r, n), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+class Qe extends c {
+  priority = 90;
+  parse(e, t, r, n) {
+    const a = (o) => {
+      const u = Math.floor((o - 1) / 7) * 7;
+      return (o + n.weekStartsOn + 6) % 7 + u;
+    };
+    switch (t) {
+      // 3
+      case "e":
+      case "ee":
+        return h(f(t.length, e), a);
+      // 3rd
+      case "eo":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "day"
+          }),
+          a
+        );
+      // Tue
+      case "eee":
+        return r.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return r.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+      default:
+        return r.day(e, { width: "wide", context: "formatting" }) || r.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(e, { width: "short", context: "formatting" }) || r.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, r, n) {
+    return e = I(e, r, n), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Ae extends c {
+  priority = 90;
+  parse(e, t, r, n) {
+    const a = (o) => {
+      const u = Math.floor((o - 1) / 7) * 7;
+      return (o + n.weekStartsOn + 6) % 7 + u;
+    };
+    switch (t) {
+      // 3
+      case "c":
+      case "cc":
+        return h(f(t.length, e), a);
+      // 3rd
+      case "co":
+        return h(
+          r.ordinalNumber(e, {
+            unit: "day"
+          }),
+          a
+        );
+      // Tue
+      case "ccc":
+        return r.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.day(e, { width: "short", context: "standalone" }) || r.day(e, { width: "narrow", context: "standalone" });
+      // T
+      case "ccccc":
+        return r.day(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return r.day(e, { width: "short", context: "standalone" }) || r.day(e, { width: "narrow", context: "standalone" });
+      default:
+        return r.day(e, { width: "wide", context: "standalone" }) || r.day(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || r.day(e, { width: "short", context: "standalone" }) || r.day(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 6;
+  }
+  set(e, t, r, n) {
+    return e = I(e, r, n), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "e",
+    "t",
+    "T"
+  ];
+}
+function Be(s, e, t) {
+  const r = x(s, t?.in), n = me(r, t), a = e - n;
+  return J(r, a, t);
+}
+class Ge extends c {
+  priority = 90;
+  parse(e, t, r) {
+    const n = (a) => a === 0 ? 7 : a;
+    switch (t) {
+      // 2
+      case "i":
+      case "ii":
+        return f(t.length, e);
+      // 2nd
+      case "io":
+        return r.ordinalNumber(e, { unit: "day" });
+      // Tue
+      case "iii":
+        return h(
+          r.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          n
+        );
+      // T
+      case "iiiii":
+        return h(
+          r.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          n
+        );
+      // Tu
+      case "iiiiii":
+        return h(
+          r.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          n
+        );
+      default:
+        return h(
+          r.day(e, {
+            width: "wide",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "short",
+            context: "formatting"
+          }) || r.day(e, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          n
+        );
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 7;
+  }
+  set(e, t, r) {
+    return e = Be(e, r), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+class Xe extends c {
+  priority = 80;
+  parse(e, t, r) {
+    switch (t) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, r) {
+    return e.setHours(H(r), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}
+class Ke extends c {
+  priority = 80;
+  parse(e, t, r) {
+    switch (t) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, r) {
+    return e.setHours(H(r), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}
+class ze extends c {
+  priority = 80;
+  parse(e, t, r) {
+    switch (t) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.dayPeriod(e, {
+          width: "wide",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.dayPeriod(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(e, t, r) {
+    return e.setHours(H(r), 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+class Ve extends c {
+  priority = 70;
+  parse(e, t, r) {
+    switch (t) {
+      case "h":
+        return l(w.hour12h, e);
+      case "ho":
+        return r.ordinalNumber(e, { unit: "hour" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 12;
+  }
+  set(e, t, r) {
+    const n = e.getHours() >= 12;
+    return n && r < 12 ? e.setHours(r + 12, 0, 0, 0) : !n && r === 12 ? e.setHours(0, 0, 0, 0) : e.setHours(r, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+class Ze extends c {
+  priority = 70;
+  parse(e, t, r) {
+    switch (t) {
+      case "H":
+        return l(w.hour23h, e);
+      case "Ho":
+        return r.ordinalNumber(e, { unit: "hour" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 23;
+  }
+  set(e, t, r) {
+    return e.setHours(r, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+class je extends c {
+  priority = 70;
+  parse(e, t, r) {
+    switch (t) {
+      case "K":
+        return l(w.hour11h, e);
+      case "Ko":
+        return r.ordinalNumber(e, { unit: "hour" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 11;
+  }
+  set(e, t, r) {
+    return e.getHours() >= 12 && r < 12 ? e.setHours(r + 12, 0, 0, 0) : e.setHours(r, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+class Ue extends c {
+  priority = 70;
+  parse(e, t, r) {
+    switch (t) {
+      case "k":
+        return l(w.hour24h, e);
+      case "ko":
+        return r.ordinalNumber(e, { unit: "hour" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 1 && t <= 24;
+  }
+  set(e, t, r) {
+    const n = r <= 24 ? r % 24 : r;
+    return e.setHours(n, 0, 0, 0), e;
+  }
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+class Je extends c {
+  priority = 60;
+  parse(e, t, r) {
+    switch (t) {
+      case "m":
+        return l(w.minute, e);
+      case "mo":
+        return r.ordinalNumber(e, { unit: "minute" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 59;
+  }
+  set(e, t, r) {
+    return e.setMinutes(r, 0, 0), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class Se extends c {
+  priority = 50;
+  parse(e, t, r) {
+    switch (t) {
+      case "s":
+        return l(w.second, e);
+      case "so":
+        return r.ordinalNumber(e, { unit: "second" });
+      default:
+        return f(t.length, e);
+    }
+  }
+  validate(e, t) {
+    return t >= 0 && t <= 59;
+  }
+  set(e, t, r) {
+    return e.setSeconds(r, 0), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class et extends c {
+  priority = 30;
+  parse(e, t) {
+    const r = (n) => Math.trunc(n * Math.pow(10, -t.length + 3));
+    return h(f(t.length, e), r);
+  }
+  set(e, t, r) {
+    return e.setMilliseconds(r), e;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+class tt extends c {
+  priority = 10;
+  parse(e, t) {
+    switch (t) {
+      case "X":
+        return Y(
+          D.basicOptionalMinutes,
+          e
+        );
+      case "XX":
+        return Y(D.basic, e);
+      case "XXXX":
+        return Y(
+          D.basicOptionalSeconds,
+          e
+        );
+      case "XXXXX":
+        return Y(
+          D.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return Y(D.extended, e);
+    }
+  }
+  set(e, t, r) {
+    return t.timestampIsSet ? e : p(
+      e,
+      e.getTime() - Q(e) - r
+    );
+  }
+  incompatibleTokens = ["t", "T", "x"];
+}
+class rt extends c {
+  priority = 10;
+  parse(e, t) {
+    switch (t) {
+      case "x":
+        return Y(
+          D.basicOptionalMinutes,
+          e
+        );
+      case "xx":
+        return Y(D.basic, e);
+      case "xxxx":
+        return Y(
+          D.basicOptionalSeconds,
+          e
+        );
+      case "xxxxx":
+        return Y(
+          D.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return Y(D.extended, e);
+    }
+  }
+  set(e, t, r) {
+    return t.timestampIsSet ? e : p(
+      e,
+      e.getTime() - Q(e) - r
+    );
+  }
+  incompatibleTokens = ["t", "T", "X"];
+}
+class st extends c {
+  priority = 40;
+  parse(e) {
+    return K(e);
+  }
+  set(e, t, r) {
+    return [p(e, r * 1e3), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+class nt extends c {
+  priority = 20;
+  parse(e) {
+    return K(e);
+  }
+  set(e, t, r) {
+    return [p(e, r), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+const at = {
+  G: new ge(),
+  y: new Me(),
+  Y: new ke(),
+  R: new Pe(),
+  u: new _e(),
+  Q: new Oe(),
+  q: new Ie(),
+  M: new Ee(),
+  L: new He(),
+  w: new We(),
+  I: new Ne(),
+  d: new ve(),
+  D: new Ce(),
+  E: new Le(),
+  e: new Qe(),
+  c: new Ae(),
+  i: new Ge(),
+  a: new Xe(),
+  b: new Ke(),
+  B: new ze(),
+  h: new Ve(),
+  H: new Ze(),
+  K: new je(),
+  k: new Ue(),
+  m: new Je(),
+  s: new Se(),
+  S: new et(),
+  X: new tt(),
+  x: new rt(),
+  t: new st(),
+  T: new nt()
+}, ot = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, it = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, ct = /^'([^]*?)'?$/, ut = /''/g, lt = /\S/, dt = /[a-zA-Z]/;
+function ft(s, e, t, r) {
+  const n = () => p(t, NaN), a = pe(), o = a.locale ?? re, u = a.firstWeekContainsDate ?? a.locale?.options?.firstWeekContainsDate ?? 1, y = a.weekStartsOn ?? a.locale?.options?.weekStartsOn ?? 0;
+  if (!e)
+    return s ? n() : x(t, r?.in);
+  const m = {
+    firstWeekContainsDate: u,
+    weekStartsOn: y,
+    locale: o
+  }, g = [new Te(r?.in, t)], Z = e.match(it).map((i) => {
+    const d = i[0];
+    if (d in R) {
+      const b = R[d];
+      return b(i, o.formatLong);
+    }
+    return i;
+  }).join("").match(ot), _ = [];
+  for (let i of Z) {
+    he(i) && v(i, e, s), we(i) && v(i, e, s);
+    const d = i[0], b = at[d];
+    if (b) {
+      const { incompatibleTokens: W } = b;
+      if (Array.isArray(W)) {
+        const q = _.find(
+          (N) => W.includes(N.token) || N.token === d
+        );
+        if (q)
+          throw new RangeError(
+            `The format string mustn't contain \`${q.fullToken}\` and \`${i}\` at the same time`
+          );
+      } else if (b.incompatibleTokens === "*" && _.length > 0)
+        throw new RangeError(
+          `The format string mustn't contain \`${i}\` and any other token at the same time`
+        );
+      _.push({ token: d, fullToken: i });
+      const O = b.run(
+        s,
+        i,
+        o.match,
+        m
+      );
+      if (!O)
+        return n();
+      g.push(O.setter), s = O.rest;
+    } else {
+      if (d.match(dt))
+        throw new RangeError(
+          "Format string contains an unescaped latin alphabet character `" + d + "`"
+        );
+      if (i === "''" ? i = "'" : d === "'" && (i = wt(i)), s.indexOf(i) === 0)
+        s = s.slice(i.length);
+      else
+        return n();
+    }
+  }
+  if (s.length > 0 && lt.test(s))
+    return n();
+  const j = g.map((i) => i.priority).sort((i, d) => d - i).filter((i, d, b) => b.indexOf(i) === d).map(
+    (i) => g.filter((d) => d.priority === i).sort((d, b) => b.subPriority - d.subPriority)
+  ).map((i) => i[0]);
+  let M = x(t, r?.in);
+  if (isNaN(+M)) return n();
+  const F = {};
+  for (const i of j) {
+    if (!i.validate(M, m))
+      return n();
+    const d = i.set(M, F, m);
+    Array.isArray(d) ? (M = d[0], Object.assign(F, d[1])) : M = d;
+  }
+  return M;
+}
+function wt(s) {
+  return s.match(ct)[1].replace(ut, "'");
+}
+const ht = "YYYY-MM-DD", yt = {
+  "YYYY-MM-DD": /^\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])$/,
+  "DD-MM-YYYY": /^(0?[1-9]|[12][0-9]|3[01])-(0?[1-9]|1[012])-\d{4}$/,
+  "MM-DD-YYYY": /^(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])-\d{4}$/
+}, pt = {
+  "YYYY-MM-DD": "yyyy-MM-dd",
+  "DD-MM-YYYY": "dd-MM-yyyy",
+  "MM-DD-YYYY": "MM-dd-yyyy"
+}, mt = /[\d]/, xt = /[A-Za-z]{2,}/, bt = (s, e) => {
+  const { selectionStart: t } = s.target, r = mt.test(s.key) || xt.test(s.key), n = e === "YYYY-MM-DD" ? t === 4 || t === 7 : t === 2 || t === 5, a = s.key === "-" && n, { ctrlKey: o, shiftKey: u, altKey: y, metaKey: m } = s;
+  !o && !u && !y && !m && !r && !a && s.preventDefault();
+}, Dt = (s, e) => {
+  if (!s)
+    return s;
+  let t = s;
+  const r = t.slice(-1), n = t.length > 1 ? t.slice(-2, -1) : "";
+  if (e === "YYYY-MM-DD") {
+    const a = t.length === 6, o = t.length === 9;
+    (a && parseInt(r, 10) > 1 && n === "-" || o && parseInt(r, 10) > 3 && n === "-") && (t = `${t.slice(0, t.length - 1)}0${r}`), (/^\d{4}$/.test(t) || /^\d{4}-\d{2}$/.test(t)) && (t += "-");
+  } else if (e === "DD-MM-YYYY") {
+    const a = t.length === 1, o = t.length === 4;
+    a && parseInt(r, 10) > 3 ? t = `0${r}` : o && parseInt(r, 10) > 1 && n === "-" && (t = `${t.slice(0, t.length - 1)}0${r}`), (/^\d{2}$/.test(t) || /^\d{2}-\d{2}$/.test(t)) && (t += "-");
+  } else if (e === "MM-DD-YYYY") {
+    const a = t.length === 1, o = t.length === 4;
+    a && parseInt(r, 10) > 1 ? t = `0${r}` : o && parseInt(r, 10) > 3 && n === "-" && (t = `${t.slice(0, t.length - 1)}0${r}`), (/^\d{2}$/.test(t) || /^\d{2}-\d{2}$/.test(t)) && (t += "-");
+  }
+  return t;
+}, Pt = (s = ht) => {
+  const e = C(() => s), t = (u) => yt[e.value].test(u), r = (u) => {
+    if (!u)
+      return /* @__PURE__ */ new Date(NaN);
+    const y = ft(u, pt[e.value], /* @__PURE__ */ new Date());
+    return new Date(y.getFullYear(), y.getMonth(), y.getDate());
+  }, n = (u) => {
+    if (!u)
+      return "";
+    const y = u.getFullYear(), m = (u.getMonth() + 1).toString().padStart(2, "0"), g = u.getDate().toString().padStart(2, "0");
+    return e.value === "DD-MM-YYYY" ? `${g}-${m}-${y}` : e.value === "MM-DD-YYYY" ? `${m}-${g}-${y}` : `${y}-${m}-${g}`;
+  };
+  return {
+    dateFormat: e,
+    isFormatValid: t,
+    parseDate: r,
+    formatDate: n,
+    dateToInputDateString: n,
+    autoFormat: (u) => Dt(u, e.value),
+    onKeyDown: (u) => {
+      bt(u, e.value);
+    }
+  };
+};
+export {
+  kt as a,
+  ce as b,
+  ne as c,
+  B as d,
+  we as e,
+  oe as g,
+  he as i,
+  R as l,
+  Pt as u,
+  v as w
+};
+//# sourceMappingURL=use-date-input-formatter.DXwvH7B0.js.map