@enya-learning/nova 0.4.3 → 0.5.0

package/dist/components/resizable.js

@@ -0,0 +1,1562 @@
+"use client";
+import { t as He } from "../chunks/utils-kyb5nny4y41y7hd8.js";
+import { jsx as j } from "react/jsx-runtime";
+import { createContext as pt, useCallback as Ve, useContext as ht, useEffect as pe, useId as gt, useImperativeHandle as Ye, useLayoutEffect as vt, useMemo as mt, useRef as F, useState as ce, useSyncExternalStore as bt } from "react";
+function yt(e, t) {
+  const n = getComputedStyle(e);
+  return t * parseFloat(n.fontSize);
+}
+function zt(e, t) {
+  const n = getComputedStyle(e.ownerDocument.documentElement);
+  return t * parseFloat(n.fontSize);
+}
+function St(e) {
+  return e / 100 * window.innerHeight;
+}
+function wt(e) {
+  return e / 100 * window.innerWidth;
+}
+function xt(e) {
+  switch (typeof e) {
+    case "number":
+      return [e, "px"];
+    case "string": {
+      const t = parseFloat(e);
+      return e.endsWith("%") ? [t, "%"] : e.endsWith("px") ? [t, "px"] : e.endsWith("rem") ? [t, "rem"] : e.endsWith("em") ? [t, "em"] : e.endsWith("vh") ? [t, "vh"] : e.endsWith("vw") ? [t, "vw"] : [t, "%"];
+    }
+  }
+}
+function re({ groupSize: e, panelElement: t, styleProp: n }) {
+  let o;
+  const [r, a] = xt(n);
+  switch (a) {
+    case "%":
+      o = r / 100 * e;
+      break;
+    case "px":
+      o = r;
+      break;
+    case "rem":
+      o = zt(t, r);
+      break;
+    case "em":
+      o = yt(t, r);
+      break;
+    case "vh":
+      o = St(r);
+      break;
+    case "vw":
+      o = wt(r);
+      break;
+  }
+  return o;
+}
+function I(e) {
+  return parseFloat(e.toFixed(3));
+}
+function te({ group: e }) {
+  const { orientation: t, panels: n } = e;
+  return n.reduce((o, r) => (o += t === "horizontal" ? r.element.offsetWidth : r.element.offsetHeight, o), 0);
+}
+function ve(e) {
+  const { panels: t } = e, n = te({ group: e });
+  return n === 0 ? t.map((o) => ({
+    groupResizeBehavior: o.panelConstraints.groupResizeBehavior,
+    collapsedSize: 0,
+    collapsible: o.panelConstraints.collapsible === !0,
+    defaultSize: void 0,
+    disabled: o.panelConstraints.disabled,
+    minSize: 0,
+    maxSize: 100,
+    panelId: o.id
+  })) : t.map((o) => {
+    const { element: r, panelConstraints: a } = o;
+    let d = 0;
+    a.collapsedSize !== void 0 && (d = I(re({
+      groupSize: n,
+      panelElement: r,
+      styleProp: a.collapsedSize
+    }) / n * 100));
+    let s;
+    a.defaultSize !== void 0 && (s = I(re({
+      groupSize: n,
+      panelElement: r,
+      styleProp: a.defaultSize
+    }) / n * 100));
+    let i = 0;
+    a.minSize !== void 0 && (i = I(re({
+      groupSize: n,
+      panelElement: r,
+      styleProp: a.minSize
+    }) / n * 100));
+    let l = 100;
+    return a.maxSize !== void 0 && (l = I(re({
+      groupSize: n,
+      panelElement: r,
+      styleProp: a.maxSize
+    }) / n * 100)), {
+      groupResizeBehavior: a.groupResizeBehavior,
+      collapsedSize: d,
+      collapsible: a.collapsible === !0,
+      defaultSize: s,
+      disabled: a.disabled,
+      minSize: i,
+      maxSize: l,
+      panelId: o.id
+    };
+  });
+}
+function P(e, t = "Assertion error") {
+  if (!e) throw Error(t);
+}
+function me(e, t) {
+  return Array.from(t).sort(e === "horizontal" ? Ct : Pt);
+}
+function Ct(e, t) {
+  const n = e.element.offsetLeft - t.element.offsetLeft;
+  return n !== 0 ? n : e.element.offsetWidth - t.element.offsetWidth;
+}
+function Pt(e, t) {
+  const n = e.element.offsetTop - t.element.offsetTop;
+  return n !== 0 ? n : e.element.offsetHeight - t.element.offsetHeight;
+}
+function Xe(e) {
+  return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.ELEMENT_NODE;
+}
+function qe(e, t) {
+  return {
+    x: e.x >= t.left && e.x <= t.right ? 0 : Math.min(Math.abs(e.x - t.left), Math.abs(e.x - t.right)),
+    y: e.y >= t.top && e.y <= t.bottom ? 0 : Math.min(Math.abs(e.y - t.top), Math.abs(e.y - t.bottom))
+  };
+}
+function Lt({ orientation: e, rects: t, targetRect: n }) {
+  const o = {
+    x: n.x + n.width / 2,
+    y: n.y + n.height / 2
+  };
+  let r, a = Number.MAX_VALUE;
+  for (const d of t) {
+    const { x: s, y: i } = qe(o, d), l = e === "horizontal" ? s : i;
+    l < a && (a = l, r = d);
+  }
+  return P(r, "No rect found"), r;
+}
+var ue;
+function kt() {
+  return ue === void 0 && (typeof matchMedia == "function" ? ue = !!matchMedia("(pointer:coarse)").matches : ue = !1), ue;
+}
+function Je(e) {
+  const { element: t, orientation: n, panels: o, separators: r } = e, a = me(n, Array.from(t.children).filter(Xe).map((f) => ({ element: f }))).map(({ element: f }) => f), d = [];
+  let s = !1, i = !1, l = -1, u = -1, c = 0, S, h = [];
+  {
+    let f = -1;
+    for (const p of a) p.hasAttribute("data-panel") && (f++, p.hasAttribute("data-disabled") || (c++, l === -1 && (l = f), u = f));
+  }
+  if (c > 1) {
+    let f = -1;
+    for (const p of a) if (p.hasAttribute("data-panel")) {
+      f++;
+      const m = o.find((g) => g.element === p);
+      if (m) {
+        if (S) {
+          const g = S.element.getBoundingClientRect(), v = p.getBoundingClientRect();
+          let b;
+          if (i) {
+            const z = n === "horizontal" ? new DOMRect(g.right, g.top, 0, g.height) : new DOMRect(g.left, g.bottom, g.width, 0), y = n === "horizontal" ? new DOMRect(v.left, v.top, 0, v.height) : new DOMRect(v.left, v.top, v.width, 0);
+            switch (h.length) {
+              case 0:
+                b = [z, y];
+                break;
+              case 1: {
+                const k = h[0];
+                b = [k, Lt({
+                  orientation: n,
+                  rects: [g, v],
+                  targetRect: k.element.getBoundingClientRect()
+                }) === g ? y : z];
+                break;
+              }
+              default:
+                b = h;
+                break;
+            }
+          } else h.length ? b = h : b = [n === "horizontal" ? new DOMRect(g.right, v.top, v.left - g.right, v.height) : new DOMRect(v.left, g.bottom, v.width, v.top - g.bottom)];
+          for (const z of b) {
+            let y = "width" in z ? z : z.element.getBoundingClientRect();
+            const k = kt() ? e.resizeTargetMinimumSize.coarse : e.resizeTargetMinimumSize.fine;
+            if (y.width < k) {
+              const E = k - y.width;
+              y = new DOMRect(y.x - E / 2, y.y, y.width + E, y.height);
+            }
+            if (y.height < k) {
+              const E = k - y.height;
+              y = new DOMRect(y.x, y.y - E / 2, y.width, y.height + E);
+            }
+            !s && !(f <= l || f > u) && d.push({
+              group: e,
+              groupSize: te({ group: e }),
+              panels: [S, m],
+              separator: "width" in z ? void 0 : z,
+              rect: y
+            }), s = !1;
+          }
+        }
+        i = !1, S = m, h = [];
+      }
+    } else if (p.hasAttribute("data-separator")) {
+      p.ariaDisabled !== null && (s = !0);
+      const m = r.find((g) => g.element === p);
+      m ? h.push(m) : (S = void 0, h = []);
+    } else i = !0;
+  }
+  return d;
+}
+var Ue = class {
+  #e = {};
+  addListener(e, t) {
+    const n = this.#e[e];
+    return n === void 0 ? this.#e[e] = [t] : n.includes(t) || n.push(t), () => {
+      this.removeListener(e, t);
+    };
+  }
+  emit(e, t) {
+    const n = this.#e[e];
+    if (n !== void 0) if (n.length === 1) n[0].call(null, t);
+    else {
+      let o = !1, r = null;
+      const a = Array.from(n);
+      for (let d = 0; d < a.length; d++) {
+        const s = a[d];
+        try {
+          s.call(null, t);
+        } catch (i) {
+          r === null && (o = !0, r = i);
+        }
+      }
+      if (o) throw r;
+    }
+  }
+  removeAllListeners() {
+    this.#e = {};
+  }
+  removeListener(e, t) {
+    const n = this.#e[e];
+    if (n !== void 0) {
+      const o = n.indexOf(t);
+      o >= 0 && n.splice(o, 1);
+    }
+  }
+}, A = /* @__PURE__ */ new Map(), Ze = new Ue();
+function Et(e) {
+  A = new Map(A), A.delete(e);
+}
+function ke(e, t) {
+  for (const [n] of A) if (n.id === e) return n;
+}
+function H(e, t) {
+  for (const [n, o] of A) if (n.id === e) return o;
+  if (t) throw Error(`Could not find data for Group with id ${e}`);
+}
+function J() {
+  return A;
+}
+function be(e, t) {
+  return Ze.addListener("groupChange", (n) => {
+    n.group.id === e && t(n);
+  });
+}
+function B(e, t) {
+  const n = A.get(e);
+  A = new Map(A), A.set(e, t), Ze.emit("groupChange", {
+    group: e,
+    prev: n,
+    next: t
+  });
+}
+function Mt(e, t, n) {
+  let o, r = {
+    x: 1 / 0,
+    y: 1 / 0
+  };
+  for (const a of t) {
+    const d = qe(n, a.rect);
+    switch (e) {
+      case "horizontal":
+        d.x <= r.x && (o = a, r = d);
+        break;
+      case "vertical":
+        d.y <= r.y && (o = a, r = d);
+        break;
+    }
+  }
+  return o ? {
+    distance: r,
+    hitRegion: o
+  } : void 0;
+}
+function Rt(e) {
+  return e !== null && typeof e == "object" && "nodeType" in e && e.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+}
+function Dt(e, t) {
+  if (e === t) throw new Error("Cannot compare node with itself");
+  const n = {
+    a: Re(e),
+    b: Re(t)
+  };
+  let o;
+  for (; n.a.at(-1) === n.b.at(-1); ) o = n.a.pop(), n.b.pop();
+  P(o, "Stacking order can only be calculated for elements with a common ancestor");
+  const r = {
+    a: Me(Ee(n.a)),
+    b: Me(Ee(n.b))
+  };
+  if (r.a === r.b) {
+    const a = o.childNodes, d = {
+      a: n.a.at(-1),
+      b: n.b.at(-1)
+    };
+    let s = a.length;
+    for (; s--; ) {
+      const i = a[s];
+      if (i === d.a) return 1;
+      if (i === d.b) return -1;
+    }
+  }
+  return Math.sign(r.a - r.b);
+}
+var It = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
+function Tt(e) {
+  const t = getComputedStyle(Ke(e) ?? e).display;
+  return t === "flex" || t === "inline-flex";
+}
+function Nt(e) {
+  const t = getComputedStyle(e);
+  return !!(t.position === "fixed" || t.zIndex !== "auto" && (t.position !== "static" || Tt(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" || It.test(t.willChange) || t.webkitOverflowScrolling === "touch");
+}
+function Ee(e) {
+  let t = e.length;
+  for (; t--; ) {
+    const n = e[t];
+    if (P(n, "Missing node"), Nt(n)) return n;
+  }
+  return null;
+}
+function Me(e) {
+  return e && Number(getComputedStyle(e).zIndex) || 0;
+}
+function Re(e) {
+  const t = [];
+  for (; e; ) t.push(e), e = Ke(e);
+  return t;
+}
+function Ke(e) {
+  const { parentNode: t } = e;
+  return Rt(t) ? t.host : t;
+}
+function Ot(e, t) {
+  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 Ft({ groupElement: e, hitRegion: t, pointerEventTarget: n }) {
+  if (!Xe(n) || n.contains(e) || e.contains(n)) return !0;
+  if (Dt(n, e) > 0) {
+    let o = n;
+    for (; o; ) {
+      if (o.contains(e)) return !0;
+      if (Ot(o.getBoundingClientRect(), t)) return !1;
+      o = o.parentElement;
+    }
+  }
+  return !0;
+}
+function ye(e, t) {
+  const n = [];
+  return t.forEach((o, r) => {
+    if (r.disabled) return;
+    const a = Je(r), d = Mt(r.orientation, a, {
+      x: e.clientX,
+      y: e.clientY
+    });
+    d && d.distance.x <= 0 && d.distance.y <= 0 && Ft({
+      groupElement: r.element,
+      hitRegion: d.hitRegion.rect,
+      pointerEventTarget: e.target
+    }) && n.push(d.hitRegion);
+  }), n;
+}
+function At(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 R(e, t, n = 0) {
+  return Math.abs(I(e) - I(t)) <= n;
+}
+function O(e, t) {
+  return R(e, t) ? 0 : e > t ? 1 : -1;
+}
+function Q({ overrideDisabledPanels: e, panelConstraints: t, prevSize: n, size: o }) {
+  const { collapsedSize: r = 0, collapsible: a, disabled: d, maxSize: s = 100, minSize: i = 0 } = t;
+  if (d && !e) return n;
+  if (O(o, i) < 0) if (a) {
+    const l = (r + i) / 2;
+    O(o, l) < 0 ? o = r : o = i;
+  } else o = i;
+  return o = Math.min(s, o), o = I(o), o;
+}
+function ie({ delta: e, initialLayout: t, panelConstraints: n, pivotIndices: o, prevLayout: r, trigger: a }) {
+  if (R(e, 0)) return t;
+  const d = a === "imperative-api", s = Object.values(t), i = Object.values(r), l = [...s], [u, c] = o;
+  P(u != null, "Invalid first pivot index"), P(c != null, "Invalid second pivot index");
+  let S = 0;
+  switch (a) {
+    case "keyboard":
+      {
+        const f = e < 0 ? c : u, p = n[f];
+        P(p, `Panel constraints not found for index ${f}`);
+        const { collapsedSize: m = 0, collapsible: g, minSize: v = 0 } = p;
+        if (g) {
+          const b = s[f];
+          if (P(b != null, `Previous layout not found for panel index ${f}`), R(b, m)) {
+            const z = v - b;
+            O(z, Math.abs(e)) > 0 && (e = e < 0 ? 0 - z : z);
+          }
+        }
+      }
+      {
+        const f = e < 0 ? u : c, p = n[f];
+        P(p, `No panel constraints found for index ${f}`);
+        const { collapsedSize: m = 0, collapsible: g, minSize: v = 0 } = p;
+        if (g) {
+          const b = s[f];
+          if (P(b != null, `Previous layout not found for panel index ${f}`), R(b, v)) {
+            const z = b - m;
+            O(z, Math.abs(e)) > 0 && (e = e < 0 ? 0 - z : z);
+          }
+        }
+      }
+      break;
+    default: {
+      const f = e < 0 ? c : u, p = n[f];
+      P(p, `Panel constraints not found for index ${f}`);
+      const m = s[f], { collapsible: g, collapsedSize: v, minSize: b } = p;
+      if (g && O(m, b) < 0) if (e > 0) {
+        const z = b - v, y = z / 2;
+        O(m + e, b) < 0 && (e = O(e, y) <= 0 ? 0 : z);
+      } else {
+        const z = b - v, y = 100 - z / 2;
+        O(m - e, b) < 0 && (e = O(100 + e, y) > 0 ? 0 : -z);
+      }
+      break;
+    }
+  }
+  {
+    const f = e < 0 ? 1 : -1;
+    let p = e < 0 ? c : u, m = 0;
+    for (; ; ) {
+      const v = s[p];
+      P(v != null, `Previous layout not found for panel index ${p}`);
+      const b = Q({
+        overrideDisabledPanels: d,
+        panelConstraints: n[p],
+        prevSize: v,
+        size: 100
+      }) - v;
+      if (m += b, p += f, p < 0 || p >= n.length) break;
+    }
+    const g = Math.min(Math.abs(e), Math.abs(m));
+    e = e < 0 ? 0 - g : g;
+  }
+  {
+    let f = e < 0 ? u : c;
+    for (; f >= 0 && f < n.length; ) {
+      const p = Math.abs(e) - Math.abs(S), m = s[f];
+      P(m != null, `Previous layout not found for panel index ${f}`);
+      const g = m - p, v = Q({
+        overrideDisabledPanels: d,
+        panelConstraints: n[f],
+        prevSize: m,
+        size: g
+      });
+      if (!R(m, v) && (S += m - v, l[f] = v, S.toFixed(3).localeCompare(Math.abs(e).toFixed(3), void 0, { numeric: !0 }) >= 0)) break;
+      e < 0 ? f-- : f++;
+    }
+  }
+  if (At(i, l)) return r;
+  {
+    const f = e < 0 ? c : u, p = s[f];
+    P(p != null, `Previous layout not found for panel index ${f}`);
+    const m = p + S, g = Q({
+      overrideDisabledPanels: d,
+      panelConstraints: n[f],
+      prevSize: p,
+      size: m
+    });
+    if (l[f] = g, !R(g, m)) {
+      let v = m - g, b = e < 0 ? c : u;
+      for (; b >= 0 && b < n.length; ) {
+        const z = l[b];
+        P(z != null, `Previous layout not found for panel index ${b}`);
+        const y = z + v, k = Q({
+          overrideDisabledPanels: d,
+          panelConstraints: n[b],
+          prevSize: z,
+          size: y
+        });
+        if (R(z, k) || (v -= k - z, l[b] = k), R(v, 0)) break;
+        e > 0 ? b-- : b++;
+      }
+    }
+  }
+  if (!R(Object.values(l).reduce((f, p) => p + f, 0), 100, 0.1)) return r;
+  const h = Object.keys(r);
+  return l.reduce((f, p, m) => (f[h[m]] = p, f), {});
+}
+function Y(e, t) {
+  if (Object.keys(e).length !== Object.keys(t).length) return !1;
+  for (const n in e) if (t[n] === void 0 || O(e[n], t[n]) !== 0) return !1;
+  return !0;
+}
+function X({ layout: e, panelConstraints: t }) {
+  const n = Object.values(e), o = [...n], r = o.reduce((s, i) => s + i, 0);
+  if (o.length !== t.length) throw Error(`Invalid ${t.length} panel layout: ${o.map((s) => `${s}%`).join(", ")}`);
+  if (!R(r, 100) && o.length > 0) for (let s = 0; s < t.length; s++) {
+    const i = o[s];
+    P(i != null, `No layout data found for index ${s}`), o[s] = 100 / r * i;
+  }
+  let a = 0;
+  for (let s = 0; s < t.length; s++) {
+    const i = n[s];
+    P(i != null, `No layout data found for index ${s}`);
+    const l = o[s];
+    P(l != null, `No layout data found for index ${s}`);
+    const u = Q({
+      overrideDisabledPanels: !0,
+      panelConstraints: t[s],
+      prevSize: i,
+      size: l
+    });
+    l != u && (a += l - u, o[s] = u);
+  }
+  if (!R(a, 0)) for (let s = 0; s < t.length; s++) {
+    const i = o[s];
+    P(i != null, `No layout data found for index ${s}`);
+    const l = i + a, u = Q({
+      overrideDisabledPanels: !0,
+      panelConstraints: t[s],
+      prevSize: i,
+      size: l
+    });
+    if (i !== u && (a -= u - i, o[s] = u, R(a, 0))) break;
+  }
+  const d = Object.keys(e);
+  return o.reduce((s, i, l) => (s[d[l]] = i, s), {});
+}
+function Qe({ groupId: e, panelId: t }) {
+  const n = () => {
+    const i = J();
+    for (const [l, { defaultLayoutDeferred: u, derivedPanelConstraints: c, layout: S, groupSize: h, separatorToPanels: f }] of i) if (l.id === e) return {
+      defaultLayoutDeferred: u,
+      derivedPanelConstraints: c,
+      group: l,
+      groupSize: h,
+      layout: S,
+      separatorToPanels: f
+    };
+    throw Error(`Group ${e} not found`);
+  }, o = () => {
+    const i = n().derivedPanelConstraints.find((l) => l.panelId === t);
+    if (i !== void 0) return i;
+    throw Error(`Panel constraints not found for Panel ${t}`);
+  }, r = () => {
+    const i = n().group.panels.find((l) => l.id === t);
+    if (i !== void 0) return i;
+    throw Error(`Layout not found for Panel ${t}`);
+  }, a = () => {
+    const i = n().layout[t];
+    if (i !== void 0) return i;
+    throw Error(`Layout not found for Panel ${t}`);
+  }, d = ({ nextSize: i, panels: l, prevLayout: u, derivedPanelConstraints: c }) => {
+    const S = a(), h = l.findIndex((m) => m.id === t), f = h === 0, p = h === l.length - 1;
+    if (p && i < S && (f || l.slice(0, h).every((m, g) => {
+      const v = c[g];
+      return v?.collapsible && R(v.collapsedSize, u[v.panelId]);
+    }))) {
+      const m = l.slice(0, h).reduce((g, v) => g + u[v.id], 0);
+      return {
+        ...u,
+        [t]: I(100 - m)
+      };
+    }
+    return ie({
+      delta: p ? S - i : i - S,
+      initialLayout: u,
+      panelConstraints: c,
+      pivotIndices: p ? [h - 1, h] : [h, h + 1],
+      prevLayout: u,
+      trigger: "imperative-api"
+    });
+  }, s = (i) => {
+    if (i === a()) return;
+    const { defaultLayoutDeferred: l, derivedPanelConstraints: u, group: c, groupSize: S, layout: h, separatorToPanels: f } = n(), p = X({
+      layout: d({
+        nextSize: i,
+        panels: c.panels,
+        prevLayout: h,
+        derivedPanelConstraints: u
+      }),
+      panelConstraints: u
+    });
+    Y(h, p) || B(c, {
+      defaultLayoutDeferred: l,
+      derivedPanelConstraints: u,
+      groupSize: S,
+      layout: p,
+      separatorToPanels: f
+    });
+  };
+  return {
+    collapse: () => {
+      const { collapsible: i, collapsedSize: l } = o(), { mutableValues: u } = r(), c = a();
+      i && c !== l && (u.expandToSize = c, s(l));
+    },
+    expand: () => {
+      const { collapsible: i, collapsedSize: l, minSize: u } = o(), { mutableValues: c } = r(), S = a();
+      if (i && S === l) {
+        let h = c.expandToSize ?? u;
+        h === 0 && (h = 1), s(h);
+      }
+    },
+    getSize: () => {
+      const { group: i } = n(), l = a(), { element: u } = r();
+      return {
+        asPercentage: l,
+        inPixels: i.orientation === "horizontal" ? u.offsetWidth : u.offsetHeight
+      };
+    },
+    isCollapsed: () => {
+      const { collapsible: i, collapsedSize: l } = o(), u = a();
+      return i && R(l, u);
+    },
+    resize: (i) => {
+      const { group: l } = n(), { element: u } = r(), c = te({ group: l });
+      s(I(re({
+        groupSize: c,
+        panelElement: u,
+        styleProp: i
+      }) / c * 100));
+    }
+  };
+}
+function De(e) {
+  e.defaultPrevented || ye(e, J()).forEach((t) => {
+    if (t.separator && !t.separator.disableDoubleClick) {
+      const n = t.panels.find((o) => o.panelConstraints.defaultSize !== void 0);
+      if (n) {
+        const o = n.panelConstraints.defaultSize, r = Qe({
+          groupId: t.group.id,
+          panelId: n.id
+        });
+        r && o !== void 0 && (r.resize(o), e.preventDefault());
+      }
+    }
+  });
+}
+function fe(e) {
+  const t = J();
+  for (const [n] of t) if (n.separators.some((o) => o.element === e)) return n;
+  throw Error("Could not find parent Group for separator element");
+}
+function _e({ groupId: e }) {
+  const t = () => {
+    const n = J();
+    for (const [o, r] of n) if (o.id === e) return {
+      group: o,
+      ...r
+    };
+    throw Error(`Could not find Group with id "${e}"`);
+  };
+  return {
+    getLayout() {
+      const { defaultLayoutDeferred: n, layout: o } = t();
+      return n ? {} : o;
+    },
+    setLayout(n) {
+      const { defaultLayoutDeferred: o, derivedPanelConstraints: r, group: a, groupSize: d, layout: s, separatorToPanels: i } = t(), l = X({
+        layout: n,
+        panelConstraints: r
+      });
+      return o ? s : (Y(s, l) || B(a, {
+        defaultLayoutDeferred: o,
+        derivedPanelConstraints: r,
+        groupSize: d,
+        layout: l,
+        separatorToPanels: i
+      }), l);
+    }
+  };
+}
+function V(e, t) {
+  const n = fe(e), o = H(n.id, !0), r = n.separators.find((l) => l.element === e);
+  P(r, "Matching separator not found");
+  const a = o.separatorToPanels.get(r);
+  P(a, "Matching panels not found");
+  const d = a.map((l) => n.panels.indexOf(l)), s = _e({ groupId: n.id }).getLayout(), i = X({
+    layout: ie({
+      delta: t,
+      initialLayout: s,
+      panelConstraints: o.derivedPanelConstraints,
+      pivotIndices: d,
+      prevLayout: s,
+      trigger: "keyboard"
+    }),
+    panelConstraints: o.derivedPanelConstraints
+  });
+  Y(s, i) || B(n, {
+    defaultLayoutDeferred: o.defaultLayoutDeferred,
+    derivedPanelConstraints: o.derivedPanelConstraints,
+    groupSize: o.groupSize,
+    layout: i,
+    separatorToPanels: o.separatorToPanels
+  });
+}
+function Ie(e) {
+  if (e.defaultPrevented) return;
+  const t = e.currentTarget, n = fe(t);
+  if (!n.disabled) switch (e.key) {
+    case "ArrowDown":
+      e.preventDefault(), n.orientation === "vertical" && V(t, 5);
+      break;
+    case "ArrowLeft":
+      e.preventDefault(), n.orientation === "horizontal" && V(t, -5);
+      break;
+    case "ArrowRight":
+      e.preventDefault(), n.orientation === "horizontal" && V(t, 5);
+      break;
+    case "ArrowUp":
+      e.preventDefault(), n.orientation === "vertical" && V(t, -5);
+      break;
+    case "End":
+      e.preventDefault(), V(t, 100);
+      break;
+    case "Enter": {
+      e.preventDefault();
+      const o = fe(t), { derivedPanelConstraints: r, layout: a, separatorToPanels: d } = H(o.id, !0), s = o.separators.find((c) => c.element === t);
+      P(s, "Matching separator not found");
+      const i = d.get(s);
+      P(i, "Matching panels not found");
+      const l = i[0], u = r.find((c) => c.panelId === l.id);
+      if (P(u, "Panel metadata not found"), u.collapsible) {
+        const c = a[l.id];
+        V(t, (u.collapsedSize === c ? o.mutableState.expandedPanelSizes[l.id] ?? u.minSize : u.collapsedSize) - c);
+      }
+      break;
+    }
+    case "F6": {
+      e.preventDefault();
+      const o = fe(t).separators.map((a) => a.element), r = Array.from(o).findIndex((a) => a === e.currentTarget);
+      P(r !== null, "Index not found"), o[e.shiftKey ? r > 0 ? r - 1 : o.length - 1 : r + 1 < o.length ? r + 1 : 0].focus({ preventScroll: !0 });
+      break;
+    }
+    case "Home":
+      e.preventDefault(), V(t, -100);
+      break;
+  }
+}
+var _ = {
+  cursorFlags: 0,
+  state: "inactive"
+}, ze = new Ue();
+function q() {
+  return _;
+}
+function $t(e) {
+  return ze.addListener("change", e);
+}
+function Gt(e) {
+  const t = _, n = { ..._ };
+  n.cursorFlags = e, _ = n, ze.emit("change", {
+    prev: t,
+    next: n
+  });
+}
+function ee(e) {
+  const t = _;
+  _ = e, ze.emit("change", {
+    prev: t,
+    next: e
+  });
+}
+function Te(e) {
+  if (e.defaultPrevented || e.pointerType === "mouse" && e.button > 0) return;
+  const t = J(), n = ye(e, t), o = /* @__PURE__ */ new Map();
+  let r = !1;
+  n.forEach((a) => {
+    a.separator && (r || (r = !0, a.separator.element.focus({
+      focusVisible: !1,
+      preventScroll: !0
+    })));
+    const d = t.get(a.group);
+    d && o.set(a.group, d.layout);
+  }), ee({
+    cursorFlags: 0,
+    hitRegions: n,
+    initialLayoutMap: o,
+    pointerDownAtPoint: {
+      x: e.clientX,
+      y: e.clientY
+    },
+    state: "active"
+  }), n.length && e.preventDefault();
+}
+var jt = (e) => e, ge = () => {
+}, et = 1, tt = 2, nt = 4, ot = 8, Ne = 3, Oe = 12, de;
+function Fe() {
+  return de === void 0 && (de = !1, typeof window < "u" && (window.navigator.userAgent.includes("Chrome") || window.navigator.userAgent.includes("Firefox")) && (de = !0)), de;
+}
+function Bt({ cursorFlags: e, groups: t, state: n }) {
+  let o = 0, r = 0;
+  switch (n) {
+    case "active":
+    case "hover":
+      t.forEach((a) => {
+        if (!a.mutableState.disableCursor) switch (a.orientation) {
+          case "horizontal":
+            o++;
+            break;
+          case "vertical":
+            r++;
+            break;
+        }
+      });
+  }
+  if (!(o === 0 && r === 0)) {
+    switch (n) {
+      case "active":
+        if (e && Fe()) {
+          const a = (e & et) !== 0, d = (e & tt) !== 0, s = (e & nt) !== 0, i = (e & ot) !== 0;
+          if (a) return s ? "se-resize" : i ? "ne-resize" : "e-resize";
+          if (d) return s ? "sw-resize" : i ? "nw-resize" : "w-resize";
+          if (s) return "s-resize";
+          if (i) return "n-resize";
+        }
+        break;
+    }
+    return Fe() ? o > 0 && r > 0 ? "move" : o > 0 ? "ew-resize" : "ns-resize" : o > 0 && r > 0 ? "grab" : o > 0 ? "col-resize" : "row-resize";
+  }
+}
+var Ae = /* @__PURE__ */ new WeakMap();
+function Se(e) {
+  if (e.defaultView === null || e.defaultView === void 0) return;
+  let { prevStyle: t, styleSheet: n } = Ae.get(e) ?? {};
+  n === void 0 && (n = new e.defaultView.CSSStyleSheet(), e.adoptedStyleSheets && (Object.isExtensible(e.adoptedStyleSheets) ? e.adoptedStyleSheets.push(n) : e.adoptedStyleSheets = [...e.adoptedStyleSheets, n]));
+  const o = q();
+  switch (o.state) {
+    case "active":
+    case "hover": {
+      const r = Bt({
+        cursorFlags: o.cursorFlags,
+        groups: o.hitRegions.map((d) => d.group),
+        state: o.state
+      }), a = `*, *:hover {cursor: ${r} !important; }`;
+      if (t === a) return;
+      t = a, r ? n.cssRules.length === 0 ? n.insertRule(a) : n.replaceSync(a) : n.cssRules.length === 1 && n.deleteRule(0);
+      break;
+    }
+    case "inactive":
+      t = void 0, n.cssRules.length === 1 && n.deleteRule(0);
+      break;
+  }
+  Ae.set(e, {
+    prevStyle: t,
+    styleSheet: n
+  });
+}
+function rt({ document: e, event: t, hitRegions: n, initialLayoutMap: o, mountedGroups: r, pointerDownAtPoint: a, prevCursorFlags: d }) {
+  let s = 0;
+  n.forEach((l) => {
+    const { group: u, groupSize: c } = l, { orientation: S, panels: h } = u, { disableCursor: f } = u.mutableState;
+    let p = 0;
+    a ? S === "horizontal" ? p = (t.clientX - a.x) / c * 100 : p = (t.clientY - a.y) / c * 100 : S === "horizontal" ? p = t.clientX < 0 ? -100 : 100 : p = t.clientY < 0 ? -100 : 100;
+    const m = o.get(u), g = r.get(u);
+    if (!m || !g) return;
+    const { defaultLayoutDeferred: v, derivedPanelConstraints: b, groupSize: z, layout: y, separatorToPanels: k } = g;
+    if (b && y && k) {
+      const E = ie({
+        delta: p,
+        initialLayout: m,
+        panelConstraints: b,
+        pivotIndices: l.panels.map((D) => h.indexOf(D)),
+        prevLayout: y,
+        trigger: "mouse-or-touch"
+      });
+      if (Y(E, y)) {
+        if (p !== 0 && !f) switch (S) {
+          case "horizontal":
+            s |= p < 0 ? et : tt;
+            break;
+          case "vertical":
+            s |= p < 0 ? nt : ot;
+            break;
+        }
+      } else B(l.group, {
+        defaultLayoutDeferred: v,
+        derivedPanelConstraints: b,
+        groupSize: z,
+        layout: E,
+        separatorToPanels: k
+      });
+    }
+  });
+  let i = 0;
+  t.movementX === 0 ? i |= d & Ne : i |= s & Ne, t.movementY === 0 ? i |= d & Oe : i |= s & Oe, Gt(i), Se(e);
+}
+function $e(e) {
+  const t = J(), n = q();
+  n.state === "active" && rt({
+    document: e.currentTarget,
+    event: e,
+    hitRegions: n.hitRegions,
+    initialLayoutMap: n.initialLayoutMap,
+    mountedGroups: t,
+    prevCursorFlags: n.cursorFlags
+  });
+}
+function Ge(e) {
+  if (e.defaultPrevented) return;
+  const t = q(), n = J();
+  switch (t.state) {
+    case "active":
+      if (e.buttons === 0) {
+        ee({
+          cursorFlags: 0,
+          state: "inactive"
+        }), t.hitRegions.forEach((o) => {
+          const r = H(o.group.id, !0);
+          B(o.group, r);
+        });
+        return;
+      }
+      for (const o of t.hitRegions) if (o.separator) {
+        const { element: r } = o.separator;
+        r.hasPointerCapture?.(e.pointerId) || r.setPointerCapture?.(e.pointerId);
+      }
+      rt({
+        document: e.currentTarget,
+        event: e,
+        hitRegions: t.hitRegions,
+        initialLayoutMap: t.initialLayoutMap,
+        mountedGroups: n,
+        pointerDownAtPoint: t.pointerDownAtPoint,
+        prevCursorFlags: t.cursorFlags
+      });
+      break;
+    default: {
+      const o = ye(e, n);
+      o.length === 0 ? t.state !== "inactive" && ee({
+        cursorFlags: 0,
+        state: "inactive"
+      }) : ee({
+        cursorFlags: 0,
+        hitRegions: o,
+        state: "hover"
+      }), Se(e.currentTarget);
+      break;
+    }
+  }
+}
+function je(e) {
+  e.relatedTarget instanceof HTMLIFrameElement && q().state === "hover" && ee({
+    cursorFlags: 0,
+    state: "inactive"
+  });
+}
+function Be(e) {
+  if (e.defaultPrevented || e.pointerType === "mouse" && e.button > 0) return;
+  const t = q();
+  t.state === "active" && (ee({
+    cursorFlags: 0,
+    state: "inactive"
+  }), t.hitRegions.length > 0 && (Se(e.currentTarget), t.hitRegions.forEach((n) => {
+    const o = H(n.group.id, !0);
+    B(n.group, o);
+  }), e.preventDefault()));
+}
+function We(e) {
+  let t = 0, n = 0;
+  const o = {};
+  for (const a of e) if (a.defaultSize !== void 0) {
+    t++;
+    const d = I(a.defaultSize);
+    n += d, o[a.panelId] = d;
+  } else o[a.panelId] = void 0;
+  const r = e.length - t;
+  if (r !== 0) {
+    const a = I((100 - n) / r);
+    for (const d of e) d.defaultSize === void 0 && (o[d.panelId] = a);
+  }
+  return o;
+}
+function Wt(e, t, n) {
+  if (!n[0]) return;
+  const o = e.panels.find((i) => i.element === t);
+  if (!o || !o.onResize) return;
+  const r = te({ group: e }), a = e.orientation === "horizontal" ? o.element.offsetWidth : o.element.offsetHeight, d = o.mutableValues.prevSize, s = {
+    asPercentage: I(a / r * 100),
+    inPixels: a
+  };
+  o.mutableValues.prevSize = s, o.onResize(s, o.id, d);
+}
+function Ht(e, t) {
+  if (Object.keys(e).length !== Object.keys(t).length) return !1;
+  for (const n in e) if (e[n] !== t[n]) return !1;
+  return !0;
+}
+function Vt({ group: e, nextGroupSize: t, prevGroupSize: n, prevLayout: o }) {
+  if (n <= 0 || t <= 0 || n === t) return o;
+  let r = 0, a = 0, d = !1;
+  const s = /* @__PURE__ */ new Map(), i = [];
+  for (const c of e.panels) {
+    const S = o[c.id] ?? 0;
+    if (c.panelConstraints.groupResizeBehavior === "preserve-pixel-size") {
+      d = !0;
+      const h = I(S / 100 * n / t * 100);
+      s.set(c.id, h), r += h;
+    } else
+      i.push(c.id), a += S;
+  }
+  if (!d || i.length === 0) return o;
+  const l = 100 - r, u = { ...o };
+  if (s.forEach((c, S) => {
+    u[S] = c;
+  }), a > 0) for (const c of i) u[c] = I((o[c] ?? 0) / a * l);
+  else {
+    const c = I(l / i.length);
+    for (const S of i) u[S] = c;
+  }
+  return u;
+}
+function Yt(e, t) {
+  const n = e.map((r) => r.id), o = Object.keys(t);
+  if (n.length !== o.length) return !1;
+  for (const r of n) if (!o.includes(r)) return !1;
+  return !0;
+}
+var K = /* @__PURE__ */ new Map();
+function Xt(e) {
+  let t = !0;
+  P(e.element.ownerDocument.defaultView, "Cannot register an unmounted Group");
+  const n = e.element.ownerDocument.defaultView.ResizeObserver, o = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), a = new n((h) => {
+    for (const f of h) {
+      const { borderBoxSize: p, target: m } = f;
+      if (m === e.element) {
+        if (t) {
+          const g = te({ group: e });
+          if (g === 0) return;
+          const v = H(e.id);
+          if (!v) return;
+          const b = ve(e), z = v.defaultLayoutDeferred ? We(b) : v.layout, y = X({
+            layout: Vt({
+              group: e,
+              nextGroupSize: g,
+              prevGroupSize: v.groupSize,
+              prevLayout: z
+            }),
+            panelConstraints: b
+          });
+          if (!v.defaultLayoutDeferred && Y(v.layout, y) && Ht(v.derivedPanelConstraints, b) && v.groupSize === g) return;
+          B(e, {
+            defaultLayoutDeferred: !1,
+            derivedPanelConstraints: b,
+            groupSize: g,
+            layout: y,
+            separatorToPanels: v.separatorToPanels
+          });
+        }
+      } else Wt(e, m, p);
+    }
+  });
+  a.observe(e.element), e.panels.forEach((h) => {
+    P(!o.has(h.id), `Panel ids must be unique; id "${h.id}" was used more than once`), o.add(h.id), h.onResize && a.observe(h.element);
+  });
+  const d = te({ group: e }), s = ve(e), i = e.panels.map(({ id: h }) => h).join(",");
+  let l = e.mutableState.defaultLayout;
+  l && (Yt(e.panels, l) || (l = void 0));
+  const u = X({
+    layout: e.mutableState.layouts[i] ?? l ?? We(s),
+    panelConstraints: s
+  }), c = e.element.ownerDocument;
+  K.set(c, (K.get(c) ?? 0) + 1);
+  const S = /* @__PURE__ */ new Map();
+  return Je(e).forEach((h) => {
+    h.separator && S.set(h.separator, h.panels);
+  }), B(e, {
+    defaultLayoutDeferred: d === 0,
+    derivedPanelConstraints: s,
+    groupSize: d,
+    layout: u,
+    separatorToPanels: S
+  }), e.separators.forEach((h) => {
+    P(!r.has(h.id), `Separator ids must be unique; id "${h.id}" was used more than once`), r.add(h.id), h.element.addEventListener("keydown", Ie);
+  }), K.get(c) === 1 && (c.addEventListener("dblclick", De, !0), c.addEventListener("pointerdown", Te, !0), c.addEventListener("pointerleave", $e), c.addEventListener("pointermove", Ge), c.addEventListener("pointerout", je), c.addEventListener("pointerup", Be, !0)), function() {
+    t = !1, K.set(c, Math.max(0, (K.get(c) ?? 0) - 1)), Et(e), e.separators.forEach((h) => {
+      h.element.removeEventListener("keydown", Ie);
+    }), K.get(c) || (c.removeEventListener("dblclick", De, !0), c.removeEventListener("pointerdown", Te, !0), c.removeEventListener("pointerleave", $e), c.removeEventListener("pointermove", Ge), c.removeEventListener("pointerout", je), c.removeEventListener("pointerup", Be, !0)), a.disconnect();
+  };
+}
+function qt() {
+  const [e, t] = ce({});
+  return [e, Ve(() => t({}), [])];
+}
+function we(e) {
+  const t = gt();
+  return `${e ?? t}`;
+}
+var U = typeof window < "u" ? vt : pe;
+function ae(e) {
+  const t = F(e);
+  return U(() => {
+    t.current = e;
+  }, [e]), Ve((...n) => t.current?.(...n), [t]);
+}
+function xe(...e) {
+  return ae((t) => {
+    e.forEach((n) => {
+      if (n) switch (typeof n) {
+        case "function":
+          n(t);
+          break;
+        case "object":
+          n.current = t;
+          break;
+      }
+    });
+  });
+}
+function Ce(e) {
+  const t = F({ ...e });
+  return U(() => {
+    for (const n in e) t.current[n] = e[n];
+  }, [e]), t.current;
+}
+var at = pt(null);
+function Jt(e, t) {
+  const n = F({
+    getLayout: () => ({}),
+    setLayout: jt
+  });
+  Ye(t, () => n.current, []), U(() => {
+    Object.assign(n.current, _e({ groupId: e }));
+  });
+}
+function it({ children: e, className: t, defaultLayout: n, disableCursor: o, disabled: r, elementRef: a, groupRef: d, id: s, onLayoutChange: i, onLayoutChanged: l, orientation: u = "horizontal", resizeTargetMinimumSize: c = {
+  coarse: 20,
+  fine: 10
+}, style: S, ...h }) {
+  const f = F({
+    onLayoutChange: {},
+    onLayoutChanged: {}
+  }), p = ae((w) => {
+    Y(f.current.onLayoutChange, w) || (f.current.onLayoutChange = w, i?.(w));
+  }), m = ae((w) => {
+    Y(f.current.onLayoutChanged, w) || (f.current.onLayoutChanged = w, l?.(w));
+  }), g = we(s), v = F(null), [b, z] = qt(), y = F({
+    lastExpandedPanelSizes: {},
+    layouts: {},
+    panels: [],
+    resizeTargetMinimumSize: c,
+    separators: []
+  }), k = xe(v, a);
+  Jt(g, d);
+  const E = ae((w, x) => {
+    const L = q(), C = ke(w), M = H(w);
+    if (M) {
+      let T = !1;
+      return L.state === "active" && (T = L.hitRegions.some((ne) => ne.group === C)), {
+        flexGrow: M.layout[x] ?? 1,
+        pointerEvents: T ? "none" : void 0
+      };
+    }
+    if (n?.[x]) return { flexGrow: n?.[x] };
+  }), D = Ce({
+    defaultLayout: n,
+    disableCursor: o
+  }), N = mt(() => ({
+    get disableCursor() {
+      return !!D.disableCursor;
+    },
+    getPanelStyles: E,
+    id: g,
+    orientation: u,
+    registerPanel: (w) => {
+      const x = y.current;
+      return x.panels = me(u, [...x.panels, w]), z(), () => {
+        x.panels = x.panels.filter((L) => L !== w), z();
+      };
+    },
+    registerSeparator: (w) => {
+      const x = y.current;
+      return x.separators = me(u, [...x.separators, w]), z(), () => {
+        x.separators = x.separators.filter((L) => L !== w), z();
+      };
+    },
+    updatePanelProps: (w, { disabled: x }) => {
+      const L = y.current.panels.find((T) => T.id === w);
+      L && (L.panelConstraints.disabled = x);
+      const C = ke(g), M = H(g);
+      C && M && B(C, {
+        ...M,
+        derivedPanelConstraints: ve(C)
+      });
+    },
+    updateSeparatorProps: (w, { disabled: x, disableDoubleClick: L }) => {
+      const C = y.current.separators.find((M) => M.id === w);
+      C && (C.disabled = x, C.disableDoubleClick = L);
+    }
+  }), [
+    E,
+    g,
+    z,
+    u,
+    D
+  ]), $ = F(null);
+  return U(() => {
+    const w = v.current;
+    if (w === null) return;
+    const x = y.current;
+    let L;
+    if (D.defaultLayout !== void 0 && Object.keys(D.defaultLayout).length === x.panels.length) {
+      L = {};
+      for (const W of x.panels) {
+        const Z = D.defaultLayout[W.id];
+        Z !== void 0 && (L[W.id] = Z);
+      }
+    }
+    const C = {
+      disabled: !!r,
+      element: w,
+      id: g,
+      mutableState: {
+        defaultLayout: L,
+        disableCursor: !!D.disableCursor,
+        expandedPanelSizes: y.current.lastExpandedPanelSizes,
+        layouts: y.current.layouts
+      },
+      orientation: u,
+      panels: x.panels,
+      resizeTargetMinimumSize: x.resizeTargetMinimumSize,
+      separators: x.separators
+    };
+    $.current = C;
+    const M = Xt(C), { defaultLayoutDeferred: T, derivedPanelConstraints: ne, layout: se } = H(C.id, !0);
+    !T && ne.length > 0 && (p(se), m(se));
+    const oe = be(g, (W) => {
+      const { defaultLayoutDeferred: Z, derivedPanelConstraints: Le, layout: le } = W.next;
+      if (Z || Le.length === 0) return;
+      const ut = C.panels.map(({ id: G }) => G).join(",");
+      C.mutableState.layouts[ut] = le, Le.forEach((G) => {
+        if (G.collapsible) {
+          const { layout: he } = W.prev ?? {};
+          if (he) {
+            const ct = R(G.collapsedSize, le[G.panelId]), ft = R(G.collapsedSize, he[G.panelId]);
+            ct && !ft && (C.mutableState.expandedPanelSizes[G.panelId] = he[G.panelId]);
+          }
+        }
+      });
+      const dt = q().state !== "active";
+      p(le), dt && m(le);
+    });
+    return () => {
+      $.current = null, M(), oe();
+    };
+  }, [
+    r,
+    g,
+    m,
+    p,
+    u,
+    b,
+    D
+  ]), pe(() => {
+    const w = $.current;
+    w && (w.mutableState.defaultLayout = n, w.mutableState.disableCursor = !!o);
+  }), /* @__PURE__ */ j(at.Provider, {
+    value: N,
+    children: /* @__PURE__ */ j("div", {
+      ...h,
+      className: t,
+      "data-group": !0,
+      "data-testid": g,
+      id: g,
+      ref: k,
+      style: {
+        height: "100%",
+        width: "100%",
+        overflow: "hidden",
+        ...S,
+        display: "flex",
+        flexDirection: u === "horizontal" ? "row" : "column",
+        flexWrap: "nowrap",
+        touchAction: u === "horizontal" ? "pan-y" : "pan-x"
+      },
+      children: e
+    })
+  });
+}
+it.displayName = "Group";
+function Pe() {
+  const e = ht(at);
+  return P(e, "Group Context not found; did you render a Panel or Separator outside of a Group?"), e;
+}
+function Ut(e, t) {
+  const { id: n } = Pe(), o = F({
+    collapse: ge,
+    expand: ge,
+    getSize: () => ({
+      asPercentage: 0,
+      inPixels: 0
+    }),
+    isCollapsed: () => !1,
+    resize: ge
+  });
+  Ye(t, () => o.current, []), U(() => {
+    Object.assign(o.current, Qe({
+      groupId: n,
+      panelId: e
+    }));
+  });
+}
+function st({ children: e, className: t, collapsedSize: n = "0%", collapsible: o = !1, defaultSize: r, disabled: a, elementRef: d, groupResizeBehavior: s = "preserve-relative-size", id: i, maxSize: l = "100%", minSize: u = "0%", onResize: c, panelRef: S, style: h, ...f }) {
+  const p = !!i, m = we(i), g = Ce({ disabled: a }), v = F(null), b = xe(v, d), { getPanelStyles: z, id: y, orientation: k, registerPanel: E, updatePanelProps: D } = Pe(), N = c !== null, $ = ae((C, M, T) => {
+    c?.(C, i, T);
+  });
+  U(() => {
+    const C = v.current;
+    if (C !== null) return E({
+      element: C,
+      id: m,
+      idIsStable: p,
+      mutableValues: {
+        expandToSize: void 0,
+        prevSize: void 0
+      },
+      onResize: N ? $ : void 0,
+      panelConstraints: {
+        groupResizeBehavior: s,
+        collapsedSize: n,
+        collapsible: o,
+        defaultSize: r,
+        disabled: g.disabled,
+        maxSize: l,
+        minSize: u
+      }
+    });
+  }, [
+    s,
+    n,
+    o,
+    r,
+    N,
+    m,
+    p,
+    l,
+    u,
+    $,
+    E,
+    g
+  ]), pe(() => {
+    D(m, { disabled: a });
+  }, [
+    a,
+    m,
+    D
+  ]), Ut(m, S);
+  const w = () => {
+    const C = z(y, m);
+    if (C) return JSON.stringify(C);
+  }, x = bt((C) => be(y, C), w, w);
+  let L;
+  return x ? L = JSON.parse(x) : r !== void 0 ? L = {
+    flexGrow: void 0,
+    flexShrink: void 0,
+    flexBasis: r
+  } : L = { flexGrow: 1 }, /* @__PURE__ */ j("div", {
+    ...f,
+    "data-disabled": a || void 0,
+    "data-panel": !0,
+    "data-testid": m,
+    id: m,
+    ref: b,
+    style: {
+      ...Zt,
+      display: "flex",
+      flexBasis: 0,
+      flexShrink: 1,
+      overflow: "visible",
+      ...L
+    },
+    children: /* @__PURE__ */ j("div", {
+      className: t,
+      style: {
+        maxHeight: "100%",
+        maxWidth: "100%",
+        flexGrow: 1,
+        overflow: "auto",
+        ...h,
+        touchAction: k === "horizontal" ? "pan-y" : "pan-x"
+      },
+      children: e
+    })
+  });
+}
+st.displayName = "Panel";
+var Zt = {
+  minHeight: 0,
+  maxHeight: "100%",
+  height: "auto",
+  minWidth: 0,
+  maxWidth: "100%",
+  width: "auto",
+  border: "none",
+  borderWidth: 0,
+  padding: 0,
+  margin: 0
+};
+function Kt({ layout: e, panelConstraints: t, panelId: n, panelIndex: o }) {
+  let r, a;
+  const d = e[n], s = t.find((i) => i.panelId === n);
+  if (s) {
+    const i = s.maxSize, l = s.collapsible ? s.collapsedSize : s.minSize, u = [o, o + 1];
+    a = X({
+      layout: ie({
+        delta: l - d,
+        initialLayout: e,
+        panelConstraints: t,
+        pivotIndices: u,
+        prevLayout: e
+      }),
+      panelConstraints: t
+    })[n], r = X({
+      layout: ie({
+        delta: i - d,
+        initialLayout: e,
+        panelConstraints: t,
+        pivotIndices: u,
+        prevLayout: e
+      }),
+      panelConstraints: t
+    })[n];
+  }
+  return {
+    valueControls: n,
+    valueMax: r,
+    valueMin: a,
+    valueNow: d
+  };
+}
+function lt({ children: e, className: t, disabled: n, disableDoubleClick: o, elementRef: r, id: a, style: d, ...s }) {
+  const i = we(a), l = Ce({
+    disabled: n,
+    disableDoubleClick: o
+  }), [u, c] = ce({}), [S, h] = ce("inactive"), [f, p] = ce(!1), m = F(null), g = xe(m, r), { disableCursor: v, id: b, orientation: z, registerSeparator: y, updateSeparatorProps: k } = Pe(), E = z === "horizontal" ? "vertical" : "horizontal";
+  U(() => {
+    const $ = m.current;
+    if ($ !== null) {
+      const w = {
+        disabled: l.disabled,
+        disableDoubleClick: l.disableDoubleClick,
+        element: $,
+        id: i
+      }, x = y(w), L = $t((M) => {
+        h(M.next.state !== "inactive" && M.next.hitRegions.some((T) => T.separator === w) ? M.next.state : "inactive");
+      }), C = be(b, (M) => {
+        const { derivedPanelConstraints: T, layout: ne, separatorToPanels: se } = M.next, oe = se.get(w);
+        if (oe) {
+          const W = oe[0], Z = oe.indexOf(W);
+          c(Kt({
+            layout: ne,
+            panelConstraints: T,
+            panelId: W.id,
+            panelIndex: Z
+          }));
+        }
+      });
+      return () => {
+        L(), C(), x();
+      };
+    }
+  }, [
+    b,
+    i,
+    y,
+    l
+  ]), pe(() => {
+    k(i, {
+      disabled: n,
+      disableDoubleClick: o
+    });
+  }, [
+    n,
+    o,
+    i,
+    k
+  ]);
+  let D;
+  n && !v && (D = "not-allowed");
+  let N;
+  return n ? N = "disabled" : S === "active" ? N = "active" : f ? N = "focus" : N = S, /* @__PURE__ */ j("div", {
+    ...s,
+    "aria-controls": u.valueControls,
+    "aria-disabled": n || void 0,
+    "aria-orientation": E,
+    "aria-valuemax": u.valueMax,
+    "aria-valuemin": u.valueMin,
+    "aria-valuenow": u.valueNow,
+    children: e,
+    className: t,
+    "data-separator": N,
+    "data-testid": i,
+    id: i,
+    onBlur: () => p(!1),
+    onFocus: () => p(!0),
+    ref: g,
+    role: "separator",
+    style: {
+      flexBasis: "auto",
+      cursor: D,
+      ...d,
+      flexGrow: 0,
+      flexShrink: 0,
+      touchAction: "none"
+    },
+    tabIndex: n ? void 0 : 0
+  });
+}
+lt.displayName = "Separator";
+function tn({ className: e, ...t }) {
+  return /* @__PURE__ */ j(it, {
+    "data-slot": "resizable-panel-group",
+    className: He("flex h-full w-full aria-[orientation=vertical]:flex-col", e),
+    ...t
+  });
+}
+function nn({ ...e }) {
+  return /* @__PURE__ */ j(st, {
+    "data-slot": "resizable-panel",
+    ...e
+  });
+}
+function on({ withHandle: e, className: t, ...n }) {
+  return /* @__PURE__ */ j(lt, {
+    "data-slot": "resizable-handle",
+    className: He("relative flex w-px items-center justify-center bg-border ring-offset-background after:absolute after:inset-y-0 after:start-1/2 after:w-1 after:-translate-x-1/2 focus-visible:ring-1 focus-visible:ring-ring focus-visible:outline-hidden aria-[orientation=horizontal]:h-px aria-[orientation=horizontal]:w-full aria-[orientation=horizontal]:after:start-0 aria-[orientation=horizontal]:after:h-1 aria-[orientation=horizontal]:after:w-full aria-[orientation=horizontal]:after:translate-x-0 aria-[orientation=horizontal]:after:-translate-y-1/2 rtl:after:translate-x-1/2 rtl:aria-[orientation=horizontal]:after:-translate-x-0 [&[aria-orientation=horizontal]>div]:rotate-90", t),
+    ...n,
+    children: e && /* @__PURE__ */ j("div", { className: "z-10 flex h-6 w-1 shrink-0 rounded-lg bg-border" })
+  });
+}
+export {
+  on as ResizableHandle,
+  nn as ResizablePanel,
+  tn as ResizablePanelGroup
+};
+
+//# sourceMappingURL=resizable.js.map