ics-ui-kit 0.1.0-alpha.9 → 0.1.0

package/dist/components/resizable.js

@@ -0,0 +1,1552 @@
+import { jsx as we } from "react/jsx-runtime";
+import * as Rn from "react";
+import { forwardRef as en, createElement as de, useContext as nn, createContext as Ln, useRef as F, useLayoutEffect as An, useImperativeHandle as tn, useEffect as te, useState as ce, useCallback as B, useMemo as kn } from "react";
+import { T as rn } from "../index-BVqs-uqP.js";
+import { I as Dn } from "../Icon-DH3ev9GK.js";
+import { c as Hn } from "../createLucideIcon-DwBrHnj9.js";
+/**
+ * @license lucide-react v0.460.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Mn = Hn("GripVertical", [
+  ["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" }]
+]), Re = Ln(null);
+Re.displayName = "PanelGroupContext";
+const A = {
+  group: "data-panel-group",
+  groupDirection: "data-panel-group-direction",
+  groupId: "data-panel-group-id",
+  panel: "data-panel",
+  panelCollapsible: "data-panel-collapsible",
+  panelId: "data-panel-id",
+  panelSize: "data-panel-size",
+  resizeHandle: "data-resize-handle",
+  resizeHandleActive: "data-resize-handle-active",
+  resizeHandleEnabled: "data-panel-resize-handle-enabled",
+  resizeHandleId: "data-panel-resize-handle-id",
+  resizeHandleState: "data-resize-handle-state"
+}, Fe = 10, re = An, je = Rn.useId, Nn = typeof je == "function" ? je : () => null;
+let $n = 0;
+function Ve(e = null) {
+  const n = Nn(), t = F(e || n || null);
+  return t.current === null && (t.current = "" + $n++), e ?? t.current;
+}
+function on({
+  children: e,
+  className: n = "",
+  collapsedSize: t,
+  collapsible: r,
+  defaultSize: i,
+  forwardedRef: o,
+  id: l,
+  maxSize: a,
+  minSize: s,
+  onCollapse: m,
+  onExpand: P,
+  onResize: f,
+  order: c,
+  style: x,
+  tagName: y = "div",
+  ...I
+}) {
+  const w = nn(Re);
+  if (w === null)
+    throw Error("Panel components must be rendered within a PanelGroup container");
+  const {
+    collapsePanel: b,
+    expandPanel: R,
+    getPanelSize: D,
+    getPanelStyle: M,
+    groupId: O,
+    isPanelCollapsed: C,
+    reevaluatePanelConstraints: S,
+    registerPanel: K,
+    resizePanel: J,
+    unregisterPanel: V
+  } = w, _ = Ve(l), k = F({
+    callbacks: {
+      onCollapse: m,
+      onExpand: P,
+      onResize: f
+    },
+    constraints: {
+      collapsedSize: t,
+      collapsible: r,
+      defaultSize: i,
+      maxSize: a,
+      minSize: s
+    },
+    id: _,
+    idIsFromProps: l !== void 0,
+    order: c
+  });
+  F({
+    didLogMissingDefaultSizeWarning: !1
+  }), re(() => {
+    const {
+      callbacks: $,
+      constraints: N
+    } = k.current, G = {
+      ...N
+    };
+    k.current.id = _, k.current.idIsFromProps = l !== void 0, k.current.order = c, $.onCollapse = m, $.onExpand = P, $.onResize = f, N.collapsedSize = t, N.collapsible = r, N.defaultSize = i, N.maxSize = a, N.minSize = s, (G.collapsedSize !== N.collapsedSize || G.collapsible !== N.collapsible || G.maxSize !== N.maxSize || G.minSize !== N.minSize) && S(k.current, G);
+  }), re(() => {
+    const $ = k.current;
+    return K($), () => {
+      V($);
+    };
+  }, [c, _, K, V]), tn(o, () => ({
+    collapse: () => {
+      b(k.current);
+    },
+    expand: ($) => {
+      R(k.current, $);
+    },
+    getId() {
+      return _;
+    },
+    getSize() {
+      return D(k.current);
+    },
+    isCollapsed() {
+      return C(k.current);
+    },
+    isExpanded() {
+      return !C(k.current);
+    },
+    resize: ($) => {
+      J(k.current, $);
+    }
+  }), [b, R, D, C, _, J]);
+  const ee = M(k.current, i);
+  return de(y, {
+    ...I,
+    children: e,
+    className: n,
+    id: _,
+    style: {
+      ...ee,
+      ...x
+    },
+    // CSS selectors
+    [A.groupId]: O,
+    [A.panel]: "",
+    [A.panelCollapsible]: r || void 0,
+    [A.panelId]: _,
+    [A.panelSize]: parseFloat("" + ee.flexGrow).toFixed(1)
+  });
+}
+const ln = en((e, n) => de(on, {
+  ...e,
+  forwardedRef: n
+}));
+on.displayName = "Panel";
+ln.displayName = "forwardRef(Panel)";
+let Be = null, Ie = -1, Z = null;
+function _n(e, n, t) {
+  const r = (n & dn) !== 0, i = (n & fn) !== 0, o = (n & pn) !== 0, l = (n & gn) !== 0;
+  if (n) {
+    if (r)
+      return o ? "se-resize" : l ? "ne-resize" : "e-resize";
+    if (i)
+      return o ? "sw-resize" : l ? "nw-resize" : "w-resize";
+    if (o)
+      return "s-resize";
+    if (l)
+      return "n-resize";
+  }
+  switch (e) {
+    case "horizontal":
+      return "ew-resize";
+    case "intersection":
+      return "move";
+    case "vertical":
+      return "ns-resize";
+  }
+}
+function Gn() {
+  Z !== null && (document.head.removeChild(Z), Be = null, Z = null, Ie = -1);
+}
+function Ne(e, n, t) {
+  var r, i;
+  const o = _n(e, n);
+  if (Be !== o) {
+    if (Be = o, Z === null && (Z = document.createElement("style"), document.head.appendChild(Z)), Ie >= 0) {
+      var l;
+      (l = Z.sheet) === null || l === void 0 || l.removeRule(Ie);
+    }
+    Ie = (r = (i = Z.sheet) === null || i === void 0 ? void 0 : i.insertRule(`*{cursor: ${o} !important;}`)) !== null && r !== void 0 ? r : -1;
+  }
+}
+function an(e) {
+  return e.type === "keydown";
+}
+function sn(e) {
+  return e.type.startsWith("pointer");
+}
+function cn(e) {
+  return e.type.startsWith("mouse");
+}
+function Le(e) {
+  if (sn(e)) {
+    if (e.isPrimary)
+      return {
+        x: e.clientX,
+        y: e.clientY
+      };
+  } else if (cn(e))
+    return {
+      x: e.clientX,
+      y: e.clientY
+    };
+  return {
+    x: 1 / 0,
+    y: 1 / 0
+  };
+}
+function Tn() {
+  if (typeof matchMedia == "function")
+    return matchMedia("(pointer:coarse)").matches ? "coarse" : "fine";
+}
+function Bn(e, n, t) {
+  return e.x < n.x + n.width && e.x + e.width > n.x && e.y < n.y + n.height && e.y + e.height > n.y;
+}
+function Fn(e, n) {
+  if (e === n) throw new Error("Cannot compare node with itself");
+  const t = {
+    a: Xe(e),
+    b: Xe(n)
+  };
+  let r;
+  for (; t.a.at(-1) === t.b.at(-1); )
+    e = t.a.pop(), n = t.b.pop(), r = e;
+  z(r, "Stacking order can only be calculated for elements with a common ancestor");
+  const i = {
+    a: qe(Oe(t.a)),
+    b: qe(Oe(t.b))
+  };
+  if (i.a === i.b) {
+    const o = r.childNodes, l = {
+      a: t.a.at(-1),
+      b: t.b.at(-1)
+    };
+    let a = o.length;
+    for (; a--; ) {
+      const s = o[a];
+      if (s === l.a) return 1;
+      if (s === l.b) return -1;
+    }
+  }
+  return Math.sign(i.a - i.b);
+}
+const Vn = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function Wn(e) {
+  var n;
+  const t = getComputedStyle((n = un(e)) !== null && n !== void 0 ? n : e).display;
+  return t === "flex" || t === "inline-flex";
+}
+function Kn(e) {
+  const n = getComputedStyle(e);
+  return !!(n.position === "fixed" || n.zIndex !== "auto" && (n.position !== "static" || Wn(e)) || +n.opacity < 1 || "transform" in n && n.transform !== "none" || "webkitTransform" in n && n.webkitTransform !== "none" || "mixBlendMode" in n && n.mixBlendMode !== "normal" || "filter" in n && n.filter !== "none" || "webkitFilter" in n && n.webkitFilter !== "none" || "isolation" in n && n.isolation === "isolate" || Vn.test(n.willChange) || n.webkitOverflowScrolling === "touch");
+}
+function Oe(e) {
+  let n = e.length;
+  for (; n--; ) {
+    const t = e[n];
+    if (z(t, "Missing node"), Kn(t)) return t;
+  }
+  return null;
+}
+function qe(e) {
+  return e && Number(getComputedStyle(e).zIndex) || 0;
+}
+function Xe(e) {
+  const n = [];
+  for (; e; )
+    n.push(e), e = un(e);
+  return n;
+}
+function un(e) {
+  const {
+    parentNode: n
+  } = e;
+  return n && n instanceof ShadowRoot ? n.host : n;
+}
+const dn = 1, fn = 2, pn = 4, gn = 8, Un = Tn() === "coarse";
+let j = [], ue = !1, Q = /* @__PURE__ */ new Map(), Ae = /* @__PURE__ */ new Map();
+const ve = /* @__PURE__ */ new Set();
+function jn(e, n, t, r, i) {
+  var o;
+  const {
+    ownerDocument: l
+  } = n, a = {
+    direction: t,
+    element: n,
+    hitAreaMargins: r,
+    setResizeHandlerState: i
+  }, s = (o = Q.get(l)) !== null && o !== void 0 ? o : 0;
+  return Q.set(l, s + 1), ve.add(a), Ee(), function() {
+    var P;
+    Ae.delete(e), ve.delete(a);
+    const f = (P = Q.get(l)) !== null && P !== void 0 ? P : 1;
+    if (Q.set(l, f - 1), Ee(), f === 1 && Q.delete(l), j.includes(a)) {
+      const c = j.indexOf(a);
+      c >= 0 && j.splice(c, 1), ke(), i("up", !0, null);
+    }
+  };
+}
+function On(e) {
+  const {
+    target: n
+  } = e, {
+    x: t,
+    y: r
+  } = Le(e);
+  ue = !0, We({
+    target: n,
+    x: t,
+    y: r
+  }), Ee(), j.length > 0 && (Ce("down", e), ke(), e.preventDefault(), mn(n) || e.stopImmediatePropagation());
+}
+function $e(e) {
+  const {
+    x: n,
+    y: t
+  } = Le(e);
+  if (ue && // Skip this check for "pointerleave" events, else Firefox triggers a false positive (see #514)
+  e.type !== "pointerleave" && e.buttons === 0 && (ue = !1, Ce("up", e)), !ue) {
+    const {
+      target: r
+    } = e;
+    We({
+      target: r,
+      x: n,
+      y: t
+    });
+  }
+  Ce("move", e), ke(), j.length > 0 && e.preventDefault();
+}
+function _e(e) {
+  const {
+    target: n
+  } = e, {
+    x: t,
+    y: r
+  } = Le(e);
+  Ae.clear(), ue = !1, j.length > 0 && (e.preventDefault(), mn(n) || e.stopImmediatePropagation()), Ce("up", e), We({
+    target: n,
+    x: t,
+    y: r
+  }), ke(), Ee();
+}
+function mn(e) {
+  let n = e;
+  for (; n; ) {
+    if (n.hasAttribute(A.resizeHandle))
+      return !0;
+    n = n.parentElement;
+  }
+  return !1;
+}
+function We({
+  target: e,
+  x: n,
+  y: t
+}) {
+  j.splice(0);
+  let r = null;
+  (e instanceof HTMLElement || e instanceof SVGElement) && (r = e), ve.forEach((i) => {
+    const {
+      element: o,
+      hitAreaMargins: l
+    } = i, a = o.getBoundingClientRect(), {
+      bottom: s,
+      left: m,
+      right: P,
+      top: f
+    } = a, c = Un ? l.coarse : l.fine;
+    if (n >= m - c && n <= P + c && t >= f - c && t <= s + c) {
+      if (r !== null && document.contains(r) && o !== r && !o.contains(r) && !r.contains(o) && // Calculating stacking order has a cost, so we should avoid it if possible
+      // That is why we only check potentially intersecting handles,
+      // and why we skip if the event target is within the handle's DOM
+      Fn(r, o) > 0) {
+        let y = r, I = !1;
+        for (; y && !y.contains(o); ) {
+          if (Bn(y.getBoundingClientRect(), a)) {
+            I = !0;
+            break;
+          }
+          y = y.parentElement;
+        }
+        if (I)
+          return;
+      }
+      j.push(i);
+    }
+  });
+}
+function Ge(e, n) {
+  Ae.set(e, n);
+}
+function ke() {
+  let e = !1, n = !1;
+  j.forEach((r) => {
+    const {
+      direction: i
+    } = r;
+    i === "horizontal" ? e = !0 : n = !0;
+  });
+  let t = 0;
+  Ae.forEach((r) => {
+    t |= r;
+  }), e && n ? Ne("intersection", t) : e ? Ne("horizontal", t) : n ? Ne("vertical", t) : Gn();
+}
+let Te;
+function Ee() {
+  var e;
+  (e = Te) === null || e === void 0 || e.abort(), Te = new AbortController();
+  const n = {
+    capture: !0,
+    signal: Te.signal
+  };
+  ve.size && (ue ? (j.length > 0 && Q.forEach((t, r) => {
+    const {
+      body: i
+    } = r;
+    t > 0 && (i.addEventListener("contextmenu", _e, n), i.addEventListener("pointerleave", $e, n), i.addEventListener("pointermove", $e, n));
+  }), Q.forEach((t, r) => {
+    const {
+      body: i
+    } = r;
+    i.addEventListener("pointerup", _e, n), i.addEventListener("pointercancel", _e, n);
+  })) : Q.forEach((t, r) => {
+    const {
+      body: i
+    } = r;
+    t > 0 && (i.addEventListener("pointerdown", On, n), i.addEventListener("pointermove", $e, n));
+  }));
+}
+function Ce(e, n) {
+  ve.forEach((t) => {
+    const {
+      setResizeHandlerState: r
+    } = t, i = j.includes(t);
+    r(e, i, n);
+  });
+}
+function qn() {
+  const [e, n] = ce(0);
+  return B(() => n((t) => t + 1), []);
+}
+function z(e, n) {
+  if (!e)
+    throw console.error(n), Error(n);
+}
+function oe(e, n, t = Fe) {
+  return e.toFixed(t) === n.toFixed(t) ? 0 : e > n ? 1 : -1;
+}
+function Y(e, n, t = Fe) {
+  return oe(e, n, t) === 0;
+}
+function W(e, n, t) {
+  return oe(e, n, t) === 0;
+}
+function Xn(e, n, t) {
+  if (e.length !== n.length)
+    return !1;
+  for (let r = 0; r < e.length; r++) {
+    const i = e[r], o = n[r];
+    if (!W(i, o, t))
+      return !1;
+  }
+  return !0;
+}
+function se({
+  panelConstraints: e,
+  panelIndex: n,
+  size: t
+}) {
+  const r = e[n];
+  z(r != null, `Panel constraints not found for index ${n}`);
+  let {
+    collapsedSize: i = 0,
+    collapsible: o,
+    maxSize: l = 100,
+    minSize: a = 0
+  } = r;
+  if (oe(t, a) < 0)
+    if (o) {
+      const s = (i + a) / 2;
+      oe(t, s) < 0 ? t = i : t = a;
+    } else
+      t = a;
+  return t = Math.min(l, t), t = parseFloat(t.toFixed(Fe)), t;
+}
+function ze({
+  delta: e,
+  initialLayout: n,
+  panelConstraints: t,
+  pivotIndices: r,
+  prevLayout: i,
+  trigger: o
+}) {
+  if (W(e, 0))
+    return n;
+  const l = [...n], [a, s] = r;
+  z(a != null, "Invalid first pivot index"), z(s != null, "Invalid second pivot index");
+  let m = 0;
+  if (o === "keyboard") {
+    {
+      const f = e < 0 ? s : a, c = t[f];
+      z(c, `Panel constraints not found for index ${f}`);
+      const {
+        collapsedSize: x = 0,
+        collapsible: y,
+        minSize: I = 0
+      } = c;
+      if (y) {
+        const w = n[f];
+        if (z(w != null, `Previous layout not found for panel index ${f}`), W(w, x)) {
+          const b = I - w;
+          oe(b, Math.abs(e)) > 0 && (e = e < 0 ? 0 - b : b);
+        }
+      }
+    }
+    {
+      const f = e < 0 ? a : s, c = t[f];
+      z(c, `No panel constraints found for index ${f}`);
+      const {
+        collapsedSize: x = 0,
+        collapsible: y,
+        minSize: I = 0
+      } = c;
+      if (y) {
+        const w = n[f];
+        if (z(w != null, `Previous layout not found for panel index ${f}`), W(w, I)) {
+          const b = w - x;
+          oe(b, Math.abs(e)) > 0 && (e = e < 0 ? 0 - b : b);
+        }
+      }
+    }
+  }
+  {
+    const f = e < 0 ? 1 : -1;
+    let c = e < 0 ? s : a, x = 0;
+    for (; ; ) {
+      const I = n[c];
+      z(I != null, `Previous layout not found for panel index ${c}`);
+      const b = se({
+        panelConstraints: t,
+        panelIndex: c,
+        size: 100
+      }) - I;
+      if (x += b, c += f, c < 0 || c >= t.length)
+        break;
+    }
+    const y = Math.min(Math.abs(e), Math.abs(x));
+    e = e < 0 ? 0 - y : y;
+  }
+  {
+    let c = e < 0 ? a : s;
+    for (; c >= 0 && c < t.length; ) {
+      const x = Math.abs(e) - Math.abs(m), y = n[c];
+      z(y != null, `Previous layout not found for panel index ${c}`);
+      const I = y - x, w = se({
+        panelConstraints: t,
+        panelIndex: c,
+        size: I
+      });
+      if (!W(y, w) && (m += y - w, l[c] = w, m.toFixed(3).localeCompare(Math.abs(e).toFixed(3), void 0, {
+        numeric: !0
+      }) >= 0))
+        break;
+      e < 0 ? c-- : c++;
+    }
+  }
+  if (Xn(i, l))
+    return i;
+  {
+    const f = e < 0 ? s : a, c = n[f];
+    z(c != null, `Previous layout not found for panel index ${f}`);
+    const x = c + m, y = se({
+      panelConstraints: t,
+      panelIndex: f,
+      size: x
+    });
+    if (l[f] = y, !W(y, x)) {
+      let I = x - y, b = e < 0 ? s : a;
+      for (; b >= 0 && b < t.length; ) {
+        const R = l[b];
+        z(R != null, `Previous layout not found for panel index ${b}`);
+        const D = R + I, M = se({
+          panelConstraints: t,
+          panelIndex: b,
+          size: D
+        });
+        if (W(R, M) || (I -= M - R, l[b] = M), W(I, 0))
+          break;
+        e > 0 ? b-- : b++;
+      }
+    }
+  }
+  const P = l.reduce((f, c) => c + f, 0);
+  return W(P, 100) ? l : i;
+}
+function Jn({
+  layout: e,
+  panelsArray: n,
+  pivotIndices: t
+}) {
+  let r = 0, i = 100, o = 0, l = 0;
+  const a = t[0];
+  z(a != null, "No pivot index found"), n.forEach((f, c) => {
+    const {
+      constraints: x
+    } = f, {
+      maxSize: y = 100,
+      minSize: I = 0
+    } = x;
+    c === a ? (r = I, i = y) : (o += I, l += y);
+  });
+  const s = Math.min(i, 100 - o), m = Math.max(r, 100 - l), P = e[a];
+  return {
+    valueMax: s,
+    valueMin: m,
+    valueNow: P
+  };
+}
+function be(e, n = document) {
+  return Array.from(n.querySelectorAll(`[${A.resizeHandleId}][data-panel-group-id="${e}"]`));
+}
+function yn(e, n, t = document) {
+  const i = be(e, t).findIndex((o) => o.getAttribute(A.resizeHandleId) === n);
+  return i ?? null;
+}
+function hn(e, n, t) {
+  const r = yn(e, n, t);
+  return r != null ? [r, r + 1] : [-1, -1];
+}
+function Yn(e) {
+  return e instanceof HTMLElement ? !0 : typeof e == "object" && e !== null && "tagName" in e && "getAttribute" in e;
+}
+function zn(e, n = document) {
+  if (Yn(n) && n.dataset.panelGroupId == e)
+    return n;
+  const t = n.querySelector(`[data-panel-group][data-panel-group-id="${e}"]`);
+  return t || null;
+}
+function De(e, n = document) {
+  const t = n.querySelector(`[${A.resizeHandleId}="${e}"]`);
+  return t || null;
+}
+function Zn(e, n, t, r = document) {
+  var i, o, l, a;
+  const s = De(n, r), m = be(e, r), P = s ? m.indexOf(s) : -1, f = (i = (o = t[P]) === null || o === void 0 ? void 0 : o.id) !== null && i !== void 0 ? i : null, c = (l = (a = t[P + 1]) === null || a === void 0 ? void 0 : a.id) !== null && l !== void 0 ? l : null;
+  return [f, c];
+}
+function Qn({
+  committedValuesRef: e,
+  eagerValuesRef: n,
+  groupId: t,
+  layout: r,
+  panelDataArray: i,
+  panelGroupElement: o,
+  setLayout: l
+}) {
+  F({
+    didWarnAboutMissingResizeHandle: !1
+  }), re(() => {
+    if (!o)
+      return;
+    const a = be(t, o);
+    for (let s = 0; s < i.length - 1; s++) {
+      const {
+        valueMax: m,
+        valueMin: P,
+        valueNow: f
+      } = Jn({
+        layout: r,
+        panelsArray: i,
+        pivotIndices: [s, s + 1]
+      }), c = a[s];
+      if (c != null) {
+        const x = i[s];
+        z(x, `No panel data found for index "${s}"`), c.setAttribute("aria-controls", x.id), c.setAttribute("aria-valuemax", "" + Math.round(m)), c.setAttribute("aria-valuemin", "" + Math.round(P)), c.setAttribute("aria-valuenow", f != null ? "" + Math.round(f) : "");
+      }
+    }
+    return () => {
+      a.forEach((s, m) => {
+        s.removeAttribute("aria-controls"), s.removeAttribute("aria-valuemax"), s.removeAttribute("aria-valuemin"), s.removeAttribute("aria-valuenow");
+      });
+    };
+  }, [t, r, i, o]), te(() => {
+    if (!o)
+      return;
+    const a = n.current;
+    z(a, "Eager values not found");
+    const {
+      panelDataArray: s
+    } = a, m = zn(t, o);
+    z(m != null, `No group found for id "${t}"`);
+    const P = be(t, o);
+    z(P, `No resize handles found for group id "${t}"`);
+    const f = P.map((c) => {
+      const x = c.getAttribute(A.resizeHandleId);
+      z(x, "Resize handle element has no handle id attribute");
+      const [y, I] = Zn(t, x, s, o);
+      if (y == null || I == null)
+        return () => {
+        };
+      const w = (b) => {
+        if (!b.defaultPrevented)
+          switch (b.key) {
+            case "Enter": {
+              b.preventDefault();
+              const R = s.findIndex((D) => D.id === y);
+              if (R >= 0) {
+                const D = s[R];
+                z(D, `No panel data found for index ${R}`);
+                const M = r[R], {
+                  collapsedSize: O = 0,
+                  collapsible: C,
+                  minSize: S = 0
+                } = D.constraints;
+                if (M != null && C) {
+                  const K = ze({
+                    delta: W(M, O) ? S - O : O - M,
+                    initialLayout: r,
+                    panelConstraints: s.map((J) => J.constraints),
+                    pivotIndices: hn(t, x, o),
+                    prevLayout: r,
+                    trigger: "keyboard"
+                  });
+                  r !== K && l(K);
+                }
+              }
+              break;
+            }
+          }
+      };
+      return c.addEventListener("keydown", w), () => {
+        c.removeEventListener("keydown", w);
+      };
+    });
+    return () => {
+      f.forEach((c) => c());
+    };
+  }, [o, e, n, t, r, i, l]);
+}
+function Je(e, n) {
+  if (e.length !== n.length)
+    return !1;
+  for (let t = 0; t < e.length; t++)
+    if (e[t] !== n[t])
+      return !1;
+  return !0;
+}
+function xn(e, n) {
+  const t = e === "horizontal", {
+    x: r,
+    y: i
+  } = Le(n);
+  return t ? r : i;
+}
+function et(e, n, t, r, i) {
+  const o = t === "horizontal", l = De(n, i);
+  z(l, `No resize handle element found for id "${n}"`);
+  const a = l.getAttribute(A.groupId);
+  z(a, "Resize handle element has no group id attribute");
+  let {
+    initialCursorPosition: s
+  } = r;
+  const m = xn(t, e), P = zn(a, i);
+  z(P, `No group element found for id "${a}"`);
+  const f = P.getBoundingClientRect(), c = o ? f.width : f.height;
+  return (m - s) / c * 100;
+}
+function nt(e, n, t, r, i, o) {
+  if (an(e)) {
+    const l = t === "horizontal";
+    let a = 0;
+    e.shiftKey ? a = 100 : i != null ? a = i : a = 10;
+    let s = 0;
+    switch (e.key) {
+      case "ArrowDown":
+        s = l ? 0 : a;
+        break;
+      case "ArrowLeft":
+        s = l ? -a : 0;
+        break;
+      case "ArrowRight":
+        s = l ? a : 0;
+        break;
+      case "ArrowUp":
+        s = l ? 0 : -a;
+        break;
+      case "End":
+        s = 100;
+        break;
+      case "Home":
+        s = -100;
+        break;
+    }
+    return s;
+  } else
+    return r == null ? 0 : et(e, n, t, r, o);
+}
+function tt({
+  panelDataArray: e
+}) {
+  const n = Array(e.length), t = e.map((o) => o.constraints);
+  let r = 0, i = 100;
+  for (let o = 0; o < e.length; o++) {
+    const l = t[o];
+    z(l, `Panel constraints not found for index ${o}`);
+    const {
+      defaultSize: a
+    } = l;
+    a != null && (r++, n[o] = a, i -= a);
+  }
+  for (let o = 0; o < e.length; o++) {
+    const l = t[o];
+    z(l, `Panel constraints not found for index ${o}`);
+    const {
+      defaultSize: a
+    } = l;
+    if (a != null)
+      continue;
+    const s = e.length - r, m = i / s;
+    r++, n[o] = m, i -= m;
+  }
+  return n;
+}
+function le(e, n, t) {
+  n.forEach((r, i) => {
+    const o = e[i];
+    z(o, `Panel data not found for index ${i}`);
+    const {
+      callbacks: l,
+      constraints: a,
+      id: s
+    } = o, {
+      collapsedSize: m = 0,
+      collapsible: P
+    } = a, f = t[s];
+    if (f == null || r !== f) {
+      t[s] = r;
+      const {
+        onCollapse: c,
+        onExpand: x,
+        onResize: y
+      } = l;
+      y && y(r, f), P && (c || x) && (x && (f == null || Y(f, m)) && !Y(r, m) && x(), c && (f == null || !Y(f, m)) && Y(r, m) && c());
+    }
+  });
+}
+function Pe(e, n) {
+  if (e.length !== n.length)
+    return !1;
+  for (let t = 0; t < e.length; t++)
+    if (e[t] != n[t])
+      return !1;
+  return !0;
+}
+function rt({
+  defaultSize: e,
+  dragState: n,
+  layout: t,
+  panelData: r,
+  panelIndex: i,
+  precision: o = 3
+}) {
+  const l = t[i];
+  let a;
+  return l == null ? a = e != null ? e.toFixed(o) : "1" : r.length === 1 ? a = "1" : a = l.toFixed(o), {
+    flexBasis: 0,
+    flexGrow: a,
+    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: n !== null ? "none" : void 0
+  };
+}
+function ot(e, n = 10) {
+  let t = null;
+  return (...i) => {
+    t !== null && clearTimeout(t), t = setTimeout(() => {
+      e(...i);
+    }, n);
+  };
+}
+function Ye(e) {
+  try {
+    if (typeof localStorage < "u")
+      e.getItem = (n) => localStorage.getItem(n), e.setItem = (n, t) => {
+        localStorage.setItem(n, t);
+      };
+    else
+      throw new Error("localStorage not supported in this environment");
+  } catch (n) {
+    console.error(n), e.getItem = () => null, e.setItem = () => {
+    };
+  }
+}
+function vn(e) {
+  return `react-resizable-panels:${e}`;
+}
+function bn(e) {
+  return e.map((n) => {
+    const {
+      constraints: t,
+      id: r,
+      idIsFromProps: i,
+      order: o
+    } = n;
+    return i ? r : o ? `${o}:${JSON.stringify(t)}` : JSON.stringify(t);
+  }).sort((n, t) => n.localeCompare(t)).join(",");
+}
+function Sn(e, n) {
+  try {
+    const t = vn(e), r = n.getItem(t);
+    if (r) {
+      const i = JSON.parse(r);
+      if (typeof i == "object" && i != null)
+        return i;
+    }
+  } catch {
+  }
+  return null;
+}
+function it(e, n, t) {
+  var r, i;
+  const o = (r = Sn(e, t)) !== null && r !== void 0 ? r : {}, l = bn(n);
+  return (i = o[l]) !== null && i !== void 0 ? i : null;
+}
+function lt(e, n, t, r, i) {
+  var o;
+  const l = vn(e), a = bn(n), s = (o = Sn(e, i)) !== null && o !== void 0 ? o : {};
+  s[a] = {
+    expandToSizes: Object.fromEntries(t.entries()),
+    layout: r
+  };
+  try {
+    i.setItem(l, JSON.stringify(s));
+  } catch (m) {
+    console.error(m);
+  }
+}
+function Ze({
+  layout: e,
+  panelConstraints: n
+}) {
+  const t = [...e], r = t.reduce((o, l) => o + l, 0);
+  if (t.length !== n.length)
+    throw Error(`Invalid ${n.length} panel layout: ${t.map((o) => `${o}%`).join(", ")}`);
+  if (!W(r, 100) && t.length > 0)
+    for (let o = 0; o < n.length; o++) {
+      const l = t[o];
+      z(l != null, `No layout data found for index ${o}`);
+      const a = 100 / r * l;
+      t[o] = a;
+    }
+  let i = 0;
+  for (let o = 0; o < n.length; o++) {
+    const l = t[o];
+    z(l != null, `No layout data found for index ${o}`);
+    const a = se({
+      panelConstraints: n,
+      panelIndex: o,
+      size: l
+    });
+    l != a && (i += l - a, t[o] = a);
+  }
+  if (!W(i, 0))
+    for (let o = 0; o < n.length; o++) {
+      const l = t[o];
+      z(l != null, `No layout data found for index ${o}`);
+      const a = l + i, s = se({
+        panelConstraints: n,
+        panelIndex: o,
+        size: a
+      });
+      if (l !== s && (i -= s - l, t[o] = s, W(i, 0)))
+        break;
+    }
+  return t;
+}
+const at = 100, xe = {
+  getItem: (e) => (Ye(xe), xe.getItem(e)),
+  setItem: (e, n) => {
+    Ye(xe), xe.setItem(e, n);
+  }
+}, Qe = {};
+function Pn({
+  autoSaveId: e = null,
+  children: n,
+  className: t = "",
+  direction: r,
+  forwardedRef: i,
+  id: o = null,
+  onLayout: l = null,
+  keyboardResizeBy: a = null,
+  storage: s = xe,
+  style: m,
+  tagName: P = "div",
+  ...f
+}) {
+  const c = Ve(o), x = F(null), [y, I] = ce(null), [w, b] = ce([]), R = qn(), D = F({}), M = F(/* @__PURE__ */ new Map()), O = F(0), C = F({
+    autoSaveId: e,
+    direction: r,
+    dragState: y,
+    id: c,
+    keyboardResizeBy: a,
+    onLayout: l,
+    storage: s
+  }), S = F({
+    layout: w,
+    panelDataArray: [],
+    panelDataArrayChanged: !1
+  });
+  F({
+    didLogIdAndOrderWarning: !1,
+    didLogPanelConstraintsWarning: !1,
+    prevPanelIds: []
+  }), tn(i, () => ({
+    getId: () => C.current.id,
+    getLayout: () => {
+      const {
+        layout: u
+      } = S.current;
+      return u;
+    },
+    setLayout: (u) => {
+      const {
+        onLayout: g
+      } = C.current, {
+        layout: v,
+        panelDataArray: p
+      } = S.current, d = Ze({
+        layout: u,
+        panelConstraints: p.map((h) => h.constraints)
+      });
+      Je(v, d) || (b(d), S.current.layout = d, g && g(d), le(p, d, D.current));
+    }
+  }), []), re(() => {
+    C.current.autoSaveId = e, C.current.direction = r, C.current.dragState = y, C.current.id = c, C.current.onLayout = l, C.current.storage = s;
+  }), Qn({
+    committedValuesRef: C,
+    eagerValuesRef: S,
+    groupId: c,
+    layout: w,
+    panelDataArray: S.current.panelDataArray,
+    setLayout: b,
+    panelGroupElement: x.current
+  }), te(() => {
+    const {
+      panelDataArray: u
+    } = S.current;
+    if (e) {
+      if (w.length === 0 || w.length !== u.length)
+        return;
+      let g = Qe[e];
+      g == null && (g = ot(lt, at), Qe[e] = g);
+      const v = [...u], p = new Map(M.current);
+      g(e, v, p, w, s);
+    }
+  }, [e, w, s]), te(() => {
+  });
+  const K = B((u) => {
+    const {
+      onLayout: g
+    } = C.current, {
+      layout: v,
+      panelDataArray: p
+    } = S.current;
+    if (u.constraints.collapsible) {
+      const d = p.map((q) => q.constraints), {
+        collapsedSize: h = 0,
+        panelSize: E,
+        pivotIndices: H
+      } = ne(p, u, v);
+      if (z(E != null, `Panel size not found for panel "${u.id}"`), !Y(E, h)) {
+        M.current.set(u.id, E);
+        const X = ae(p, u) === p.length - 1 ? E - h : h - E, L = ze({
+          delta: X,
+          initialLayout: v,
+          panelConstraints: d,
+          pivotIndices: H,
+          prevLayout: v,
+          trigger: "imperative-api"
+        });
+        Pe(v, L) || (b(L), S.current.layout = L, g && g(L), le(p, L, D.current));
+      }
+    }
+  }, []), J = B((u, g) => {
+    const {
+      onLayout: v
+    } = C.current, {
+      layout: p,
+      panelDataArray: d
+    } = S.current;
+    if (u.constraints.collapsible) {
+      const h = d.map((U) => U.constraints), {
+        collapsedSize: E = 0,
+        panelSize: H = 0,
+        minSize: q = 0,
+        pivotIndices: X
+      } = ne(d, u, p), L = g ?? q;
+      if (Y(H, E)) {
+        const U = M.current.get(u.id), ye = U != null && U >= L ? U : L, Me = ae(d, u) === d.length - 1 ? H - ye : ye - H, T = ze({
+          delta: Me,
+          initialLayout: p,
+          panelConstraints: h,
+          pivotIndices: X,
+          prevLayout: p,
+          trigger: "imperative-api"
+        });
+        Pe(p, T) || (b(T), S.current.layout = T, v && v(T), le(d, T, D.current));
+      }
+    }
+  }, []), V = B((u) => {
+    const {
+      layout: g,
+      panelDataArray: v
+    } = S.current, {
+      panelSize: p
+    } = ne(v, u, g);
+    return z(p != null, `Panel size not found for panel "${u.id}"`), p;
+  }, []), _ = B((u, g) => {
+    const {
+      panelDataArray: v
+    } = S.current, p = ae(v, u);
+    return rt({
+      defaultSize: g,
+      dragState: y,
+      layout: w,
+      panelData: v,
+      panelIndex: p
+    });
+  }, [y, w]), k = B((u) => {
+    const {
+      layout: g,
+      panelDataArray: v
+    } = S.current, {
+      collapsedSize: p = 0,
+      collapsible: d,
+      panelSize: h
+    } = ne(v, u, g);
+    return z(h != null, `Panel size not found for panel "${u.id}"`), d === !0 && Y(h, p);
+  }, []), ee = B((u) => {
+    const {
+      layout: g,
+      panelDataArray: v
+    } = S.current, {
+      collapsedSize: p = 0,
+      collapsible: d,
+      panelSize: h
+    } = ne(v, u, g);
+    return z(h != null, `Panel size not found for panel "${u.id}"`), !d || oe(h, p) > 0;
+  }, []), $ = B((u) => {
+    const {
+      panelDataArray: g
+    } = S.current;
+    g.push(u), g.sort((v, p) => {
+      const d = v.order, h = p.order;
+      return d == null && h == null ? 0 : d == null ? -1 : h == null ? 1 : d - h;
+    }), S.current.panelDataArrayChanged = !0, R();
+  }, [R]);
+  re(() => {
+    if (S.current.panelDataArrayChanged) {
+      S.current.panelDataArrayChanged = !1;
+      const {
+        autoSaveId: u,
+        onLayout: g,
+        storage: v
+      } = C.current, {
+        layout: p,
+        panelDataArray: d
+      } = S.current;
+      let h = null;
+      if (u) {
+        const H = it(u, d, v);
+        H && (M.current = new Map(Object.entries(H.expandToSizes)), h = H.layout);
+      }
+      h == null && (h = tt({
+        panelDataArray: d
+      }));
+      const E = Ze({
+        layout: h,
+        panelConstraints: d.map((H) => H.constraints)
+      });
+      Je(p, E) || (b(E), S.current.layout = E, g && g(E), le(d, E, D.current));
+    }
+  }), re(() => {
+    const u = S.current;
+    return () => {
+      u.layout = [];
+    };
+  }, []);
+  const N = B((u) => {
+    let g = !1;
+    const v = x.current;
+    return v && window.getComputedStyle(v, null).getPropertyValue("direction") === "rtl" && (g = !0), function(d) {
+      d.preventDefault();
+      const h = x.current;
+      if (!h)
+        return () => null;
+      const {
+        direction: E,
+        dragState: H,
+        id: q,
+        keyboardResizeBy: X,
+        onLayout: L
+      } = C.current, {
+        layout: U,
+        panelDataArray: ye
+      } = S.current, {
+        initialLayout: Se
+      } = H ?? {}, Me = hn(q, u, h);
+      let T = nt(d, u, E, H, X, h);
+      const Ke = E === "horizontal";
+      Ke && g && (T = -T);
+      const En = ye.map((Cn) => Cn.constraints), he = ze({
+        delta: T,
+        initialLayout: Se ?? U,
+        panelConstraints: En,
+        pivotIndices: Me,
+        prevLayout: U,
+        trigger: an(d) ? "keyboard" : "mouse-or-touch"
+      }), Ue = !Pe(U, he);
+      (sn(d) || cn(d)) && O.current != T && (O.current = T, !Ue && T !== 0 ? Ke ? Ge(u, T < 0 ? dn : fn) : Ge(u, T < 0 ? pn : gn) : Ge(u, 0)), Ue && (b(he), S.current.layout = he, L && L(he), le(ye, he, D.current));
+    };
+  }, []), G = B((u, g) => {
+    const {
+      onLayout: v
+    } = C.current, {
+      layout: p,
+      panelDataArray: d
+    } = S.current, h = d.map((U) => U.constraints), {
+      panelSize: E,
+      pivotIndices: H
+    } = ne(d, u, p);
+    z(E != null, `Panel size not found for panel "${u.id}"`);
+    const X = ae(d, u) === d.length - 1 ? E - g : g - E, L = ze({
+      delta: X,
+      initialLayout: p,
+      panelConstraints: h,
+      pivotIndices: H,
+      prevLayout: p,
+      trigger: "imperative-api"
+    });
+    Pe(p, L) || (b(L), S.current.layout = L, v && v(L), le(d, L, D.current));
+  }, []), fe = B((u, g) => {
+    const {
+      layout: v,
+      panelDataArray: p
+    } = S.current, {
+      collapsedSize: d = 0,
+      collapsible: h
+    } = g, {
+      collapsedSize: E = 0,
+      collapsible: H,
+      maxSize: q = 100,
+      minSize: X = 0
+    } = u.constraints, {
+      panelSize: L
+    } = ne(p, u, v);
+    L != null && (h && H && Y(L, d) ? Y(d, E) || G(u, E) : L < X ? G(u, X) : L > q && G(u, q));
+  }, [G]), pe = B((u, g) => {
+    const {
+      direction: v
+    } = C.current, {
+      layout: p
+    } = S.current;
+    if (!x.current)
+      return;
+    const d = De(u, x.current);
+    z(d, `Drag handle element not found for id "${u}"`);
+    const h = xn(v, g);
+    I({
+      dragHandleId: u,
+      dragHandleRect: d.getBoundingClientRect(),
+      initialCursorPosition: h,
+      initialLayout: p
+    });
+  }, []), ge = B(() => {
+    I(null);
+  }, []), He = B((u) => {
+    const {
+      panelDataArray: g
+    } = S.current, v = ae(g, u);
+    v >= 0 && (g.splice(v, 1), delete D.current[u.id], S.current.panelDataArrayChanged = !0, R());
+  }, [R]), ie = kn(() => ({
+    collapsePanel: K,
+    direction: r,
+    dragState: y,
+    expandPanel: J,
+    getPanelSize: V,
+    getPanelStyle: _,
+    groupId: c,
+    isPanelCollapsed: k,
+    isPanelExpanded: ee,
+    reevaluatePanelConstraints: fe,
+    registerPanel: $,
+    registerResizeHandle: N,
+    resizePanel: G,
+    startDragging: pe,
+    stopDragging: ge,
+    unregisterPanel: He,
+    panelGroupElement: x.current
+  }), [K, y, r, J, V, _, c, k, ee, fe, $, N, G, pe, ge, He]), me = {
+    display: "flex",
+    flexDirection: r === "horizontal" ? "row" : "column",
+    height: "100%",
+    overflow: "hidden",
+    width: "100%"
+  };
+  return de(Re.Provider, {
+    value: ie
+  }, de(P, {
+    ...f,
+    children: n,
+    className: t,
+    id: o,
+    ref: x,
+    style: {
+      ...me,
+      ...m
+    },
+    // CSS selectors
+    [A.group]: "",
+    [A.groupDirection]: r,
+    [A.groupId]: c
+  }));
+}
+const wn = en((e, n) => de(Pn, {
+  ...e,
+  forwardedRef: n
+}));
+Pn.displayName = "PanelGroup";
+wn.displayName = "forwardRef(PanelGroup)";
+function ae(e, n) {
+  return e.findIndex((t) => t === n || t.id === n.id);
+}
+function ne(e, n, t) {
+  const r = ae(e, n), o = r === e.length - 1 ? [r - 1, r] : [r, r + 1], l = t[r];
+  return {
+    ...n.constraints,
+    panelSize: l,
+    pivotIndices: o
+  };
+}
+function st({
+  disabled: e,
+  handleId: n,
+  resizeHandler: t,
+  panelGroupElement: r
+}) {
+  te(() => {
+    if (e || t == null || r == null)
+      return;
+    const i = De(n, r);
+    if (i == null)
+      return;
+    const o = (l) => {
+      if (!l.defaultPrevented)
+        switch (l.key) {
+          case "ArrowDown":
+          case "ArrowLeft":
+          case "ArrowRight":
+          case "ArrowUp":
+          case "End":
+          case "Home": {
+            l.preventDefault(), t(l);
+            break;
+          }
+          case "F6": {
+            l.preventDefault();
+            const a = i.getAttribute(A.groupId);
+            z(a, `No group element found for id "${a}"`);
+            const s = be(a, r), m = yn(a, n, r);
+            z(m !== null, `No resize element found for id "${n}"`);
+            const P = l.shiftKey ? m > 0 ? m - 1 : s.length - 1 : m + 1 < s.length ? m + 1 : 0;
+            s[P].focus();
+            break;
+          }
+        }
+    };
+    return i.addEventListener("keydown", o), () => {
+      i.removeEventListener("keydown", o);
+    };
+  }, [r, e, n, t]);
+}
+function In({
+  children: e = null,
+  className: n = "",
+  disabled: t = !1,
+  hitAreaMargins: r,
+  id: i,
+  onBlur: o,
+  onClick: l,
+  onDragging: a,
+  onFocus: s,
+  onPointerDown: m,
+  onPointerUp: P,
+  style: f = {},
+  tabIndex: c = 0,
+  tagName: x = "div",
+  ...y
+}) {
+  var I, w;
+  const b = F(null), R = F({
+    onClick: l,
+    onDragging: a,
+    onPointerDown: m,
+    onPointerUp: P
+  });
+  te(() => {
+    R.current.onClick = l, R.current.onDragging = a, R.current.onPointerDown = m, R.current.onPointerUp = P;
+  });
+  const D = nn(Re);
+  if (D === null)
+    throw Error("PanelResizeHandle components must be rendered within a PanelGroup container");
+  const {
+    direction: M,
+    groupId: O,
+    registerResizeHandle: C,
+    startDragging: S,
+    stopDragging: K,
+    panelGroupElement: J
+  } = D, V = Ve(i), [_, k] = ce("inactive"), [ee, $] = ce(!1), [N, G] = ce(null), fe = F({
+    state: _
+  });
+  re(() => {
+    fe.current.state = _;
+  }), te(() => {
+    if (t)
+      G(null);
+    else {
+      const ie = C(V);
+      G(() => ie);
+    }
+  }, [t, V, C]);
+  const pe = (I = r?.coarse) !== null && I !== void 0 ? I : 15, ge = (w = r?.fine) !== null && w !== void 0 ? w : 5;
+  return te(() => {
+    if (t || N == null)
+      return;
+    const ie = b.current;
+    z(ie, "Element ref not attached");
+    let me = !1;
+    return jn(V, ie, M, {
+      coarse: pe,
+      fine: ge
+    }, (g, v, p) => {
+      if (!v) {
+        k("inactive");
+        return;
+      }
+      switch (g) {
+        case "down": {
+          k("drag"), me = !1, z(p, 'Expected event to be defined for "down" action'), S(V, p);
+          const {
+            onDragging: d,
+            onPointerDown: h
+          } = R.current;
+          d?.(!0), h?.();
+          break;
+        }
+        case "move": {
+          const {
+            state: d
+          } = fe.current;
+          me = !0, d !== "drag" && k("hover"), z(p, 'Expected event to be defined for "move" action'), N(p);
+          break;
+        }
+        case "up": {
+          k("hover"), K();
+          const {
+            onClick: d,
+            onDragging: h,
+            onPointerUp: E
+          } = R.current;
+          h?.(!1), E?.(), me || d?.();
+          break;
+        }
+      }
+    });
+  }, [pe, M, t, ge, C, V, N, S, K]), st({
+    disabled: t,
+    handleId: V,
+    resizeHandler: N,
+    panelGroupElement: J
+  }), de(x, {
+    ...y,
+    children: e,
+    className: n,
+    id: i,
+    onBlur: () => {
+      $(!1), o?.();
+    },
+    onFocus: () => {
+      $(!0), s?.();
+    },
+    ref: b,
+    role: "separator",
+    style: {
+      ...{
+        touchAction: "none",
+        userSelect: "none"
+      },
+      ...f
+    },
+    tabIndex: c,
+    // CSS selectors
+    [A.groupDirection]: M,
+    [A.groupId]: O,
+    [A.resizeHandle]: "",
+    [A.resizeHandleActive]: _ === "drag" ? "pointer" : ee ? "keyboard" : void 0,
+    [A.resizeHandleEnabled]: !t,
+    [A.resizeHandleId]: V,
+    [A.resizeHandleState]: _
+  });
+}
+In.displayName = "PanelResizeHandle";
+const ct = rn({
+  base: "flex h-full w-full data-[panel-group-direction=vertical]:flex-col"
+}), yt = ({
+  className: e,
+  ...n
+}) => /* @__PURE__ */ we(wn, { className: ct({ className: e }), ...n }), ht = ln, ut = rn({
+  slots: {
+    wrapper: [
+      "relative flex w-px items-center justify-center bg-secondary-border hover:bg-primary-border",
+      "after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2",
+      "focus-visible:shadow-focus focus-visible:outline-none",
+      "data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 [&[data-panel-group-direction=vertical]>div]:rotate-90"
+    ],
+    handle: "z-10 flex h-4 w-2.5 items-center justify-center rounded-sm border border-secondary-border bg-secondary-border hover:border-primary-border hover:bg-primary-border",
+    icon: "h-2.5 w-2.5"
+  }
+}), zt = ({
+  withHandle: e,
+  className: n,
+  ...t
+}) => {
+  const r = ut();
+  return /* @__PURE__ */ we(In, { className: r.wrapper({ className: n }), ...t, children: e && /* @__PURE__ */ we("div", { className: r.handle(), children: /* @__PURE__ */ we(Dn, { icon: Mn, className: r.icon() }) }) });
+};
+export {
+  zt as ResizableHandle,
+  ht as ResizablePanel,
+  yt as ResizablePanelGroup
+};
+//# sourceMappingURL=resizable.js.map