@arolariu/components 0.0.21 → 0.0.22

package/dist/es/resizable.js

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