@orchidui/dashboard 1.8.1-95 → 1.8.1-96

package/dist/ui/resizable/index.js

@@ -0,0 +1,1432 @@
+import { watchEffect as oe, defineComponent as se, toRefs as Be, ref as $, computed as te, watch as we, createBlock as ue, openBlock as Z, unref as P, normalizeStyle as Ne, withCtx as ce, renderSlot as ve, onMounted as ft, onUnmounted as pt, mergeProps as Ge, createElementBlock as mt, createCommentVNode as vt, createVNode as ht } from "vue";
+import { c as He } from "../../utils-SFgRDk1R.js";
+import { u as $e } from "../../useForwardPropsEmits-0XKBv1pB.js";
+import { u as Fe } from "../../useForwardExpose-DZT6mL_U.js";
+import { u as Ee } from "../../useId-reAg216X.js";
+import { P as Pe } from "../../Primitive-B3twiLO1.js";
+import { c as gt } from "../../createContext-CZEfaSVa.js";
+import { u as yt } from "../../useDirection-C3C_TLKm.js";
+import { a as zt } from "../../arrays-4jDZqbdb.js";
+import { c as St } from "../../createLucideIcon-eXqDwUWj.js";
+import { r as Te } from "../../index-OpE2oGce.js";
+function x(e, t = "Assertion failed!") {
+  if (!e)
+    throw console.error(t), new Error(t);
+}
+const de = typeof document < "u";
+function Oe(e, t = document) {
+  var a;
+  if (!de)
+    return null;
+  if (t instanceof HTMLElement && ((a = t == null ? void 0 : t.dataset) == null ? void 0 : a.panelGroupId) === e)
+    return t;
+  const n = t.querySelector(
+    `[data-panel-group][data-panel-group-id="${e}"]`
+  );
+  return n || null;
+}
+function he(e, t = document) {
+  if (!de)
+    return null;
+  const n = t.querySelector(`[data-panel-resize-handle-id="${e}"]`);
+  return n || null;
+}
+function Ve(e, t, n = document) {
+  return de ? ie(e, n).findIndex(
+    (o) => o.getAttribute("data-panel-resize-handle-id") === t
+  ) ?? null : null;
+}
+function ie(e, t = document) {
+  return de ? Array.from(
+    t.querySelectorAll(
+      `[data-panel-resize-handle-id][data-panel-group-id="${e}"]`
+    )
+  ) : [];
+}
+function xt(e, t, n, a = document) {
+  var f, h;
+  const l = he(t, a), o = ie(e, a), i = l ? o.indexOf(l) : -1, r = ((f = n[i]) == null ? void 0 : f.id) ?? null, c = ((h = n[i + 1]) == null ? void 0 : h.id) ?? null;
+  return [r, c];
+}
+function je(e) {
+  return e.type === "keydown";
+}
+function Ke(e) {
+  return e.type.startsWith("mouse");
+}
+function Xe(e) {
+  return e.type.startsWith("touch");
+}
+function ge(e) {
+  if (Ke(e))
+    return {
+      x: e.clientX,
+      y: e.clientY
+    };
+  if (Xe(e)) {
+    const t = e.touches[0];
+    if (t && t.clientX && t.clientY)
+      return {
+        x: t.clientX,
+        y: t.clientY
+      };
+  }
+  return {
+    x: Number.POSITIVE_INFINITY,
+    y: Number.POSITIVE_INFINITY
+  };
+}
+function We(e, t) {
+  const n = e === "horizontal", { x: a, y: l } = ge(t);
+  return n ? a : l;
+}
+function bt(e, t, n, a, l) {
+  const o = n === "horizontal", i = he(t, l);
+  x(i);
+  const r = i.getAttribute("data-panel-group-id");
+  x(r);
+  const { initialCursorPosition: c } = a, f = We(n, e), h = Oe(r, l);
+  x(h);
+  const u = h.getBoundingClientRect(), m = o ? u.width : u.height;
+  return (f - c) / m * 100;
+}
+function wt(e, t, n, a, l, o) {
+  if (je(e)) {
+    const i = n === "horizontal";
+    let r = 0;
+    e.shiftKey ? r = 100 : r = l ?? 10;
+    let c = 0;
+    switch (e.key) {
+      case "ArrowDown":
+        c = i ? 0 : r;
+        break;
+      case "ArrowLeft":
+        c = i ? -r : 0;
+        break;
+      case "ArrowRight":
+        c = i ? r : 0;
+        break;
+      case "ArrowUp":
+        c = i ? 0 : -r;
+        break;
+      case "End":
+        c = 100;
+        break;
+      case "Home":
+        c = -100;
+        break;
+    }
+    return c;
+  } else
+    return a == null ? 0 : bt(
+      e,
+      t,
+      n,
+      a,
+      o
+    );
+}
+function Et({
+  layout: e,
+  panelsArray: t,
+  pivotIndices: n
+}) {
+  let a = 0, l = 100, o = 0, i = 0;
+  const r = n[0];
+  x(r != null), t.forEach((u, m) => {
+    const { constraints: v } = u, { maxSize: g = 100, minSize: w = 0 } = v;
+    m === r ? (a = w, l = g) : (o += w, i += g);
+  });
+  const c = Math.min(l, 100 - o), f = Math.max(a, 100 - i), h = e[r];
+  return {
+    valueMax: c,
+    valueMin: f,
+    valueNow: h
+  };
+}
+function Pt({
+  panelDataArray: e
+}) {
+  const t = Array.from({ length: e.length }), n = e.map(
+    (o) => o.constraints
+  );
+  let a = 0, l = 100;
+  for (let o = 0; o < e.length; o++) {
+    const i = n[o];
+    x(i);
+    const { defaultSize: r } = i;
+    r != null && (a++, t[o] = r, l -= r);
+  }
+  for (let o = 0; o < e.length; o++) {
+    const i = n[o];
+    x(i);
+    const { defaultSize: r } = i;
+    if (r != null)
+      continue;
+    const c = e.length - a, f = l / c;
+    a++, t[o] = f, l -= f;
+  }
+  return t;
+}
+function ee(e, t, n) {
+  t.forEach((a, l) => {
+    const o = e[l];
+    x(o);
+    const { callbacks: i, constraints: r, id: c } = o, { collapsedSize: f = 0, collapsible: h } = r, u = n[c];
+    if (u == null || a !== u) {
+      n[c] = a;
+      const { onCollapse: m, onExpand: v, onResize: g } = i;
+      g && g(a, u), h && (m || v) && (v && (u == null || u === f) && a !== f && v(), m && (u == null || u !== f) && a === f && m());
+    }
+  });
+}
+function It(e, t = 10) {
+  let n = null;
+  return (...l) => {
+    n !== null && clearTimeout(n), n = setTimeout(() => {
+      e(...l);
+    }, t);
+  };
+}
+const Ie = 10;
+function le(e, t, n = Ie) {
+  e = Number.parseFloat(e.toFixed(n)), t = Number.parseFloat(t.toFixed(n));
+  const a = e - t;
+  return a === 0 ? 0 : a > 0 ? 1 : -1;
+}
+function N(e, t, n) {
+  return le(e, t, n) === 0;
+}
+function J({
+  panelConstraints: e,
+  panelIndex: t,
+  size: n
+}) {
+  const a = e[t];
+  x(a != null);
+  const { collapsedSize: l = 0, collapsible: o, maxSize: i = 100, minSize: r = 0 } = a;
+  if (le(n, r) < 0)
+    if (o) {
+      const c = (l + r) / 2;
+      le(n, c) < 0 ? n = l : n = r;
+    } else
+      n = r;
+  return n = Math.min(i, n), n = Number.parseFloat(n.toFixed(Ie)), n;
+}
+function fe(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function ne({
+  delta: e,
+  layout: t,
+  panelConstraints: n,
+  pivotIndices: a,
+  trigger: l
+}) {
+  if (N(e, 0))
+    return t;
+  const o = [...t], [i, r] = a;
+  x(i != null), x(r != null);
+  let c = 0;
+  if (l === "keyboard") {
+    {
+      const h = e < 0 ? r : i, u = n[h];
+      if (x(u), u.collapsible) {
+        const m = t[h];
+        x(m != null);
+        const v = n[h];
+        x(v);
+        const { collapsedSize: g = 0, minSize: w = 0 } = v;
+        if (N(m, g)) {
+          const d = w - m;
+          le(d, Math.abs(e)) > 0 && (e = e < 0 ? 0 - d : d);
+        }
+      }
+    }
+    {
+      const h = e < 0 ? i : r, u = n[h];
+      x(u);
+      const { collapsible: m } = u;
+      if (m) {
+        const v = t[h];
+        x(v != null);
+        const g = n[h];
+        x(g);
+        const { collapsedSize: w = 0, minSize: d = 0 } = g;
+        if (N(v, d)) {
+          const b = v - w;
+          le(b, Math.abs(e)) > 0 && (e = e < 0 ? 0 - b : b);
+        }
+      }
+    }
+  }
+  {
+    const h = e < 0 ? 1 : -1;
+    let u = e < 0 ? r : i, m = 0;
+    for (; ; ) {
+      const g = t[u];
+      x(g != null);
+      const d = J({
+        panelConstraints: n,
+        panelIndex: u,
+        size: 100
+      }) - g;
+      if (m += d, u += h, u < 0 || u >= n.length)
+        break;
+    }
+    const v = Math.min(Math.abs(e), Math.abs(m));
+    e = e < 0 ? 0 - v : v;
+  }
+  {
+    let u = e < 0 ? i : r;
+    for (; u >= 0 && u < n.length; ) {
+      const m = Math.abs(e) - Math.abs(c), v = t[u];
+      x(v != null);
+      const g = v - m, w = J({
+        panelConstraints: n,
+        panelIndex: u,
+        size: g
+      });
+      if (!N(v, w) && (c += v - w, o[u] = w, c.toPrecision(3).localeCompare(Math.abs(e).toPrecision(3), void 0, {
+        numeric: !0
+      }) >= 0))
+        break;
+      e < 0 ? u-- : u++;
+    }
+  }
+  if (N(c, 0))
+    return t;
+  {
+    const h = e < 0 ? r : i, u = t[h];
+    x(u != null);
+    const m = u + c, v = J({
+      panelConstraints: n,
+      panelIndex: h,
+      size: m
+    });
+    if (o[h] = v, !N(v, m)) {
+      let g = m - v, d = e < 0 ? r : i;
+      for (; d >= 0 && d < n.length; ) {
+        const b = o[d];
+        x(b != null);
+        const L = b + g, I = J({
+          panelConstraints: n,
+          panelIndex: d,
+          size: L
+        });
+        if (N(b, I) || (g -= I - b, o[d] = I), N(g, 0))
+          break;
+        e > 0 ? d-- : d++;
+      }
+    }
+  }
+  const f = o.reduce((h, u) => u + h, 0);
+  return N(f, 100) ? o : t;
+}
+function Ue(e, t, n) {
+  const a = Ve(
+    e,
+    t,
+    n
+  );
+  return a != null ? [a, a + 1] : [-1, -1];
+}
+function Ct(e, t, n) {
+  return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+}
+function kt(e, t) {
+  if (e === t)
+    throw new Error("Cannot compare node with itself");
+  const n = {
+    a: De(e),
+    b: De(t)
+  };
+  let a;
+  for (; n.a.at(-1) === n.b.at(-1); )
+    e = n.a.pop(), t = n.b.pop(), a = e;
+  x(a);
+  const l = {
+    a: Me(Re(n.a)),
+    b: Me(Re(n.b))
+  };
+  if (l.a === l.b) {
+    const o = a.childNodes, i = {
+      a: n.a.at(-1),
+      b: n.b.at(-1)
+    };
+    let r = o.length;
+    for (; r--; ) {
+      const c = o[r];
+      if (c === i.a)
+        return 1;
+      if (c === i.b)
+        return -1;
+    }
+  }
+  return Math.sign(l.a - l.b);
+}
+const At = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function Lt(e) {
+  const t = getComputedStyle(qe(e)).display;
+  return t === "flex" || t === "inline-flex";
+}
+function Rt(e) {
+  const t = getComputedStyle(e);
+  return !!(t.position === "fixed" || t.zIndex !== "auto" && (t.position !== "static" || Lt(e)) || +t.opacity < 1 || "transform" in t && t.transform !== "none" || "webkitTransform" in t && t.webkitTransform !== "none" || "mixBlendMode" in t && t.mixBlendMode !== "normal" || "filter" in t && t.filter !== "none" || "webkitFilter" in t && t.webkitFilter !== "none" || "isolation" in t && t.isolation === "isolate" || At.test(t.willChange) || t.webkitOverflowScrolling === "touch");
+}
+function Re(e) {
+  let t = e.length;
+  for (; t--; ) {
+    const n = e[t];
+    if (x(n), Rt(n))
+      return n;
+  }
+  return null;
+}
+function Me(e) {
+  return e && Number(getComputedStyle(e).zIndex) || 0;
+}
+function De(e) {
+  const t = [];
+  for (; e; )
+    t.push(e), e = qe(e);
+  return t;
+}
+function qe(e) {
+  var t;
+  return e.parentNode instanceof DocumentFragment && ((t = e.parentNode) == null ? void 0 : t.host) || e.parentNode;
+}
+let be = null, q = null;
+function Mt(e, t) {
+  if (t) {
+    const n = (t & Je) !== 0, a = (t & Ze) !== 0, l = (t & Qe) !== 0, o = (t & et) !== 0;
+    if (n)
+      return l ? "se-resize" : o ? "ne-resize" : "e-resize";
+    if (a)
+      return l ? "sw-resize" : o ? "nw-resize" : "w-resize";
+    if (l)
+      return "s-resize";
+    if (o)
+      return "n-resize";
+  }
+  switch (e) {
+    case "horizontal":
+      return "ew-resize";
+    case "intersection":
+      return "move";
+    case "vertical":
+      return "ns-resize";
+  }
+}
+function Ye() {
+  q !== null && (document.head.removeChild(q), be = null, q = null);
+}
+function Se(e, t) {
+  const n = Mt(e, t);
+  be !== n && (be = n, q === null && (q = document.createElement("style"), document.head.appendChild(q)), q.innerHTML = `*{cursor: ${n}!important;}`);
+}
+function Dt({
+  defaultSize: e,
+  dragState: t,
+  layout: n,
+  panelData: a,
+  panelIndex: l,
+  precision: o = 3
+}) {
+  const i = n[l];
+  let r;
+  return i == null ? r = e !== void 0 ? e.toPrecision(o) : "1" : a.length === 1 ? r = "1" : r = i.toPrecision(o), {
+    flexBasis: 0,
+    flexGrow: r,
+    flexShrink: 1,
+    // Without this, Panel sizes may be unintentionally overridden by their content
+    overflow: "hidden",
+    // Disable pointer events inside of a panel during resize
+    // This avoid edge cases like nested iframes
+    pointerEvents: t !== null ? "none" : void 0
+  };
+}
+const Je = 1, Ze = 2, Qe = 4, et = 8;
+function _t() {
+  if (typeof matchMedia == "function")
+    return matchMedia("(pointer:coarse)").matches ? "coarse" : "fine";
+}
+const Bt = _t() === "coarse", K = [];
+let ye = !1;
+const j = /* @__PURE__ */ new Map(), ze = /* @__PURE__ */ new Map(), re = /* @__PURE__ */ new Set();
+function Nt(e, t, n, a, l) {
+  const { ownerDocument: o } = t, i = {
+    direction: n,
+    element: t,
+    hitAreaMargins: a,
+    setResizeHandlerState: l
+  }, r = j.get(o) ?? 0;
+  return j.set(o, r + 1), re.add(i), me(), function() {
+    ze.delete(e), re.delete(i);
+    const f = j.get(o) ?? 1;
+    j.set(o, f - 1), me(), Ye(), f === 1 && j.delete(o);
+  };
+}
+function pe(e) {
+  const { target: t } = e, { x: n, y: a } = ge(e);
+  ye = !0, Ce({ target: t, x: n, y: a }), me(), K.length > 0 && (ke("down", e), e.preventDefault());
+}
+function O(e) {
+  const { x: t, y: n } = ge(e);
+  if (!ye) {
+    const { target: a } = e;
+    Ce({ target: a, x: t, y: n });
+  }
+  ke("move", e), tt(), K.length > 0 && e.preventDefault();
+}
+function V(e) {
+  const { target: t } = e, { x: n, y: a } = ge(e);
+  ze.clear(), ye = !1, K.length > 0 && e.preventDefault(), ke("up", e), Ce({ target: t, x: n, y: a }), tt(), me();
+}
+function Ce({
+  target: e,
+  x: t,
+  y: n
+}) {
+  K.splice(0);
+  let a = null;
+  e instanceof HTMLElement && (a = e), re.forEach((l) => {
+    const { element: o, hitAreaMargins: i } = l, r = o.getBoundingClientRect(), { bottom: c, left: f, right: h, top: u } = r, m = Bt ? i.coarse : i.fine;
+    if (t >= f - m && t <= h + m && n >= u - m && n <= c + m) {
+      if (a !== null && o !== a && !o.contains(a) && !a.contains(o) && kt(a, o) > 0) {
+        let g = a, w = !1;
+        for (; g && !g.contains(o); ) {
+          if (Ct(
+            g.getBoundingClientRect(),
+            r
+          )) {
+            w = !0;
+            break;
+          }
+          g = g.parentElement;
+        }
+        if (w)
+          return;
+      }
+      K.push(l);
+    }
+  });
+}
+function xe(e, t) {
+  ze.set(e, t);
+}
+function tt() {
+  let e = !1, t = !1;
+  K.forEach((a) => {
+    const { direction: l } = a;
+    l.value === "horizontal" ? e = !0 : t = !0;
+  });
+  let n = 0;
+  ze.forEach((a) => {
+    n |= a;
+  }), e && t ? Se("intersection", n) : e ? Se("horizontal", n) : t ? Se("vertical", n) : Ye();
+}
+function me() {
+  j.forEach((e, t) => {
+    const { body: n } = t;
+    n.removeEventListener("contextmenu", V), n.removeEventListener("mousedown", pe), n.removeEventListener("mouseleave", O), n.removeEventListener("mousemove", O), n.removeEventListener("touchmove", O), n.removeEventListener("touchstart", pe);
+  }), window.removeEventListener("mouseup", V), window.removeEventListener("touchcancel", V), window.removeEventListener("touchend", V), re.size > 0 && (ye ? (K.length > 0 && j.forEach((e, t) => {
+    const { body: n } = t;
+    e > 0 && (n.addEventListener("contextmenu", V), n.addEventListener("mouseleave", O), n.addEventListener("mousemove", O), n.addEventListener("touchmove", O, {
+      passive: !1
+    }));
+  }), window.addEventListener("mouseup", V), window.addEventListener("touchcancel", V), window.addEventListener("touchend", V)) : j.forEach((e, t) => {
+    const { body: n } = t;
+    e > 0 && (n.addEventListener("mousedown", pe), n.addEventListener("mousemove", O), n.addEventListener("touchmove", O, {
+      passive: !1
+    }), n.addEventListener("touchstart", pe));
+  }));
+}
+function ke(e, t) {
+  re.forEach((n) => {
+    const { setResizeHandlerState: a } = n, l = K.includes(n);
+    a(e, l, t);
+  });
+}
+function Gt({
+  layout: e,
+  panelConstraints: t
+}) {
+  const n = [...e], a = n.reduce(
+    (o, i) => o + i,
+    0
+  );
+  if (n.length !== t.length)
+    throw new Error(
+      `Invalid ${t.length} panel layout: ${n.map((o) => `${o}%`).join(", ")}`
+    );
+  if (!N(a, 100)) {
+    console.warn(
+      `WARNING: Invalid layout total size: ${n.map((o) => `${o}%`).join(", ")}. Layout normalization will be applied.`
+    );
+    for (let o = 0; o < t.length; o++) {
+      const i = n[o];
+      x(i != null);
+      const r = 100 / a * i;
+      n[o] = r;
+    }
+  }
+  let l = 0;
+  for (let o = 0; o < t.length; o++) {
+    const i = n[o];
+    x(i != null);
+    const r = J({
+      panelConstraints: t,
+      panelIndex: o,
+      size: i
+    });
+    i !== r && (l += i - r, n[o] = r);
+  }
+  if (!N(l, 0))
+    for (let o = 0; o < t.length; o++) {
+      const i = n[o];
+      x(i != null);
+      const r = i + l, c = J({
+        panelConstraints: t,
+        panelIndex: o,
+        size: r
+      });
+      if (i !== c && (l -= c - i, n[o] = c, N(l, 0)))
+        break;
+    }
+  return n;
+}
+function Ht({
+  eagerValuesRef: e,
+  groupId: t,
+  layout: n,
+  panelDataArray: a,
+  panelGroupElement: l,
+  setLayout: o
+}) {
+  oe((i) => {
+    const r = l.value;
+    if (!r)
+      return;
+    const c = ie(
+      t,
+      r
+    );
+    for (let f = 0; f < a.length - 1; f++) {
+      const { valueMax: h, valueMin: u, valueNow: m } = Et({
+        layout: n.value,
+        panelsArray: a,
+        pivotIndices: [f, f + 1]
+      }), v = c[f];
+      if (v != null) {
+        const g = a[f];
+        x(g), v.setAttribute("aria-controls", g.id), v.setAttribute(
+          "aria-valuemax",
+          `${Math.round(h)}`
+        ), v.setAttribute(
+          "aria-valuemin",
+          `${Math.round(u)}`
+        ), v.setAttribute(
+          "aria-valuenow",
+          m != null ? `${Math.round(m)}` : ""
+        );
+      }
+    }
+    i(() => {
+      c.forEach((f) => {
+        f.removeAttribute("aria-controls"), f.removeAttribute("aria-valuemax"), f.removeAttribute("aria-valuemin"), f.removeAttribute("aria-valuenow");
+      });
+    });
+  }), oe((i) => {
+    const r = l.value;
+    if (!r)
+      return;
+    const c = e.value;
+    x(c);
+    const { panelDataArray: f } = c, h = Oe(t, r);
+    x(h != null, `No group found for id "${t}"`);
+    const u = ie(t, r);
+    x(u);
+    const m = u.map((v) => {
+      const g = v.getAttribute("data-panel-resize-handle-id");
+      x(g);
+      const [w, d] = xt(
+        t,
+        g,
+        f,
+        r
+      );
+      if (w == null || d == null)
+        return () => {
+        };
+      const b = (L) => {
+        if (!L.defaultPrevented)
+          switch (L.key) {
+            case "Enter": {
+              L.preventDefault();
+              const I = f.findIndex(
+                (B) => B.id === w
+              );
+              if (I >= 0) {
+                const B = f[I];
+                x(B);
+                const R = n.value[I], {
+                  collapsedSize: G = 0,
+                  collapsible: F,
+                  minSize: C = 0
+                } = B.constraints;
+                if (R != null && F) {
+                  const M = ne({
+                    delta: N(R, G) ? C - G : G - R,
+                    layout: n.value,
+                    panelConstraints: f.map(
+                      (Y) => Y.constraints
+                    ),
+                    pivotIndices: Ue(
+                      t,
+                      g,
+                      r
+                    ),
+                    trigger: "keyboard"
+                  });
+                  n.value !== M && o(M);
+                }
+              }
+              break;
+            }
+          }
+      };
+      return v.addEventListener("keydown", b), () => {
+        v.removeEventListener("keydown", b);
+      };
+    });
+    i(() => {
+      m.forEach((v) => v());
+    });
+  });
+}
+function _e(e) {
+  try {
+    if (typeof localStorage < "u")
+      e.getItem = (t) => localStorage.getItem(t), e.setItem = (t, n) => {
+        localStorage.setItem(t, n);
+      };
+    else
+      throw new TypeError("localStorage not supported in this environment");
+  } catch (t) {
+    console.error(t), e.getItem = () => null, e.setItem = () => {
+    };
+  }
+}
+function nt(e) {
+  return `reka:${e}`;
+}
+function at(e) {
+  return e.map((t) => {
+    const { constraints: n, id: a, idIsFromProps: l, order: o } = t;
+    return l ? a : o ? `${o}:${JSON.stringify(n)}` : JSON.stringify(n);
+  }).sort((t, n) => t.localeCompare(n)).join(",");
+}
+function ot(e, t) {
+  try {
+    const n = nt(e), a = t.getItem(n);
+    if (a) {
+      const l = JSON.parse(a);
+      if (typeof l == "object" && l != null)
+        return l;
+    }
+  } catch {
+  }
+  return null;
+}
+function $t(e, t, n) {
+  const a = ot(e, n) ?? {}, l = at(t);
+  return a[l] ?? null;
+}
+function Ft(e, t, n, a, l) {
+  const o = nt(e), i = at(t), r = ot(e, l) ?? {};
+  r[i] = {
+    expandToSizes: Object.fromEntries(n.entries()),
+    layout: a
+  };
+  try {
+    l.setItem(o, JSON.stringify(r));
+  } catch (c) {
+    console.error(c);
+  }
+}
+const Tt = 100, ae = {
+  getItem: (e) => (_e(ae), ae.getItem(e)),
+  setItem: (e, t) => {
+    _e(ae), ae.setItem(e, t);
+  }
+}, [it, Ot] = gt("PanelGroup"), Vt = /* @__PURE__ */ se({
+  __name: "SplitterGroup",
+  props: {
+    id: {},
+    autoSaveId: { default: null },
+    direction: {},
+    keyboardResizeBy: { default: 10 },
+    storage: { default: () => ae },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["layout"],
+  setup(e, { emit: t }) {
+    const n = e, a = t, l = {}, { direction: o } = Be(n), i = Ee(n.id, "reka-splitter-group"), r = yt(), { forwardRef: c, currentElement: f } = Fe(), h = $(null), u = $([]), m = $({}), v = $(/* @__PURE__ */ new Map()), g = $(0), w = te(() => ({
+      autoSaveId: n.autoSaveId,
+      direction: n.direction,
+      dragState: h.value,
+      id: i,
+      keyboardResizeBy: n.keyboardResizeBy,
+      storage: n.storage
+    })), d = $({
+      layout: u.value,
+      panelDataArray: [],
+      panelDataArrayChanged: !1
+    }), b = (s) => u.value = s;
+    Ht({
+      eagerValuesRef: d,
+      groupId: i,
+      layout: u,
+      panelDataArray: d.value.panelDataArray,
+      setLayout: b,
+      panelGroupElement: f
+    }), oe(() => {
+      const { panelDataArray: s } = d.value, { autoSaveId: z } = n;
+      if (z) {
+        if (u.value.length === 0 || u.value.length !== s.length)
+          return;
+        let p = l[z];
+        p || (p = It(
+          Ft,
+          Tt
+        ), l[z] = p);
+        const y = [...s], E = new Map(
+          v.value
+        );
+        p(
+          z,
+          y,
+          E,
+          u.value,
+          n.storage
+        );
+      }
+    });
+    function L(s, z) {
+      const { panelDataArray: p } = d.value, y = X(p, s);
+      return Dt({
+        defaultSize: z,
+        dragState: h.value,
+        layout: u.value,
+        panelData: p,
+        panelIndex: y
+      });
+    }
+    function I(s) {
+      const { panelDataArray: z } = d.value;
+      z.push(s), z.sort((p, y) => {
+        const E = p.order, S = y.order;
+        return E == null && S == null ? 0 : E == null ? -1 : S == null ? 1 : E - S;
+      }), d.value.panelDataArrayChanged = !0;
+    }
+    we(() => d.value.panelDataArrayChanged, () => {
+      if (d.value.panelDataArrayChanged) {
+        d.value.panelDataArrayChanged = !1;
+        const { autoSaveId: s, storage: z } = w.value, { layout: p, panelDataArray: y } = d.value;
+        let E = null;
+        if (s) {
+          const A = $t(s, y, z);
+          A && (v.value = new Map(
+            Object.entries(A.expandToSizes)
+          ), E = A.layout);
+        }
+        E === null && (E = Pt({
+          panelDataArray: y
+        }));
+        const S = Gt({
+          layout: E,
+          panelConstraints: y.map(
+            (A) => A.constraints
+          )
+        });
+        zt(p, S) || (b(S), d.value.layout = S, a("layout", S), ee(
+          y,
+          S,
+          m.value
+        ));
+      }
+    });
+    function B(s) {
+      return function(p) {
+        p.preventDefault();
+        const y = f.value;
+        if (!y)
+          return () => null;
+        const { direction: E, dragState: S, id: A, keyboardResizeBy: H } = w.value, { layout: D, panelDataArray: k } = d.value, { initialLayout: U } = S ?? {}, T = Ue(
+          A,
+          s,
+          y
+        );
+        let _ = wt(
+          p,
+          s,
+          E,
+          S,
+          H,
+          y
+        );
+        if (_ === 0)
+          return;
+        const Ae = E === "horizontal";
+        r.value === "rtl" && Ae && (_ = -_);
+        const ct = k.map((dt) => dt.constraints), Q = ne({
+          delta: _,
+          layout: U ?? D,
+          panelConstraints: ct,
+          pivotIndices: T,
+          trigger: je(p) ? "keyboard" : "mouse-or-touch"
+        }), Le = !fe(D, Q);
+        (Ke(p) || Xe(p)) && g.value !== _ && (g.value = _, Le ? xe(s, 0) : Ae ? xe(
+          s,
+          _ < 0 ? Je : Ze
+        ) : xe(
+          s,
+          _ < 0 ? Qe : et
+        )), Le && (b(Q), d.value.layout = Q, a("layout", Q), ee(
+          k,
+          Q,
+          m.value
+        ));
+      };
+    }
+    function R(s, z) {
+      const { layout: p, panelDataArray: y } = d.value, E = y.map((U) => U.constraints), { panelSize: S, pivotIndices: A } = W(
+        y,
+        s,
+        p
+      );
+      x(S != null);
+      const D = X(y, s) === y.length - 1 ? S - z : z - S, k = ne({
+        delta: D,
+        layout: p,
+        panelConstraints: E,
+        pivotIndices: A,
+        trigger: "imperative-api"
+      });
+      fe(p, k) || (b(k), d.value.layout = k, a("layout", k), ee(
+        y,
+        k,
+        m.value
+      ));
+    }
+    function G(s, z) {
+      const { layout: p, panelDataArray: y } = d.value, E = X(y, s);
+      y[E] = s, d.value.panelDataArrayChanged = !0;
+      const {
+        collapsedSize: S = 0,
+        collapsible: A
+      } = z, {
+        collapsedSize: H = 0,
+        collapsible: D,
+        maxSize: k = 100,
+        minSize: U = 0
+      } = s.constraints, { panelSize: T } = W(
+        y,
+        s,
+        p
+      );
+      T !== null && (A && D && T === S ? S !== H && R(s, H) : T < U ? R(s, U) : T > k && R(s, k));
+    }
+    function F(s, z) {
+      const { direction: p } = w.value, { layout: y } = d.value;
+      if (!f.value)
+        return;
+      const E = he(
+        s,
+        f.value
+      );
+      x(E);
+      const S = We(
+        p,
+        z
+      );
+      h.value = {
+        dragHandleId: s,
+        dragHandleRect: E.getBoundingClientRect(),
+        initialCursorPosition: S,
+        initialLayout: y
+      };
+    }
+    function C() {
+      h.value = null;
+    }
+    function M(s) {
+      const { panelDataArray: z } = d.value, p = X(z, s);
+      p >= 0 && (z.splice(p, 1), delete m.value[s.id], d.value.panelDataArrayChanged = !0);
+    }
+    function Y(s) {
+      const { layout: z, panelDataArray: p } = d.value;
+      if (s.constraints.collapsible) {
+        const y = p.map(
+          (H) => H.constraints
+        ), {
+          collapsedSize: E = 0,
+          panelSize: S,
+          pivotIndices: A
+        } = W(p, s, z);
+        if (x(
+          S != null,
+          `Panel size not found for panel "${s.id}"`
+        ), S !== E) {
+          v.value.set(s.id, S);
+          const D = X(p, s) === p.length - 1 ? S - E : E - S, k = ne({
+            delta: D,
+            layout: z,
+            panelConstraints: y,
+            pivotIndices: A,
+            trigger: "imperative-api"
+          });
+          fe(z, k) || (b(k), d.value.layout = k, a("layout", k), ee(
+            p,
+            k,
+            m.value
+          ));
+        }
+      }
+    }
+    function lt(s) {
+      const { layout: z, panelDataArray: p } = d.value;
+      if (s.constraints.collapsible) {
+        const y = p.map(
+          (D) => D.constraints
+        ), {
+          collapsedSize: E = 0,
+          panelSize: S,
+          minSize: A = 0,
+          pivotIndices: H
+        } = W(p, s, z);
+        if (S === E) {
+          const D = v.value.get(
+            s.id
+          ), k = D != null && D >= A ? D : A, T = X(p, s) === p.length - 1 ? S - k : k - S, _ = ne({
+            delta: T,
+            layout: z,
+            panelConstraints: y,
+            pivotIndices: H,
+            trigger: "imperative-api"
+          });
+          fe(z, _) || (b(_), d.value.layout = _, a("layout", _), ee(
+            p,
+            _,
+            m.value
+          ));
+        }
+      }
+    }
+    function rt(s) {
+      const { layout: z, panelDataArray: p } = d.value, { panelSize: y } = W(p, s, z);
+      return x(
+        y != null,
+        `Panel size not found for panel "${s.id}"`
+      ), y;
+    }
+    function st(s) {
+      const { layout: z, panelDataArray: p } = d.value, {
+        collapsedSize: y = 0,
+        collapsible: E,
+        panelSize: S
+      } = W(p, s, z);
+      return E ? S === void 0 ? s.constraints.defaultSize === s.constraints.collapsedSize : S === y : !1;
+    }
+    function ut(s) {
+      const { layout: z, panelDataArray: p } = d.value, {
+        collapsedSize: y = 0,
+        collapsible: E,
+        panelSize: S
+      } = W(p, s, z);
+      return x(
+        S != null,
+        `Panel size not found for panel "${s.id}"`
+      ), !E || S > y;
+    }
+    Ot({
+      direction: o,
+      dragState: h.value,
+      groupId: i,
+      reevaluatePanelConstraints: G,
+      registerPanel: I,
+      registerResizeHandle: B,
+      resizePanel: R,
+      startDragging: F,
+      stopDragging: C,
+      unregisterPanel: M,
+      panelGroupElement: f,
+      collapsePanel: Y,
+      expandPanel: lt,
+      isPanelCollapsed: st,
+      isPanelExpanded: ut,
+      getPanelSize: rt,
+      getPanelStyle: L
+    });
+    function X(s, z) {
+      return s.findIndex(
+        (p) => p === z || p.id === z.id
+      );
+    }
+    function W(s, z, p) {
+      const y = X(s, z), S = y === s.length - 1 ? [y - 1, y] : [y, y + 1], A = p[y];
+      return {
+        ...z.constraints,
+        panelSize: A,
+        pivotIndices: S
+      };
+    }
+    return (s, z) => (Z(), ue(P(Pe), {
+      ref: P(c),
+      as: s.as,
+      "as-child": s.asChild,
+      style: Ne({
+        display: "flex",
+        flexDirection: P(o) === "horizontal" ? "row" : "column",
+        height: "100%",
+        overflow: "hidden",
+        width: "100%"
+      }),
+      "data-panel-group": "",
+      "data-orientation": P(o),
+      "data-panel-group-id": P(i)
+    }, {
+      default: ce(() => [
+        ve(s.$slots, "default", { layout: u.value })
+      ]),
+      _: 3
+    }, 8, ["as", "as-child", "style", "data-orientation", "data-panel-group-id"]));
+  }
+}), ln = /* @__PURE__ */ se({
+  __name: "SplitterPanel",
+  props: {
+    collapsedSize: {},
+    collapsible: { type: Boolean },
+    defaultSize: {},
+    id: {},
+    maxSize: {},
+    minSize: {},
+    order: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["collapse", "expand", "resize"],
+  setup(e, { expose: t, emit: n }) {
+    const a = e, l = n, o = it();
+    if (o === null)
+      throw new Error(
+        "SplitterPanel components must be rendered within a SplitterGroup container"
+      );
+    const { collapsePanel: i, expandPanel: r, getPanelSize: c, getPanelStyle: f, isPanelCollapsed: h, resizePanel: u, groupId: m, reevaluatePanelConstraints: v, registerPanel: g, unregisterPanel: w } = o, d = Ee(a.id, "reka-splitter-panel"), b = te(() => ({
+      callbacks: {
+        onCollapse: () => l("collapse"),
+        onExpand: () => l("expand"),
+        onResize: (...C) => l("resize", ...C)
+      },
+      constraints: {
+        collapsedSize: a.collapsedSize && Number.parseFloat(a.collapsedSize.toFixed(Ie)),
+        collapsible: a.collapsible,
+        defaultSize: a.defaultSize,
+        /** Panel id (unique within group); falls back to useId when not provided */
+        /** Panel id (unique within group); falls back to useId when not provided */
+        maxSize: a.maxSize,
+        minSize: a.minSize
+      },
+      id: d,
+      idIsFromProps: a.id !== void 0,
+      order: a.order
+    }));
+    we(() => b.value.constraints, (C, M) => {
+      (M.collapsedSize !== C.collapsedSize || M.collapsible !== C.collapsible || M.maxSize !== C.maxSize || M.minSize !== C.minSize) && v(b.value, M);
+    }, { deep: !0 }), ft(() => {
+      const C = b.value;
+      g(C), pt(() => {
+        w(C);
+      });
+    });
+    const L = te(() => f(b.value, a.defaultSize)), I = te(() => h(b.value)), B = te(() => !I.value);
+    function R() {
+      i(b.value);
+    }
+    function G() {
+      r(b.value);
+    }
+    function F(C) {
+      u(b.value, C);
+    }
+    return t({
+      /** If panel is `collapsible`, collapse it fully. */
+      collapse: R,
+      /** If panel is currently collapsed, expand it to its most recent size. */
+      expand: G,
+      /** Gets the current size of the panel as a percentage (1 - 100). */
+      getSize() {
+        return c(b.value);
+      },
+      /** Resize panel to the specified percentage (1 - 100). */
+      resize: F,
+      /** Returns `true` if the panel is currently collapsed */
+      isCollapsed: I,
+      /** Returns `true` if the panel is currently not collapsed */
+      isExpanded: B
+    }), (C, M) => (Z(), ue(P(Pe), {
+      id: P(d),
+      style: Ne(L.value),
+      as: C.as,
+      "as-child": C.asChild,
+      "data-panel": "",
+      "data-panel-collapsible": C.collapsible || void 0,
+      "data-panel-group-id": P(m),
+      "data-panel-id": P(d),
+      "data-panel-size": Number.parseFloat(`${L.value.flexGrow}`).toFixed(1),
+      "data-state": C.collapsible ? I.value ? "collapsed" : "expanded" : void 0
+    }, {
+      default: ce(() => [
+        ve(C.$slots, "default", {
+          isCollapsed: I.value,
+          isExpanded: B.value,
+          expand: G,
+          collapse: R,
+          resize: F
+        })
+      ]),
+      _: 3
+    }, 8, ["id", "style", "as", "as-child", "data-panel-collapsible", "data-panel-group-id", "data-panel-id", "data-panel-size", "data-state"]));
+  }
+});
+function jt({
+  disabled: e,
+  handleId: t,
+  resizeHandler: n,
+  panelGroupElement: a
+}) {
+  oe((l) => {
+    const o = a.value;
+    if (e.value || n.value === null || o === null)
+      return;
+    const i = he(t, o);
+    if (i == null)
+      return;
+    const r = (c) => {
+      var f;
+      if (!c.defaultPrevented)
+        switch (c.key) {
+          case "ArrowDown":
+          case "ArrowLeft":
+          case "ArrowRight":
+          case "ArrowUp":
+          case "End":
+          case "Home": {
+            c.preventDefault(), (f = n.value) == null || f.call(n, c);
+            break;
+          }
+          case "F6": {
+            c.preventDefault();
+            const h = i.getAttribute("data-panel-group-id");
+            x(h);
+            const u = ie(
+              h,
+              o
+            ), m = Ve(
+              h,
+              t,
+              o
+            );
+            x(m !== null);
+            const v = c.shiftKey ? m > 0 ? m - 1 : u.length - 1 : m + 1 < u.length ? m + 1 : 0;
+            u[v].focus();
+            break;
+          }
+        }
+    };
+    i.addEventListener("keydown", r), l(() => {
+      i.removeEventListener("keydown", r);
+    });
+  });
+}
+const Kt = /* @__PURE__ */ se({
+  __name: "SplitterResizeHandle",
+  props: {
+    id: {},
+    hitAreaMargins: {},
+    tabindex: { default: 0 },
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["dragging"],
+  setup(e, { emit: t }) {
+    const n = e, a = t, { forwardRef: l, currentElement: o } = Fe(), { disabled: i } = Be(n), r = it();
+    if (r === null)
+      throw new Error(
+        "PanelResizeHandle components must be rendered within a PanelGroup container"
+      );
+    const {
+      direction: c,
+      groupId: f,
+      registerResizeHandle: h,
+      startDragging: u,
+      stopDragging: m,
+      panelGroupElement: v
+    } = r, g = Ee(n.id, "reka-splitter-resize-handle"), w = $("inactive"), d = $(!1), b = $(null);
+    return we(i, () => {
+      de && (i.value ? b.value = null : b.value = h(g));
+    }, { immediate: !0 }), oe((L) => {
+      var R, G;
+      if (i.value || b.value === null)
+        return;
+      const I = o.value;
+      if (!I)
+        return;
+      x(I);
+      const B = (F, C, M) => {
+        var Y;
+        if (C)
+          switch (F) {
+            case "down": {
+              w.value = "drag", u(g, M), a("dragging", !0);
+              break;
+            }
+            case "move": {
+              w.value !== "drag" && (w.value = "hover"), (Y = b.value) == null || Y.call(b, M);
+              break;
+            }
+            case "up": {
+              w.value = "hover", m(), a("dragging", !1);
+              break;
+            }
+          }
+        else
+          w.value = "inactive";
+      };
+      L(Nt(
+        g,
+        I,
+        c,
+        {
+          // Coarse inputs (e.g. finger/touch)
+          coarse: ((R = n.hitAreaMargins) == null ? void 0 : R.coarse) ?? 15,
+          // Fine inputs (e.g. mouse)
+          fine: ((G = n.hitAreaMargins) == null ? void 0 : G.fine) ?? 5
+        },
+        B
+      ));
+    }), jt({
+      disabled: i,
+      resizeHandler: b,
+      handleId: g,
+      panelGroupElement: v
+    }), (L, I) => (Z(), ue(P(Pe), {
+      id: P(g),
+      ref: P(l),
+      style: {
+        touchAction: "none",
+        userSelect: "none"
+      },
+      as: L.as,
+      "as-child": L.asChild,
+      role: "separator",
+      "data-resize-handle": "",
+      tabindex: L.tabindex,
+      "data-state": w.value,
+      "data-disabled": P(i) ? "" : void 0,
+      "data-orientation": P(c),
+      "data-panel-group-id": P(f),
+      "data-resize-handle-active": w.value === "drag" ? "pointer" : d.value ? "keyboard" : void 0,
+      "data-resize-handle-state": w.value,
+      "data-panel-resize-handle-enabled": !P(i),
+      "data-panel-resize-handle-id": P(g),
+      onBlur: I[0] || (I[0] = (B) => d.value = !1),
+      onFocus: I[1] || (I[1] = (B) => d.value = !1)
+    }, {
+      default: ce(() => [
+        ve(L.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "as", "as-child", "tabindex", "data-state", "data-disabled", "data-orientation", "data-panel-group-id", "data-resize-handle-active", "data-resize-handle-state", "data-panel-resize-handle-enabled", "data-panel-resize-handle-id"]));
+  }
+});
+/**
+ * @license lucide-vue-next v0.514.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Xt = St("grip-vertical", [
+  ["circle", { cx: "9", cy: "12", r: "1", key: "1vctgf" }],
+  ["circle", { cx: "9", cy: "5", r: "1", key: "hp0tcf" }],
+  ["circle", { cx: "9", cy: "19", r: "1", key: "fkjjf6" }],
+  ["circle", { cx: "15", cy: "12", r: "1", key: "1tmaij" }],
+  ["circle", { cx: "15", cy: "5", r: "1", key: "19l28e" }],
+  ["circle", { cx: "15", cy: "19", r: "1", key: "f4zoj3" }]
+]), Wt = {
+  key: 0,
+  class: "z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border"
+}, rn = /* @__PURE__ */ se({
+  __name: "ResizableHandle",
+  props: {
+    id: {},
+    hitAreaMargins: {},
+    tabindex: {},
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {},
+    withHandle: { type: Boolean }
+  },
+  emits: ["dragging"],
+  setup(e, { emit: t }) {
+    const n = e, a = t, l = Te(n, "class"), o = $e(l, a);
+    return (i, r) => (Z(), ue(P(Kt), Ge(P(o), {
+      class: P(He)("relative flex w-px items-center justify-center bg-border after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring focus-visible:ring-offset-1 [&[data-orientation=vertical]]:h-px [&[data-orientation=vertical]]:w-full [&[data-orientation=vertical]]:after:left-0 [&[data-orientation=vertical]]:after:h-1 [&[data-orientation=vertical]]:after:w-full [&[data-orientation=vertical]]:after:-translate-y-1/2 [&[data-orientation=vertical]]:after:translate-x-0 [&[data-orientation=vertical]>div]:rotate-90", n.class)
+    }), {
+      default: ce(() => [
+        n.withHandle ? (Z(), mt("div", Wt, [
+          ht(P(Xt), { class: "h-2.5 w-2.5" })
+        ])) : vt("", !0)
+      ]),
+      _: 1
+    }, 16, ["class"]));
+  }
+}), sn = /* @__PURE__ */ se({
+  __name: "ResizablePanelGroup",
+  props: {
+    id: {},
+    autoSaveId: {},
+    direction: {},
+    keyboardResizeBy: {},
+    storage: {},
+    asChild: { type: Boolean },
+    as: { type: [String, Object, Function] },
+    class: {}
+  },
+  emits: ["layout"],
+  setup(e, { emit: t }) {
+    const n = e, a = t, l = Te(n, "class"), o = $e(l, a);
+    return (i, r) => (Z(), ue(P(Vt), Ge(P(o), {
+      class: P(He)("flex h-full w-full data-[panel-group-direction=vertical]:flex-col", n.class)
+    }), {
+      default: ce(() => [
+        ve(i.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+});
+export {
+  rn as ResizableHandle,
+  ln as ResizablePanel,
+  sn as ResizablePanelGroup
+};