react-timelane 0.0.0 → 0.0.1

package/dist/react-timelane.js

@@ -0,0 +1,4744 @@
+import { jsx as v, jsxs as K, Fragment as Se } from "react/jsx-runtime";
+import Rt, { useRef as ce, createContext as Vt, useContext as Qt, useState as G, useEffect as ee, memo as Jt, useCallback as Ke, useMemo as Zt, PureComponent as er } from "react";
+function re({ children: e }) {
+  const t = ce(null);
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      className: "timeline-layout",
+      onWheel: (r) => {
+        t.current && (r.ctrlKey || r.shiftKey) && (t.current.scrollLeft += r.deltaY, r.preventDefault());
+      },
+      ref: t,
+      children: /* @__PURE__ */ v("div", { className: "timeline-layout-inner", children: e })
+    }
+  );
+}
+function tr({ children: e }) {
+  return /* @__PURE__ */ v("div", { className: "timeline-layout-header", children: e });
+}
+function rr({ children: e }) {
+  return /* @__PURE__ */ v("div", { className: "timeline-layout-background", children: e });
+}
+function nr({ children: e }) {
+  return /* @__PURE__ */ v("div", { className: "timeline-layout-body", children: e });
+}
+function ir({ children: e }) {
+  return /* @__PURE__ */ v("div", { className: "timeline-layout-footer", children: e });
+}
+function ar({
+  side: e = "left",
+  children: t
+}) {
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      className: `timeline-layout-aside ${e == "left" ? "timeline-layout-aside-left" : "timeline-layout-aside-right"}`,
+      children: t
+    }
+  );
+}
+function or({
+  corner: e = "top left",
+  children: t
+}) {
+  let r = "";
+  switch (e) {
+    case "top left":
+      r = "timeline-layout-corner-top-left";
+      break;
+    case "top right":
+      r = "timeline-layout-corner-top-right";
+      break;
+    case "bottom left":
+      r = "timeline-layout-corner-bottom-left";
+      break;
+    case "bottom right":
+      r = "timeline-layout-corner-bottom-right";
+      break;
+  }
+  return /* @__PURE__ */ v("div", { className: `timeline-layout-corner ${r}`, children: t });
+}
+re.Header = tr;
+re.Body = nr;
+re.Background = rr;
+re.Footer = ir;
+re.Aside = ar;
+re.Corner = or;
+const sr = {
+  start: new Date(2025, 1, 1),
+  end: new Date(2025, 5, 1),
+  pixelsPerDay: 30,
+  pixelsPerResource: 100,
+  showMonths: !0,
+  showWeeks: !0,
+  showDays: !0,
+  allowOverlaps: !0,
+  focusedDate: null
+}, ur = {
+  settings: sr,
+  setSettings: () => {
+  }
+}, kt = Vt(ur), ge = () => Qt(kt);
+function fa({
+  swimlanes: e,
+  focusedSwimlane: t,
+  setFocusedSwimlane: r = () => {
+  },
+  onSwimlaneHeaderClick: n = () => {
+  },
+  onSwimlaneHeaderDoubleClick: i = () => {
+  },
+  onSwimlaneHeaderContextMenu: a = () => {
+  },
+  renderSwimlaneHeader: u = lr
+}) {
+  const { settings: c } = ge();
+  return /* @__PURE__ */ v("div", { className: "timeline-aside", children: e && e.map((s) => /* @__PURE__ */ v(
+    cr,
+    {
+      height: c.pixelsPerResource,
+      isFocused: t ? t.id === s.id : !1,
+      onClick: (o) => {
+        r(s), n(s, o);
+      },
+      onDoubleClick: (o) => i(s, o),
+      onContextMenu: (o) => a(s, o),
+      children: u(s)
+    },
+    s.id
+  )) });
+}
+function cr({
+  height: e,
+  isFocused: t,
+  onClick: r,
+  onDoubleClick: n,
+  onContextMenu: i,
+  children: a
+}) {
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      className: `timeline-aside-swimlane-header ${t ? "timeline-aside-swimlane-header-focused" : ""}`,
+      style: { height: `${e}px` },
+      onClick: r,
+      onDoubleClick: n,
+      onContextMenu: i,
+      children: a
+    }
+  );
+}
+function lr(e) {
+  return /* @__PURE__ */ v("div", { children: e.id });
+}
+const Nt = 6048e5, dr = 864e5, Ve = Symbol.for("constructDateFrom");
+function W(e, t) {
+  return typeof e == "function" ? e(t) : e && typeof e == "object" && Ve in e ? e[Ve](t) : e instanceof Date ? new e.constructor(t) : new Date(t);
+}
+function N(e, t) {
+  return W(t || e, e);
+}
+function le(e, t, r) {
+  const n = N(e, r == null ? void 0 : r.in);
+  return isNaN(t) ? W(e, NaN) : (t && n.setDate(n.getDate() + t), n);
+}
+function At(e, t) {
+  return N(e, t == null ? void 0 : t.in).getDay() === 0;
+}
+let fr = {};
+function Te() {
+  return fr;
+}
+function j(e, t) {
+  var c, s, o, f;
+  const r = Te(), n = (t == null ? void 0 : t.weekStartsOn) ?? ((s = (c = t == null ? void 0 : t.locale) == null ? void 0 : c.options) == null ? void 0 : s.weekStartsOn) ?? r.weekStartsOn ?? ((f = (o = r.locale) == null ? void 0 : o.options) == null ? void 0 : f.weekStartsOn) ?? 0, i = N(e, t == null ? void 0 : t.in), a = i.getDay(), u = (a < n ? 7 : 0) + a - n;
+  return i.setDate(i.getDate() - u), i.setHours(0, 0, 0, 0), i;
+}
+function Oe(e, t) {
+  return j(e, { ...t, weekStartsOn: 1 });
+}
+function zt(e, t) {
+  const r = N(e, t == null ? void 0 : t.in), n = r.getFullYear(), i = W(r, 0);
+  i.setFullYear(n + 1, 0, 4), i.setHours(0, 0, 0, 0);
+  const a = Oe(i), u = W(r, 0);
+  u.setFullYear(n, 0, 4), u.setHours(0, 0, 0, 0);
+  const c = Oe(u);
+  return r.getTime() >= a.getTime() ? n + 1 : r.getTime() >= c.getTime() ? n : n - 1;
+}
+function Qe(e) {
+  const t = N(e), r = new Date(
+    Date.UTC(
+      t.getFullYear(),
+      t.getMonth(),
+      t.getDate(),
+      t.getHours(),
+      t.getMinutes(),
+      t.getSeconds(),
+      t.getMilliseconds()
+    )
+  );
+  return r.setUTCFullYear(t.getFullYear()), +e - +r;
+}
+function Ie(e, ...t) {
+  const r = W.bind(
+    null,
+    e || t.find((n) => typeof n == "object")
+  );
+  return t.map(r);
+}
+function De(e, t) {
+  const r = N(e, t == null ? void 0 : t.in);
+  return r.setHours(0, 0, 0, 0), r;
+}
+function B(e, t, r) {
+  const [n, i] = Ie(
+    r == null ? void 0 : r.in,
+    e,
+    t
+  ), a = De(n), u = De(i), c = +a - Qe(a), s = +u - Qe(u);
+  return Math.round((c - s) / dr);
+}
+function hr(e, t) {
+  const r = zt(e, t), n = W(e, 0);
+  return n.setFullYear(r, 0, 4), n.setHours(0, 0, 0, 0), Oe(n);
+}
+function gr(e, t, r) {
+  return le(e, t * 7, r);
+}
+function pr(e, t) {
+  let r, n = t == null ? void 0 : t.in;
+  return e.forEach((i) => {
+    !n && typeof i == "object" && (n = W.bind(null, i));
+    const a = N(i, n);
+    (!r || r < a || isNaN(+a)) && (r = a);
+  }), W(n, r || NaN);
+}
+function mr(e, t) {
+  let r, n = t == null ? void 0 : t.in;
+  return e.forEach((i) => {
+    !n && typeof i == "object" && (n = W.bind(null, i));
+    const a = N(i, n);
+    (!r || r > a || isNaN(+a)) && (r = a);
+  }), W(n, r || NaN);
+}
+function yr(e, t, r) {
+  const [n, i] = Ie(
+    r == null ? void 0 : r.in,
+    e,
+    t
+  );
+  return +De(n) == +De(i);
+}
+function vr(e) {
+  return e instanceof Date || typeof e == "object" && Object.prototype.toString.call(e) === "[object Date]";
+}
+function br(e) {
+  return !(!vr(e) && typeof e != "number" || isNaN(+N(e)));
+}
+function je(e, t) {
+  const [r, n] = Ie(e, t.start, t.end);
+  return { start: r, end: n };
+}
+function Ct(e, t) {
+  const { start: r, end: n } = je(t == null ? void 0 : t.in, e);
+  let i = +r > +n;
+  const a = i ? +r : +n, u = i ? n : r;
+  u.setHours(0, 0, 0, 0);
+  let c = 1;
+  const s = [];
+  for (; +u <= a; )
+    s.push(W(r, u)), u.setDate(u.getDate() + c), u.setHours(0, 0, 0, 0);
+  return i ? s.reverse() : s;
+}
+function wr(e, t) {
+  const { start: r, end: n } = je(t == null ? void 0 : t.in, e);
+  let i = +r > +n;
+  const a = i ? +r : +n, u = i ? n : r;
+  u.setHours(0, 0, 0, 0), u.setDate(1);
+  let c = 1;
+  const s = [];
+  for (; +u <= a; )
+    s.push(W(r, u)), u.setMonth(u.getMonth() + c);
+  return i ? s.reverse() : s;
+}
+function xr(e, t) {
+  const { start: r, end: n } = je(t == null ? void 0 : t.in, e);
+  let i = +r > +n;
+  const a = j(i ? n : r, t), u = j(i ? r : n, t);
+  a.setHours(15), u.setHours(15);
+  const c = +u.getTime();
+  let s = a, o = (t == null ? void 0 : t.step) ?? 1;
+  if (!o) return [];
+  o < 0 && (o = -o, i = !i);
+  const f = [];
+  for (; +s <= c; )
+    s.setHours(0), f.push(W(r, s)), s = gr(s, o), s.setHours(15);
+  return i ? f.reverse() : f;
+}
+function Sr(e, t) {
+  const r = N(e, t == null ? void 0 : t.in);
+  return r.setFullYear(r.getFullYear(), 0, 1), r.setHours(0, 0, 0, 0), r;
+}
+const Or = {
+  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"
+  }
+}, Dr = (e, t, r) => {
+  let n;
+  const i = Or[e];
+  return typeof i == "string" ? n = i : t === 1 ? n = i.one : n = i.other.replace("{{count}}", t.toString()), r != null && r.addSuffix ? r.comparison && r.comparison > 0 ? "in " + n : n + " ago" : n;
+};
+function Me(e) {
+  return (t = {}) => {
+    const r = t.width ? String(t.width) : e.defaultWidth;
+    return e.formats[r] || e.formats[e.defaultWidth];
+  };
+}
+const Tr = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+}, Mr = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+}, Er = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+}, Pr = {
+  date: Me({
+    formats: Tr,
+    defaultWidth: "full"
+  }),
+  time: Me({
+    formats: Mr,
+    defaultWidth: "full"
+  }),
+  dateTime: Me({
+    formats: Er,
+    defaultWidth: "full"
+  })
+}, Rr = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+}, kr = (e, t, r, n) => Rr[e];
+function ie(e) {
+  return (t, r) => {
+    const n = r != null && r.context ? String(r.context) : "standalone";
+    let i;
+    if (n === "formatting" && e.formattingValues) {
+      const u = e.defaultFormattingWidth || e.defaultWidth, c = r != null && r.width ? String(r.width) : u;
+      i = e.formattingValues[c] || e.formattingValues[u];
+    } else {
+      const u = e.defaultWidth, c = r != null && r.width ? String(r.width) : e.defaultWidth;
+      i = e.values[c] || e.values[u];
+    }
+    const a = e.argumentCallback ? e.argumentCallback(t) : t;
+    return i[a];
+  };
+}
+const Nr = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+}, Ar = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+}, zr = {
+  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"
+  ]
+}, Cr = {
+  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"
+  ]
+}, _r = {
+  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"
+  }
+}, Wr = {
+  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"
+  }
+}, Lr = (e, t) => {
+  const r = Number(e), n = r % 100;
+  if (n > 20 || n < 10)
+    switch (n % 10) {
+      case 1:
+        return r + "st";
+      case 2:
+        return r + "nd";
+      case 3:
+        return r + "rd";
+    }
+  return r + "th";
+}, Hr = {
+  ordinalNumber: Lr,
+  era: ie({
+    values: Nr,
+    defaultWidth: "wide"
+  }),
+  quarter: ie({
+    values: Ar,
+    defaultWidth: "wide",
+    argumentCallback: (e) => e - 1
+  }),
+  month: ie({
+    values: zr,
+    defaultWidth: "wide"
+  }),
+  day: ie({
+    values: Cr,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: ie({
+    values: _r,
+    defaultWidth: "wide",
+    formattingValues: Wr,
+    defaultFormattingWidth: "wide"
+  })
+};
+function ae(e) {
+  return (t, r = {}) => {
+    const n = r.width, i = n && e.matchPatterns[n] || e.matchPatterns[e.defaultMatchWidth], a = t.match(i);
+    if (!a)
+      return null;
+    const u = a[0], c = n && e.parsePatterns[n] || e.parsePatterns[e.defaultParseWidth], s = Array.isArray(c) ? jr(c, (l) => l.test(u)) : (
+      // [TODO] -- I challenge you to fix the type
+      Ir(c, (l) => l.test(u))
+    );
+    let o;
+    o = e.valueCallback ? e.valueCallback(s) : s, o = r.valueCallback ? (
+      // [TODO] -- I challenge you to fix the type
+      r.valueCallback(o)
+    ) : o;
+    const f = t.slice(u.length);
+    return { value: o, rest: f };
+  };
+}
+function Ir(e, t) {
+  for (const r in e)
+    if (Object.prototype.hasOwnProperty.call(e, r) && t(e[r]))
+      return r;
+}
+function jr(e, t) {
+  for (let r = 0; r < e.length; r++)
+    if (t(e[r]))
+      return r;
+}
+function Yr(e) {
+  return (t, r = {}) => {
+    const n = t.match(e.matchPattern);
+    if (!n) return null;
+    const i = n[0], a = t.match(e.parsePattern);
+    if (!a) return null;
+    let u = e.valueCallback ? e.valueCallback(a[0]) : a[0];
+    u = r.valueCallback ? r.valueCallback(u) : u;
+    const c = t.slice(i.length);
+    return { value: u, rest: c };
+  };
+}
+const Fr = /^(\d+)(th|st|nd|rd)?/i, Br = /\d+/i, $r = {
+  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
+}, qr = {
+  any: [/^b/i, /^(a|c)/i]
+}, Xr = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+}, Ur = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, Gr = {
+  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
+}, Kr = {
+  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
+  ]
+}, Vr = {
+  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
+}, Qr = {
+  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]
+}, Jr = {
+  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
+}, Zr = {
+  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
+  }
+}, en = {
+  ordinalNumber: Yr({
+    matchPattern: Fr,
+    parsePattern: Br,
+    valueCallback: (e) => parseInt(e, 10)
+  }),
+  era: ae({
+    matchPatterns: $r,
+    defaultMatchWidth: "wide",
+    parsePatterns: qr,
+    defaultParseWidth: "any"
+  }),
+  quarter: ae({
+    matchPatterns: Xr,
+    defaultMatchWidth: "wide",
+    parsePatterns: Ur,
+    defaultParseWidth: "any",
+    valueCallback: (e) => e + 1
+  }),
+  month: ae({
+    matchPatterns: Gr,
+    defaultMatchWidth: "wide",
+    parsePatterns: Kr,
+    defaultParseWidth: "any"
+  }),
+  day: ae({
+    matchPatterns: Vr,
+    defaultMatchWidth: "wide",
+    parsePatterns: Qr,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: ae({
+    matchPatterns: Jr,
+    defaultMatchWidth: "any",
+    parsePatterns: Zr,
+    defaultParseWidth: "any"
+  })
+}, tn = {
+  code: "en-US",
+  formatDistance: Dr,
+  formatLong: Pr,
+  formatRelative: kr,
+  localize: Hr,
+  match: en,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+function rn(e, t) {
+  const r = N(e, t == null ? void 0 : t.in);
+  return B(r, Sr(r)) + 1;
+}
+function nn(e, t) {
+  const r = N(e, t == null ? void 0 : t.in), n = +Oe(r) - +hr(r);
+  return Math.round(n / Nt) + 1;
+}
+function _t(e, t) {
+  var f, l, d, h;
+  const r = N(e, t == null ? void 0 : t.in), n = r.getFullYear(), i = Te(), a = (t == null ? void 0 : t.firstWeekContainsDate) ?? ((l = (f = t == null ? void 0 : t.locale) == null ? void 0 : f.options) == null ? void 0 : l.firstWeekContainsDate) ?? i.firstWeekContainsDate ?? ((h = (d = i.locale) == null ? void 0 : d.options) == null ? void 0 : h.firstWeekContainsDate) ?? 1, u = W((t == null ? void 0 : t.in) || e, 0);
+  u.setFullYear(n + 1, 0, a), u.setHours(0, 0, 0, 0);
+  const c = j(u, t), s = W((t == null ? void 0 : t.in) || e, 0);
+  s.setFullYear(n, 0, a), s.setHours(0, 0, 0, 0);
+  const o = j(s, t);
+  return +r >= +c ? n + 1 : +r >= +o ? n : n - 1;
+}
+function an(e, t) {
+  var c, s, o, f;
+  const r = Te(), n = (t == null ? void 0 : t.firstWeekContainsDate) ?? ((s = (c = t == null ? void 0 : t.locale) == null ? void 0 : c.options) == null ? void 0 : s.firstWeekContainsDate) ?? r.firstWeekContainsDate ?? ((f = (o = r.locale) == null ? void 0 : o.options) == null ? void 0 : f.firstWeekContainsDate) ?? 1, i = _t(e, t), a = W((t == null ? void 0 : t.in) || e, 0);
+  return a.setFullYear(i, 0, n), a.setHours(0, 0, 0, 0), j(a, t);
+}
+function on(e, t) {
+  const r = N(e, t == null ? void 0 : t.in), n = +j(r, t) - +an(r, t);
+  return Math.round(n / Nt) + 1;
+}
+function T(e, t) {
+  const r = e < 0 ? "-" : "", n = Math.abs(e).toString().padStart(t, "0");
+  return r + n;
+}
+const Y = {
+  // Year
+  y(e, t) {
+    const r = e.getFullYear(), n = r > 0 ? r : 1 - r;
+    return T(t === "yy" ? n % 100 : n, t.length);
+  },
+  // Month
+  M(e, t) {
+    const r = e.getMonth();
+    return t === "M" ? String(r + 1) : T(r + 1, 2);
+  },
+  // Day of the month
+  d(e, t) {
+    return T(e.getDate(), t.length);
+  },
+  // AM or PM
+  a(e, t) {
+    const r = e.getHours() / 12 >= 1 ? "pm" : "am";
+    switch (t) {
+      case "a":
+      case "aa":
+        return r.toUpperCase();
+      case "aaa":
+        return r;
+      case "aaaaa":
+        return r[0];
+      case "aaaa":
+      default:
+        return r === "am" ? "a.m." : "p.m.";
+    }
+  },
+  // Hour [1-12]
+  h(e, t) {
+    return T(e.getHours() % 12 || 12, t.length);
+  },
+  // Hour [0-23]
+  H(e, t) {
+    return T(e.getHours(), t.length);
+  },
+  // Minute
+  m(e, t) {
+    return T(e.getMinutes(), t.length);
+  },
+  // Second
+  s(e, t) {
+    return T(e.getSeconds(), t.length);
+  },
+  // Fraction of second
+  S(e, t) {
+    const r = t.length, n = e.getMilliseconds(), i = Math.trunc(
+      n * Math.pow(10, r - 3)
+    );
+    return T(i, t.length);
+  }
+}, Q = {
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night"
+}, Je = {
+  // Era
+  G: function(e, t, r) {
+    const n = e.getFullYear() > 0 ? 1 : 0;
+    switch (t) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return r.era(n, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return r.era(n, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return r.era(n, { width: "wide" });
+    }
+  },
+  // Year
+  y: function(e, t, r) {
+    if (t === "yo") {
+      const n = e.getFullYear(), i = n > 0 ? n : 1 - n;
+      return r.ordinalNumber(i, { unit: "year" });
+    }
+    return Y.y(e, t);
+  },
+  // Local week-numbering year
+  Y: function(e, t, r, n) {
+    const i = _t(e, n), a = i > 0 ? i : 1 - i;
+    if (t === "YY") {
+      const u = a % 100;
+      return T(u, 2);
+    }
+    return t === "Yo" ? r.ordinalNumber(a, { unit: "year" }) : T(a, t.length);
+  },
+  // ISO week-numbering year
+  R: function(e, t) {
+    const r = zt(e);
+    return T(r, t.length);
+  },
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function(e, t) {
+    const r = e.getFullYear();
+    return T(r, t.length);
+  },
+  // Quarter
+  Q: function(e, t, r) {
+    const n = Math.ceil((e.getMonth() + 1) / 3);
+    switch (t) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(n);
+      // 01, 02, 03, 04
+      case "QQ":
+        return T(n, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return r.ordinalNumber(n, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return r.quarter(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return r.quarter(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return r.quarter(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Stand-alone quarter
+  q: function(e, t, r) {
+    const n = Math.ceil((e.getMonth() + 1) / 3);
+    switch (t) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(n);
+      // 01, 02, 03, 04
+      case "qq":
+        return T(n, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return r.ordinalNumber(n, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return r.quarter(n, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return r.quarter(n, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return r.quarter(n, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  // Month
+  M: function(e, t, r) {
+    const n = e.getMonth();
+    switch (t) {
+      case "M":
+      case "MM":
+        return Y.M(e, t);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return r.ordinalNumber(n + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return r.month(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return r.month(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return r.month(n, { width: "wide", context: "formatting" });
+    }
+  },
+  // Stand-alone month
+  L: function(e, t, r) {
+    const n = e.getMonth();
+    switch (t) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(n + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return T(n + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return r.ordinalNumber(n + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return r.month(n, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return r.month(n, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return r.month(n, { width: "wide", context: "standalone" });
+    }
+  },
+  // Local week of year
+  w: function(e, t, r, n) {
+    const i = on(e, n);
+    return t === "wo" ? r.ordinalNumber(i, { unit: "week" }) : T(i, t.length);
+  },
+  // ISO week of year
+  I: function(e, t, r) {
+    const n = nn(e);
+    return t === "Io" ? r.ordinalNumber(n, { unit: "week" }) : T(n, t.length);
+  },
+  // Day of the month
+  d: function(e, t, r) {
+    return t === "do" ? r.ordinalNumber(e.getDate(), { unit: "date" }) : Y.d(e, t);
+  },
+  // Day of year
+  D: function(e, t, r) {
+    const n = rn(e);
+    return t === "Do" ? r.ordinalNumber(n, { unit: "dayOfYear" }) : T(n, t.length);
+  },
+  // Day of week
+  E: function(e, t, r) {
+    const n = e.getDay();
+    switch (t) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return r.day(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "EEEEE":
+        return r.day(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return r.day(n, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return r.day(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Local day of week
+  e: function(e, t, r, n) {
+    const i = e.getDay(), a = (i - n.weekStartsOn + 8) % 7 || 7;
+    switch (t) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(a);
+      // Padded numerical value
+      case "ee":
+        return T(a, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return r.ordinalNumber(a, { unit: "day" });
+      case "eee":
+        return r.day(i, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "eeeee":
+        return r.day(i, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return r.day(i, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return r.day(i, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Stand-alone local day of week
+  c: function(e, t, r, n) {
+    const i = e.getDay(), a = (i - n.weekStartsOn + 8) % 7 || 7;
+    switch (t) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(a);
+      // Padded numerical value
+      case "cc":
+        return T(a, t.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return r.ordinalNumber(a, { unit: "day" });
+      case "ccc":
+        return r.day(i, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      // T
+      case "ccccc":
+        return r.day(i, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // Tu
+      case "cccccc":
+        return r.day(i, {
+          width: "short",
+          context: "standalone"
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return r.day(i, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  // ISO day of week
+  i: function(e, t, r) {
+    const n = e.getDay(), i = n === 0 ? 7 : n;
+    switch (t) {
+      // 2
+      case "i":
+        return String(i);
+      // 02
+      case "ii":
+        return T(i, t.length);
+      // 2nd
+      case "io":
+        return r.ordinalNumber(i, { unit: "day" });
+      // Tue
+      case "iii":
+        return r.day(n, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      // T
+      case "iiiii":
+        return r.day(n, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "iiiiii":
+        return r.day(n, {
+          width: "short",
+          context: "formatting"
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return r.day(n, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // AM or PM
+  a: function(e, t, r) {
+    const i = e.getHours() / 12 >= 1 ? "pm" : "am";
+    switch (t) {
+      case "a":
+      case "aa":
+        return r.dayPeriod(i, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "aaa":
+        return r.dayPeriod(i, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "aaaaa":
+        return r.dayPeriod(i, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return r.dayPeriod(i, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // AM, PM, midnight, noon
+  b: function(e, t, r) {
+    const n = e.getHours();
+    let i;
+    switch (n === 12 ? i = Q.noon : n === 0 ? i = Q.midnight : i = n / 12 >= 1 ? "pm" : "am", t) {
+      case "b":
+      case "bb":
+        return r.dayPeriod(i, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "bbb":
+        return r.dayPeriod(i, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "bbbbb":
+        return r.dayPeriod(i, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return r.dayPeriod(i, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // in the morning, in the afternoon, in the evening, at night
+  B: function(e, t, r) {
+    const n = e.getHours();
+    let i;
+    switch (n >= 17 ? i = Q.evening : n >= 12 ? i = Q.afternoon : n >= 4 ? i = Q.morning : i = Q.night, t) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return r.dayPeriod(i, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return r.dayPeriod(i, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return r.dayPeriod(i, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  // Hour [1-12]
+  h: function(e, t, r) {
+    if (t === "ho") {
+      let n = e.getHours() % 12;
+      return n === 0 && (n = 12), r.ordinalNumber(n, { unit: "hour" });
+    }
+    return Y.h(e, t);
+  },
+  // Hour [0-23]
+  H: function(e, t, r) {
+    return t === "Ho" ? r.ordinalNumber(e.getHours(), { unit: "hour" }) : Y.H(e, t);
+  },
+  // Hour [0-11]
+  K: function(e, t, r) {
+    const n = e.getHours() % 12;
+    return t === "Ko" ? r.ordinalNumber(n, { unit: "hour" }) : T(n, t.length);
+  },
+  // Hour [1-24]
+  k: function(e, t, r) {
+    let n = e.getHours();
+    return n === 0 && (n = 24), t === "ko" ? r.ordinalNumber(n, { unit: "hour" }) : T(n, t.length);
+  },
+  // Minute
+  m: function(e, t, r) {
+    return t === "mo" ? r.ordinalNumber(e.getMinutes(), { unit: "minute" }) : Y.m(e, t);
+  },
+  // Second
+  s: function(e, t, r) {
+    return t === "so" ? r.ordinalNumber(e.getSeconds(), { unit: "second" }) : Y.s(e, t);
+  },
+  // Fraction of second
+  S: function(e, t) {
+    return Y.S(e, t);
+  },
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function(e, t, r) {
+    const n = e.getTimezoneOffset();
+    if (n === 0)
+      return "Z";
+    switch (t) {
+      // Hours and optional minutes
+      case "X":
+        return et(n);
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX":
+        return U(n);
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX":
+      // Hours and minutes with `:` delimiter
+      default:
+        return U(n, ":");
+    }
+  },
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function(e, t, r) {
+    const n = e.getTimezoneOffset();
+    switch (t) {
+      // Hours and optional minutes
+      case "x":
+        return et(n);
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx":
+        return U(n);
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx":
+      // Hours and minutes with `:` delimiter
+      default:
+        return U(n, ":");
+    }
+  },
+  // Timezone (GMT)
+  O: function(e, t, r) {
+    const n = e.getTimezoneOffset();
+    switch (t) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + Ze(n, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + U(n, ":");
+    }
+  },
+  // Timezone (specific non-location)
+  z: function(e, t, r) {
+    const n = e.getTimezoneOffset();
+    switch (t) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + Ze(n, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + U(n, ":");
+    }
+  },
+  // Seconds timestamp
+  t: function(e, t, r) {
+    const n = Math.trunc(+e / 1e3);
+    return T(n, t.length);
+  },
+  // Milliseconds timestamp
+  T: function(e, t, r) {
+    return T(+e, t.length);
+  }
+};
+function Ze(e, t = "") {
+  const r = e > 0 ? "-" : "+", n = Math.abs(e), i = Math.trunc(n / 60), a = n % 60;
+  return a === 0 ? r + String(i) : r + String(i) + t + T(a, 2);
+}
+function et(e, t) {
+  return e % 60 === 0 ? (e > 0 ? "-" : "+") + T(Math.abs(e) / 60, 2) : U(e, t);
+}
+function U(e, t = "") {
+  const r = e > 0 ? "-" : "+", n = Math.abs(e), i = T(Math.trunc(n / 60), 2), a = T(n % 60, 2);
+  return r + i + t + a;
+}
+const tt = (e, t) => {
+  switch (e) {
+    case "P":
+      return t.date({ width: "short" });
+    case "PP":
+      return t.date({ width: "medium" });
+    case "PPP":
+      return t.date({ width: "long" });
+    case "PPPP":
+    default:
+      return t.date({ width: "full" });
+  }
+}, Wt = (e, t) => {
+  switch (e) {
+    case "p":
+      return t.time({ width: "short" });
+    case "pp":
+      return t.time({ width: "medium" });
+    case "ppp":
+      return t.time({ width: "long" });
+    case "pppp":
+    default:
+      return t.time({ width: "full" });
+  }
+}, sn = (e, t) => {
+  const r = e.match(/(P+)(p+)?/) || [], n = r[1], i = r[2];
+  if (!i)
+    return tt(e, t);
+  let a;
+  switch (n) {
+    case "P":
+      a = t.dateTime({ width: "short" });
+      break;
+    case "PP":
+      a = t.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      a = t.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      a = t.dateTime({ width: "full" });
+      break;
+  }
+  return a.replace("{{date}}", tt(n, t)).replace("{{time}}", Wt(i, t));
+}, un = {
+  p: Wt,
+  P: sn
+}, cn = /^D+$/, ln = /^Y+$/, dn = ["D", "DD", "YY", "YYYY"];
+function fn(e) {
+  return cn.test(e);
+}
+function hn(e) {
+  return ln.test(e);
+}
+function gn(e, t, r) {
+  const n = pn(e, t, r);
+  if (console.warn(n), dn.includes(e)) throw new RangeError(n);
+}
+function pn(e, t, r) {
+  const n = e[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${e.toLowerCase()}\` instead of \`${e}\` (in \`${t}\`) for formatting ${n} to the input \`${r}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+const mn = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, yn = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, vn = /^'([^]*?)'?$/, bn = /''/g, wn = /[a-zA-Z]/;
+function I(e, t, r) {
+  var f, l, d, h;
+  const n = Te(), i = n.locale ?? tn, a = n.firstWeekContainsDate ?? ((l = (f = n.locale) == null ? void 0 : f.options) == null ? void 0 : l.firstWeekContainsDate) ?? 1, u = n.weekStartsOn ?? ((h = (d = n.locale) == null ? void 0 : d.options) == null ? void 0 : h.weekStartsOn) ?? 0, c = N(e, r == null ? void 0 : r.in);
+  if (!br(c))
+    throw new RangeError("Invalid time value");
+  let s = t.match(yn).map((g) => {
+    const p = g[0];
+    if (p === "p" || p === "P") {
+      const m = un[p];
+      return m(g, i.formatLong);
+    }
+    return g;
+  }).join("").match(mn).map((g) => {
+    if (g === "''")
+      return { isToken: !1, value: "'" };
+    const p = g[0];
+    if (p === "'")
+      return { isToken: !1, value: xn(g) };
+    if (Je[p])
+      return { isToken: !0, value: g };
+    if (p.match(wn))
+      throw new RangeError(
+        "Format string contains an unescaped latin alphabet character `" + p + "`"
+      );
+    return { isToken: !1, value: g };
+  });
+  i.localize.preprocessor && (s = i.localize.preprocessor(c, s));
+  const o = {
+    firstWeekContainsDate: a,
+    weekStartsOn: u,
+    locale: i
+  };
+  return s.map((g) => {
+    if (!g.isToken) return g.value;
+    const p = g.value;
+    (hn(p) || fn(p)) && gn(p, t, String(e));
+    const m = Je[p[0]];
+    return m(c, p, i.localize, o);
+  }).join("");
+}
+function xn(e) {
+  const t = e.match(vn);
+  return t ? t[1].replace(bn, "'") : e;
+}
+function Sn(e, t) {
+  return N(e, t == null ? void 0 : t.in).getDay();
+}
+function On(e, t) {
+  const r = N(e, t == null ? void 0 : t.in), n = r.getMonth();
+  return r.setFullYear(r.getFullYear(), n + 1, 0), r.setHours(0, 0, 0, 0), N(r, t == null ? void 0 : t.in);
+}
+function Dn(e, t, r) {
+  let n = t - Sn(e, r);
+  return n <= 0 && (n += 7), le(e, n, r);
+}
+function Tn(e, t) {
+  return Dn(e, 0, t);
+}
+function ze(e, t, r) {
+  const n = N(e, r == null ? void 0 : r.in);
+  return n.setHours(t), n;
+}
+function Ye(e, t, r) {
+  const n = En(e, t, r), i = Mn(e, t);
+  return { width: n, height: i };
+}
+function Mn(e, t) {
+  return t.pixelsPerResource;
+}
+function En(e, t, r) {
+  return Math.abs(
+    (B(r.end, r.start) + 1) * t.pixelsPerDay
+  );
+}
+function Fe(e, t, r, n) {
+  const i = Lt(e, t, n), a = Rn(e, t, r.start, n);
+  return {
+    ...i,
+    ...a
+  };
+}
+function Lt(e, t, r) {
+  const n = B(e.end, e.start) * r.pixelsPerDay, i = e.size / t.capacity * r.pixelsPerResource;
+  return { width: n, height: i };
+}
+function Be(e, t, r) {
+  return B(e, t) * r.pixelsPerDay + r.pixelsPerDay / 2;
+}
+function Pn(e, t, r) {
+  return e / t * r.pixelsPerResource;
+}
+function Rn(e, t, r, n) {
+  const i = Be(e.start, r, n), a = Pn(e.offset, t.capacity, n);
+  return { x: i, y: a };
+}
+function Z(e, t) {
+  const r = e.element.getBoundingClientRect(), n = {
+    x: r.x - t.initial.input.pageX,
+    y: r.y - t.initial.input.pageY
+  }, i = {
+    x: n.x / r.width,
+    y: n.y / r.height
+  };
+  return {
+    absolute: n,
+    relative: i
+  };
+}
+function Ht(e, t, r, n, i) {
+  return {
+    id: e.id,
+    swimlaneId: t.id,
+    start: ze(
+      le(i.start, Math.floor(r.x / n.pixelsPerDay)),
+      12
+    ),
+    end: ze(
+      le(
+        i.start,
+        Math.floor(
+          (r.x + r.width) / n.pixelsPerDay
+        )
+      ),
+      12
+    ),
+    offset: Math.floor(
+      r.y / n.pixelsPerResource * t.capacity
+    ),
+    size: Math.floor(
+      r.height / n.pixelsPerResource * t.capacity
+    ),
+    payload: e.payload
+  };
+}
+function ha({
+  focusedDay: e
+}) {
+  const { settings: t } = ge();
+  return /* @__PURE__ */ v("div", { className: "timeline-background", children: /* @__PURE__ */ K("div", { className: "timeline-background-inner", children: [
+    e && /* @__PURE__ */ v(
+      "div",
+      {
+        className: "timeline-background-focused-day-position",
+        style: {
+          width: `${t.pixelsPerDay}px`,
+          marginLeft: `${Be(e, t.start, t) - t.pixelsPerDay / 2}px`
+        }
+      }
+    ),
+    /* @__PURE__ */ v(
+      "div",
+      {
+        id: "timeline-background-date-anchor",
+        style: {
+          position: "absolute",
+          top: 0,
+          width: "1px",
+          height: "100%"
+        }
+      }
+    ),
+    Ct(t).map((r, n) => /* @__PURE__ */ v(
+      "div",
+      {
+        className: `timeline-background-day-label ${At(r) ? "timeline-background-day-label-sunday" : ""} `,
+        style: { width: `${t.pixelsPerDay}px` },
+        "data-day": I(r, "yyyy-MM-dd")
+      },
+      n
+    ))
+  ] }) });
+}
+function kn(e, t) {
+  const r = B(t, e) + 1;
+  return /* @__PURE__ */ v(Se, { children: r > 4 ? I(e, "LLLL yyyy") : /* @__PURE__ */ v(Se, {}) });
+}
+function Nn(e, t) {
+  const r = B(t, e) + 1, n = `KW ${I(e, "w")} (${I(
+    e,
+    "MM-dd"
+  )} - ${I(t, "MM-dd")}`;
+  return /* @__PURE__ */ v("div", { title: n, children: r > 2 ? /* @__PURE__ */ K(Se, { children: [
+    "KW ",
+    I(e, "w")
+  ] }) : /* @__PURE__ */ v(Se, {}) });
+}
+function An(e) {
+  const t = `${I(e, "yyyy-MM-dd")}`;
+  return /* @__PURE__ */ v("div", { title: t, children: I(e, "d") });
+}
+function zn({
+  range: e,
+  pixels: t,
+  focusedDay: r,
+  setFocusedDay: n = () => {
+  },
+  render: i = An,
+  onDayClick: a = () => {
+  }
+}) {
+  return /* @__PURE__ */ v("div", { className: "timeline-header-days", children: Ct(e).map((u, c) => /* @__PURE__ */ v(
+    "div",
+    {
+      className: `timeline-header-day-label ${r && yr(r, u) ? "timeline-header-day-label-focused" : ""}`,
+      style: { width: `${t.pixelsPerDay}px` },
+      onClick: (s) => {
+        a({ day: u, e: s }), n(u);
+      },
+      children: i(u)
+    },
+    c
+  )) });
+}
+function Cn({
+  range: e,
+  pixels: t,
+  setFocusedDay: r = () => {
+  },
+  render: n = Nn,
+  onWeekClick: i = () => {
+  }
+}) {
+  return /* @__PURE__ */ v("div", { className: "timeline-header-weeks", children: xr(e, { weekStartsOn: 1 }).map((a, u) => {
+    a < e.start && (a = e.start);
+    let c = At(a) ? a : Tn(a);
+    c > e.end && (c = e.end);
+    const s = B(c, a) + 1;
+    return /* @__PURE__ */ v(
+      "div",
+      {
+        className: "timeline-header-week-label",
+        style: {
+          width: `${t.pixelsPerDay * s}px`
+        },
+        onClick: (o) => {
+          i({ firstDay: a, lastDay: c, e: o }), r(a);
+        },
+        children: n(a, c)
+      },
+      u
+    );
+  }) });
+}
+function _n({
+  range: e,
+  pixels: t,
+  setFocusedDay: r = () => {
+  },
+  render: n = kn,
+  onMonthClick: i = () => {
+  }
+}) {
+  return /* @__PURE__ */ v("div", { className: "timeline-header-months", children: wr(e).map((a, u) => {
+    a < e.start && (a = e.start);
+    let c = On(a);
+    c > e.end && (c = e.end);
+    const s = B(c, a) + 1;
+    return /* @__PURE__ */ v(
+      "div",
+      {
+        className: "timeline-header-month-label",
+        style: {
+          width: `${t.pixelsPerDay * s}px`
+        },
+        onClick: (o) => {
+          i({ firstDay: a, lastDay: c, e: o }), r(a);
+        },
+        children: n(a, c)
+      },
+      u
+    );
+  }) });
+}
+function ga({
+  focusedDay: e,
+  setFocusedDay: t = () => {
+  },
+  renderMonthHeader: r,
+  renderWeekHeader: n,
+  renderDayHeader: i,
+  onMonthClick: a,
+  onDayClick: u,
+  onWeekClick: c
+}) {
+  const { settings: s } = ge();
+  return /* @__PURE__ */ K("div", { className: "timeline-header", children: [
+    s.showMonths && /* @__PURE__ */ v(
+      _n,
+      {
+        range: s,
+        pixels: s,
+        setFocusedDay: t,
+        render: r,
+        onMonthClick: a
+      }
+    ),
+    s.showWeeks && /* @__PURE__ */ v(
+      Cn,
+      {
+        range: s,
+        pixels: s,
+        setFocusedDay: t,
+        render: n,
+        onWeekClick: c
+      }
+    ),
+    s.showDays && /* @__PURE__ */ v(
+      zn,
+      {
+        range: s,
+        pixels: s,
+        focusedDay: e,
+        setFocusedDay: t,
+        render: i,
+        onDayClick: u
+      }
+    )
+  ] });
+}
+const Wn = ({
+  settings: e,
+  children: t
+}) => {
+  const [r, n] = G(e);
+  return ee(() => {
+    n((i) => ({ ...i, _settings: e }));
+  }, [e]), /* @__PURE__ */ v(kt.Provider, { value: { settings: r, setSettings: n }, children: t });
+};
+function pa({
+  children: e,
+  start: t = new Date(2025, 1, 1),
+  end: r = new Date(2025, 5, 1),
+  pixelsPerDay: n = 30,
+  pixelsPerResource: i = 100,
+  showMonths: a = !0,
+  showWeeks: u = !0,
+  showDays: c = !0,
+  allowOverlaps: s = !0,
+  focusedDate: o = null
+}) {
+  return /* @__PURE__ */ v("div", { className: "timeline", children: /* @__PURE__ */ v(
+    Wn,
+    {
+      settings: {
+        start: t,
+        end: r,
+        pixelsPerDay: n,
+        pixelsPerResource: i,
+        showDays: c,
+        showMonths: a,
+        showWeeks: u,
+        allowOverlaps: s,
+        focusedDate: o
+      },
+      children: e
+    }
+  ) });
+}
+function Ln(e) {
+  if (Array.isArray(e)) return e;
+}
+function Hn(e, t) {
+  var r = e == null ? null : typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (r != null) {
+    var n, i, a, u, c = [], s = !0, o = !1;
+    try {
+      if (a = (r = r.call(e)).next, t !== 0) for (; !(s = (n = a.call(r)).done) && (c.push(n.value), c.length !== t); s = !0) ;
+    } catch (f) {
+      o = !0, i = f;
+    } finally {
+      try {
+        if (!s && r.return != null && (u = r.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw i;
+      }
+    }
+    return c;
+  }
+}
+function Ce(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
+  return n;
+}
+function It(e, t) {
+  if (e) {
+    if (typeof e == "string") return Ce(e, t);
+    var r = {}.toString.call(e).slice(8, -1);
+    return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? Ce(e, t) : void 0;
+  }
+}
+function In() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function jt(e, t) {
+  return Ln(e) || Hn(e, t) || It(e, t) || In();
+}
+var Ee = {}, oe = {}, rt;
+function Yt() {
+  if (rt) return oe;
+  rt = 1, Object.defineProperty(oe, "__esModule", { value: !0 }), oe.bind = void 0;
+  function e(t, r) {
+    var n = r.type, i = r.listener, a = r.options;
+    return t.addEventListener(n, i, a), function() {
+      t.removeEventListener(n, i, a);
+    };
+  }
+  return oe.bind = e, oe;
+}
+var X = {}, nt;
+function jn() {
+  if (nt) return X;
+  nt = 1;
+  var e = X && X.__assign || function() {
+    return e = Object.assign || function(a) {
+      for (var u, c = 1, s = arguments.length; c < s; c++) {
+        u = arguments[c];
+        for (var o in u) Object.prototype.hasOwnProperty.call(u, o) && (a[o] = u[o]);
+      }
+      return a;
+    }, e.apply(this, arguments);
+  };
+  Object.defineProperty(X, "__esModule", { value: !0 }), X.bindAll = void 0;
+  var t = /* @__PURE__ */ Yt();
+  function r(a) {
+    if (!(typeof a > "u"))
+      return typeof a == "boolean" ? {
+        capture: a
+      } : a;
+  }
+  function n(a, u) {
+    if (u == null)
+      return a;
+    var c = e(e({}, a), { options: e(e({}, r(u)), r(a.options)) });
+    return c;
+  }
+  function i(a, u, c) {
+    var s = u.map(function(o) {
+      var f = n(o, c);
+      return (0, t.bind)(a, f);
+    });
+    return function() {
+      s.forEach(function(f) {
+        return f();
+      });
+    };
+  }
+  return X.bindAll = i, X;
+}
+var it;
+function Yn() {
+  return it || (it = 1, function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.bindAll = e.bind = void 0;
+    var t = /* @__PURE__ */ Yt();
+    Object.defineProperty(e, "bind", { enumerable: !0, get: function() {
+      return t.bind;
+    } });
+    var r = /* @__PURE__ */ jn();
+    Object.defineProperty(e, "bindAll", { enumerable: !0, get: function() {
+      return r.bindAll;
+    } });
+  }(Ee)), Ee;
+}
+var te = /* @__PURE__ */ Yn(), Ft = "data-pdnd-honey-pot";
+function Bt(e) {
+  return e instanceof Element && e.hasAttribute(Ft);
+}
+function $t(e) {
+  var t = document.elementsFromPoint(e.x, e.y), r = jt(t, 2), n = r[0], i = r[1];
+  return n ? Bt(n) ? i ?? null : n : null;
+}
+function de(e) {
+  "@babel/helpers - typeof";
+  return de = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, de(e);
+}
+function Fn(e, t) {
+  if (de(e) != "object" || !e) return e;
+  var r = e[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(e, t);
+    if (de(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function Bn(e) {
+  var t = Fn(e, "string");
+  return de(t) == "symbol" ? t : t + "";
+}
+function $e(e, t, r) {
+  return (t = Bn(t)) in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+var $n = 2147483647;
+function at(e, t) {
+  var r = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    t && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function ot(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? at(Object(r), !0).forEach(function(n) {
+      $e(e, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : at(Object(r)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return e;
+}
+var fe = 2, st = fe / 2;
+function qn(e) {
+  return {
+    x: Math.floor(e.x),
+    y: Math.floor(e.y)
+  };
+}
+function Xn(e) {
+  return {
+    x: e.x - st,
+    y: e.y - st
+  };
+}
+function Un(e) {
+  return {
+    x: Math.max(e.x, 0),
+    y: Math.max(e.y, 0)
+  };
+}
+function Gn(e) {
+  return {
+    x: Math.min(e.x, window.innerWidth - fe),
+    y: Math.min(e.y, window.innerHeight - fe)
+  };
+}
+function ut(e) {
+  var t = e.client, r = Gn(Un(Xn(qn(t))));
+  return DOMRect.fromRect({
+    x: r.x,
+    y: r.y,
+    width: fe,
+    height: fe
+  });
+}
+function ct(e) {
+  var t = e.clientRect;
+  return {
+    left: "".concat(t.left, "px"),
+    top: "".concat(t.top, "px"),
+    width: "".concat(t.width, "px"),
+    height: "".concat(t.height, "px")
+  };
+}
+function Kn(e) {
+  var t = e.client, r = e.clientRect;
+  return (
+    // is within horizontal bounds
+    t.x >= r.x && t.x <= r.x + r.width && // is within vertical bounds
+    t.y >= r.y && t.y <= r.y + r.height
+  );
+}
+function Vn(e) {
+  var t = e.initial, r = document.createElement("div");
+  r.setAttribute(Ft, "true");
+  var n = ut({
+    client: t
+  });
+  Object.assign(r.style, ot(ot({
+    // Setting a background color explicitly to avoid any inherited styles.
+    // Looks like this could be `opacity: 0`, but worried that _might_
+    // cause the element to be ignored on some platforms.
+    // When debugging, set backgroundColor to something like "red".
+    backgroundColor: "transparent",
+    position: "fixed",
+    // Being explicit to avoid inheriting styles
+    padding: 0,
+    margin: 0,
+    boxSizing: "border-box"
+  }, ct({
+    clientRect: n
+  })), {}, {
+    // We want this element to absorb pointer events,
+    // it's kind of the whole point 😉
+    pointerEvents: "auto",
+    // Want to make sure the honey pot is top of everything else.
+    // Don't need to worry about native drag previews, as they will
+    // have been rendered (and removed) before the honey pot is rendered
+    zIndex: $n
+  })), document.body.appendChild(r);
+  var i = te.bind(window, {
+    type: "pointermove",
+    listener: function(u) {
+      var c = {
+        x: u.clientX,
+        y: u.clientY
+      };
+      n = ut({
+        client: c
+      }), Object.assign(r.style, ct({
+        clientRect: n
+      }));
+    },
+    // using capture so we are less likely to be impacted by event stopping
+    options: {
+      capture: !0
+    }
+  });
+  return function(u) {
+    var c = u.current;
+    if (i(), Kn({
+      client: c,
+      clientRect: n
+    })) {
+      r.remove();
+      return;
+    }
+    function s() {
+      o(), r.remove();
+    }
+    var o = te.bindAll(window, [
+      {
+        type: "pointerdown",
+        listener: s
+      },
+      {
+        type: "pointermove",
+        listener: s
+      },
+      {
+        type: "focusin",
+        listener: s
+      },
+      {
+        type: "focusout",
+        listener: s
+      },
+      // a 'pointerdown' should happen before 'dragstart', but just being super safe
+      {
+        type: "dragstart",
+        listener: s
+      },
+      // if the user has dragged something out of the window
+      // and then is dragging something back into the window
+      // the first events we will see are "dragenter" (and then "dragover").
+      // So if we see any of these we need to clear the post drag fix.
+      {
+        type: "dragenter",
+        listener: s
+      },
+      {
+        type: "dragover",
+        listener: s
+      }
+      // Not adding a "wheel" event listener, as "wheel" by itself does not
+      // resolve the bug.
+    ], {
+      // Using `capture` so less likely to be impacted by other code stopping events
+      capture: !0
+    });
+  };
+}
+function Qn() {
+  var e = null;
+  function t() {
+    return e = null, te.bind(window, {
+      type: "pointermove",
+      listener: function(i) {
+        e = {
+          x: i.clientX,
+          y: i.clientY
+        };
+      },
+      // listening for pointer move in capture phase
+      // so we are less likely to be impacted by events being stopped.
+      options: {
+        capture: !0
+      }
+    });
+  }
+  function r() {
+    var n = null;
+    return function(a) {
+      var u = a.eventName, c = a.payload;
+      if (u === "onDragStart") {
+        var s = c.location.initial.input, o = e ?? {
+          x: s.clientX,
+          y: s.clientY
+        };
+        n = Vn({
+          initial: o
+        });
+      }
+      if (u === "onDrop") {
+        var f, l = c.location.current.input;
+        (f = n) === null || f === void 0 || f({
+          current: {
+            x: l.clientX,
+            y: l.clientY
+          }
+        }), n = null, e = null;
+      }
+    };
+  }
+  return {
+    bindEvents: t,
+    getOnPostDispatch: r
+  };
+}
+function Jn(e) {
+  if (Array.isArray(e)) return Ce(e);
+}
+function Zn(e) {
+  if (typeof Symbol < "u" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+}
+function ei() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function qt(e) {
+  return Jn(e) || Zn(e) || It(e) || ei();
+}
+function ne(e) {
+  var t = null;
+  return function() {
+    if (!t) {
+      for (var n = arguments.length, i = new Array(n), a = 0; a < n; a++)
+        i[a] = arguments[a];
+      var u = e.apply(this, i);
+      t = {
+        result: u
+      };
+    }
+    return t.result;
+  };
+}
+var ti = ne(function() {
+  return process.env.NODE_ENV === "test" ? !1 : navigator.userAgent.includes("Firefox");
+}), qe = ne(function() {
+  if (process.env.NODE_ENV === "test")
+    return !1;
+  var t = navigator, r = t.userAgent;
+  return r.includes("AppleWebKit") && !r.includes("Chrome");
+}), _e = {
+  isLeavingWindow: Symbol("leaving"),
+  isEnteringWindow: Symbol("entering")
+};
+function ri(e) {
+  var t = e.dragLeave;
+  return qe() ? t.hasOwnProperty(_e.isLeavingWindow) : !1;
+}
+(function() {
+  if (typeof window > "u" || process.env.NODE_ENV === "test" || !qe())
+    return;
+  function t() {
+    return {
+      enterCount: 0,
+      isOverWindow: !1
+    };
+  }
+  var r = t();
+  function n() {
+    r = t();
+  }
+  te.bindAll(
+    window,
+    [{
+      type: "dragstart",
+      listener: function() {
+        r.enterCount = 0, r.isOverWindow = !0;
+      }
+    }, {
+      type: "drop",
+      listener: n
+    }, {
+      type: "dragend",
+      listener: n
+    }, {
+      type: "dragenter",
+      listener: function(a) {
+        !r.isOverWindow && r.enterCount === 0 && (a[_e.isEnteringWindow] = !0), r.isOverWindow = !0, r.enterCount++;
+      }
+    }, {
+      type: "dragleave",
+      listener: function(a) {
+        r.enterCount--, r.isOverWindow && r.enterCount === 0 && (a[_e.isLeavingWindow] = !0, r.isOverWindow = !1);
+      }
+    }],
+    // using `capture: true` so that adding event listeners
+    // in bubble phase will have the correct symbols
+    {
+      capture: !0
+    }
+  );
+})();
+function ni(e) {
+  return "nodeName" in e;
+}
+function ii(e) {
+  return ni(e) && e.ownerDocument !== document;
+}
+function ai(e) {
+  var t = e.dragLeave, r = t.type, n = t.relatedTarget;
+  return r !== "dragleave" ? !1 : qe() ? ri({
+    dragLeave: t
+  }) : n == null ? !0 : ti() ? ii(n) : n instanceof HTMLIFrameElement;
+}
+function oi(e) {
+  var t = e.onDragEnd;
+  return [
+    // ## Detecting drag ending for removed draggables
+    //
+    // If a draggable element is removed during a drag and the user drops:
+    // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+    // 2. if not over a valid drop target (or cancelled): we get nothing
+    // The "dragend" event will not fire on the source draggable if it has been
+    // removed from the DOM.
+    // So we need to figure out if a drag operation has finished by looking at other events
+    // We can do this by looking at other events
+    // ### First detection: "pointermove" events
+    // 1. "pointermove" events cannot fire during a drag and drop operation
+    // according to the spec. So if we get a "pointermove" it means that
+    // the drag and drop operations has finished. So if we get a "pointermove"
+    // we know that the drag is over
+    // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+    // other pointer events. However, firefox will allow a few
+    // pointer event to get through after a drag starts.
+    // The most I've seen is 3
+    {
+      type: "pointermove",
+      listener: /* @__PURE__ */ function() {
+        var r = 0;
+        return function() {
+          if (r < 20) {
+            r++;
+            return;
+          }
+          t();
+        };
+      }()
+    },
+    // ### Second detection: "pointerdown" events
+    // If we receive this event then we know that a drag operation has finished
+    // and potentially another one is about to start.
+    // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+    {
+      type: "pointerdown",
+      listener: t
+    }
+  ];
+}
+function ue(e) {
+  return {
+    altKey: e.altKey,
+    button: e.button,
+    buttons: e.buttons,
+    ctrlKey: e.ctrlKey,
+    metaKey: e.metaKey,
+    shiftKey: e.shiftKey,
+    clientX: e.clientX,
+    clientY: e.clientY,
+    pageX: e.pageX,
+    pageY: e.pageY
+  };
+}
+var si = function(t) {
+  var r = [], n = null, i = function() {
+    for (var u = arguments.length, c = new Array(u), s = 0; s < u; s++)
+      c[s] = arguments[s];
+    r = c, !n && (n = requestAnimationFrame(function() {
+      n = null, t.apply(void 0, r);
+    }));
+  };
+  return i.cancel = function() {
+    n && (cancelAnimationFrame(n), n = null);
+  }, i;
+}, Pe = si(function(e) {
+  return e();
+}), pe = /* @__PURE__ */ function() {
+  var e = null;
+  function t(n) {
+    var i = requestAnimationFrame(function() {
+      e = null, n();
+    });
+    e = {
+      frameId: i,
+      fn: n
+    };
+  }
+  function r() {
+    e && (cancelAnimationFrame(e.frameId), e.fn(), e = null);
+  }
+  return {
+    schedule: t,
+    flush: r
+  };
+}();
+function ui(e) {
+  var t = e.source, r = e.initial, n = e.dispatchEvent, i = {
+    dropTargets: []
+  };
+  function a(c) {
+    n(c), i = {
+      dropTargets: c.payload.location.current.dropTargets
+    };
+  }
+  var u = {
+    start: function(s) {
+      var o = s.nativeSetDragImage, f = {
+        current: r,
+        previous: i,
+        initial: r
+      };
+      a({
+        eventName: "onGenerateDragPreview",
+        payload: {
+          source: t,
+          location: f,
+          nativeSetDragImage: o
+        }
+      }), pe.schedule(function() {
+        a({
+          eventName: "onDragStart",
+          payload: {
+            source: t,
+            location: f
+          }
+        });
+      });
+    },
+    dragUpdate: function(s) {
+      var o = s.current;
+      pe.flush(), Pe.cancel(), a({
+        eventName: "onDropTargetChange",
+        payload: {
+          source: t,
+          location: {
+            initial: r,
+            previous: i,
+            current: o
+          }
+        }
+      });
+    },
+    drag: function(s) {
+      var o = s.current;
+      Pe(function() {
+        pe.flush();
+        var f = {
+          initial: r,
+          previous: i,
+          current: o
+        };
+        a({
+          eventName: "onDrag",
+          payload: {
+            source: t,
+            location: f
+          }
+        });
+      });
+    },
+    drop: function(s) {
+      var o = s.current, f = s.updatedSourcePayload;
+      pe.flush(), Pe.cancel(), a({
+        eventName: "onDrop",
+        payload: {
+          source: f ?? t,
+          location: {
+            current: o,
+            previous: i,
+            initial: r
+          }
+        }
+      });
+    }
+  };
+  return u;
+}
+var We = {
+  isActive: !1
+};
+function Xt() {
+  return !We.isActive;
+}
+function ci(e) {
+  return e.dataTransfer ? e.dataTransfer.setDragImage.bind(e.dataTransfer) : null;
+}
+function li(e) {
+  var t = e.current, r = e.next;
+  if (t.length !== r.length)
+    return !0;
+  for (var n = 0; n < t.length; n++)
+    if (t[n].element !== r[n].element)
+      return !0;
+  return !1;
+}
+function di(e) {
+  var t = e.event, r = e.dragType, n = e.getDropTargetsOver, i = e.dispatchEvent;
+  if (!Xt())
+    return;
+  var a = fi({
+    event: t,
+    dragType: r,
+    getDropTargetsOver: n
+  });
+  We.isActive = !0;
+  var u = {
+    current: a
+  };
+  Re({
+    event: t,
+    current: a.dropTargets
+  });
+  var c = ui({
+    source: r.payload,
+    dispatchEvent: i,
+    initial: a
+  });
+  function s(h) {
+    var g = li({
+      current: u.current.dropTargets,
+      next: h.dropTargets
+    });
+    u.current = h, g && c.dragUpdate({
+      current: u.current
+    });
+  }
+  function o(h) {
+    var g = ue(h), p = Bt(h.target) ? $t({
+      x: g.clientX,
+      y: g.clientY
+    }) : h.target, m = n({
+      target: p,
+      input: g,
+      source: r.payload,
+      current: u.current.dropTargets
+    });
+    m.length && (h.preventDefault(), Re({
+      event: h,
+      current: m
+    })), s({
+      dropTargets: m,
+      input: g
+    });
+  }
+  function f() {
+    u.current.dropTargets.length && s({
+      dropTargets: [],
+      input: u.current.input
+    }), c.drop({
+      current: u.current,
+      updatedSourcePayload: null
+    }), l();
+  }
+  function l() {
+    We.isActive = !1, d();
+  }
+  var d = te.bindAll(
+    window,
+    [{
+      // 👋 Note: we are repurposing the `dragover` event as our `drag` event
+      // this is because firefox does not publish pointer coordinates during
+      // a `drag` event, but does for every other type of drag event
+      // `dragover` fires on all elements that are being dragged over
+      // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
+      // 🦊😤
+      type: "dragover",
+      listener: function(g) {
+        o(g), c.drag({
+          current: u.current
+        });
+      }
+    }, {
+      type: "dragenter",
+      listener: o
+    }, {
+      type: "dragleave",
+      listener: function(g) {
+        ai({
+          dragLeave: g
+        }) && (s({
+          input: u.current.input,
+          dropTargets: []
+        }), r.startedFrom === "external" && f());
+      }
+    }, {
+      // A "drop" can only happen if the browser allowed the drop
+      type: "drop",
+      listener: function(g) {
+        if (u.current = {
+          dropTargets: u.current.dropTargets,
+          input: ue(g)
+        }, !u.current.dropTargets.length) {
+          f();
+          return;
+        }
+        g.preventDefault(), Re({
+          event: g,
+          current: u.current.dropTargets
+        }), c.drop({
+          current: u.current,
+          // When dropping something native, we need to extract the latest
+          // `.items` from the "drop" event as it is now accessible
+          updatedSourcePayload: r.type === "external" ? r.getDropPayload(g) : null
+        }), l();
+      }
+    }, {
+      // "dragend" fires when on the drag source (eg a draggable element)
+      // when the drag is finished.
+      // "dragend" will fire after "drop" (if there was a successful drop)
+      // "dragend" does not fire if the draggable source has been removed during the drag
+      // or for external drag sources (eg files)
+      // This "dragend" listener will not fire if there was a successful drop
+      // as we will have already removed the event listener
+      type: "dragend",
+      listener: function(g) {
+        u.current = {
+          dropTargets: u.current.dropTargets,
+          input: ue(g)
+        }, f();
+      }
+    }].concat(qt(oi({
+      onDragEnd: f
+    }))),
+    // Once we have started a managed drag operation it is important that we see / own all drag events
+    // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
+    // all "drop" events in the bubble phase on the `document.body`.
+    // This meant that we never saw the "drop" event.
+    {
+      capture: !0
+    }
+  );
+  c.start({
+    nativeSetDragImage: ci(t)
+  });
+}
+function Re(e) {
+  var t, r = e.event, n = e.current, i = (t = n[0]) === null || t === void 0 ? void 0 : t.dropEffect;
+  i != null && r.dataTransfer && (r.dataTransfer.dropEffect = i);
+}
+function fi(e) {
+  var t = e.event, r = e.dragType, n = e.getDropTargetsOver, i = ue(t);
+  if (r.startedFrom === "external")
+    return {
+      input: i,
+      dropTargets: []
+    };
+  var a = n({
+    input: i,
+    source: r.payload,
+    target: t.target,
+    current: []
+  });
+  return {
+    input: i,
+    dropTargets: a
+  };
+}
+var lt = {
+  canStart: Xt,
+  start: di
+}, Le = /* @__PURE__ */ new Map();
+function hi(e) {
+  var t = e.typeKey, r = e.mount, n = Le.get(t);
+  if (n)
+    return n.usageCount++, n;
+  var i = {
+    typeKey: t,
+    unmount: r(),
+    usageCount: 1
+  };
+  return Le.set(t, i), i;
+}
+function gi(e) {
+  var t = hi(e);
+  return function() {
+    t.usageCount--, !(t.usageCount > 0) && (t.unmount(), Le.delete(e.typeKey));
+  };
+}
+function Xe() {
+  for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++)
+    t[r] = arguments[r];
+  return function() {
+    t.forEach(function(i) {
+      return i();
+    });
+  };
+}
+function Ut(e, t) {
+  var r = t.attribute, n = t.value;
+  return e.setAttribute(r, n), function() {
+    return e.removeAttribute(r);
+  };
+}
+function dt(e, t) {
+  var r = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    t && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function F(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? dt(Object(r), !0).forEach(function(n) {
+      $e(e, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : dt(Object(r)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return e;
+}
+function ke(e, t) {
+  var r = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!r) {
+    if (Array.isArray(e) || (r = pi(e)) || t) {
+      r && (e = r);
+      var n = 0, i = function() {
+      };
+      return { s: i, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(o) {
+        throw o;
+      }, f: i };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var a, u = !0, c = !1;
+  return { s: function() {
+    r = r.call(e);
+  }, n: function() {
+    var o = r.next();
+    return u = o.done, o;
+  }, e: function(o) {
+    c = !0, a = o;
+  }, f: function() {
+    try {
+      u || r.return == null || r.return();
+    } finally {
+      if (c) throw a;
+    }
+  } };
+}
+function pi(e, t) {
+  if (e) {
+    if (typeof e == "string") return ft(e, t);
+    var r = {}.toString.call(e).slice(8, -1);
+    return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? ft(e, t) : void 0;
+  }
+}
+function ft(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
+  return n;
+}
+function Ne(e) {
+  return e.slice(0).reverse();
+}
+function mi(e) {
+  var t = e.typeKey, r = e.defaultDropEffect, n = /* @__PURE__ */ new WeakMap(), i = "data-drop-target-for-".concat(t), a = "[".concat(i, "]");
+  function u(h) {
+    return n.set(h.element, h), function() {
+      return n.delete(h.element);
+    };
+  }
+  function c(h) {
+    if (process.env.NODE_ENV !== "production") {
+      var g = n.get(h.element);
+      g && console.warn("You have already registered a [".concat(t, "] dropTarget on the same element"), {
+        existing: g,
+        proposed: h
+      }), h.element instanceof HTMLIFrameElement && console.warn(`
+            We recommend not registering <iframe> elements as drop targets
+            as it can result in some strange browser event ordering.
+          `.replace(/\s{2,}/g, " ").trim());
+    }
+    var p = Xe(Ut(h.element, {
+      attribute: i,
+      value: "true"
+    }), u(h));
+    return ne(p);
+  }
+  function s(h) {
+    var g, p, m, b, O = h.source, x = h.target, w = h.input, M = h.result, S = M === void 0 ? [] : M;
+    if (x == null)
+      return S;
+    if (!(x instanceof Element))
+      return x instanceof Node ? s({
+        source: O,
+        target: x.parentElement,
+        input: w,
+        result: S
+      }) : S;
+    var z = x.closest(a);
+    if (z == null)
+      return S;
+    var E = n.get(z);
+    if (E == null)
+      return S;
+    var y = {
+      input: w,
+      source: O,
+      element: E.element
+    };
+    if (E.canDrop && !E.canDrop(y))
+      return s({
+        source: O,
+        target: E.element.parentElement,
+        input: w,
+        result: S
+      });
+    var D = (g = (p = E.getData) === null || p === void 0 ? void 0 : p.call(E, y)) !== null && g !== void 0 ? g : {}, P = (m = (b = E.getDropEffect) === null || b === void 0 ? void 0 : b.call(E, y)) !== null && m !== void 0 ? m : r, R = {
+      data: D,
+      element: E.element,
+      dropEffect: P,
+      // we are collecting _actual_ drop targets, so these are
+      // being applied _not_ due to stickiness
+      isActiveDueToStickiness: !1
+    };
+    return s({
+      source: O,
+      target: E.element.parentElement,
+      input: w,
+      // Using bubble ordering. Same ordering as `event.getPath()`
+      result: [].concat(qt(S), [R])
+    });
+  }
+  function o(h) {
+    var g = h.eventName, p = h.payload, m = ke(p.location.current.dropTargets), b;
+    try {
+      for (m.s(); !(b = m.n()).done; ) {
+        var O, x = b.value, w = n.get(x.element), M = F(F({}, p), {}, {
+          self: x
+        });
+        w == null || (O = w[g]) === null || O === void 0 || O.call(
+          w,
+          // I cannot seem to get the types right here.
+          // TS doesn't seem to like that one event can need `nativeSetDragImage`
+          // @ts-expect-error
+          M
+        );
+      }
+    } catch (S) {
+      m.e(S);
+    } finally {
+      m.f();
+    }
+  }
+  var f = {
+    onGenerateDragPreview: o,
+    onDrag: o,
+    onDragStart: o,
+    onDrop: o,
+    onDropTargetChange: function(g) {
+      var p = g.payload, m = new Set(p.location.current.dropTargets.map(function(q) {
+        return q.element;
+      })), b = /* @__PURE__ */ new Set(), O = ke(p.location.previous.dropTargets), x;
+      try {
+        for (O.s(); !(x = O.n()).done; ) {
+          var w, M = x.value;
+          b.add(M.element);
+          var S = n.get(M.element), z = m.has(M.element), E = F(F({}, p), {}, {
+            self: M
+          });
+          if (S == null || (w = S.onDropTargetChange) === null || w === void 0 || w.call(S, E), !z) {
+            var y;
+            S == null || (y = S.onDragLeave) === null || y === void 0 || y.call(S, E);
+          }
+        }
+      } catch (q) {
+        O.e(q);
+      } finally {
+        O.f();
+      }
+      var D = ke(p.location.current.dropTargets), P;
+      try {
+        for (D.s(); !(P = D.n()).done; ) {
+          var R, L, $ = P.value;
+          if (!b.has($.element)) {
+            var V = F(F({}, p), {}, {
+              self: $
+            }), A = n.get($.element);
+            A == null || (R = A.onDropTargetChange) === null || R === void 0 || R.call(A, V), A == null || (L = A.onDragEnter) === null || L === void 0 || L.call(A, V);
+          }
+        }
+      } catch (q) {
+        D.e(q);
+      } finally {
+        D.f();
+      }
+    }
+  };
+  function l(h) {
+    f[h.eventName](h);
+  }
+  function d(h) {
+    var g = h.source, p = h.target, m = h.input, b = h.current, O = s({
+      source: g,
+      target: p,
+      input: m
+    });
+    if (O.length >= b.length)
+      return O;
+    for (var x = Ne(b), w = Ne(O), M = [], S = 0; S < x.length; S++) {
+      var z, E = x[S], y = w[S];
+      if (y != null) {
+        M.push(y);
+        continue;
+      }
+      var D = M[S - 1], P = x[S - 1];
+      if ((D == null ? void 0 : D.element) !== (P == null ? void 0 : P.element))
+        break;
+      var R = n.get(E.element);
+      if (!R)
+        break;
+      var L = {
+        input: m,
+        source: g,
+        element: R.element
+      };
+      if (R.canDrop && !R.canDrop(L) || !((z = R.getIsSticky) !== null && z !== void 0 && z.call(R, L)))
+        break;
+      M.push(F(F({}, E), {}, {
+        // making it clear to consumers this drop target is active due to stickiness
+        isActiveDueToStickiness: !0
+      }));
+    }
+    return Ne(M);
+  }
+  return {
+    dropTargetForConsumers: c,
+    getIsOver: d,
+    dispatchEvent: l
+  };
+}
+function yi(e, t) {
+  var r = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!r) {
+    if (Array.isArray(e) || (r = vi(e)) || t) {
+      r && (e = r);
+      var n = 0, i = function() {
+      };
+      return { s: i, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(o) {
+        throw o;
+      }, f: i };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var a, u = !0, c = !1;
+  return { s: function() {
+    r = r.call(e);
+  }, n: function() {
+    var o = r.next();
+    return u = o.done, o;
+  }, e: function(o) {
+    c = !0, a = o;
+  }, f: function() {
+    try {
+      u || r.return == null || r.return();
+    } finally {
+      if (c) throw a;
+    }
+  } };
+}
+function vi(e, t) {
+  if (e) {
+    if (typeof e == "string") return ht(e, t);
+    var r = {}.toString.call(e).slice(8, -1);
+    return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? ht(e, t) : void 0;
+  }
+}
+function ht(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
+  return n;
+}
+function gt(e, t) {
+  var r = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    t && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function bi(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var r = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? gt(Object(r), !0).forEach(function(n) {
+      $e(e, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : gt(Object(r)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return e;
+}
+function wi() {
+  var e = /* @__PURE__ */ new Set(), t = null;
+  function r(a) {
+    t && (!a.canMonitor || a.canMonitor(t.canMonitorArgs)) && t.active.add(a);
+  }
+  function n(a) {
+    var u = bi({}, a);
+    e.add(u), r(u);
+    function c() {
+      e.delete(u), t && t.active.delete(u);
+    }
+    return ne(c);
+  }
+  function i(a) {
+    var u = a.eventName, c = a.payload;
+    if (u === "onGenerateDragPreview") {
+      t = {
+        canMonitorArgs: {
+          initial: c.location.initial,
+          source: c.source
+        },
+        active: /* @__PURE__ */ new Set()
+      };
+      var s = yi(e), o;
+      try {
+        for (s.s(); !(o = s.n()).done; ) {
+          var f = o.value;
+          r(f);
+        }
+      } catch (m) {
+        s.e(m);
+      } finally {
+        s.f();
+      }
+    }
+    if (t) {
+      for (var l = Array.from(t.active), d = 0, h = l; d < h.length; d++) {
+        var g = h[d];
+        if (t.active.has(g)) {
+          var p;
+          (p = g[u]) === null || p === void 0 || p.call(g, c);
+        }
+      }
+      u === "onDrop" && (t.active.clear(), t = null);
+    }
+  }
+  return {
+    dispatchEvent: i,
+    monitorForConsumers: n
+  };
+}
+function xi(e) {
+  var t = e.typeKey, r = e.mount, n = e.dispatchEventToSource, i = e.onPostDispatch, a = e.defaultDropEffect, u = wi(), c = mi({
+    typeKey: t,
+    defaultDropEffect: a
+  });
+  function s(l) {
+    n == null || n(l), c.dispatchEvent(l), u.dispatchEvent(l), i == null || i(l);
+  }
+  function o(l) {
+    var d = l.event, h = l.dragType;
+    lt.start({
+      event: d,
+      dragType: h,
+      getDropTargetsOver: c.getIsOver,
+      dispatchEvent: s
+    });
+  }
+  function f() {
+    function l() {
+      var d = {
+        canStart: lt.canStart,
+        start: o
+      };
+      return r(d);
+    }
+    return gi({
+      typeKey: t,
+      mount: l
+    });
+  }
+  return {
+    registerUsage: f,
+    dropTarget: c.dropTargetForConsumers,
+    monitor: u.monitorForConsumers
+  };
+}
+var Si = ne(function() {
+  return navigator.userAgent.toLocaleLowerCase().includes("android");
+}), Oi = "pdnd:android-fallback", pt = "text/plain", Di = "text/uri-list", Ti = "application/vnd.pdnd", he = /* @__PURE__ */ new WeakMap();
+function Mi(e) {
+  return he.set(e.element, e), function() {
+    he.delete(e.element);
+  };
+}
+var mt = Qn(), Ue = xi({
+  typeKey: "element",
+  defaultDropEffect: "move",
+  mount: function(t) {
+    return Xe(mt.bindEvents(), te.bind(document, {
+      type: "dragstart",
+      listener: function(n) {
+        var i, a, u, c, s, o;
+        if (t.canStart(n) && !n.defaultPrevented) {
+          if (!n.dataTransfer) {
+            process.env.NODE_ENV !== "production" && console.warn(`
+              It appears as though you have are not testing DragEvents correctly.
+
+              - If you are unit testing, ensure you have polyfilled DragEvent.
+              - If you are browser testing, ensure you are dispatching drag events correctly.
+
+              Please see our testing guides for more information:
+              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing
+            `.replace(/ {2}/g, ""));
+            return;
+          }
+          var f = n.target;
+          if (!(f instanceof HTMLElement))
+            return null;
+          var l = he.get(f);
+          if (!l)
+            return null;
+          var d = ue(n), h = {
+            element: l.element,
+            dragHandle: (i = l.dragHandle) !== null && i !== void 0 ? i : null,
+            input: d
+          };
+          if (l.canDrag && !l.canDrag(h))
+            return n.preventDefault(), null;
+          if (l.dragHandle) {
+            var g = $t({
+              x: d.clientX,
+              y: d.clientY
+            });
+            if (!l.dragHandle.contains(g))
+              return n.preventDefault(), null;
+          }
+          var p = (a = (u = l.getInitialDataForExternal) === null || u === void 0 ? void 0 : u.call(l, h)) !== null && a !== void 0 ? a : null;
+          if (p)
+            for (var m = 0, b = Object.entries(p); m < b.length; m++) {
+              var O = jt(b[m], 2), x = O[0], w = O[1];
+              n.dataTransfer.setData(x, w ?? "");
+            }
+          Si() && !n.dataTransfer.types.includes(pt) && !n.dataTransfer.types.includes(Di) && n.dataTransfer.setData(pt, Oi), n.dataTransfer.setData(Ti, "");
+          var M = {
+            element: l.element,
+            dragHandle: (c = l.dragHandle) !== null && c !== void 0 ? c : null,
+            data: (s = (o = l.getInitialData) === null || o === void 0 ? void 0 : o.call(l, h)) !== null && s !== void 0 ? s : {}
+          }, S = {
+            type: "element",
+            payload: M,
+            startedFrom: "internal"
+          };
+          t.start({
+            event: n,
+            dragType: S
+          });
+        }
+      }
+    }));
+  },
+  dispatchEventToSource: function(t) {
+    var r, n, i = t.eventName, a = t.payload;
+    (r = he.get(a.source.element)) === null || r === void 0 || (n = r[i]) === null || n === void 0 || n.call(
+      r,
+      // I cannot seem to get the types right here.
+      // TS doesn't seem to like that one event can need `nativeSetDragImage`
+      // @ts-expect-error
+      a
+    );
+  },
+  onPostDispatch: mt.getOnPostDispatch()
+}), Ei = Ue.dropTarget, Pi = Ue.monitor;
+function Ri(e) {
+  if (process.env.NODE_ENV !== "production" && e.dragHandle && !e.element.contains(e.dragHandle) && console.warn("Drag handle element must be contained in draggable element", {
+    element: e.element,
+    dragHandle: e.dragHandle
+  }), process.env.NODE_ENV !== "production") {
+    var t = he.get(e.element);
+    t && console.warn("You have already registered a `draggable` on the same element", {
+      existing: t,
+      proposed: e
+    });
+  }
+  var r = Xe(
+    // making the draggable register the adapter rather than drop targets
+    // this is because you *must* have a draggable element to start a drag
+    // but you _might_ not have any drop targets immediately
+    // (You might create drop targets async)
+    Ue.registerUsage(),
+    Mi(e),
+    Ut(e.element, {
+      attribute: "draggable",
+      value: "true"
+    })
+  );
+  return ne(r);
+}
+var ki = process.env.NODE_ENV === "production", yt = "Invariant failed";
+function He(e, t) {
+  if (!e) {
+    if (ki)
+      throw new Error(yt);
+    var r = yt;
+    throw new Error(r);
+  }
+}
+function Ni({
+  children: e,
+  onDragStart: t = () => {
+  },
+  onDrag: r = () => {
+  },
+  onDrop: n = () => {
+  },
+  onDragEnter: i = () => {
+  },
+  onDragLeave: a = () => {
+  }
+}) {
+  const u = ce(null);
+  return ee(() => {
+    const c = u.current;
+    return He(c), Ei({
+      element: c,
+      getData: () => ({ drop: "drop" }),
+      onDragStart: ({ source: s, location: o }) => {
+        const f = me(o), l = Z(s, o);
+        t(f, l, s.data);
+      },
+      onDragEnter: ({ source: s, location: o }) => {
+        const f = me(o), l = Z(s, o);
+        i(f, l, s.data);
+      },
+      onDrag: ({ source: s, location: o }) => {
+        const f = me(o), l = Z(s, o);
+        r(f, l, s.data);
+      },
+      onDrop: ({ source: s, location: o }) => {
+        const f = me(o), l = Z(s, o);
+        n(f, l, s.data);
+      },
+      onDragLeave: ({ source: s, location: o }) => {
+        const f = Z(s, o);
+        a(f, s.data);
+      }
+    });
+  }, [r, a, t, n, i]), /* @__PURE__ */ v("div", { className: "timeline-drop-target", ref: u, children: e });
+}
+function me(e) {
+  const t = e.current.dropTargets[0].element.getBoundingClientRect();
+  return {
+    x: e.current.input.pageX - t.x,
+    y: e.current.input.pageY - t.y
+  };
+}
+function Ai({
+  x: e,
+  y: t,
+  width: r,
+  height: n,
+  children: i
+}) {
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      className: "timeline-drop-preview",
+      style: {
+        left: `${e}px`,
+        top: `${t}px`,
+        width: `${r}px`,
+        height: `${n}px`
+      },
+      children: i
+    }
+  );
+}
+function zi(e, t, r, n, i, a, u, c, s) {
+  if (n === null)
+    return null;
+  const o = Ye(
+    e,
+    a,
+    c
+  ), f = t.filter((d) => d.id !== r.id).map((d) => Fe(d, e, c, a));
+  let l = null;
+  return l = Ci(
+    e,
+    r,
+    i,
+    a,
+    n
+  ), l = Wi(l, u), l = _i(
+    l,
+    o
+  ), l = Li(
+    l,
+    f,
+    o,
+    s
+  ), l;
+}
+function Ci(e, t, r, n, i) {
+  const { width: a, height: u } = Lt(t, e, n), c = i.x + a * r.relative.x, s = i.y + u * r.relative.y;
+  return {
+    x: c,
+    y: s,
+    width: a,
+    height: u
+  };
+}
+function _i(e, t) {
+  const r = Math.max(
+    0,
+    Math.min(e.x, t.width - e.width)
+  ), n = Math.max(
+    0,
+    Math.min(e.y, t.height - e.height)
+  );
+  return {
+    ...e,
+    x: r,
+    y: n
+  };
+}
+function Wi(e, t) {
+  const r = {
+    ...e
+  };
+  return t && t.x && (r.x = vt(r.x, t.x, t.offsetX || 0)), t && t.y && (r.y = vt(r.y, t.y, t.offsetY || 0)), r;
+}
+function vt(e, t, r) {
+  return Math.max(
+    r,
+    r + Math.round((e - r) / t) * t
+  );
+}
+function Li(e, t, r, n) {
+  const i = {
+    ...e
+  };
+  if (!n) {
+    let a = !0;
+    for (; a; ) {
+      const u = t.find((c) => se(i, c));
+      u !== void 0 ? i.y = u.y + u.height : a = !1;
+    }
+  }
+  return ji(i, r) ? i : null;
+}
+function se(e, t) {
+  return !(e.x >= t.x + t.width || t.x >= e.x + e.width || e.y >= t.y + t.height || t.y >= e.y + e.height);
+}
+function Hi(e, t) {
+  const r = Math.max(e.x, t.x), n = Math.max(e.y, t.y), i = Math.min(e.x + e.width, t.x + t.width), a = Math.min(e.y + e.height, t.y + t.height);
+  return r < i && n < a ? {
+    x: r,
+    y: n,
+    width: i - r,
+    height: a - n
+  } : null;
+}
+function Ii(e, t) {
+  return !(e.start >= t.end || t.start >= e.end || e.offset >= t.offset + t.size || t.offset >= e.offset + e.size);
+}
+function ji(e, t) {
+  return e.x >= 0 && e.y >= 0 && e.x + e.width <= t.width && e.y + e.height <= t.height;
+}
+function Yi(e, t, r, n, i) {
+  const a = Fi(
+    e,
+    t,
+    r.capacity,
+    n
+  );
+  if (a) {
+    const u = Bi(
+      e,
+      i.start,
+      i.end,
+      n,
+      a
+    );
+    if (u)
+      return {
+        start: u.lower,
+        end: u.upper,
+        minOffset: a.lower,
+        maxOffset: a.upper
+      };
+  }
+  return null;
+}
+function Fi(e, t, r, n) {
+  const i = n.filter((f) => f.start <= e && f.end >= e);
+  if (i.find(
+    (f) => f.offset <= t && f.offset + f.size >= t
+  ))
+    return null;
+  const u = i.filter((f) => f.offset + f.size <= t), c = i.filter((f) => f.offset >= t), s = u.length > 0 ? Math.max(...u.map((f) => f.offset + f.size)) : 0, o = c.length > 0 ? Math.min(...c.map((f) => f.offset)) : r;
+  return {
+    lower: s,
+    upper: o
+  };
+}
+function Bi(e, t, r, n, i) {
+  const a = {
+    start: t,
+    end: r,
+    offset: i.lower,
+    size: i.upper - i.lower
+  }, u = n.filter(
+    (l) => Ii(l, a)
+  );
+  if (u.length === 0)
+    return {
+      lower: t,
+      upper: r
+    };
+  const c = u.filter((l) => l.end <= e), s = u.filter((l) => l.start >= e), o = c.length > 0 ? pr(c.map((l) => l.end)) : t, f = s.length > 0 ? mr(s.map((l) => l.start)) : r;
+  return {
+    lower: o,
+    upper: f
+  };
+}
+var ye = { exports: {} }, C = {};
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var bt;
+function $i() {
+  if (bt) return C;
+  bt = 1;
+  var e = Rt;
+  function t(s) {
+    var o = "https://react.dev/errors/" + s;
+    if (1 < arguments.length) {
+      o += "?args[]=" + encodeURIComponent(arguments[1]);
+      for (var f = 2; f < arguments.length; f++)
+        o += "&args[]=" + encodeURIComponent(arguments[f]);
+    }
+    return "Minified React error #" + s + "; visit " + o + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+  }
+  function r() {
+  }
+  var n = {
+    d: {
+      f: r,
+      r: function() {
+        throw Error(t(522));
+      },
+      D: r,
+      C: r,
+      L: r,
+      m: r,
+      X: r,
+      S: r,
+      M: r
+    },
+    p: 0,
+    findDOMNode: null
+  }, i = Symbol.for("react.portal");
+  function a(s, o, f) {
+    var l = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+    return {
+      $$typeof: i,
+      key: l == null ? null : "" + l,
+      children: s,
+      containerInfo: o,
+      implementation: f
+    };
+  }
+  var u = e.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  function c(s, o) {
+    if (s === "font") return "";
+    if (typeof o == "string")
+      return o === "use-credentials" ? o : "";
+  }
+  return C.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = n, C.createPortal = function(s, o) {
+    var f = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
+    if (!o || o.nodeType !== 1 && o.nodeType !== 9 && o.nodeType !== 11)
+      throw Error(t(299));
+    return a(s, o, null, f);
+  }, C.flushSync = function(s) {
+    var o = u.T, f = n.p;
+    try {
+      if (u.T = null, n.p = 2, s) return s();
+    } finally {
+      u.T = o, n.p = f, n.d.f();
+    }
+  }, C.preconnect = function(s, o) {
+    typeof s == "string" && (o ? (o = o.crossOrigin, o = typeof o == "string" ? o === "use-credentials" ? o : "" : void 0) : o = null, n.d.C(s, o));
+  }, C.prefetchDNS = function(s) {
+    typeof s == "string" && n.d.D(s);
+  }, C.preinit = function(s, o) {
+    if (typeof s == "string" && o && typeof o.as == "string") {
+      var f = o.as, l = c(f, o.crossOrigin), d = typeof o.integrity == "string" ? o.integrity : void 0, h = typeof o.fetchPriority == "string" ? o.fetchPriority : void 0;
+      f === "style" ? n.d.S(
+        s,
+        typeof o.precedence == "string" ? o.precedence : void 0,
+        {
+          crossOrigin: l,
+          integrity: d,
+          fetchPriority: h
+        }
+      ) : f === "script" && n.d.X(s, {
+        crossOrigin: l,
+        integrity: d,
+        fetchPriority: h,
+        nonce: typeof o.nonce == "string" ? o.nonce : void 0
+      });
+    }
+  }, C.preinitModule = function(s, o) {
+    if (typeof s == "string")
+      if (typeof o == "object" && o !== null) {
+        if (o.as == null || o.as === "script") {
+          var f = c(
+            o.as,
+            o.crossOrigin
+          );
+          n.d.M(s, {
+            crossOrigin: f,
+            integrity: typeof o.integrity == "string" ? o.integrity : void 0,
+            nonce: typeof o.nonce == "string" ? o.nonce : void 0
+          });
+        }
+      } else o == null && n.d.M(s);
+  }, C.preload = function(s, o) {
+    if (typeof s == "string" && typeof o == "object" && o !== null && typeof o.as == "string") {
+      var f = o.as, l = c(f, o.crossOrigin);
+      n.d.L(s, f, {
+        crossOrigin: l,
+        integrity: typeof o.integrity == "string" ? o.integrity : void 0,
+        nonce: typeof o.nonce == "string" ? o.nonce : void 0,
+        type: typeof o.type == "string" ? o.type : void 0,
+        fetchPriority: typeof o.fetchPriority == "string" ? o.fetchPriority : void 0,
+        referrerPolicy: typeof o.referrerPolicy == "string" ? o.referrerPolicy : void 0,
+        imageSrcSet: typeof o.imageSrcSet == "string" ? o.imageSrcSet : void 0,
+        imageSizes: typeof o.imageSizes == "string" ? o.imageSizes : void 0,
+        media: typeof o.media == "string" ? o.media : void 0
+      });
+    }
+  }, C.preloadModule = function(s, o) {
+    if (typeof s == "string")
+      if (o) {
+        var f = c(o.as, o.crossOrigin);
+        n.d.m(s, {
+          as: typeof o.as == "string" && o.as !== "script" ? o.as : void 0,
+          crossOrigin: f,
+          integrity: typeof o.integrity == "string" ? o.integrity : void 0
+        });
+      } else n.d.m(s);
+  }, C.requestFormReset = function(s) {
+    n.d.r(s);
+  }, C.unstable_batchedUpdates = function(s, o) {
+    return s(o);
+  }, C.useFormState = function(s, o, f) {
+    return u.H.useFormState(s, o, f);
+  }, C.useFormStatus = function() {
+    return u.H.useHostTransitionStatus();
+  }, C.version = "19.1.0", C;
+}
+var _ = {};
+/**
+ * @license React
+ * react-dom.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var wt;
+function qi() {
+  return wt || (wt = 1, process.env.NODE_ENV !== "production" && function() {
+    function e() {
+    }
+    function t(l) {
+      return "" + l;
+    }
+    function r(l, d, h) {
+      var g = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+      try {
+        t(g);
+        var p = !1;
+      } catch {
+        p = !0;
+      }
+      return p && (console.error(
+        "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+        typeof Symbol == "function" && Symbol.toStringTag && g[Symbol.toStringTag] || g.constructor.name || "Object"
+      ), t(g)), {
+        $$typeof: o,
+        key: g == null ? null : "" + g,
+        children: l,
+        containerInfo: d,
+        implementation: h
+      };
+    }
+    function n(l, d) {
+      if (l === "font") return "";
+      if (typeof d == "string")
+        return d === "use-credentials" ? d : "";
+    }
+    function i(l) {
+      return l === null ? "`null`" : l === void 0 ? "`undefined`" : l === "" ? "an empty string" : 'something with type "' + typeof l + '"';
+    }
+    function a(l) {
+      return l === null ? "`null`" : l === void 0 ? "`undefined`" : l === "" ? "an empty string" : typeof l == "string" ? JSON.stringify(l) : typeof l == "number" ? "`" + l + "`" : 'something with type "' + typeof l + '"';
+    }
+    function u() {
+      var l = f.H;
+      return l === null && console.error(
+        `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+      ), l;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var c = Rt, s = {
+      d: {
+        f: e,
+        r: function() {
+          throw Error(
+            "Invalid form element. requestFormReset must be passed a form that was rendered by React."
+          );
+        },
+        D: e,
+        C: e,
+        L: e,
+        m: e,
+        X: e,
+        S: e,
+        M: e
+      },
+      p: 0,
+      findDOMNode: null
+    }, o = Symbol.for("react.portal"), f = c.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+    typeof Map == "function" && Map.prototype != null && typeof Map.prototype.forEach == "function" && typeof Set == "function" && Set.prototype != null && typeof Set.prototype.clear == "function" && typeof Set.prototype.forEach == "function" || console.error(
+      "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
+    ), _.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = s, _.createPortal = function(l, d) {
+      var h = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
+      if (!d || d.nodeType !== 1 && d.nodeType !== 9 && d.nodeType !== 11)
+        throw Error("Target container is not a DOM element.");
+      return r(l, d, null, h);
+    }, _.flushSync = function(l) {
+      var d = f.T, h = s.p;
+      try {
+        if (f.T = null, s.p = 2, l)
+          return l();
+      } finally {
+        f.T = d, s.p = h, s.d.f() && console.error(
+          "flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
+        );
+      }
+    }, _.preconnect = function(l, d) {
+      typeof l == "string" && l ? d != null && typeof d != "object" ? console.error(
+        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+        a(d)
+      ) : d != null && typeof d.crossOrigin != "string" && console.error(
+        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+        i(d.crossOrigin)
+      ) : console.error(
+        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        i(l)
+      ), typeof l == "string" && (d ? (d = d.crossOrigin, d = typeof d == "string" ? d === "use-credentials" ? d : "" : void 0) : d = null, s.d.C(l, d));
+    }, _.prefetchDNS = function(l) {
+      if (typeof l != "string" || !l)
+        console.error(
+          "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          i(l)
+        );
+      else if (1 < arguments.length) {
+        var d = arguments[1];
+        typeof d == "object" && d.hasOwnProperty("crossOrigin") ? console.error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          a(d)
+        ) : console.error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          a(d)
+        );
+      }
+      typeof l == "string" && s.d.D(l);
+    }, _.preinit = function(l, d) {
+      if (typeof l == "string" && l ? d == null || typeof d != "object" ? console.error(
+        "ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
+        a(d)
+      ) : d.as !== "style" && d.as !== "script" && console.error(
+        'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
+        a(d.as)
+      ) : console.error(
+        "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        i(l)
+      ), typeof l == "string" && d && typeof d.as == "string") {
+        var h = d.as, g = n(h, d.crossOrigin), p = typeof d.integrity == "string" ? d.integrity : void 0, m = typeof d.fetchPriority == "string" ? d.fetchPriority : void 0;
+        h === "style" ? s.d.S(
+          l,
+          typeof d.precedence == "string" ? d.precedence : void 0,
+          {
+            crossOrigin: g,
+            integrity: p,
+            fetchPriority: m
+          }
+        ) : h === "script" && s.d.X(l, {
+          crossOrigin: g,
+          integrity: p,
+          fetchPriority: m,
+          nonce: typeof d.nonce == "string" ? d.nonce : void 0
+        });
+      }
+    }, _.preinitModule = function(l, d) {
+      var h = "";
+      if (typeof l == "string" && l || (h += " The `href` argument encountered was " + i(l) + "."), d !== void 0 && typeof d != "object" ? h += " The `options` argument encountered was " + i(d) + "." : d && "as" in d && d.as !== "script" && (h += " The `as` option encountered was " + a(d.as) + "."), h)
+        console.error(
+          "ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
+          h
+        );
+      else
+        switch (h = d && typeof d.as == "string" ? d.as : "script", h) {
+          case "script":
+            break;
+          default:
+            h = a(h), console.error(
+              'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
+              h,
+              l
+            );
+        }
+      typeof l == "string" && (typeof d == "object" && d !== null ? (d.as == null || d.as === "script") && (h = n(
+        d.as,
+        d.crossOrigin
+      ), s.d.M(l, {
+        crossOrigin: h,
+        integrity: typeof d.integrity == "string" ? d.integrity : void 0,
+        nonce: typeof d.nonce == "string" ? d.nonce : void 0
+      })) : d == null && s.d.M(l));
+    }, _.preload = function(l, d) {
+      var h = "";
+      if (typeof l == "string" && l || (h += " The `href` argument encountered was " + i(l) + "."), d == null || typeof d != "object" ? h += " The `options` argument encountered was " + i(d) + "." : typeof d.as == "string" && d.as || (h += " The `as` option encountered was " + i(d.as) + "."), h && console.error(
+        'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
+        h
+      ), typeof l == "string" && typeof d == "object" && d !== null && typeof d.as == "string") {
+        h = d.as;
+        var g = n(
+          h,
+          d.crossOrigin
+        );
+        s.d.L(l, h, {
+          crossOrigin: g,
+          integrity: typeof d.integrity == "string" ? d.integrity : void 0,
+          nonce: typeof d.nonce == "string" ? d.nonce : void 0,
+          type: typeof d.type == "string" ? d.type : void 0,
+          fetchPriority: typeof d.fetchPriority == "string" ? d.fetchPriority : void 0,
+          referrerPolicy: typeof d.referrerPolicy == "string" ? d.referrerPolicy : void 0,
+          imageSrcSet: typeof d.imageSrcSet == "string" ? d.imageSrcSet : void 0,
+          imageSizes: typeof d.imageSizes == "string" ? d.imageSizes : void 0,
+          media: typeof d.media == "string" ? d.media : void 0
+        });
+      }
+    }, _.preloadModule = function(l, d) {
+      var h = "";
+      typeof l == "string" && l || (h += " The `href` argument encountered was " + i(l) + "."), d !== void 0 && typeof d != "object" ? h += " The `options` argument encountered was " + i(d) + "." : d && "as" in d && typeof d.as != "string" && (h += " The `as` option encountered was " + i(d.as) + "."), h && console.error(
+        'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
+        h
+      ), typeof l == "string" && (d ? (h = n(
+        d.as,
+        d.crossOrigin
+      ), s.d.m(l, {
+        as: typeof d.as == "string" && d.as !== "script" ? d.as : void 0,
+        crossOrigin: h,
+        integrity: typeof d.integrity == "string" ? d.integrity : void 0
+      })) : s.d.m(l));
+    }, _.requestFormReset = function(l) {
+      s.d.r(l);
+    }, _.unstable_batchedUpdates = function(l, d) {
+      return l(d);
+    }, _.useFormState = function(l, d, h) {
+      return u().useFormState(l, d, h);
+    }, _.useFormStatus = function() {
+      return u().useHostTransitionStatus();
+    }, _.version = "19.1.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }()), _;
+}
+var xt;
+function Xi() {
+  if (xt) return ye.exports;
+  xt = 1;
+  function e() {
+    if (!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > "u" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != "function")) {
+      if (process.env.NODE_ENV !== "production")
+        throw new Error("^_^");
+      try {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e);
+      } catch (t) {
+        console.error(t);
+      }
+    }
+  }
+  return process.env.NODE_ENV === "production" ? (e(), ye.exports = $i()) : ye.exports = qi(), ye.exports;
+}
+var Ui = Xi(), k = function() {
+  return k = Object.assign || function(e) {
+    for (var t, r = 1, n = arguments.length; r < n; r++) {
+      t = arguments[r];
+      for (var i in t) Object.prototype.hasOwnProperty.call(t, i) && (e[i] = t[i]);
+    }
+    return e;
+  }, k.apply(this, arguments);
+}, St = {
+  width: "100%",
+  height: "10px",
+  top: "0px",
+  left: "0px",
+  cursor: "row-resize"
+}, Ot = {
+  width: "10px",
+  height: "100%",
+  top: "0px",
+  left: "0px",
+  cursor: "col-resize"
+}, ve = {
+  width: "20px",
+  height: "20px",
+  position: "absolute",
+  zIndex: 1
+}, Gi = {
+  top: k(k({}, St), { top: "-5px" }),
+  right: k(k({}, Ot), { left: void 0, right: "-5px" }),
+  bottom: k(k({}, St), { top: void 0, bottom: "-5px" }),
+  left: k(k({}, Ot), { left: "-5px" }),
+  topRight: k(k({}, ve), { right: "-10px", top: "-10px", cursor: "ne-resize" }),
+  bottomRight: k(k({}, ve), { right: "-10px", bottom: "-10px", cursor: "se-resize" }),
+  bottomLeft: k(k({}, ve), { left: "-10px", bottom: "-10px", cursor: "sw-resize" }),
+  topLeft: k(k({}, ve), { left: "-10px", top: "-10px", cursor: "nw-resize" })
+}, Ki = Jt(function(e) {
+  var t = e.onResizeStart, r = e.direction, n = e.children, i = e.replaceStyles, a = e.className, u = Ke(function(o) {
+    t(o, r);
+  }, [t, r]), c = Ke(function(o) {
+    t(o, r);
+  }, [t, r]), s = Zt(function() {
+    return k(k({ position: "absolute", userSelect: "none" }, Gi[r]), i ?? {});
+  }, [i, r]);
+  return v("div", { className: a || void 0, style: s, onMouseDown: u, onTouchStart: c, children: n });
+}), Vi = /* @__PURE__ */ function() {
+  var e = function(t, r) {
+    return e = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n, i) {
+      n.__proto__ = i;
+    } || function(n, i) {
+      for (var a in i) Object.prototype.hasOwnProperty.call(i, a) && (n[a] = i[a]);
+    }, e(t, r);
+  };
+  return function(t, r) {
+    if (typeof r != "function" && r !== null)
+      throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+    e(t, r);
+    function n() {
+      this.constructor = t;
+    }
+    t.prototype = r === null ? Object.create(r) : (n.prototype = r.prototype, new n());
+  };
+}(), H = function() {
+  return H = Object.assign || function(e) {
+    for (var t, r = 1, n = arguments.length; r < n; r++) {
+      t = arguments[r];
+      for (var i in t) Object.prototype.hasOwnProperty.call(t, i) && (e[i] = t[i]);
+    }
+    return e;
+  }, H.apply(this, arguments);
+}, Qi = {
+  width: "auto",
+  height: "auto"
+}, be = function(e, t, r) {
+  return Math.max(Math.min(e, r), t);
+}, Dt = function(e, t, r) {
+  var n = Math.round(e / t);
+  return n * t + r * (n - 1);
+}, J = function(e, t) {
+  return new RegExp(e, "i").test(t);
+}, we = function(e) {
+  return !!(e.touches && e.touches.length);
+}, Ji = function(e) {
+  return !!((e.clientX || e.clientX === 0) && (e.clientY || e.clientY === 0));
+}, Tt = function(e, t, r) {
+  r === void 0 && (r = 0);
+  var n = t.reduce(function(a, u, c) {
+    return Math.abs(u - e) < Math.abs(t[a] - e) ? c : a;
+  }, 0), i = Math.abs(t[n] - e);
+  return r === 0 || i < r ? t[n] : e;
+}, Ae = function(e) {
+  return e = e.toString(), e === "auto" || e.endsWith("px") || e.endsWith("%") || e.endsWith("vh") || e.endsWith("vw") || e.endsWith("vmax") || e.endsWith("vmin") ? e : "".concat(e, "px");
+}, xe = function(e, t, r, n) {
+  if (e && typeof e == "string") {
+    if (e.endsWith("px"))
+      return Number(e.replace("px", ""));
+    if (e.endsWith("%")) {
+      var i = Number(e.replace("%", "")) / 100;
+      return t * i;
+    }
+    if (e.endsWith("vw")) {
+      var i = Number(e.replace("vw", "")) / 100;
+      return r * i;
+    }
+    if (e.endsWith("vh")) {
+      var i = Number(e.replace("vh", "")) / 100;
+      return n * i;
+    }
+  }
+  return e;
+}, Zi = function(e, t, r, n, i, a, u) {
+  return n = xe(n, e.width, t, r), i = xe(i, e.height, t, r), a = xe(a, e.width, t, r), u = xe(u, e.height, t, r), {
+    maxWidth: typeof n > "u" ? void 0 : Number(n),
+    maxHeight: typeof i > "u" ? void 0 : Number(i),
+    minWidth: typeof a > "u" ? void 0 : Number(a),
+    minHeight: typeof u > "u" ? void 0 : Number(u)
+  };
+}, ea = function(e) {
+  return Array.isArray(e) ? e : [e, e];
+}, ta = [
+  "as",
+  "ref",
+  "style",
+  "className",
+  "grid",
+  "gridGap",
+  "snap",
+  "bounds",
+  "boundsByDirection",
+  "size",
+  "defaultSize",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "lockAspectRatio",
+  "lockAspectRatioExtraWidth",
+  "lockAspectRatioExtraHeight",
+  "enable",
+  "handleStyles",
+  "handleClasses",
+  "handleWrapperStyle",
+  "handleWrapperClass",
+  "children",
+  "onResizeStart",
+  "onResize",
+  "onResizeStop",
+  "handleComponent",
+  "scale",
+  "resizeRatio",
+  "snapGap"
+], Mt = "__resizable_base__", ra = (
+  /** @class */
+  function(e) {
+    Vi(t, e);
+    function t(r) {
+      var n, i, a, u, c = e.call(this, r) || this;
+      return c.ratio = 1, c.resizable = null, c.parentLeft = 0, c.parentTop = 0, c.resizableLeft = 0, c.resizableRight = 0, c.resizableTop = 0, c.resizableBottom = 0, c.targetLeft = 0, c.targetTop = 0, c.delta = {
+        width: 0,
+        height: 0
+      }, c.appendBase = function() {
+        if (!c.resizable || !c.window)
+          return null;
+        var s = c.parentNode;
+        if (!s)
+          return null;
+        var o = c.window.document.createElement("div");
+        return o.style.width = "100%", o.style.height = "100%", o.style.position = "absolute", o.style.transform = "scale(0, 0)", o.style.left = "0", o.style.flex = "0 0 100%", o.classList ? o.classList.add(Mt) : o.className += Mt, s.appendChild(o), o;
+      }, c.removeBase = function(s) {
+        var o = c.parentNode;
+        o && o.removeChild(s);
+      }, c.state = {
+        isResizing: !1,
+        width: (i = (n = c.propsSize) === null || n === void 0 ? void 0 : n.width) !== null && i !== void 0 ? i : "auto",
+        height: (u = (a = c.propsSize) === null || a === void 0 ? void 0 : a.height) !== null && u !== void 0 ? u : "auto",
+        direction: "right",
+        original: {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        },
+        backgroundStyle: {
+          height: "100%",
+          width: "100%",
+          backgroundColor: "rgba(0,0,0,0)",
+          cursor: "auto",
+          opacity: 0,
+          position: "fixed",
+          zIndex: 9999,
+          top: "0",
+          left: "0",
+          bottom: "0",
+          right: "0"
+        },
+        flexBasis: void 0
+      }, c.onResizeStart = c.onResizeStart.bind(c), c.onMouseMove = c.onMouseMove.bind(c), c.onMouseUp = c.onMouseUp.bind(c), c;
+    }
+    return Object.defineProperty(t.prototype, "parentNode", {
+      get: function() {
+        return this.resizable ? this.resizable.parentNode : null;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "window", {
+      get: function() {
+        return !this.resizable || !this.resizable.ownerDocument ? null : this.resizable.ownerDocument.defaultView;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "propsSize", {
+      get: function() {
+        return this.props.size || this.props.defaultSize || Qi;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "size", {
+      get: function() {
+        var r = 0, n = 0;
+        if (this.resizable && this.window) {
+          var i = this.resizable.offsetWidth, a = this.resizable.offsetHeight, u = this.resizable.style.position;
+          u !== "relative" && (this.resizable.style.position = "relative"), r = this.resizable.style.width !== "auto" ? this.resizable.offsetWidth : i, n = this.resizable.style.height !== "auto" ? this.resizable.offsetHeight : a, this.resizable.style.position = u;
+        }
+        return { width: r, height: n };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "sizeStyle", {
+      get: function() {
+        var r = this, n = this.props.size, i = function(c) {
+          var s;
+          if (typeof r.state[c] > "u" || r.state[c] === "auto")
+            return "auto";
+          if (r.propsSize && r.propsSize[c] && (!((s = r.propsSize[c]) === null || s === void 0) && s.toString().endsWith("%"))) {
+            if (r.state[c].toString().endsWith("%"))
+              return r.state[c].toString();
+            var o = r.getParentSize(), f = Number(r.state[c].toString().replace("px", "")), l = f / o[c] * 100;
+            return "".concat(l, "%");
+          }
+          return Ae(r.state[c]);
+        }, a = n && typeof n.width < "u" && !this.state.isResizing ? Ae(n.width) : i("width"), u = n && typeof n.height < "u" && !this.state.isResizing ? Ae(n.height) : i("height");
+        return { width: a, height: u };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), t.prototype.getParentSize = function() {
+      if (!this.parentNode)
+        return this.window ? { width: this.window.innerWidth, height: this.window.innerHeight } : { width: 0, height: 0 };
+      var r = this.appendBase();
+      if (!r)
+        return { width: 0, height: 0 };
+      var n = !1, i = this.parentNode.style.flexWrap;
+      i !== "wrap" && (n = !0, this.parentNode.style.flexWrap = "wrap"), r.style.position = "relative", r.style.minWidth = "100%", r.style.minHeight = "100%";
+      var a = {
+        width: r.offsetWidth,
+        height: r.offsetHeight
+      };
+      return n && (this.parentNode.style.flexWrap = i), this.removeBase(r), a;
+    }, t.prototype.bindEvents = function() {
+      this.window && (this.window.addEventListener("mouseup", this.onMouseUp), this.window.addEventListener("mousemove", this.onMouseMove), this.window.addEventListener("mouseleave", this.onMouseUp), this.window.addEventListener("touchmove", this.onMouseMove, {
+        capture: !0,
+        passive: !1
+      }), this.window.addEventListener("touchend", this.onMouseUp));
+    }, t.prototype.unbindEvents = function() {
+      this.window && (this.window.removeEventListener("mouseup", this.onMouseUp), this.window.removeEventListener("mousemove", this.onMouseMove), this.window.removeEventListener("mouseleave", this.onMouseUp), this.window.removeEventListener("touchmove", this.onMouseMove, !0), this.window.removeEventListener("touchend", this.onMouseUp));
+    }, t.prototype.componentDidMount = function() {
+      if (!(!this.resizable || !this.window)) {
+        var r = this.window.getComputedStyle(this.resizable);
+        this.setState({
+          width: this.state.width || this.size.width,
+          height: this.state.height || this.size.height,
+          flexBasis: r.flexBasis !== "auto" ? r.flexBasis : void 0
+        });
+      }
+    }, t.prototype.componentWillUnmount = function() {
+      this.window && this.unbindEvents();
+    }, t.prototype.createSizeForCssProperty = function(r, n) {
+      var i = this.propsSize && this.propsSize[n];
+      return this.state[n] === "auto" && this.state.original[n] === r && (typeof i > "u" || i === "auto") ? "auto" : r;
+    }, t.prototype.calculateNewMaxFromBoundary = function(r, n) {
+      var i = this.props.boundsByDirection, a = this.state.direction, u = i && J("left", a), c = i && J("top", a), s, o;
+      if (this.props.bounds === "parent") {
+        var f = this.parentNode;
+        f && (s = u ? this.resizableRight - this.parentLeft : f.offsetWidth + (this.parentLeft - this.resizableLeft), o = c ? this.resizableBottom - this.parentTop : f.offsetHeight + (this.parentTop - this.resizableTop));
+      } else this.props.bounds === "window" ? this.window && (s = u ? this.resizableRight : this.window.innerWidth - this.resizableLeft, o = c ? this.resizableBottom : this.window.innerHeight - this.resizableTop) : this.props.bounds && (s = u ? this.resizableRight - this.targetLeft : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft), o = c ? this.resizableBottom - this.targetTop : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop));
+      return s && Number.isFinite(s) && (r = r && r < s ? r : s), o && Number.isFinite(o) && (n = n && n < o ? n : o), { maxWidth: r, maxHeight: n };
+    }, t.prototype.calculateNewSizeFromDirection = function(r, n) {
+      var i = this.props.scale || 1, a = ea(this.props.resizeRatio || 1), u = a[0], c = a[1], s = this.state, o = s.direction, f = s.original, l = this.props, d = l.lockAspectRatio, h = l.lockAspectRatioExtraHeight, g = l.lockAspectRatioExtraWidth, p = f.width, m = f.height, b = h || 0, O = g || 0;
+      return J("right", o) && (p = f.width + (r - f.x) * u / i, d && (m = (p - O) / this.ratio + b)), J("left", o) && (p = f.width - (r - f.x) * u / i, d && (m = (p - O) / this.ratio + b)), J("bottom", o) && (m = f.height + (n - f.y) * c / i, d && (p = (m - b) * this.ratio + O)), J("top", o) && (m = f.height - (n - f.y) * c / i, d && (p = (m - b) * this.ratio + O)), { newWidth: p, newHeight: m };
+    }, t.prototype.calculateNewSizeFromAspectRatio = function(r, n, i, a) {
+      var u = this.props, c = u.lockAspectRatio, s = u.lockAspectRatioExtraHeight, o = u.lockAspectRatioExtraWidth, f = typeof a.width > "u" ? 10 : a.width, l = typeof i.width > "u" || i.width < 0 ? r : i.width, d = typeof a.height > "u" ? 10 : a.height, h = typeof i.height > "u" || i.height < 0 ? n : i.height, g = s || 0, p = o || 0;
+      if (c) {
+        var m = (d - g) * this.ratio + p, b = (h - g) * this.ratio + p, O = (f - p) / this.ratio + g, x = (l - p) / this.ratio + g, w = Math.max(f, m), M = Math.min(l, b), S = Math.max(d, O), z = Math.min(h, x);
+        r = be(r, w, M), n = be(n, S, z);
+      } else
+        r = be(r, f, l), n = be(n, d, h);
+      return { newWidth: r, newHeight: n };
+    }, t.prototype.setBoundingClientRect = function() {
+      var r = 1 / (this.props.scale || 1);
+      if (this.props.bounds === "parent") {
+        var n = this.parentNode;
+        if (n) {
+          var i = n.getBoundingClientRect();
+          this.parentLeft = i.left * r, this.parentTop = i.top * r;
+        }
+      }
+      if (this.props.bounds && typeof this.props.bounds != "string") {
+        var a = this.props.bounds.getBoundingClientRect();
+        this.targetLeft = a.left * r, this.targetTop = a.top * r;
+      }
+      if (this.resizable) {
+        var u = this.resizable.getBoundingClientRect(), c = u.left, s = u.top, o = u.right, f = u.bottom;
+        this.resizableLeft = c * r, this.resizableRight = o * r, this.resizableTop = s * r, this.resizableBottom = f * r;
+      }
+    }, t.prototype.onResizeStart = function(r, n) {
+      if (!(!this.resizable || !this.window)) {
+        var i = 0, a = 0;
+        if (r.nativeEvent && Ji(r.nativeEvent) ? (i = r.nativeEvent.clientX, a = r.nativeEvent.clientY) : r.nativeEvent && we(r.nativeEvent) && (i = r.nativeEvent.touches[0].clientX, a = r.nativeEvent.touches[0].clientY), this.props.onResizeStart && this.resizable) {
+          var u = this.props.onResizeStart(r, n, this.resizable);
+          if (u === !1)
+            return;
+        }
+        this.props.size && (typeof this.props.size.height < "u" && this.props.size.height !== this.state.height && this.setState({ height: this.props.size.height }), typeof this.props.size.width < "u" && this.props.size.width !== this.state.width && this.setState({ width: this.props.size.width })), this.ratio = typeof this.props.lockAspectRatio == "number" ? this.props.lockAspectRatio : this.size.width / this.size.height;
+        var c, s = this.window.getComputedStyle(this.resizable);
+        if (s.flexBasis !== "auto") {
+          var o = this.parentNode;
+          if (o) {
+            var f = this.window.getComputedStyle(o).flexDirection;
+            this.flexDir = f.startsWith("row") ? "row" : "column", c = s.flexBasis;
+          }
+        }
+        this.setBoundingClientRect(), this.bindEvents();
+        var l = {
+          original: {
+            x: i,
+            y: a,
+            width: this.size.width,
+            height: this.size.height
+          },
+          isResizing: !0,
+          backgroundStyle: H(H({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(r.target).cursor || "auto" }),
+          direction: n,
+          flexBasis: c
+        };
+        this.setState(l);
+      }
+    }, t.prototype.onMouseMove = function(r) {
+      var n = this;
+      if (!(!this.state.isResizing || !this.resizable || !this.window)) {
+        if (this.window.TouchEvent && we(r))
+          try {
+            r.preventDefault(), r.stopPropagation();
+          } catch {
+          }
+        var i = this.props, a = i.maxWidth, u = i.maxHeight, c = i.minWidth, s = i.minHeight, o = we(r) ? r.touches[0].clientX : r.clientX, f = we(r) ? r.touches[0].clientY : r.clientY, l = this.state, d = l.direction, h = l.original, g = l.width, p = l.height, m = this.getParentSize(), b = Zi(m, this.window.innerWidth, this.window.innerHeight, a, u, c, s);
+        a = b.maxWidth, u = b.maxHeight, c = b.minWidth, s = b.minHeight;
+        var O = this.calculateNewSizeFromDirection(o, f), x = O.newHeight, w = O.newWidth, M = this.calculateNewMaxFromBoundary(a, u);
+        this.props.snap && this.props.snap.x && (w = Tt(w, this.props.snap.x, this.props.snapGap)), this.props.snap && this.props.snap.y && (x = Tt(x, this.props.snap.y, this.props.snapGap));
+        var S = this.calculateNewSizeFromAspectRatio(w, x, { width: M.maxWidth, height: M.maxHeight }, { width: c, height: s });
+        if (w = S.newWidth, x = S.newHeight, this.props.grid) {
+          var z = Dt(w, this.props.grid[0], this.props.gridGap ? this.props.gridGap[0] : 0), E = Dt(x, this.props.grid[1], this.props.gridGap ? this.props.gridGap[1] : 0), y = this.props.snapGap || 0, D = y === 0 || Math.abs(z - w) <= y ? z : w, P = y === 0 || Math.abs(E - x) <= y ? E : x;
+          w = D, x = P;
+        }
+        var R = {
+          width: w - h.width,
+          height: x - h.height
+        };
+        if (this.delta = R, g && typeof g == "string") {
+          if (g.endsWith("%")) {
+            var L = w / m.width * 100;
+            w = "".concat(L, "%");
+          } else if (g.endsWith("vw")) {
+            var $ = w / this.window.innerWidth * 100;
+            w = "".concat($, "vw");
+          } else if (g.endsWith("vh")) {
+            var V = w / this.window.innerHeight * 100;
+            w = "".concat(V, "vh");
+          }
+        }
+        if (p && typeof p == "string") {
+          if (p.endsWith("%")) {
+            var L = x / m.height * 100;
+            x = "".concat(L, "%");
+          } else if (p.endsWith("vw")) {
+            var $ = x / this.window.innerWidth * 100;
+            x = "".concat($, "vw");
+          } else if (p.endsWith("vh")) {
+            var V = x / this.window.innerHeight * 100;
+            x = "".concat(V, "vh");
+          }
+        }
+        var A = {
+          width: this.createSizeForCssProperty(w, "width"),
+          height: this.createSizeForCssProperty(x, "height")
+        };
+        this.flexDir === "row" ? A.flexBasis = A.width : this.flexDir === "column" && (A.flexBasis = A.height);
+        var q = this.state.width !== A.width, Gt = this.state.height !== A.height, Kt = this.state.flexBasis !== A.flexBasis, Ge = q || Gt || Kt;
+        Ge && Ui.flushSync(function() {
+          n.setState(A);
+        }), this.props.onResize && Ge && this.props.onResize(r, d, this.resizable, R);
+      }
+    }, t.prototype.onMouseUp = function(r) {
+      var n, i, a = this.state, u = a.isResizing, c = a.direction;
+      a.original, !(!u || !this.resizable) && (this.props.onResizeStop && this.props.onResizeStop(r, c, this.resizable, this.delta), this.props.size && this.setState({ width: (n = this.props.size.width) !== null && n !== void 0 ? n : "auto", height: (i = this.props.size.height) !== null && i !== void 0 ? i : "auto" }), this.unbindEvents(), this.setState({
+        isResizing: !1,
+        backgroundStyle: H(H({}, this.state.backgroundStyle), { cursor: "auto" })
+      }));
+    }, t.prototype.updateSize = function(r) {
+      var n, i;
+      this.setState({ width: (n = r.width) !== null && n !== void 0 ? n : "auto", height: (i = r.height) !== null && i !== void 0 ? i : "auto" });
+    }, t.prototype.renderResizer = function() {
+      var r = this, n = this.props, i = n.enable, a = n.handleStyles, u = n.handleClasses, c = n.handleWrapperStyle, s = n.handleWrapperClass, o = n.handleComponent;
+      if (!i)
+        return null;
+      var f = Object.keys(i).map(function(l) {
+        return i[l] !== !1 ? v(Ki, { direction: l, onResizeStart: r.onResizeStart, replaceStyles: a && a[l], className: u && u[l], children: o && o[l] ? o[l] : null }, l) : null;
+      });
+      return v("div", { className: s, style: c, children: f });
+    }, t.prototype.render = function() {
+      var r = this, n = Object.keys(this.props).reduce(function(u, c) {
+        return ta.indexOf(c) !== -1 || (u[c] = r.props[c]), u;
+      }, {}), i = H(H(H({ position: "relative", userSelect: this.state.isResizing ? "none" : "auto" }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: "border-box", flexShrink: 0 });
+      this.state.flexBasis && (i.flexBasis = this.state.flexBasis);
+      var a = this.props.as || "div";
+      return K(a, H({ style: i, className: this.props.className }, n, {
+        // `ref` is after `extendsProps` to ensure this one wins over a version
+        // passed in
+        ref: function(u) {
+          u && (r.resizable = u);
+        },
+        children: [this.state.isResizing && v("div", { style: this.state.backgroundStyle }), this.props.children, this.renderResizer()]
+      }));
+    }, t.defaultProps = {
+      as: "div",
+      onResizeStart: function() {
+      },
+      onResize: function() {
+      },
+      onResizeStop: function() {
+      },
+      enable: {
+        top: !0,
+        right: !0,
+        bottom: !0,
+        left: !0,
+        topRight: !0,
+        bottomRight: !0,
+        bottomLeft: !0,
+        topLeft: !0
+      },
+      style: {},
+      grid: [1, 1],
+      gridGap: [0, 0],
+      lockAspectRatio: !1,
+      lockAspectRatioExtraWidth: 0,
+      lockAspectRatioExtraHeight: 0,
+      scale: 1,
+      resizeRatio: 1,
+      snapGap: 0
+    }, t;
+  }(er)
+);
+function na({
+  item: e,
+  rectangle: t,
+  boundingRectangle: r,
+  children: n,
+  onDrag: i,
+  onDragStart: a,
+  onDrop: u,
+  onUpdate: c,
+  onResizeStart: s
+}) {
+  const o = ce(null), f = ce(null), [l, d] = G(t);
+  return ee(() => {
+    d(t);
+  }, [t]), ee(() => (He(o.current), He(f.current), Ri({
+    element: o.current,
+    dragHandle: f.current,
+    onDragStart: ({ source: h, location: g }) => {
+      const p = Z(h, g);
+      a(p.absolute, p.relative);
+    },
+    onDrag: () => {
+      i();
+    },
+    onDrop: () => {
+      u();
+    },
+    getInitialData: () => ({ ...e })
+  })), [e, i, a, u]), /* @__PURE__ */ v(
+    "div",
+    {
+      id: `timeline-item-${e.id}`,
+      className: "timeline-item",
+      "data-timeline-item-id": e.id,
+      ref: o,
+      style: {
+        width: `${l.width}px`,
+        height: `${l.height}px`,
+        minWidth: `${l.width}px`,
+        minHeight: `${l.height}px`,
+        maxWidth: `${l.width}px`,
+        maxHeight: `${l.height}px`,
+        top: `${l.y}px`,
+        left: `${l.x}px`
+      },
+      onMouseDown: (h) => {
+        h.stopPropagation();
+      },
+      onClick: (h) => {
+        h.stopPropagation();
+      },
+      children: /* @__PURE__ */ v(
+        ra,
+        {
+          enable: {
+            right: !0,
+            left: !0,
+            top: !0,
+            bottom: !0
+          },
+          handleClasses: {
+            left: "timeline-item-resize-handle timeline-item-resize-handle-left",
+            right: "timeline-item-resize-handle timeline-item-resize-handle-right"
+          },
+          size: {
+            width: l.width,
+            height: l.height
+          },
+          onResizeStart: () => {
+            s();
+          },
+          onResize: (h, g, p, m) => {
+            d((b) => g === "right" ? {
+              ...b,
+              width: t.width + m.width
+            } : g === "left" ? {
+              ...b,
+              x: t.x - m.width,
+              width: t.width + m.width
+            } : g === "bottom" ? {
+              ...b,
+              height: Math.min(
+                t.height + m.height,
+                r.height - t.y
+              )
+            } : g === "top" ? {
+              ...b,
+              y: t.y - m.height,
+              height: t.height + m.height
+            } : b);
+          },
+          onResizeStop: (h, g, p, m) => {
+            let b = t;
+            g === "right" ? b = {
+              ...t,
+              width: t.width + m.width
+            } : g === "left" ? b = {
+              ...t,
+              x: t.x - m.width,
+              width: t.width + m.width
+            } : g === "bottom" ? b = {
+              ...t,
+              height: Math.min(
+                t.height + m.height,
+                r.height - t.y
+              )
+            } : g === "top" && (b = {
+              ...t,
+              y: t.y - m.height,
+              height: t.height + m.height
+            }), c(b);
+          },
+          style: { overflow: "hidden" },
+          children: /* @__PURE__ */ v("div", { className: "timeline-item-drag-handle", ref: f, children: n })
+        }
+      )
+    }
+  );
+}
+function ia({
+  swimlane: e,
+  item: t,
+  settings: r,
+  children: n,
+  onDragStart: i,
+  onDrag: a,
+  onDrop: u,
+  onUpdate: c,
+  onResizeStart: s
+}) {
+  const o = Fe(t, e, r, r), f = Ye(
+    e,
+    r,
+    r
+  );
+  return /* @__PURE__ */ v(
+    na,
+    {
+      item: t,
+      rectangle: o,
+      boundingRectangle: f,
+      onDrag: a,
+      onDragStart: i,
+      onDrop: u,
+      onUpdate: (l) => {
+        const d = Ht(
+          t,
+          e,
+          l,
+          r,
+          r
+        );
+        c(d);
+      },
+      onResizeStart: s,
+      children: n
+    }
+  );
+}
+function aa({ overlap: e }) {
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        left: `${e.x}px`,
+        top: `${e.y}px`,
+        width: `${e.width - 1}px`,
+        height: `${e.height - 1}px`,
+        background: "rgba(255,0,0, 0.3)",
+        marginLeft: "1px",
+        pointerEvents: "none"
+      }
+    }
+  );
+}
+function Et(e) {
+  return "id" in e && "swimlaneId" in e && "start" in e && "end" in e && "size" in e && "offset" in e;
+}
+function oa({
+  swimlane: e,
+  items: t,
+  focused: r = !1,
+  onItemUpdate: n = () => {
+  },
+  onMouseUp: i = () => {
+  },
+  onClick: a = () => {
+  },
+  onDoubleClick: u = () => {
+  },
+  onContextMenu: c = () => {
+  },
+  renderItem: s = sa,
+  onResizeStart: o = () => {
+  }
+}) {
+  const { settings: f } = ge(), l = {
+    x: f.pixelsPerDay,
+    offsetX: f.pixelsPerDay / 2
+  }, d = Ye(
+    e,
+    f,
+    f
+  ), [h, g] = G(null), [p, m] = G(
+    null
+  );
+  function b(y) {
+    const D = y.currentTarget.getBoundingClientRect();
+    return ze(
+      le(
+        f.start,
+        (y.clientX - D.left) / f.pixelsPerDay
+      ),
+      12
+    );
+  }
+  function O(y) {
+    const D = y.currentTarget.getBoundingClientRect();
+    return (y.pageY - D.top) / D.height * e.capacity;
+  }
+  function x(y, D, P) {
+    if (!Et(P)) return;
+    const R = zi(
+      e,
+      t,
+      P,
+      y,
+      D,
+      f,
+      l,
+      f,
+      f.allowOverlaps
+    );
+    m(R);
+  }
+  function w(y, D, P) {
+    if (!Et(P) || p === null) return;
+    const R = Ht(
+      P,
+      e,
+      p,
+      f,
+      f
+    );
+    n(R), m(null);
+  }
+  function M() {
+    m(null);
+  }
+  function S(y, D) {
+    const P = b(y), R = O(y), L = Yi(
+      P,
+      R,
+      e,
+      t,
+      f
+    );
+    D == "single" ? a(P, L, y) : u(P, L, y);
+  }
+  const z = t.map((y) => ({
+    id: y.id,
+    ...Fe(y, e, f, f)
+  })), E = z.flatMap(
+    (y) => z.map((D) => y.id < D.id ? Hi(y, D) : null)
+  ).filter((y) => y !== null);
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      id: `timeline-swimlane-${e.id}`,
+      className: `timeline-swimlane ${r ? "timeline-swimlane-focused" : ""}`,
+      "data-timeline-swimlane-id": e.id,
+      style: d,
+      onMouseUp: i,
+      onClick: (y) => S(y, "single"),
+      onDoubleClick: (y) => S(y, "double"),
+      onContextMenu: (y) => {
+        c(b(y), y);
+      },
+      children: /* @__PURE__ */ K(
+        Ni,
+        {
+          onDrag: x,
+          onDragLeave: M,
+          onDrop: w,
+          children: [
+            t.map((y, D) => /* @__PURE__ */ v(
+              ia,
+              {
+                item: y,
+                settings: f,
+                swimlane: e,
+                onDragStart: () => {
+                  g(y);
+                },
+                onDrag: () => {
+                },
+                onDrop: () => {
+                  g(null);
+                },
+                onUpdate: n,
+                onResizeStart: () => {
+                  o(y.payload);
+                },
+                children: s(
+                  y,
+                  h !== null && h.id === y.id
+                )
+              },
+              D
+            )),
+            p && /* @__PURE__ */ v(Ai, { ...p }),
+            E.map((y, D) => /* @__PURE__ */ v(aa, { overlap: y }, D))
+          ]
+        }
+      )
+    }
+  );
+}
+function sa(e, t) {
+  return /* @__PURE__ */ K("div", { children: [
+    e.id,
+    " (",
+    I(e.start, "yyyy-mm-dd"),
+    " -",
+    " ",
+    I(e.end, "yyyy-mm-dd"),
+    ")",
+    t ? "dragging" : ""
+  ] });
+}
+function ma({
+  lanes: e,
+  items: t,
+  renderItem: r,
+  onItemUpdate: n = () => {
+  },
+  onLaneClick: i = () => {
+  },
+  onLaneDoubleClick: a = () => {
+  },
+  onLaneContextMenu: u = () => {
+  }
+}) {
+  return /* @__PURE__ */ v("div", { className: "timeline-body", children: e.map((c) => /* @__PURE__ */ v(
+    oa,
+    {
+      swimlane: c,
+      items: t.filter((s) => s.swimlaneId === c.id),
+      renderItem: r,
+      onItemUpdate: n,
+      onClick: (s, o, f) => i(c, s, o, f),
+      onDoubleClick: (s, o, f) => a(c, s, o, f),
+      onContextMenu: (s, o) => u(c, s, o)
+    },
+    c.id
+  )) });
+}
+function ya({
+  children: e,
+  onSelect: t
+}) {
+  const [r, n] = G([]), i = ce(null), [a, u] = G(null), [c, s] = G(null);
+  ee(() => Pi({
+    onDragStart: (d) => {
+      n([d.source.data.id]);
+    }
+  }), []), ee(() => {
+    t(r);
+  }, [t, r]);
+  function o(d) {
+    !d.shiftKey && !d.ctrlKey && n([]), u({ x: d.clientX, y: d.clientY });
+  }
+  function f(d) {
+    if (a) {
+      const h = {
+        x: Math.min(d.clientX, a.x),
+        y: Math.min(d.clientY, a.y),
+        width: Math.abs(d.clientX - a.x),
+        height: Math.abs(d.clientY - a.y)
+      }, g = d.currentTarget.getBoundingClientRect();
+      s({
+        ...h,
+        x: h.x - g.left,
+        y: h.y - g.top
+      }), document.querySelectorAll(".timeline-drop-target").forEach((p) => {
+        se(p.getBoundingClientRect(), h) && p.querySelectorAll(".timeline-item").forEach((m) => {
+          se(m.getBoundingClientRect(), h) ? m.classList.add("timeline-item-marked") : m.classList.remove("timeline-item-marked");
+        });
+      }), (h.width > 5 || h.height > 5) && !i.current && (i.current = Pt, window.addEventListener("click", Pt, !0));
+    }
+  }
+  function l(d) {
+    if (a && c) {
+      d.stopPropagation();
+      const h = {
+        x: Math.min(d.clientX, a.x),
+        y: Math.min(d.clientY, a.y),
+        width: Math.abs(d.clientX - a.x),
+        height: Math.abs(d.clientY - a.y)
+      }, g = Array.from(
+        document.querySelectorAll(".timeline-drop-target")
+      ).filter((p) => se(p.getBoundingClientRect(), h)).map((p) => Array.from(p.querySelectorAll(".timeline-item"))).flatMap((p) => p).filter((p) => se(p.getBoundingClientRect(), h)).map((p) => p instanceof HTMLElement ? Number.parseInt(p.dataset.timelineItemId || "-1") : -1).filter((p) => p > 0);
+      g.length > 0 && (d.shiftKey || d.ctrlKey ? n((p) => Array.from(/* @__PURE__ */ new Set([...p, ...g]))) : n(g)), document.querySelectorAll(".timeline-item-marked").forEach((p) => {
+        p.classList.remove("timeline-item-marked");
+      });
+    }
+    u(null), s(null), requestAnimationFrame(() => {
+      i.current && i.current !== null && (window.removeEventListener("click", i.current, !0), i.current = null);
+    });
+  }
+  return /* @__PURE__ */ K(
+    "div",
+    {
+      onMouseDown: o,
+      onMouseMove: f,
+      onMouseUp: l,
+      style: {
+        position: "relative"
+      },
+      children: [
+        c && /* @__PURE__ */ v(ua, { rect: c }),
+        e
+      ]
+    }
+  );
+}
+const Pt = (e) => {
+  e.preventDefault(), e.stopPropagation();
+};
+function ua({ rect: e }) {
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      id: "mouse-selection-indicator",
+      style: {
+        border: "1px dashed blue",
+        position: "absolute",
+        top: `${e.y}px`,
+        left: `${e.x}px`,
+        width: `${e.width}px`,
+        height: `${e.height}px`,
+        zIndex: 1e6
+      }
+    }
+  );
+}
+const va = () => {
+  const { settings: e } = ge();
+  function t(a) {
+    a instanceof Object ? (a.horz !== void 0 && r(a.horz), a.vert !== void 0 && n(a.vert)) : i(a);
+  }
+  function r(a) {
+    window.requestAnimationFrame(() => {
+      const u = document.getElementById(
+        "timeline-background-date-anchor"
+      );
+      if (u) {
+        const c = Be(a, e.start, e);
+        u.style.setProperty("left", `${c}px`), u.scrollIntoView({
+          block: "nearest",
+          inline: "center",
+          behavior: "smooth"
+        });
+      }
+    });
+  }
+  function n(a) {
+    window.requestAnimationFrame(() => {
+      const u = document.getElementById(
+        `timeline-swimlane-${a}`
+      );
+      u && u.scrollIntoView({ block: "center", behavior: "smooth" });
+    });
+  }
+  function i(a) {
+    window.requestAnimationFrame(() => {
+      const u = document.getElementById(
+        `timeline-item-${a}`
+      );
+      u && u.scrollIntoView({
+        block: "center",
+        inline: "center",
+        behavior: "smooth"
+      });
+    });
+  }
+  return { scrollTo: t, scrollToDate: r, scrollToItem: i, scrollToLane: n };
+};
+export {
+  oa as CoreSwimlane,
+  zn as DaysHeader,
+  _n as MonthsHeader,
+  fa as TimelineAside,
+  ha as TimelineBackground,
+  ma as TimelineBody,
+  ga as TimelineHeader,
+  re as TimelineLayout,
+  ya as TimelineSelectionLayer,
+  pa as TimelineWrapper,
+  Cn as WeeksHeader,
+  Be as dateToPixel,
+  se as doOverlap,
+  Yi as getAvailableSpace,
+  zi as getDropPreviewRectangle,
+  Ye as getDropTargetDimensions,
+  Mn as getDropTargetHeight,
+  En as getDropTargetWidth,
+  Z as getGrabPosition,
+  Lt as getItemDimensions,
+  Rn as getItemPosition,
+  Fe as getItemRectangle,
+  Hi as getOverlap,
+  Ht as getUpdatedItem,
+  Et as isCoreItem,
+  ji as isWithinTargetDimensions,
+  Ii as itemsDoOverlap,
+  Pn as offsetToPixel,
+  An as renderDayHeader,
+  kn as renderMonthHeader,
+  Nn as renderWeekHeader,
+  va as useScroll,
+  ge as useTimelineContext
+};