@aiquants/resize-panels 1.4.0 → 1.6.0

package/dist/index.js

@@ -0,0 +1,2258 @@
+import { createContext as vt, useContext as Mt, useCallback as pe, useMemo as te, useReducer as wt, useState as ye, useRef as ie, useEffect as re, useLayoutEffect as je, memo as Ke, useId as ut, useSyncExternalStore as ft } from "react";
+import { jsx as A, jsxs as le } from "react/jsx-runtime";
+import { twMerge as ke } from "tailwind-merge";
+import { createPortal as Et } from "react-dom";
+const pt = vt(null), Qe = () => {
+  const t = Mt(pt);
+  if (!t)
+    throw new Error("usePanelGroup must be used within a PanelGroup");
+  return t;
+}, zt = (t, e = 0) => {
+  if (!Number.isFinite(t))
+    return t;
+  const n = 10 ** e, d = t * n, r = Math.floor(d), l = d - r, i = Number.EPSILON * Math.max(1, Math.abs(d));
+  return l < 0.5 - i ? r / n : l > 0.5 + i ? (r + 1) / n : (r % 2 === 0 ? r : r + 1) / n;
+}, gt = 12, tt = 8, Bt = 8, Rt = 8, ht = 0.05, xt = 10, It = 0.05, Ft = 20, Nt = 0.05, it = 0, St = 6, me = (t, e) => e <= 0 ? 0 : zt(t / e * 100, St), Te = (t, e) => !t || e <= 0 ? 0 : t / 100 * e, Xe = (t, e = "percentage") => {
+  if (t !== void 0)
+    return typeof t == "number" ? { value: t, unit: e } : t;
+}, rt = (t, e) => t ? t.unit === "percentage" ? t.value / 100 * e : t.value : 0, q = (t, e, n) => t ? typeof t == "number" ? t / 100 * n : t.unit === "pixels" ? t.value : t.value / 100 * n : e, ze = (t, e, n) => Math.min(Math.max(t, e), n), qe = (t) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return it;
+  const e = t * ht, n = Math.min(gt, xt, e);
+  return Math.max(it, n);
+}, mt = (t, e, n, d = {}) => {
+  if (Math.abs(e) <= 0)
+    return e;
+  const r = d.enforceAutoMinSize ?? !1, l = t.map((s, a) => ({ panel: s, index: a })).filter(({ panel: s }) => !s.collapsed && (s.sizeUnit === "pixels" || s.originalPixelSize !== void 0));
+  if (l.length === 0)
+    return e;
+  const i = e > 0, f = [...l].sort((s, a) => {
+    const o = s.panel.pixelAdjustPriority ?? s.index + 1, x = a.panel.pixelAdjustPriority ?? a.index + 1;
+    return o === x ? i ? a.index - s.index : s.index - a.index : i ? x - o : o - x;
+  });
+  let u = e;
+  const z = (s) => {
+    for (const { index: a } of f) {
+      if (Math.abs(u) <= 0)
+        break;
+      const o = t[a];
+      if (!o || o.collapsed)
+        continue;
+      const x = Xe(o.minSize, "pixels"), C = Xe(o.maxSize, "pixels"), P = x ? rt(x, n) : 0, v = C ? rt(C, n) : n, S = r ? q(o.autoMinSize, 0, n) : 0, y = Math.max(P, S), m = o.preferredPixelSize !== void 0 ? ze(o.preferredPixelSize, y, v) : o.size, D = o.collapseFromStart || o.collapseFromEnd;
+      if (u > 0) {
+        if (Math.abs(o.size) <= 0 && (o.percentageSize ?? 0) <= 0)
+          continue;
+        const J = Math.max(o.size, m), ae = s ? Math.min(v, J) : v, W = Math.max(0, ae - o.size);
+        if (W <= 0)
+          continue;
+        const O = Math.min(W, u);
+        if (O <= 0)
+          continue;
+        const B = o.size + O, ee = me(B, n), k = D ? B : o.sizeBeforeCollapse, $ = D ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? B : o.measuredPixelSizeBeforeCollapse;
+        t[a] = {
+          ...o,
+          size: B,
+          percentageSize: ee,
+          sizeBeforeCollapse: k,
+          measuredPixelSizeBeforeCollapse: $,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, u -= O;
+      } else {
+        const X = s ? m : y, J = Math.max(0, o.size - X);
+        if (J <= 0)
+          continue;
+        const ae = Math.min(J, Math.abs(u));
+        if (ae <= 0)
+          continue;
+        const W = o.size - ae, O = me(W, n), B = D ? W : o.sizeBeforeCollapse, ee = D ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? W : o.measuredPixelSizeBeforeCollapse;
+        t[a] = {
+          ...o,
+          size: W,
+          percentageSize: O,
+          sizeBeforeCollapse: B,
+          measuredPixelSizeBeforeCollapse: ee,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, u += ae;
+      }
+    }
+  };
+  return z(!0), (i && u > 0 || !i && u < 0) && z(!1), u;
+}, Ue = (t) => {
+  if (!t)
+    return 0;
+  const e = parseFloat(t);
+  return Number.isFinite(e) ? e : 0;
+}, Le = (t, e) => {
+  const n = t.getBoundingClientRect(), d = typeof window < "u" ? window.getComputedStyle(t) : null, r = d ? Ue(d.borderLeftWidth) + Ue(d.borderRightWidth) : 0, l = d ? Ue(d.borderTopWidth) + Ue(d.borderBottomWidth) : 0;
+  if (e === "horizontal") {
+    const z = n.width > 0 ? n.width : t.offsetWidth, s = n.width > 0 ? Math.max(0, n.width - r) : t.clientWidth, a = t.offsetWidth > 0 ? t.offsetWidth : t.clientWidth + r;
+    return {
+      inner: s > 0 ? s : Math.max(0, t.clientWidth),
+      outer: z > 0 ? z : Math.max(0, a)
+    };
+  }
+  const i = n.height > 0 ? n.height : t.offsetHeight, f = n.height > 0 ? Math.max(0, n.height - l) : t.clientHeight, u = t.offsetHeight > 0 ? t.offsetHeight : t.clientHeight + l;
+  return {
+    inner: f > 0 ? f : Math.max(0, t.clientHeight),
+    outer: i > 0 ? i : Math.max(0, u)
+  };
+}, At = (t, e) => {
+  try {
+    localStorage.setItem(`panel-layout-${t}`, JSON.stringify(e));
+  } catch (n) {
+    console.warn("Failed to save panel layout:", n);
+  }
+}, Lt = (t) => {
+  try {
+    const e = localStorage.getItem(`panel-layout-${t}`);
+    return e ? JSON.parse(e) : null;
+  } catch (e) {
+    return console.warn("Failed to load panel layout:", e), null;
+  }
+};
+var Ve = /* @__PURE__ */ ((t) => (t[t.DEBUG = 0] = "DEBUG", t[t.INFO = 1] = "INFO", t[t.WARN = 2] = "WARN", t[t.ERROR = 3] = "ERROR", t[t.NONE = 4] = "NONE", t))(Ve || {});
+const we = class we {
+  /**
+   * @constructor
+   * @param {LogLevel} [level=LogLevel.WARN] - The minimum log level to output.
+   * @param {string} [prefix="[resize-panels]"] - The prefix to add to all log messages.
+   * @param {ILogger} [impl=console] - The implementation to use for logging.
+   */
+  constructor(e = 2, n = "[resize-panels]", d = console) {
+    this.level = e, this.prefix = n, this.impl = d;
+  }
+  /**
+   * @method setLevel
+   * @description Updates the current log level for the static instance.
+   * @description 静的インスタンスの現在のログレベルを更新します。
+   * @param {LogLevel} level - The new log level.
+   */
+  static setLevel(e) {
+    we.instance.setLevel(e);
+  }
+  /**
+   * @method setLevel
+   * @description Updates the current log level.
+   * @description 現在のログレベルを更新します。
+   * @param {LogLevel} level - The new log level.
+   */
+  setLevel(e) {
+    this.level = e;
+  }
+  /**
+   * @method setImplementation
+   * @description Updates the logger implementation for the static instance.
+   * @description 静的インスタンスのロガーの実装を更新します。
+   * @param {ILogger} impl - The new logger implementation.
+   */
+  static setImplementation(e) {
+    we.instance.setImplementation(e);
+  }
+  /**
+   * @method setImplementation
+   * @description Updates the logger implementation.
+   * @description ロガーの実装を更新します。
+   * @param {ILogger} impl - The new logger implementation.
+   */
+  setImplementation(e) {
+    this.impl = e;
+  }
+  /**
+   * @method setPrefix
+   * @description Updates the log prefix for the static instance.
+   * @description 静的インスタンスのログのプレフィックスを更新します。
+   * @param {string} prefix - The new prefix.
+   */
+  static setPrefix(e) {
+    we.instance.setPrefix(e);
+  }
+  /**
+   * @method setPrefix
+   * @description Updates the log prefix.
+   * @description ログのプレフィックスを更新します。
+   * @param {string} prefix - The new prefix.
+   */
+  setPrefix(e) {
+    this.prefix = e;
+  }
+  formatMessage(e) {
+    return typeof e == "string" ? [`${this.prefix} ${e}`] : [this.prefix, e];
+  }
+  static debug(e, ...n) {
+    we.instance.debug(e, ...n);
+  }
+  debug(e, ...n) {
+    this.level <= 0 && this.impl.debug(...this.formatMessage(e), ...n);
+  }
+  static info(e, ...n) {
+    we.instance.info(e, ...n);
+  }
+  info(e, ...n) {
+    this.level <= 1 && this.impl.info(...this.formatMessage(e), ...n);
+  }
+  static warn(e, ...n) {
+    we.instance.warn(e, ...n);
+  }
+  warn(e, ...n) {
+    this.level <= 2 && this.impl.warn(...this.formatMessage(e), ...n);
+  }
+  static error(e, ...n) {
+    we.instance.error(e, ...n);
+  }
+  error(e, ...n) {
+    this.level <= 3 && this.impl.error(...this.formatMessage(e), ...n);
+  }
+};
+we.instance = new we(2, "[resize-panels]");
+let Ge = we;
+const ue = new Ge(Ve.INFO, "[resize-panels]"), Ce = (t) => t.map((e) => ({
+  id: e.id,
+  size: e.size,
+  percentageSize: e.percentageSize,
+  preferredPercentageSize: e.preferredPercentageSize,
+  sizeBeforeCollapse: e.sizeBeforeCollapse,
+  percentageSizeBeforeCollapse: e.percentageSizeBeforeCollapse,
+  preferredPercentageSizeBeforeCollapse: e.preferredPercentageSizeBeforeCollapse,
+  measuredPercentageSize: e.measuredPercentageSize,
+  excludeFromAutoGrowth: e.excludeFromAutoGrowth ?? !1,
+  collapsed: e.collapsed ?? !1,
+  collapseFromStart: e.collapseFromStart,
+  collapseFromEnd: e.collapseFromEnd,
+  collapsedByDirection: e.collapsedByDirection ?? null
+})), We = (t) => t ? Ce([t])[0] : null, Ae = (t) => t ? !!(t.collapseFromStart || t.collapseFromEnd) : !1, Ze = (t, e) => {
+  if (!Number.isFinite(e) || e <= 0)
+    return t;
+  const n = t.map((u) => ({ ...u })), d = [];
+  for (let u = 0; u < n.length; u += 1) {
+    const z = n[u];
+    if (z.collapsed) {
+      n[u] = {
+        ...z,
+        size: 0,
+        percentageSize: 0
+      };
+      continue;
+    }
+    const s = Math.max(0, q(z.minSize, 0, e)), a = Math.max(0, q(z.autoMinSize, 0, e)), o = Math.max(s, a), x = Math.max(1e-3, o), C = q(z.maxSize, e, e), P = Math.max(o, C), v = z.sizeUnit === "pixels" || z.originalPixelSize !== void 0, S = Math.max(0, z.size);
+    let y = o;
+    if (v) {
+      const D = z.preferredPixelSize ?? z.size ?? z.originalPixelSize ?? o;
+      y = ze(D, o, P);
+    } else {
+      const D = z.preferredPercentageSize ?? z.percentageSize ?? me(z.size, e), X = Te(D, e);
+      y = ze(X, o, P);
+    }
+    const m = !v && (z.excludeFromAutoGrowth ?? !1) && S <= x;
+    d.push({
+      index: u,
+      isPixelPanel: v,
+      minSize: o,
+      maxSize: P,
+      preferredSize: y,
+      priority: z.pixelAdjustPriority ?? u + 1,
+      flexPriority: v ? void 0 : z.flexAdjustPriority,
+      excludeFromGrowth: m
+    });
+  }
+  if (d.length === 0)
+    return n;
+  const r = /* @__PURE__ */ new Map();
+  let l = 0;
+  for (const u of d)
+    r.set(u.index, u.minSize), l += u.minSize;
+  let i = e - l;
+  const f = (u, z) => {
+    if (z <= 0)
+      return 0;
+    const s = r.get(u.index) ?? u.minSize, a = Math.max(0, u.maxSize - s);
+    if (a <= 0)
+      return 0;
+    const o = Math.min(z, a);
+    return r.set(u.index, s + o), o;
+  };
+  if (i > 0) {
+    const u = (s) => {
+      for (; i > 1e-6; ) {
+        let o = 0;
+        const x = [];
+        for (const v of s) {
+          if (!v.isPixelPanel && v.excludeFromGrowth)
+            continue;
+          const S = r.get(v.index) ?? v.minSize, y = Math.min(v.preferredSize, v.maxSize), m = Math.max(0, y - S);
+          m > 1e-6 && (o += m, x.push({ descriptor: v, capacity: m }));
+        }
+        if (x.length === 0 || o <= 1e-6)
+          break;
+        let C = 0;
+        const P = i;
+        for (const v of x) {
+          if (i <= 1e-6)
+            break;
+          if (!v.descriptor.isPixelPanel && v.descriptor.excludeFromGrowth)
+            continue;
+          const S = P * v.capacity / o, y = Math.min(v.capacity, S);
+          if (y <= 0)
+            continue;
+          const m = f(v.descriptor, y);
+          m > 0 && (i -= m, C += m);
+        }
+        if (C <= 1e-6)
+          break;
+      }
+    }, z = d.filter((s) => s.isPixelPanel);
+    z.sort((s, a) => a.priority - s.priority);
+    for (const s of z) {
+      if (i <= 0)
+        break;
+      const a = r.get(s.index) ?? s.minSize, o = Math.min(s.preferredSize, s.maxSize), x = Math.max(0, o - a);
+      if (x <= 0)
+        continue;
+      const C = f(s, Math.min(x, i));
+      C > 0 && (i -= C);
+    }
+    if (i > 0) {
+      const s = d.filter((a) => !a.isPixelPanel);
+      if (s.length > 0) {
+        const a = s.filter((o) => o.flexPriority !== void 0 && !o.excludeFromGrowth);
+        if (a.length > 0) {
+          a.sort((o, x) => (x.flexPriority ?? 0) - (o.flexPriority ?? 0));
+          for (const o of a) {
+            if (i <= 0)
+              break;
+            if (o.excludeFromGrowth)
+              continue;
+            const x = r.get(o.index) ?? o.minSize, C = Math.min(o.preferredSize, o.maxSize), P = Math.max(0, C - x);
+            if (P <= 0)
+              continue;
+            const v = f(o, Math.min(P, i));
+            v > 0 && (i -= v);
+          }
+        }
+        if (i > 0) {
+          const o = a.length > 0 ? s.filter((x) => x.flexPriority === void 0 && !x.excludeFromGrowth) : s.filter((x) => !x.excludeFromGrowth);
+          o.length > 0 && u(o);
+        }
+      }
+    }
+  }
+  if (i > 0) {
+    let u = i;
+    for (; ; ) {
+      let z = 0;
+      const s = [];
+      for (const o of d) {
+        if (!o.isPixelPanel && o.excludeFromGrowth)
+          continue;
+        const x = r.get(o.index) ?? o.minSize, C = o.isPixelPanel ? Math.min(o.maxSize, o.preferredSize) : o.maxSize, P = Math.max(0, C - x);
+        P > 0 && (s.push(o), z += P);
+      }
+      if (z <= 0)
+        break;
+      const a = i;
+      for (const o of s) {
+        if (i <= 0)
+          break;
+        if (!o.isPixelPanel && o.excludeFromGrowth)
+          continue;
+        const x = r.get(o.index) ?? o.minSize, C = o.isPixelPanel ? Math.min(o.maxSize, o.preferredSize) : o.maxSize, P = Math.max(0, C - x);
+        if (P <= 0)
+          continue;
+        const v = a * P / z, S = f(o, Math.min(P, v));
+        S > 0 && (i -= S);
+      }
+      if (i <= 1e-6 || Math.abs(u - i) <= 1e-6)
+        break;
+      u = i;
+    }
+    i = Math.max(0, i);
+  }
+  if (i < 0) {
+    let u = i;
+    const z = d.filter((s) => s.isPixelPanel);
+    for (z.sort((s, a) => s.priority - a.priority); !(i >= 0); ) {
+      let s = !1;
+      for (const a of z) {
+        if (i >= 0)
+          break;
+        const o = r.get(a.index) ?? a.minSize, x = ze(a.preferredSize, a.minSize, a.maxSize), C = Math.max(0, o - x);
+        if (C > 0 && i < 0) {
+          const v = Math.min(C, Math.abs(i));
+          r.set(a.index, o - v), i += v, s = !0;
+          continue;
+        }
+        const P = Math.max(0, o - a.minSize);
+        if (P > 0 && i < 0) {
+          const v = Math.min(P, Math.abs(i));
+          r.set(a.index, o - v), i += v, s = !0;
+        }
+      }
+      if (!s || Math.abs(u - i) <= 1e-6)
+        break;
+      u = i;
+    }
+  }
+  for (const u of d) {
+    const z = r.get(u.index) ?? u.minSize, s = n[u.index], a = Ae(s), o = a ? z : s.sizeBeforeCollapse, x = a ? s.measuredPixelSizeBeforeCollapse ?? s.measuredPixelSize ?? z : s.measuredPixelSizeBeforeCollapse, C = e > 0 ? me(z, e) : 0;
+    n[u.index] = {
+      ...s,
+      size: z,
+      percentageSize: C,
+      preferredPercentageSize: s.preferredPercentageSize,
+      preferredPixelSize: u.isPixelPanel ? s.preferredPixelSize ?? z : s.preferredPixelSize,
+      sizeBeforeCollapse: o,
+      measuredPixelSizeBeforeCollapse: x,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    };
+  }
+  return Ne(n);
+}, Ne = (t) => {
+  let e = 0;
+  for (const r of t)
+    r.collapsed || (e += Math.max(r.size, 0));
+  if (e <= 0) {
+    let r = !1;
+    const l = t.map((i) => (i.percentageSize ?? 0) !== 0 ? (r = !0, {
+      ...i,
+      percentageSize: 0,
+      measuredPercentageSize: i.measuredPercentageSize !== void 0 ? 0 : i.measuredPercentageSize
+    }) : !i.collapsed && i.sizeBeforeCollapse !== i.size ? (r = !0, {
+      ...i,
+      sizeBeforeCollapse: i.size
+    }) : i);
+    return r ? l : t;
+  }
+  let n = !1;
+  const d = t.map((r) => {
+    if (r.collapsed)
+      return (r.percentageSize ?? 0) !== 0 ? (n = !0, {
+        ...r,
+        percentageSize: 0,
+        measuredPercentageSize: r.measuredPercentageSize !== void 0 ? 0 : r.measuredPercentageSize
+      }) : r;
+    const l = me(r.size, e), i = r.measuredPercentageSize, z = (i !== void 0 ? Math.abs(i - l) : 1 / 0) < 1e-4 && i !== void 0 ? i : l, s = zt(z, St), o = Math.abs((r.percentageSize ?? 0) - s) > 0 || r.percentageSize === void 0, x = r.sizeBeforeCollapse === void 0 || r.sizeBeforeCollapse !== r.size, C = Ae(r), P = C && x, v = r.measuredPixelSize ?? r.size, S = C && (r.measuredPixelSizeBeforeCollapse === void 0 || r.measuredPixelSizeBeforeCollapse !== v);
+    if (!(o || P || S))
+      return r;
+    n = !0;
+    const y = P ? r.size : r.sizeBeforeCollapse, m = S ? v : r.measuredPixelSizeBeforeCollapse;
+    return {
+      ...r,
+      percentageSize: s,
+      sizeBeforeCollapse: y,
+      measuredPixelSizeBeforeCollapse: m,
+      collapsedByDirection: r.collapsed ? r.collapsedByDirection ?? null : null
+    };
+  });
+  return n ? d : t;
+}, $e = (t, e) => {
+  if (e <= 0)
+    return !1;
+  const n = [];
+  let d = 0;
+  for (let s = 0; s < t.length; s += 1) {
+    const a = t[s];
+    !a || a.collapsed || (n.push(s), d += a.size);
+  }
+  if (n.length === 0)
+    return !1;
+  let r = e - d;
+  if (Math.abs(r) <= 0)
+    return !1;
+  let l = !1;
+  const i = (s) => {
+    const a = t[s], o = q(a.minSize, 0, e), x = q(a.autoMinSize, 0, e), C = Math.max(o, x), P = q(a.maxSize, e, e), v = a.sizeUnit === "percentage" && a.originalPixelSize === void 0;
+    return {
+      index: s,
+      minSize: C,
+      maxSize: P,
+      isFlexible: v
+    };
+  }, f = (s, a) => {
+    if (!Number.isFinite(a) || Math.abs(a) <= 0)
+      return;
+    const o = t[s];
+    if (!o)
+      return;
+    const x = Math.max(0, o.size + a);
+    if (Math.abs(x - o.size) <= 0)
+      return;
+    const C = me(x, e), P = Ae(o), v = P ? x : o.sizeBeforeCollapse, S = P ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? x : o.measuredPixelSizeBeforeCollapse;
+    t[s] = {
+      ...o,
+      size: x,
+      percentageSize: C,
+      sizeBeforeCollapse: v,
+      measuredPixelSizeBeforeCollapse: S,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    }, r -= a, l = !0;
+  }, u = (s) => {
+    for (const a of s) {
+      if (Math.abs(r) <= 0)
+        break;
+      const o = t[a.index];
+      if (!o || o.collapsed)
+        continue;
+      const x = o.size;
+      if (r > 0) {
+        const C = Math.max(0, a.maxSize - x);
+        if (C <= 0)
+          continue;
+        const P = Math.min(C, r);
+        if (P <= 0)
+          continue;
+        f(a.index, P);
+      } else {
+        const C = Math.max(0, x - a.minSize);
+        if (C <= 0)
+          continue;
+        const P = Math.min(C, Math.abs(r));
+        if (P <= 0)
+          continue;
+        f(a.index, -P);
+      }
+    }
+  }, z = n.map((s) => i(s)).filter((s) => s.isFlexible);
+  if (z.length > 0 && u(z), Math.abs(r) > 0) {
+    const s = r;
+    r = mt(t, r, e, { enforceAutoMinSize: !0 }), Math.abs(r - s) > 0 && (l = !0);
+  }
+  return l;
+}, nt = (t, e, n) => {
+  if (!(t.sizeUnit === "pixels" || t.originalPixelSize !== void 0) || t.pixelAdjustPriority !== void 0)
+    return t;
+  const r = e.filter((i, f) => f !== n && (i.sizeUnit === "pixels" || i.originalPixelSize !== void 0)).map((i) => i.pixelAdjustPriority).filter((i) => i !== void 0), l = r.length > 0 ? Math.max(...r) + 1 : 1;
+  return {
+    ...t,
+    pixelAdjustPriority: l
+  };
+}, Dt = (t, e) => {
+  switch (e.type) {
+    case "REGISTER_PANEL": {
+      ue.debug("REGISTER_PANEL", e.panel);
+      const n = t.findIndex((l) => l.id === e.panel.id);
+      if (n >= 0) {
+        const l = [...t], i = t[n], f = {
+          ...i,
+          minSize: e.panel.minSize,
+          maxSize: e.panel.maxSize,
+          collapseFromStart: e.panel.collapseFromStart,
+          collapseFromEnd: e.panel.collapseFromEnd,
+          collapsedByDirection: e.panel.collapsedByDirection !== void 0 ? e.panel.collapsedByDirection : i.collapsedByDirection,
+          sizeUnit: e.panel.sizeUnit,
+          originalPixelSize: e.panel.originalPixelSize,
+          preferredPercentageSize: e.panel.preferredPercentageSize !== void 0 ? e.panel.preferredPercentageSize : i.preferredPercentageSize,
+          preferredPercentageSizeBeforeCollapse: e.panel.preferredPercentageSizeBeforeCollapse !== void 0 ? e.panel.preferredPercentageSizeBeforeCollapse : i.preferredPercentageSizeBeforeCollapse,
+          percentageSizeBeforeCollapse: e.panel.percentageSizeBeforeCollapse !== void 0 ? e.panel.percentageSizeBeforeCollapse : i.percentageSizeBeforeCollapse,
+          pixelAdjustPriority: e.panel.pixelAdjustPriority !== void 0 ? e.panel.pixelAdjustPriority : i.pixelAdjustPriority,
+          autoMinSize: e.panel.autoMinSize !== void 0 ? e.panel.autoMinSize : i.autoMinSize,
+          excludeFromAutoGrowth: e.panel.excludeFromAutoGrowth !== void 0 ? e.panel.excludeFromAutoGrowth : i.excludeFromAutoGrowth
+        }, u = nt(f, t, n);
+        return ue.debug("register panel (update)", {
+          panelId: u.id,
+          incoming: We(e.panel),
+          previous: We(i),
+          next: We(u)
+        }), l[n] = u, l;
+      }
+      const d = { ...e.panel }, r = nt(d, t);
+      return ue.debug("register panel (insert)", {
+        panelId: r.id,
+        incoming: We(r),
+        previousLength: t.length
+      }), [...t, r];
+    }
+    case "UNREGISTER_PANEL": {
+      ue.debug("UNREGISTER_PANEL", e.id);
+      const n = t.filter((r) => r.id !== e.id), d = Ne(n);
+      return ue.debug("unregister panel", {
+        panelId: e.id,
+        previous: Ce(t),
+        filtered: Ce(n),
+        next: Ce(d)
+      }), d;
+    }
+    case "RESIZE_PANELS": {
+      ue.debug("RESIZE_PANELS", e.leftId, e.rightId, e.leftSize, e.rightSize);
+      const n = t.findIndex((g) => g.id === e.leftId), d = t.findIndex((g) => g.id === e.rightId);
+      if (n === -1 || d === -1) return t;
+      const r = [...t], l = r[n], i = r[d];
+      if (l.collapsed || i.collapsed || e.leftSize === l.size && e.rightSize === i.size)
+        return t;
+      const f = e.containerSize ?? t.reduce((g, M) => g + M.size, 0), u = q(l.minSize, 0, f), z = q(l.maxSize, f, f), s = q(i.minSize, 0, f), a = q(i.maxSize, f, f), o = l.size + i.size, x = t.reduce((g, M) => M.collapsed ? g : g + M.size, 0), C = x - o, P = u + s, v = z + a, S = ze(e.leftSize + e.rightSize, P, v);
+      let y = f > 0 ? f - C : S;
+      Number.isFinite(y) || (y = S);
+      const m = ze(Math.max(S, y), P, v), D = (g) => ({
+        min: Math.max(u, g - a),
+        max: Math.min(z, g - s)
+      }), X = (g) => ({
+        min: Math.max(s, g - z),
+        max: Math.min(a, g - u)
+      }), J = Math.abs(e.leftSize - l.size), ae = Math.abs(e.rightSize - i.size), W = J >= ae;
+      let O = l.size, B = i.size;
+      if (W) {
+        const g = D(m);
+        if (g.min > g.max)
+          return t;
+        const M = ze(e.leftSize, g.min, g.max), p = m - M;
+        if (p < s || p > a)
+          return t;
+        O = M, B = p;
+      } else {
+        const g = X(m);
+        if (g.min > g.max)
+          return t;
+        const M = ze(e.rightSize, g.min, g.max), p = m - M;
+        if (p < u || p > z)
+          return t;
+        B = M, O = p;
+      }
+      const ee = O + B;
+      if (m !== ee)
+        return t;
+      const k = x - l.size - i.size + ee, $ = f > 0 ? f : k, G = $ > 0 ? me(O, $) : 0, j = $ > 0 ? me(B, $) : 0, b = l.sizeUnit === "pixels" || l.originalPixelSize !== void 0 ? O : l.preferredPixelSize, H = i.sizeUnit === "pixels" || i.originalPixelSize !== void 0 ? B : i.preferredPixelSize, he = q(l.autoMinSize, 0, f), ce = q(i.autoMinSize, 0, f), ge = Math.max(1e-3, he), Pe = Math.max(1e-3, ce), ne = l.sizeUnit === "percentage" && l.originalPixelSize === void 0, de = i.sizeUnit === "percentage" && i.originalPixelSize === void 0;
+      let fe = l.excludeFromAutoGrowth, xe = i.excludeFromAutoGrowth;
+      ne && (O <= ge ? fe = !0 : O > ge && (fe = !1)), de && (B <= Pe ? xe = !0 : B > Pe && (xe = !1));
+      const ve = Ae(l), h = Ae(i);
+      return r[n] = {
+        ...l,
+        size: O,
+        percentageSize: G,
+        preferredPercentageSize: G > 0 ? G : l.preferredPercentageSize,
+        preferredPixelSize: b,
+        sizeBeforeCollapse: ve ? O : l.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: fe
+      }, r[d] = {
+        ...i,
+        size: B,
+        percentageSize: j,
+        preferredPercentageSize: j > 0 ? j : i.preferredPercentageSize,
+        preferredPixelSize: H,
+        sizeBeforeCollapse: h ? B : i.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: xe
+      }, f > 0 && $e(r, f) ? Ne(r) : r;
+    }
+    case "SET_PANELS": {
+      ue.debug("SET_PANELS", e.panels);
+      const n = e.panels.map((u) => {
+        const z = u.sizeUnit === "pixels" || u.originalPixelSize !== void 0, s = u.preferredPercentageSize !== void 0 ? u.preferredPercentageSize : u.percentageSize, a = u.preferredPixelSize !== void 0 ? u.preferredPixelSize : z ? u.size : u.preferredPixelSize;
+        return {
+          ...u,
+          preferredPercentageSize: s,
+          preferredPixelSize: a
+        };
+      }), d = Ce(t), r = Ce(n), l = Ne(n), i = Ce(l);
+      let f = d.length === i.length;
+      if (f)
+        for (let u = 0; u < i.length; u += 1) {
+          const z = i[u], s = d[u];
+          if (!s) {
+            f = !1;
+            break;
+          }
+          if (!(s.id === z.id && s.size === z.size && s.percentageSize === z.percentageSize && s.sizeBeforeCollapse === z.sizeBeforeCollapse && s.measuredPercentageSize === z.measuredPercentageSize && s.collapsed === z.collapsed)) {
+            f = !1;
+            break;
+          }
+        }
+      return f ? (ue.debug("set panels skipped (no diff)", {
+        previous: d,
+        incoming: r,
+        next: i,
+        previousLength: d.length,
+        incomingLength: r.length
+      }), t) : (ue.debug("set panels", {
+        previous: d,
+        incoming: r,
+        next: i,
+        previousLength: d.length,
+        incomingLength: r.length
+      }), l);
+    }
+    case "CONTAINER_RESIZED": {
+      if (ue.debug("CONTAINER_RESIZED", e.containerSize), e.containerSize <= 0)
+        return ue.debug("container resized skipped (non-positive size)", {
+          containerSize: e.containerSize,
+          panels: Ce(t)
+        }), t;
+      ue.debug("container resized (before)", {
+        containerSize: e.containerSize,
+        panels: Ce(t)
+      });
+      const n = Ze(t, e.containerSize);
+      if (ue.debug("container resized (after recalc)", {
+        containerSize: e.containerSize,
+        panels: Ce(n)
+      }), e.containerSize > 0 && $e(n, e.containerSize)) {
+        const d = Ne(n);
+        return ue.debug("container resized (after reconcile)", {
+          containerSize: e.containerSize,
+          panels: Ce(d)
+        }), d;
+      }
+      return ue.debug("container resized (final)", {
+        containerSize: e.containerSize,
+        panels: Ce(n)
+      }), n;
+    }
+    case "COLLAPSE_PANEL": {
+      ue.debug("COLLAPSE_PANEL", e.id);
+      const n = t.findIndex((o) => o.id === e.id);
+      if (n === -1)
+        return t;
+      const d = t[n], r = e.from === "start" ? d.collapseFromStart : d.collapseFromEnd;
+      if (!(Ae(d) && r) || d.collapsed)
+        return t;
+      const i = d.size, f = d.measuredPixelSize ?? i, u = d.percentageSize ?? d.preferredPercentageSize ?? 0, z = {
+        ...d,
+        collapsed: !0,
+        collapsedByDirection: e.from,
+        sizeBeforeCollapse: i,
+        percentageSizeBeforeCollapse: u,
+        preferredPercentageSizeBeforeCollapse: d.preferredPercentageSize ?? u,
+        preferredPixelSizeBeforeCollapse: d.preferredPixelSize ?? i,
+        measuredPixelSizeBeforeCollapse: f,
+        size: 0,
+        percentageSize: 0,
+        preferredPercentageSize: d.preferredPercentageSize,
+        measuredPixelSize: d.measuredPixelSize !== void 0 ? 0 : d.measuredPixelSize,
+        measuredPercentageSize: d.measuredPercentageSize !== void 0 ? 0 : d.measuredPercentageSize
+      }, s = [...t];
+      s[n] = z;
+      const a = Ze(s, e.containerSize);
+      return e.containerSize > 0 && $e(a, e.containerSize) ? Ne(a) : a;
+    }
+    case "EXPAND_PANEL": {
+      ue.debug("EXPAND_PANEL", e.id, e.targetSize);
+      const n = t.findIndex((m) => m.id === e.id);
+      if (n === -1)
+        return t;
+      const d = e.containerSize, r = t[n], l = e.from === "start" ? r.collapseFromStart : r.collapseFromEnd;
+      if (!(Ae(r) && l && r.collapsed) || r.collapsedByDirection && r.collapsedByDirection !== e.from)
+        return t;
+      const f = [e.targetSize, r.sizeBeforeCollapse, r.measuredPixelSizeBeforeCollapse, r.preferredPixelSizeBeforeCollapse, r.originalPixelSize].find((m) => m !== void 0) ?? 0, u = q(r.minSize, 0, d), z = q(r.maxSize, d, d), s = ze(f, u, z), a = me(s, d), o = r.measuredPixelSizeBeforeCollapse ?? s, x = me(o, d), C = r.preferredPercentageSizeBeforeCollapse ?? r.percentageSizeBeforeCollapse ?? a, P = r.preferredPixelSizeBeforeCollapse ?? r.preferredPixelSize ?? s, v = {
+        ...r,
+        collapsed: !1,
+        collapsedByDirection: null,
+        size: s,
+        percentageSize: a,
+        preferredPercentageSize: C,
+        preferredPixelSize: P,
+        sizeBeforeCollapse: s,
+        percentageSizeBeforeCollapse: void 0,
+        preferredPercentageSizeBeforeCollapse: void 0,
+        preferredPixelSizeBeforeCollapse: void 0,
+        measuredPixelSize: s,
+        measuredPixelSizeBeforeCollapse: o,
+        measuredPercentageSize: x
+      }, S = [...t];
+      S[n] = v;
+      const y = Ze(S, d);
+      return d > 0 && $e(y, d) ? Ne(y) : y;
+    }
+    default:
+      return t;
+  }
+}, _e = new Ge(Ve.INFO, "[resize-panels]"), Ot = ({ direction: t, style: e, onLayout: n, autoSaveId: d, showDebugInfo: r = !1 }) => {
+  const [l, i] = wt(Dt, []), [f, u] = ye({ width: 0, height: 0 }), [z, s] = ye(!1), [a, o] = ye(!1), [x, C] = ye(null), [P, v] = ye({}), [S, y] = ye({}), m = ie(null), D = ie(n), X = ie(!1), J = ie(0), ae = ie(f), W = ie(f), O = ie(z), B = ie(x?.reason ?? null), ee = ie({}), k = ie(null), $ = ie(null), G = pe((h) => h.map((g) => ({ ...g })), []);
+  re(() => {
+    W.current = f;
+  }, [f]), re(() => {
+    O.current = z;
+  }, [z]), re(() => {
+    B.current = x?.reason ?? null;
+  }, [x?.reason]), re(() => {
+    if (x)
+      return;
+    const h = t === "horizontal" ? f.width : f.height;
+    !Number.isFinite(h) || h <= 4 || l.length !== 0 && (k.current = G(l));
+  }, [x, l, t, f.width, f.height, G]), re(() => {
+    const h = $.current;
+    if (x) {
+      $.current = x;
+      return;
+    }
+    if (h && !x && k.current) {
+      $.current = null;
+      const g = G(k.current);
+      i({ type: "SET_PANELS", panels: g });
+      return;
+    }
+    $.current = x;
+  }, [x, G]), je(() => {
+    if (!m.current) return;
+    const h = new ResizeObserver((g) => {
+      for (const M of g) {
+        const p = M.target, E = p ? Le(p, "horizontal") : null, R = p ? Le(p, "vertical") : null, _ = E ? E.inner : 0, V = R ? R.inner : 0, F = M.contentRect.width, N = M.contentRect.height, T = _ > 0 ? _ : F, w = V > 0 ? V : N;
+        u((L) => (!z && T > 0 && w > 0 && s(!0), L.width === T && L.height === w ? L : { width: T, height: w }));
+      }
+    });
+    return h.observe(m.current), () => h.disconnect();
+  }, [z]), je(() => {
+    const h = ae.current, g = f, M = t === "horizontal" ? Math.abs(h.width - g.width) > 0 : Math.abs(h.height - g.height) > 0;
+    if (a && M) {
+      const p = t === "horizontal" ? g.width : g.height;
+      i({ type: "CONTAINER_RESIZED", containerSize: p, direction: t });
+    }
+    ae.current = g;
+  }, [f, a, t]);
+  const j = pe(() => {
+    _e.debug("panels[0]?.id", l[0]?.id);
+    const h = l.some((c) => {
+      if (c.collapsed || c.sizeUnit !== "percentage")
+        return !1;
+      const U = c.collapseFromStart || c.collapseFromEnd ? c.sizeBeforeCollapse ?? c.measuredPixelSizeBeforeCollapse ?? c.originalPixelSize ?? c.measuredPixelSize ?? 0 : c.measuredPixelSize ?? c.originalPixelSize ?? c.size, Z = c.percentageSize !== void 0 && c.percentageSize > 0;
+      return c.size <= 0 && (U > 0 || Z);
+    }), g = t === "horizontal" ? f.width : f.height, M = g > 0;
+    if (x || !M || !(l.length > 0 && (l.length !== J.current || !a || h)))
+      return;
+    const R = l.filter((c) => !c.collapsed && (c.originalPixelSize !== void 0 || c.sizeUnit === "pixels")).reduce((c, I) => {
+      const U = I.preferredPixelSize ?? I.originalPixelSize ?? I.size;
+      return c + Math.max(0, U ?? 0);
+    }, 0), _ = l.filter((c) => c.sizeUnit === "percentage" && !c.collapsed), V = _.map((c) => c.id), F = _.map((c) => {
+      const I = c.preferredPercentageSize ?? c.percentageSize;
+      return I !== void 0 && I > 0 ? Te(I, g) : c.size > 0 ? c.size : 0;
+    }), N = F.reduce((c, I) => c + I, 0), T = g - R, w = Math.max(0, T), L = w > 0, K = l.map((c) => {
+      if (c.collapsed) {
+        const I = c.sizeBeforeCollapse ?? c.measuredPixelSizeBeforeCollapse ?? c.originalPixelSize ?? (c.sizeUnit === "pixels" ? c.size : void 0), U = c.sizeUnit === "percentage" && c.percentageSize !== void 0 ? Te(c.percentageSize, g) : void 0, Z = I ?? U ?? 0, Q = c.measuredPixelSizeBeforeCollapse ?? c.measuredPixelSize ?? Z;
+        return {
+          ...c,
+          size: 0,
+          percentageSize: 0,
+          preferredPercentageSize: c.preferredPercentageSize,
+          sizeBeforeCollapse: Z,
+          percentageSizeBeforeCollapse: c.percentageSizeBeforeCollapse ?? c.percentageSize ?? c.preferredPercentageSize ?? 0,
+          preferredPercentageSizeBeforeCollapse: c.preferredPercentageSizeBeforeCollapse ?? c.preferredPercentageSize ?? c.percentageSize ?? void 0,
+          preferredPixelSizeBeforeCollapse: c.preferredPixelSizeBeforeCollapse ?? c.preferredPixelSize ?? Z,
+          measuredPixelSizeBeforeCollapse: Q
+        };
+      }
+      if (c.sizeUnit === "pixels" || c.originalPixelSize !== void 0) {
+        const I = c.size, U = g > 0 ? me(I, g) : 0, Z = {
+          ...c,
+          size: I,
+          percentageSize: U,
+          preferredPixelSize: c.preferredPixelSize ?? c.originalPixelSize ?? I,
+          preferredPercentageSize: c.preferredPercentageSize !== void 0 ? c.preferredPercentageSize : U > 0 ? U : void 0
+        };
+        if (c.collapseFromStart || c.collapseFromEnd) {
+          const Q = c.sizeBeforeCollapse ?? I, Se = c.measuredPixelSizeBeforeCollapse ?? c.measuredPixelSize ?? Q;
+          Z.sizeBeforeCollapse = Q, Z.measuredPixelSizeBeforeCollapse = Se, Z.preferredPixelSizeBeforeCollapse = c.preferredPixelSizeBeforeCollapse ?? c.preferredPixelSize ?? Q;
+        }
+        return Z;
+      }
+      if (c.sizeUnit === "percentage") {
+        const I = V.indexOf(c.id), U = I !== -1 ? F[I] : 0, Z = q(c.minSize, 0, g), Q = q(c.maxSize, g, g), Se = Math.max(
+          Z,
+          c.sizeBeforeCollapse ?? 0,
+          c.measuredPixelSizeBeforeCollapse ?? 0,
+          c.measuredPixelSize ?? 0,
+          c.originalPixelSize ?? 0,
+          c.size > 0 ? c.size : 0,
+          c.percentageSize !== void 0 ? Te(c.percentageSize, g) : 0,
+          1
+        ), Be = U > 0 ? U : Se;
+        let be;
+        if (!L)
+          be = Z;
+        else if (I !== -1 && N > 0) {
+          const Me = Be / N, Fe = w * Me;
+          be = ze(Fe, Z, Q);
+        } else {
+          const Me = c.percentageSize !== void 0 ? Te(c.percentageSize, g) : c.size, Fe = Me > 0 ? Me : Be;
+          be = ze(Fe, Z, Q);
+        }
+        const Re = g > 0 ? me(be, g) : 0, Ie = {
+          ...c,
+          size: be,
+          percentageSize: Re,
+          preferredPercentageSize: c.preferredPercentageSize !== void 0 ? c.preferredPercentageSize : Re > 0 ? Re : void 0
+        };
+        if (c.collapseFromStart || c.collapseFromEnd) {
+          const Me = c.sizeBeforeCollapse ?? be, Fe = c.measuredPixelSizeBeforeCollapse ?? c.measuredPixelSize ?? Me;
+          Ie.sizeBeforeCollapse = Me, Ie.measuredPixelSizeBeforeCollapse = Fe, Ie.preferredPixelSizeBeforeCollapse = c.preferredPixelSizeBeforeCollapse ?? c.preferredPixelSize ?? Me;
+        }
+        return Ie;
+      }
+      return c;
+    }), oe = [];
+    for (let c = 0; c < K.length; c += 1) {
+      const I = K[c];
+      I.sizeUnit === "percentage" && !I.collapsed && oe.push(c);
+    }
+    const Y = oe.reduce((c, I) => c + K[I].size, 0), se = T - Y;
+    Math.abs(se) > 0 && mt(K, se, g, { enforceAutoMinSize: !0 }), i({ type: "SET_PANELS", panels: K }), J.current = l.length, o(!0);
+  }, [l, t, f.width, f.height, a, x]);
+  re(() => {
+    const h = t === "horizontal" ? f.width : f.height, g = h > 0, M = g && l.length > 0, p = M ? l.reduce((N, T) => {
+      if (T.collapsed)
+        return N;
+      const w = q(T.minSize, 0, h);
+      return N + Math.max(0, w);
+    }, 0) : null, E = M ? l.reduce((N, T) => {
+      if (T.collapsed)
+        return N;
+      const w = q(T.maxSize, h, h);
+      return N + Math.max(0, w);
+    }, 0) : null, R = p ?? x?.totalMinimumSize ?? null, _ = E ?? x?.totalMaximumSize ?? null;
+    if (!g) {
+      x && C((N) => !N || N.availableContainerSize === h ? N : {
+        reason: N.reason,
+        // totalMinimumSize: previous.totalMinimumSize,
+        // totalMaximumSize: previous.totalMaximumSize,
+        totalMinimumSize: null,
+        totalMaximumSize: null,
+        availableContainerSize: h
+      });
+      return;
+    }
+    const V = R !== null && R - h > Number.EPSILON, F = _ !== null && h - _ > Number.EPSILON;
+    if (V || F) {
+      const T = {
+        reason: V ? "minimum-exceeded" : "maximum-insufficient",
+        totalMinimumSize: R,
+        totalMaximumSize: _,
+        availableContainerSize: h
+      };
+      C((w) => w && w.reason === T.reason && Math.abs((w.totalMinimumSize ?? 0) - (T.totalMinimumSize ?? 0)) <= Number.EPSILON && Math.abs((w.totalMaximumSize ?? 0) - (T.totalMaximumSize ?? 0)) <= Number.EPSILON && Math.abs(w.availableContainerSize - T.availableContainerSize) <= Number.EPSILON ? w : T);
+      return;
+    }
+    if (x) {
+      const N = x.reason === "minimum-exceeded", T = x.reason === "maximum-insufficient";
+      (!N || R !== null) && (!T || _ !== null) && !V && !F && C((Y) => Y && null);
+    }
+  }, [l, t, f.width, f.height, x]), re(() => {
+    j();
+  }, [j]), re(() => {
+    D.current = n;
+  }, [n]);
+  const b = te(() => l.map((h) => h.size), [l]);
+  je(() => {
+    b.length > 0 && D.current && D.current(b);
+  }, [b]), re(() => {
+    if (d && b.length > 0) {
+      const h = setTimeout(() => {
+        At(d, b);
+      }, 200);
+      return () => clearTimeout(h);
+    }
+  }, [d, b]), re(() => {
+    if (!d || l.length === 0 || X.current)
+      return;
+    const h = t === "horizontal" ? f.width : f.height;
+    if (h <= 0)
+      return;
+    const g = Lt(d);
+    if (g && g.length === l.length) {
+      const M = l.map((p, E) => {
+        const R = q(p.minSize, 0, h), _ = q(p.maxSize, h, h), V = ze(g[E], R, _), F = me(V, h), N = p.sizeUnit === "pixels" || p.originalPixelSize !== void 0 ? V : p.preferredPixelSize;
+        return {
+          ...p,
+          size: V,
+          percentageSize: F,
+          preferredPercentageSize: F > 0 ? F : p.preferredPercentageSize,
+          preferredPixelSize: N
+        };
+      });
+      i({ type: "SET_PANELS", panels: M }), X.current = !0;
+    }
+  }, [d, l, f.width, f.height, t]);
+  const H = pe((h) => {
+    const g = W.current, M = ee.current, p = JSON.stringify({
+      id: h.id,
+      size: h.size ?? null,
+      percentageSize: h.percentageSize ?? null,
+      preferredPercentageSize: h.preferredPercentageSize ?? null,
+      preferredPixelSize: h.preferredPixelSize ?? null,
+      sizeUnit: h.sizeUnit,
+      originalPixelSize: h.originalPixelSize ?? null,
+      minSize: h.minSize ?? null,
+      maxSize: h.maxSize ?? null,
+      collapseFromStart: h.collapseFromStart,
+      collapseFromEnd: h.collapseFromEnd,
+      collapsed: h.collapsed ?? !1,
+      collapsedByDirection: h.collapsedByDirection ?? null,
+      sizeBeforeCollapse: h.sizeBeforeCollapse ?? null,
+      percentageSizeBeforeCollapse: h.percentageSizeBeforeCollapse ?? null,
+      preferredPercentageSizeBeforeCollapse: h.preferredPercentageSizeBeforeCollapse ?? null,
+      preferredPixelSizeBeforeCollapse: h.preferredPixelSizeBeforeCollapse ?? null,
+      pixelAdjustPriority: h.pixelAdjustPriority ?? null
+    });
+    if (M[h.id] === p) {
+      _e.debug("useResizablePanels.registerPanel skipped", {
+        panelId: h.id,
+        reason: "duplicate-registration"
+      });
+      return;
+    }
+    M[h.id] = p, _e.debug("useResizablePanels.registerPanel", {
+      panelId: h.id,
+      containerReady: O.current,
+      violationReason: B.current,
+      containerSize: {
+        width: g.width,
+        height: g.height
+      }
+    }), i({ type: "REGISTER_PANEL", panel: h });
+  }, []), he = pe((h) => {
+    const g = W.current;
+    _e.debug("useResizablePanels.unregisterPanel", {
+      panelId: h,
+      containerReady: O.current,
+      violationReason: B.current,
+      containerSize: {
+        width: g.width,
+        height: g.height
+      }
+    }), i({ type: "UNREGISTER_PANEL", id: h }), delete ee.current[h], v((M) => {
+      if (!(h in M))
+        return M;
+      const p = { ...M };
+      return delete p[h], p;
+    });
+  }, []), ce = pe(
+    (h, g, M, p) => {
+      const E = t === "horizontal" ? f.width : f.height, R = l.find((Y) => Y.id === h), _ = l.find((Y) => Y.id === g);
+      if (!(R && _)) {
+        i({ type: "RESIZE_PANELS", leftId: h, rightId: g, leftSize: M, rightSize: p, containerSize: E });
+        return;
+      }
+      if (R.collapsed || _.collapsed)
+        return;
+      const V = q(R.minSize, 0, E), F = q(R.maxSize, E, E), N = q(_.minSize, 0, E), T = q(_.maxSize, E, E);
+      let w = ze(M, V, F), L = ze(p, N, T);
+      const K = w + L, oe = M + p;
+      if (K !== oe) {
+        const Y = oe - K;
+        if (Y > 0) {
+          const se = F - w, c = T - L, I = se + c;
+          if (I > 0) {
+            const U = Math.min(Y * (se / I), se), Z = Math.min(Y - U, c);
+            w += U, L += Z;
+          }
+        } else if (Y < 0) {
+          const se = Math.abs(Y), c = w - V, I = L - N, U = c + I;
+          if (U > 0) {
+            const Z = Math.min(se * (c / U), c), Q = Math.min(se - Z, I);
+            w -= Z, L -= Q;
+          }
+        }
+      }
+      w = ze(w, V, F), L = ze(L, N, T), w + L !== oe && _e.error("Total size after constraints should be close to the original total size.", { constrainedLeftSize: w, constrainedRightSize: L, originalTotalSize: oe }), i({ type: "RESIZE_PANELS", leftId: h, rightId: g, leftSize: w, rightSize: L, containerSize: E });
+    },
+    [t, f.width, f.height, l]
+  ), ge = pe(
+    (h, g) => {
+      const M = t === "horizontal" ? f.width : f.height;
+      i({ type: "COLLAPSE_PANEL", id: h, from: g, containerSize: M });
+    },
+    [t, f.width, f.height]
+  ), Pe = pe(
+    (h, g, M) => {
+      const p = t === "horizontal" ? f.width : f.height;
+      i({ type: "EXPAND_PANEL", id: h, from: g, containerSize: p, targetSize: M });
+    },
+    [t, f.width, f.height]
+  ), ne = pe(
+    (h) => l.find((g) => g.id === h),
+    [l]
+  ), de = pe((h, g) => {
+    v((M) => {
+      if (g === null) {
+        if (!(h in M))
+          return M;
+        const E = { ...M };
+        return delete E[h], E;
+      }
+      const p = M[h];
+      return p && p.pixelSize === g.pixelSize && p.percentageSize === g.percentageSize ? M : {
+        ...M,
+        [h]: g
+      };
+    });
+  }, []), fe = pe((h, g) => {
+    y((M) => {
+      if (g === null) {
+        if (!(h in M))
+          return M;
+        const E = { ...M };
+        return delete E[h], E;
+      }
+      const p = M[h];
+      return p && Math.abs(p.thickness - g.thickness) <= 0.25 && p.visible === g.visible && p.direction === g.direction && p.startPanelId === g.startPanelId && p.endPanelId === g.endPanelId ? M : {
+        ...M,
+        [h]: g
+      };
+    });
+  }, []), xe = te(
+    () => ({
+      direction: t,
+      panels: l,
+      containerSize: f,
+      isContainerReady: z,
+      showDebugInfo: r,
+      registerPanel: H,
+      unregisterPanel: he,
+      resizePanels: ce,
+      collapsePanel: ge,
+      expandPanel: Pe,
+      getPanel: ne,
+      reportPanelMeasurement: de,
+      panelMeasurements: P,
+      reportHandleMeasurement: fe,
+      handleMeasurements: S,
+      layoutConstraintViolation: x
+    }),
+    [t, l, f, z, r, H, he, ce, ge, Pe, ne, de, P, fe, S, x]
+  ), ve = te(
+    () => ({
+      display: "flex",
+      flexDirection: t === "horizontal" ? "row" : "column",
+      alignItems: "stretch",
+      width: "100%",
+      height: "100%",
+      minWidth: "0px",
+      minHeight: "0px",
+      position: "relative",
+      overflow: "hidden",
+      // リサイズハンドルのはみ出しでスクロールバーを表示させない
+      ...e
+    }),
+    [t, e]
+  );
+  return {
+    groupRef: m,
+    contextValue: xe,
+    groupStyle: ve
+  };
+}, di = (t) => {
+  const { getPanel: e, collapsePanel: n, expandPanel: d } = Qe(), r = e(t), l = pe(
+    (u) => {
+      n(t, u);
+    },
+    [n, t]
+  ), i = pe(
+    (u, z) => {
+      d(t, u, z);
+    },
+    [d, t]
+  ), f = pe(
+    (u, z) => {
+      r?.collapsed ? i(u, z) : l(u);
+    },
+    [r?.collapsed, l, i]
+  );
+  return te(
+    () => ({
+      panel: r,
+      isCollapsed: r?.collapsed ?? !1,
+      canCollapseFromStart: r?.collapseFromStart ?? !1,
+      canCollapseFromEnd: r?.collapseFromEnd ?? !1,
+      collapse: l,
+      expand: i,
+      toggle: f
+    }),
+    [r, l, i, f]
+  );
+}, _t = ({ panel: t, measuredPixelSize: e, measuredPercentageSize: n, containerAxisSize: d, containerLabel: r }) => {
+  const l = t?.size, i = typeof l == "number" && Number.isFinite(l) ? `${l.toFixed(3)}px` : "-", f = t?.percentageSize !== void 0 ? `${t.percentageSize.toFixed(3)}%` : "-", u = Number.isFinite(e) ? `${e.toFixed(3)}px` : "-", z = Number.isFinite(n) ? `${n.toFixed(3)}%` : "-", s = Number.isFinite(d) ? `${d.toFixed(3)}px` : "-", a = `${i} / ${f}`, o = `${u} / ${z}`, x = t?.sizeUnit === "pixels" ? "Fixed" : "Flexible", C = [x, `${r}: ${s}`, `size (state): ${a}`, `size (measured): ${o}`];
+  return {
+    stateValueDisplay: a,
+    measuredValueDisplay: o,
+    containerDisplay: s,
+    headlineLabel: x,
+    titleText: C.join(`
+`)
+  };
+}, Tt = Ke(({ panel: t, measuredPixelSize: e, measuredPercentageSize: n, containerAxisSize: d, direction: r }) => {
+  const l = r === "horizontal" ? "container width" : "container height", { stateValueDisplay: i, measuredValueDisplay: f, containerDisplay: u, headlineLabel: z, titleText: s } = te(
+    () => _t({
+      panel: t,
+      measuredPixelSize: e,
+      measuredPercentageSize: n,
+      containerAxisSize: d,
+      containerLabel: l
+    }),
+    [t, e, n, d, l]
+  ), a = {
+    position: "absolute",
+    top: "2px",
+    right: "4px",
+    backgroundColor: "rgba(30, 41, 59, 0.6)",
+    color: "#fff",
+    padding: "4px 8px",
+    borderRadius: "6px",
+    fontSize: "11px",
+    fontFamily: "monospace",
+    pointerEvents: "auto",
+    zIndex: 10,
+    boxShadow: "0 2px 4px rgba(0,0,0,0.3)",
+    border: "1px solid rgba(255,255,255,0.1)",
+    maxWidth: "calc(100% - 12px)",
+    minWidth: "60px",
+    width: "fit-content",
+    overflow: "hidden"
+  }, o = {
+    display: "flex",
+    flexDirection: "column",
+    gap: "1px",
+    minWidth: "0",
+    width: "100%"
+  }, x = {
+    display: "flex",
+    justifyContent: "flex-start",
+    alignItems: "center",
+    gap: "6px",
+    fontSize: "10px",
+    color: "#ccc",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, C = {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    gap: "6px",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, P = {
+    marginLeft: "auto",
+    fontVariantNumeric: "tabular-nums",
+    whiteSpace: "nowrap"
+  };
+  return /* @__PURE__ */ A("div", { style: a, title: s, children: /* @__PURE__ */ le("div", { style: o, children: [
+    /* @__PURE__ */ A("div", { style: x, children: /* @__PURE__ */ A("span", { children: z }) }),
+    /* @__PURE__ */ le("div", { style: C, children: [
+      /* @__PURE__ */ A("span", { children: l }),
+      /* @__PURE__ */ A("span", { style: P, children: u })
+    ] }),
+    /* @__PURE__ */ le("div", { style: C, children: [
+      /* @__PURE__ */ A("span", { children: "size (state)" }),
+      /* @__PURE__ */ A("span", { style: P, children: i })
+    ] }),
+    /* @__PURE__ */ le("div", { style: C, children: [
+      /* @__PURE__ */ A("span", { children: "size (measured)" }),
+      /* @__PURE__ */ A("span", { style: P, children: f })
+    ] })
+  ] }) });
+}), Je = new Ge(Ve.INFO, "[resize-panels]"), kt = {
+  both: {
+    collapseFromStart: !0,
+    collapseFromEnd: !0
+  },
+  start: {
+    collapseFromStart: !0,
+    collapseFromEnd: !1
+  },
+  end: {
+    collapseFromStart: !1,
+    collapseFromEnd: !0
+  }
+}, Gt = (t) => {
+  if (!t)
+    return {
+      collapseFromStart: !1,
+      collapseFromEnd: !1
+    };
+  const e = kt[t.from];
+  if (!e)
+    throw new Error("Invalid collapsible configuration: unsupported 'from' value");
+  return e;
+}, ot = ({ ref: t, setState: e, panelIdRef: n, label: d }) => (r) => {
+  if (!Number.isFinite(r))
+    return;
+  const l = r < 0 ? 0 : r;
+  t.current !== l && (t.current = l, Je.debug(`commit ${d}`, {
+    panelId: n.current,
+    [d]: l
+  }), e(l));
+}, ui = Ke(
+  ({ id: t, defaultSize: e = { value: 50, unit: "percentage" }, minSize: n, maxSize: d, autoMinSize: r, className: l, style: i, children: f, order: u = 0, collapsible: z, defaultCollapsed: s = !1, pixelAdjustPriority: a, flexAdjustPriority: o, contentOverflow: x = "auto" }) => {
+    const { direction: C, registerPanel: P, unregisterPanel: v, getPanel: S, showDebugInfo: y, isContainerReady: m, reportPanelMeasurement: D, containerSize: X } = Qe(), J = ie(null), ae = ut(), W = ie(t || `panel-${ae}`), O = te(() => Gt(z), [z]), B = O.collapseFromStart || O.collapseFromEnd, ee = te(() => B ? O.collapseFromStart ? "start" : O.collapseFromEnd ? "end" : null : null, [B, O.collapseFromStart, O.collapseFromEnd]), k = B && s, $ = te(() => Xe(e), [e]), G = $?.unit === "pixels", j = G ? void 0 : $?.value, b = S(W.current), H = !!b?.collapsed, he = (b?.size ?? 0) <= 0, ce = H || he, [ge, Pe] = ye(() => G && $ ? $.value : b?.size !== void 0 ? b.size : 0), [ne, de] = ye(() => !G && $ ? $.value : b?.percentageSize !== void 0 ? b.percentageSize : 0), fe = ie(ne);
+    fe.current = ne;
+    const xe = ie(ge);
+    xe.current = ge;
+    const ve = te(
+      () => ot({
+        ref: xe,
+        setState: Pe,
+        panelIdRef: W,
+        label: "pixel"
+      }),
+      []
+    ), h = te(
+      () => ot({
+        ref: fe,
+        setState: de,
+        panelIdRef: W,
+        label: "percentage"
+      }),
+      []
+    ), g = pe(() => {
+      xe.current !== 0 && (xe.current = 0, Pe(0)), fe.current !== 0 && (fe.current = 0, de(0));
+    }, []);
+    re(() => {
+      if (!m)
+        return;
+      let w = 0;
+      if (G && $) {
+        let U = $.value;
+        n && typeof n == "object" && n.unit === "pixels" && (U = Math.max(U, n.value)), d && typeof d == "object" && d.unit === "pixels" && (U = Math.min(U, d.value)), w = U;
+      }
+      const L = k, K = L ? ee : null;
+      s && !B && Je.warn("Panel defaultCollapsed is ignored because collapsible configuration is not provided.");
+      const oe = B && L && G ? w : void 0, Y = B ? j : void 0, se = G ? w : void 0, c = {
+        id: W.current,
+        size: L ? 0 : w,
+        percentageSize: L ? 0 : j,
+        preferredPercentageSize: j,
+        preferredPixelSize: se,
+        sizeUnit: $?.unit || "percentage",
+        originalPixelSize: G ? w : void 0,
+        minSize: n,
+        maxSize: d,
+        collapseFromStart: O.collapseFromStart,
+        collapseFromEnd: O.collapseFromEnd,
+        collapsedByDirection: K,
+        collapsed: L,
+        sizeBeforeCollapse: oe,
+        percentageSizeBeforeCollapse: Y,
+        preferredPercentageSizeBeforeCollapse: B ? j : void 0,
+        preferredPixelSizeBeforeCollapse: B ? se : void 0,
+        pixelAdjustPriority: a,
+        flexAdjustPriority: o,
+        autoMinSize: r
+      };
+      return P(c), () => {
+        v(W.current), D(W.current, null);
+      };
+    }, [
+      r,
+      O.collapseFromEnd,
+      O.collapseFromStart,
+      s,
+      $,
+      o,
+      B,
+      m,
+      G,
+      d,
+      n,
+      a,
+      ee,
+      j,
+      P,
+      D,
+      k,
+      v
+    ]);
+    const M = b?.size ?? 0;
+    re(() => {
+      const w = J.current;
+      if (!w) return;
+      const L = () => {
+        if (!b)
+          return;
+        const c = w.parentElement;
+        if (!c) return;
+        const I = w.getBoundingClientRect(), U = Le(c, "horizontal"), Z = Le(c, "vertical"), Q = C === "horizontal" ? I.width : I.height, Se = C === "horizontal" ? U.inner : Z.inner, Be = qe(Se);
+        if (ce) {
+          g();
+          return;
+        }
+        const be = b.size ?? 0, Re = Math.max(2, Be * 0.5);
+        if (be > Be && Q < Re) {
+          Je.debug("skip noisy measurement", {
+            panelId: W.current,
+            expectedPanelSize: be,
+            measured: Q,
+            noiseThreshold: Re
+          });
+          return;
+        }
+        if (Q > 0) {
+          ve(Q), Se > 0 && h(Q / Se * 100);
+          return;
+        }
+        b.size !== void 0 && ve(b.size), b.percentageSize !== void 0 ? h(b.percentageSize) : b.sizeUnit === "pixels" && b.size !== void 0 && Se > 0 && h(b.size / Se * 100);
+      }, K = new ResizeObserver(() => {
+        L();
+      });
+      K.observe(w), L();
+      const oe = [], Y = new MutationObserver(() => {
+        (() => {
+          if (!J.current) return !1;
+          const I = J.current.getBoundingClientRect();
+          return (C === "horizontal" ? I.width : I.height) !== xe.current;
+        })() && setTimeout(L, 0);
+      }), se = w.parentElement;
+      return se && Y.observe(se, {
+        childList: !0,
+        subtree: !0,
+        attributes: !0,
+        attributeFilter: ["style", "class"]
+      }), () => {
+        K.disconnect(), Y.disconnect();
+        for (const c of oe)
+          clearTimeout(c);
+      };
+    }, [h, ve, b, C, ce, g]);
+    const p = b?.size, E = b?.percentageSize, R = b?.sizeUnit;
+    re(() => {
+      if (b) {
+        if (ce) {
+          g();
+          return;
+        }
+        if (p !== void 0 && ve(p), E !== void 0)
+          h(E);
+        else if (R === "pixels" && p !== void 0) {
+          const w = J.current, L = w?.parentElement;
+          if (w && L) {
+            const { width: K, height: oe } = w.getBoundingClientRect(), Y = L.clientWidth, se = L.clientHeight, c = C === "horizontal" ? K : oe, I = C === "horizontal" ? Y : se;
+            if (c > 0 && I > 0) {
+              const U = c / I * 100;
+              h(U);
+            }
+          }
+        }
+      }
+    }, [h, ve, b, E, p, R, C, ce, g]), re(() => {
+      D(W.current, {
+        pixelSize: ge,
+        percentageSize: ne
+      });
+    }, [D, ge, ne]);
+    const _ = () => ce ? "0px" : b?.originalPixelSize !== void 0 ? `${M}px` : b?.percentageSize !== void 0 ? `${b.percentageSize}%` : `${M}px`, V = b?.sizeUnit === "percentage" && !b?.collapsed ? 1 : 0, F = {
+      flexBasis: _(),
+      flexGrow: 0,
+      flexShrink: V,
+      overflow: "hidden",
+      position: "relative",
+      boxSizing: "border-box",
+      minHeight: "0px",
+      minWidth: "0px",
+      ...i
+    };
+    C === "horizontal" ? (F.height = "100%", F.minWidth = 0) : (F.width = "100%", F.minHeight = 0), ce && (C === "horizontal" ? (F.width = "0px", F.minWidth = "0px") : (F.height = "0px", F.minHeight = "0px"), F.flexGrow = 0, F.flexShrink = 0, F.pointerEvents = "none", F.visibility = "hidden", H && (F.display = "none"));
+    const N = C === "horizontal" ? X.width : X.height, T = te(
+      () => ({
+        position: "absolute",
+        inset: "0px",
+        overflow: x,
+        display: "flex",
+        flexDirection: "column",
+        width: "100%",
+        height: "100%",
+        minWidth: "0px",
+        minHeight: "0px"
+      }),
+      [x]
+    );
+    return /* @__PURE__ */ le(
+      "div",
+      {
+        ref: J,
+        className: ke("panel", l),
+        style: F,
+        "data-panel-id": W.current,
+        "data-panel-size": M,
+        "data-panel-size-unit": b?.sizeUnit || "percentage",
+        "data-panel-pixel-size": b?.sizeUnit === "pixels" ? b?.originalPixelSize : null,
+        "data-panel-order": u,
+        "data-panel-collapsible": B,
+        "data-panel-collapse-start": O.collapseFromStart,
+        "data-panel-collapse-end": O.collapseFromEnd,
+        "data-panel-collapsed": b?.collapsed,
+        "aria-hidden": ce,
+        children: [
+          /* @__PURE__ */ A("div", { style: T, children: f }),
+          y && /* @__PURE__ */ A(Tt, { panel: b, measuredPixelSize: ge, measuredPercentageSize: ne, containerAxisSize: N, direction: C })
+        ]
+      }
+    );
+  }
+), Ht = (t) => JSON.stringify(
+  t.map((e) => ({
+    id: e.id,
+    size: e.size,
+    percentageSize: e.percentageSize ?? null,
+    preferredPercentageSize: e.preferredPercentageSize ?? null,
+    preferredPixelSize: e.preferredPixelSize ?? null,
+    sizeUnit: e.sizeUnit,
+    originalPixelSize: e.originalPixelSize ?? null,
+    minSize: e.minSize ?? null,
+    maxSize: e.maxSize ?? null,
+    autoMinSize: e.autoMinSize ?? null,
+    collapseFromStart: e.collapseFromStart,
+    collapseFromEnd: e.collapseFromEnd,
+    collapsedByDirection: e.collapsedByDirection ?? null,
+    collapsed: e.collapsed ?? !1,
+    sizeBeforeCollapse: e.sizeBeforeCollapse ?? null,
+    preferredPercentageSizeBeforeCollapse: e.preferredPercentageSizeBeforeCollapse ?? null,
+    preferredPixelSizeBeforeCollapse: e.preferredPixelSizeBeforeCollapse ?? null,
+    measuredPixelSizeBeforeCollapse: e.measuredPixelSizeBeforeCollapse ?? null,
+    pixelAdjustPriority: e.pixelAdjustPriority ?? null,
+    flexAdjustPriority: e.flexAdjustPriority ?? null,
+    measuredPixelSize: e.measuredPixelSize ?? null,
+    measuredPercentageSize: e.measuredPercentageSize ?? null
+  }))
+), Ut = (t) => JSON.stringify(
+  t.map((e) => ({
+    id: e.id,
+    thickness: e.thickness,
+    visible: e.visible,
+    direction: e.direction,
+    startPanelId: e.startPanelId ?? null,
+    endPanelId: e.endPanelId ?? null
+  }))
+), Wt = () => {
+  const t = /* @__PURE__ */ new Set(), e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+  let d = null, r = 0, l = !0, i = [], f = {
+    ownerId: null,
+    groups: i
+  };
+  const u = () => {
+    for (const S of t)
+      S();
+  }, z = () => {
+    l = !0, u();
+  }, s = () => {
+    const S = d;
+    if (S && n.has(S))
+      return !1;
+    d = null;
+    const y = n.values().next();
+    return y.done || (d = y.value), S !== d;
+  };
+  return {
+    subscribe: (S) => (t.add(S), () => {
+      t.delete(S);
+    }),
+    getSnapshot: () => (s() && (l = !0), l && (i = Array.from(e.values()).sort((y, m) => y.index - m.index).map(({ serializedPanels: y, serializedHandles: m, ...D }) => D), f = {
+      ownerId: d,
+      groups: i
+    }, l = !1), f),
+    getOwnerId: () => (s() && (l = !0), d),
+    enableGroup: (S) => {
+      const y = n.size;
+      n.add(S), n.size !== y && s() && z();
+    },
+    disableGroup: (S) => {
+      n.delete(S) && s() && z();
+    },
+    updateGroup: (S, y) => {
+      const m = e.get(S), D = m?.index ?? r++, X = Ht(y.panels), J = Ut(y.handles), ae = m?.displayName !== y.displayName, W = m?.direction !== y.direction, O = m ? m.containerSize.width !== y.containerSize.width || m.containerSize.height !== y.containerSize.height : !0;
+      let B = m?.serializedPanels !== X;
+      if (!B && m)
+        if (m.panels.length !== y.panels.length)
+          B = !0;
+        else
+          for (let j = 0; j < y.panels.length; j += 1) {
+            const b = m.panels[j], H = y.panels[j];
+            if (!(b && H)) {
+              B = !0;
+              break;
+            }
+            if (b.id !== H.id || b.size !== H.size || b.percentageSize !== H.percentageSize || b.collapsed !== H.collapsed || b.measuredPixelSize !== H.measuredPixelSize || b.measuredPercentageSize !== H.measuredPercentageSize) {
+              B = !0;
+              break;
+            }
+          }
+      let ee = m?.serializedHandles !== J;
+      if (!ee && m)
+        if (m.handles.length !== y.handles.length)
+          ee = !0;
+        else
+          for (let j = 0; j < y.handles.length; j += 1) {
+            const b = m.handles[j], H = y.handles[j];
+            if (!(b && H)) {
+              ee = !0;
+              break;
+            }
+            if (b.id !== H.id || b.thickness !== H.thickness || b.visible !== H.visible || b.direction !== H.direction || b.startPanelId !== H.startPanelId || b.endPanelId !== H.endPanelId) {
+              ee = !0;
+              break;
+            }
+          }
+      if (!m && y.panels.length === 0 && y.handles.length === 0 || m && !ae && !W && !O && !B && !ee)
+        return;
+      const k = y.panels.map((j) => ({ ...j })), $ = y.handles.map((j) => ({ ...j })), G = { ...y.containerSize };
+      e.set(S, {
+        groupId: S,
+        displayName: y.displayName,
+        direction: y.direction,
+        containerSize: G,
+        panels: k,
+        handles: $,
+        index: D,
+        serializedPanels: X,
+        serializedHandles: J
+      }), z();
+    },
+    removeGroup: (S) => {
+      const y = e.delete(S), m = n.delete(S), D = s();
+      (y || m || D) && z();
+    }
+  };
+}, Ee = Wt(), $t = () => ft(Ee.subscribe, Ee.getOwnerId, Ee.getOwnerId), jt = () => ft(Ee.subscribe, Ee.getSnapshot, Ee.getSnapshot), Vt = (t) => {
+  Ee.enableGroup(t);
+}, st = (t) => {
+  Ee.disableGroup(t);
+}, Yt = (t, e) => {
+  Ee.updateGroup(t, e);
+}, at = (t) => {
+  Ee.removeGroup(t);
+};
+let lt = 0;
+const Zt = () => (lt += 1, `panel-group-${lt}`), De = (t, e) => typeof t != "number" || !Number.isFinite(t) ? "—" : `${(t < 0 ? 0 : t).toFixed(8)}${e}`, Xt = {
+  position: "fixed",
+  left: "50%",
+  bottom: "20px",
+  transform: "translate(-50%, 0)",
+  zIndex: 100,
+  maxWidth: "min(90vw, 1120px)",
+  width: "100%",
+  borderRadius: "14px",
+  backgroundColor: "rgba(15, 23, 42, 0.72)",
+  color: "#e2e8f0",
+  fontFamily: "monospace",
+  fontSize: "11px",
+  lineHeight: 1.6,
+  boxShadow: "0 22px 45px rgba(15,23,42,0.45)",
+  border: "1px solid rgba(148, 163, 184, 0.22)",
+  backdropFilter: "blur(10px)",
+  WebkitBackdropFilter: "blur(10px)",
+  pointerEvents: "auto",
+  overflow: "auto"
+}, qt = {
+  display: "flex",
+  justifyContent: "space-between",
+  alignItems: "center",
+  flexWrap: "wrap",
+  gap: "12px"
+}, Jt = {
+  display: "flex",
+  flexDirection: "column",
+  gap: "4px"
+}, Kt = {
+  padding: "6px 10px",
+  borderRadius: "9999px",
+  border: "1px solid rgba(148, 163, 184, 0.35)",
+  color: "#e2e8f0",
+  fontWeight: 600,
+  fontSize: "10px",
+  letterSpacing: "0.03em",
+  textTransform: "uppercase",
+  cursor: "pointer",
+  transition: "background-color 0.18s ease, border-color 0.18s ease"
+}, Qt = {
+  padding: "10px 12px",
+  borderRadius: "10px",
+  backgroundColor: "rgba(30, 41, 59, 0.55)",
+  border: "1px solid rgba(148, 163, 184, 0.18)",
+  display: "flex",
+  flexDirection: "column",
+  gap: "10px"
+}, ei = {
+  padding: "8px 10px",
+  borderRadius: "8px",
+  backgroundColor: "rgba(15, 23, 42, 0.55)",
+  border: "1px solid rgba(148, 163, 184, 0.16)",
+  display: "flex",
+  flexDirection: "column",
+  gap: "4px"
+}, ct = {
+  display: "flex",
+  justifyContent: "space-between",
+  alignItems: "center",
+  gap: "6px"
+}, ti = {
+  display: "grid",
+  gridTemplateColumns: "auto 1fr",
+  gap: "2px 10px",
+  color: "#e2e8f0"
+}, ii = {
+  padding: "2px 6px",
+  borderRadius: "9999px",
+  fontSize: "10px",
+  textTransform: "uppercase"
+}, ri = (t) => {
+  const e = t.reason === "minimum-exceeded", n = e ? "Layout unavailable: minimum panel sizes exceed the container." : "Layout unavailable: panels cannot fill the container with their maximum sizes.", d = e ? `Min required: ${Math.ceil(t.totalMinimumSize ?? 0)}px | Available: ${Math.floor(t.availableContainerSize)}px` : `Max total: ${Math.floor(t.totalMaximumSize ?? 0)}px | Needed: ${Math.floor(t.availableContainerSize)}px`;
+  return { summary: n, detail: d };
+}, ni = (t, e) => {
+  let n = !1;
+  const d = t.map((r) => {
+    const l = e[r.id];
+    return !l || r.measuredPixelSize === l.pixelSize && r.measuredPercentageSize === l.percentageSize ? r : (n = !0, {
+      ...r,
+      measuredPixelSize: l.pixelSize,
+      measuredPercentageSize: l.percentageSize
+    });
+  });
+  return n ? d : t;
+}, dt = (t, e, n) => {
+  const d = Le(t, "horizontal"), r = Le(t, "vertical"), l = t.getBoundingClientRect(), i = d.inner > 0 ? d.inner : e ?? l.width, f = r.inner > 0 ? r.inner : n ?? l.height;
+  return { width: i, height: f };
+}, fi = (t) => {
+  const { id: e, className: n, style: d, children: r, direction: l } = t, { groupRef: i, contextValue: f, groupStyle: u } = Ot(t), [z, s] = ye({ width: 0, height: 0 }), a = f.layoutConstraintViolation, o = !!a, x = te(() => {
+    if (!a)
+      return null;
+    const { summary: k, detail: $ } = ri(a);
+    return /* @__PURE__ */ le(
+      "div",
+      {
+        className: "flex w-full flex-1 flex-col items-center justify-center gap-2 rounded-lg border border-slate-300 border-dashed bg-slate-100/70 px-6 py-8 text-center text-slate-600 text-sm dark:border-slate-600 dark:bg-slate-800/50 dark:text-slate-200",
+        "data-panel-group-placeholder": "constraint-violation",
+        children: [
+          /* @__PURE__ */ A("span", { children: k }),
+          /* @__PURE__ */ A("span", { className: "text-slate-500 text-xs dark:text-slate-400", children: $ })
+        ]
+      }
+    );
+  }, [a]), P = ie(e ?? Zt()).current, v = e ?? P, S = f.showDebugInfo && f.panels.length > 0, y = S ? f.panels : [], m = S ? f.panelMeasurements : {}, D = te(() => {
+    if (!S)
+      return [];
+    const k = Object.values(f.handleMeasurements);
+    return k.length <= 1 ? k : k.slice().sort(($, G) => $.id.localeCompare(G.id));
+  }, [f.handleMeasurements, S]), X = f.containerSize, J = z.width > 0 ? z.width : X.width, ae = z.height > 0 ? z.height : X.height, W = $t(), O = S && W === P;
+  je(() => {
+    if (!S) {
+      s({ width: 0, height: 0 });
+      return;
+    }
+    if (typeof window > "u" || typeof ResizeObserver > "u")
+      return;
+    const k = i.current;
+    if (!k)
+      return;
+    const $ = (j) => {
+      s((b) => b.width === j.width && b.height === j.height ? b : j);
+    }, G = new ResizeObserver((j) => {
+      for (const b of j) {
+        if (b.target !== k)
+          continue;
+        const H = dt(k, b.contentRect.width, b.contentRect.height);
+        $(H);
+      }
+    });
+    return G.observe(k), $(dt(k)), () => {
+      G.disconnect();
+    };
+  }, [i, S]);
+  const B = te(() => ni(y, m), [y, m]);
+  re(() => {
+    if (!S) {
+      st(P), at(P);
+      return;
+    }
+    return Vt(P), () => {
+      st(P), at(P);
+    };
+  }, [S, P]), re(() => {
+    S && Yt(P, {
+      displayName: v,
+      direction: l,
+      containerSize: {
+        width: J,
+        height: ae
+      },
+      panels: B,
+      handles: D
+    });
+  }, [S, P, v, l, J, ae, B, D]);
+  const ee = te(() => {
+    const k = {
+      ...u,
+      ...d
+    };
+    return k.position || (k.position = "relative"), k;
+  }, [u, d]);
+  return /* @__PURE__ */ le(pt.Provider, { value: f, children: [
+    /* @__PURE__ */ le("div", { ref: i, className: ke("panel-group", l === "horizontal" ? "flex-row" : "flex-col", n), style: ee, "data-panel-group-id": e, "data-panel-group-direction": l, children: [
+      r,
+      o && x ? /* @__PURE__ */ A(
+        "div",
+        {
+          className: "pointer-events-auto",
+          style: {
+            position: "absolute",
+            inset: 0,
+            zIndex: 40,
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            backgroundColor: "rgba(248, 250, 252, 0.82)",
+            backdropFilter: "blur(2px)"
+          },
+          children: x
+        }
+      ) : null
+    ] }),
+    O && /* @__PURE__ */ A(oi, {})
+  ] });
+}, oi = () => {
+  const e = jt().groups, [n, d] = ye(!0);
+  if (e.length === 0 || typeof document > "u")
+    return null;
+  const r = e.reduce((u, z) => u + z.panels.length, 0), l = e.reduce((u, z) => u + (z.handles?.length ?? 0), 0), i = () => d((u) => !u), f = /* @__PURE__ */ le(
+    "div",
+    {
+      style: {
+        ...Xt,
+        padding: n ? "10px 18px" : "14px 18px",
+        maxHeight: n ? "52px" : "min(65vh, 520px)",
+        transition: "max-height 0.24s ease, padding 0.24s ease"
+      },
+      children: [
+        /* @__PURE__ */ le(
+          "div",
+          {
+            style: {
+              ...qt,
+              marginBottom: n ? 0 : "12px"
+            },
+            children: [
+              /* @__PURE__ */ le("div", { style: Jt, children: [
+                /* @__PURE__ */ A(
+                  "span",
+                  {
+                    style: {
+                      fontWeight: 700,
+                      fontSize: "12px",
+                      letterSpacing: "0.03em"
+                    },
+                    children: "Panel Overview"
+                  }
+                ),
+                /* @__PURE__ */ le("span", { style: { color: "#cbd5f5" }, children: [
+                  "groups: ",
+                  e.length,
+                  " / panels: ",
+                  r,
+                  " / resizers: ",
+                  l
+                ] })
+              ] }),
+              /* @__PURE__ */ A(
+                "button",
+                {
+                  type: "button",
+                  onClick: i,
+                  style: {
+                    ...Kt,
+                    backgroundColor: n ? "rgba(59, 130, 246, 0.2)" : "rgba(71, 85, 105, 0.45)"
+                  },
+                  title: n ? "Panel Overview を開く" : "Panel Overview を閉じる",
+                  children: n ? "開く" : "閉じる"
+                }
+              )
+            ]
+          }
+        ),
+        !n && /* @__PURE__ */ A(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              gap: "12px",
+              maxHeight: "45vh",
+              overflowY: "auto",
+              paddingRight: "6px"
+            },
+            children: e.map((u, z) => {
+              const s = u.direction === "horizontal" ? u.containerSize.width : u.containerSize.height;
+              return /* @__PURE__ */ le("div", { style: Qt, children: [
+                /* @__PURE__ */ le(
+                  "div",
+                  {
+                    style: {
+                      ...ct,
+                      flexWrap: "wrap",
+                      gap: "10px",
+                      color: "#dbeafe"
+                    },
+                    children: [
+                      /* @__PURE__ */ le(
+                        "span",
+                        {
+                          style: {
+                            fontWeight: 600,
+                            fontSize: "11px",
+                            letterSpacing: "0.02em",
+                            textTransform: "uppercase"
+                          },
+                          children: [
+                            "group ",
+                            z + 1,
+                            ": ",
+                            u.displayName
+                          ]
+                        }
+                      ),
+                      /* @__PURE__ */ le("span", { children: [
+                        "direction: ",
+                        u.direction,
+                        " / container: ",
+                        De(u.containerSize.width, "px"),
+                        " × ",
+                        De(u.containerSize.height, "px")
+                      ] })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ A(
+                  "div",
+                  {
+                    style: {
+                      display: "grid",
+                      gridTemplateColumns: "repeat(auto-fill, minmax(220px, 1fr))",
+                      gap: "10px"
+                    },
+                    children: u.panels.map((a, o) => {
+                      const x = a.measuredPixelSize ?? a.size, C = a.size, P = De(C, "px"), v = a.percentageSize ?? (s > 0 ? a.size / s * 100 : void 0), S = a.measuredPercentageSize !== void 0 ? a.measuredPercentageSize : s > 0 ? x / s * 100 : void 0, y = a.collapsed || x <= gt, m = a.collapsed ? "collapsed" : y ? "hidden" : "visible", D = De(v, "%"), X = De(S, "%"), J = De(x, "px");
+                      return /* @__PURE__ */ le("div", { style: ei, children: [
+                        /* @__PURE__ */ le("div", { style: ct, children: [
+                          /* @__PURE__ */ A("span", { style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" }, children: a.id }),
+                          /* @__PURE__ */ A(
+                            "span",
+                            {
+                              style: {
+                                ...ii,
+                                backgroundColor: a.collapsed ? "rgba(251, 113, 133, 0.25)" : y ? "rgba(250, 204, 21, 0.25)" : "rgba(74, 222, 128, 0.25)",
+                                color: a.collapsed ? "#fecdd3" : y ? "#fef08a" : "#bbf7d0"
+                              },
+                              children: m
+                            }
+                          )
+                        ] }),
+                        /* @__PURE__ */ le("div", { style: ti, children: [
+                          /* @__PURE__ */ A("span", { children: "size (state):" }),
+                          /* @__PURE__ */ A("span", { children: P }),
+                          /* @__PURE__ */ A("span", { children: "size (measured):" }),
+                          /* @__PURE__ */ A("span", { children: J }),
+                          /* @__PURE__ */ A("span", { children: "percentage (state):" }),
+                          /* @__PURE__ */ A("span", { children: D }),
+                          /* @__PURE__ */ A("span", { children: "percentage (measured):" }),
+                          /* @__PURE__ */ A("span", { children: X }),
+                          /* @__PURE__ */ A("span", { children: "unit:" }),
+                          /* @__PURE__ */ A("span", { children: a.sizeUnit }),
+                          /* @__PURE__ */ A("span", { children: "min:" }),
+                          /* @__PURE__ */ A("span", { children: a.minSize !== void 0 ? JSON.stringify(a.minSize) : "—" }),
+                          /* @__PURE__ */ A("span", { children: "auto min:" }),
+                          /* @__PURE__ */ A("span", { children: a.autoMinSize !== void 0 ? JSON.stringify(a.autoMinSize) : "—" }),
+                          /* @__PURE__ */ A("span", { children: "max:" }),
+                          /* @__PURE__ */ A("span", { children: a.maxSize !== void 0 ? JSON.stringify(a.maxSize) : "—" }),
+                          /* @__PURE__ */ A("span", { children: "priority:" }),
+                          /* @__PURE__ */ A("span", { children: a.pixelAdjustPriority ?? "—" }),
+                          /* @__PURE__ */ A("span", { children: "flex priority:" }),
+                          /* @__PURE__ */ A("span", { children: a.flexAdjustPriority ?? "—" })
+                        ] })
+                      ] }, a.id || o);
+                    })
+                  }
+                )
+              ] }, u.groupId);
+            })
+          }
+        )
+      ]
+    }
+  );
+  return Et(f, document.body);
+}, pi = Ke(({ id: t, disabled: e = !1, className: n, style: d, children: r, onDragging: l }) => {
+  const { direction: i, resizePanels: f, getPanel: u, collapsePanel: z, expandPanel: s, panels: a, reportHandleMeasurement: o, containerSize: x, layoutConstraintViolation: C } = Qe(), [P, v] = ye(!1), S = ie(null), y = ie(null), m = ie(""), D = ie(""), [X, J] = ye({ left: null, right: null }), ae = ut(), W = ie(t ?? `resize-handle-${ae}`), O = ie(null), B = t ?? W.current, ee = !!C, k = e || ee;
+  re(() => {
+    if (S.current) {
+      const p = S.current.parentElement;
+      if (p) {
+        y.current = p;
+        const E = Array.from(p.children), R = S.current, _ = E.indexOf(R);
+        if (_ > 0 && _ < E.length - 1) {
+          let V = null, F = null;
+          for (let N = _ - 1; N >= 0; N -= 1) {
+            const T = E[N];
+            if (T.dataset.panelId) {
+              V = T;
+              break;
+            }
+          }
+          for (let N = _ + 1; N < E.length; N += 1) {
+            const T = E[N];
+            if (T.dataset.panelId) {
+              F = T;
+              break;
+            }
+          }
+          m.current = V?.dataset.panelId || "", D.current = F?.dataset.panelId || "", J({
+            left: m.current || null,
+            right: D.current || null
+          });
+        }
+      }
+    }
+  }, []), re(() => {
+    if (B === W.current)
+      return;
+    const p = W.current;
+    W.current = B, O.current = null, p !== B && o(p, null);
+  }, [o, B]), re(() => {
+    const p = W.current;
+    return () => {
+      o(p, null);
+    };
+  }, [o]);
+  const $ = pe(
+    (p) => {
+      if (k || !y.current) return;
+      p.preventDefault(), p.stopPropagation();
+      const E = y.current, { inner: R } = Le(E, i), _ = { x: p.clientX, y: p.clientY }, V = u(m.current), F = u(D.current);
+      if (!(V && F)) return;
+      const N = V.size, T = F.size;
+      let w = 0;
+      const L = Rt;
+      v(!0), l?.(!0), p.currentTarget.setPointerCapture(p.pointerId);
+      const K = (Y) => {
+        if (!S.current) return;
+        Y.preventDefault(), Y.stopPropagation();
+        const se = performance.now();
+        if (se - w < L) return;
+        w = se;
+        const c = i === "horizontal" ? Y.clientX - _.x : Y.clientY - _.y;
+        if (c === 0)
+          return;
+        const I = N + c, U = T - c, Z = u(m.current), Q = u(D.current);
+        if (Z && Q && m.current && D.current) {
+          const Se = q(Z.minSize, 0, R), Be = q(Q.minSize, 0, R), be = Se, Re = Be, Ie = Math.min(R * ht, xt), Me = Math.min(R * It, Ft), Fe = Q.collapseFromStart, Pt = Q.collapsedByDirection ?? "start";
+          if (Fe && !Q.collapsed && U <= Math.max(Be * 0.3, Ie)) {
+            z(D.current, "start");
+            return;
+          }
+          const bt = Z.collapseFromEnd, Ct = Z.collapsedByDirection ?? "end";
+          if (bt && !Z.collapsed && I <= Math.max(Se * 0.3, Ie)) {
+            z(m.current, "end");
+            return;
+          }
+          if (Q.collapsed && U > Math.max(Be * 0.3, Me)) {
+            s(D.current, Pt, U);
+            return;
+          }
+          if (Z.collapsed && I > Math.max(Se * 0.3, Me)) {
+            s(m.current, Ct, I);
+            return;
+          }
+          if (R > 0) {
+            const et = Z.size + Q.size, He = qe(R);
+            let Ye = !1;
+            if (be <= He && I <= He && N !== 0) {
+              const Oe = Math.max(0, et - 0);
+              Oe >= Re && (f(m.current, D.current, 0, Oe), Ye = !0);
+            } else if (Re <= He && U <= He && T !== 0) {
+              const Oe = Math.max(0, et - 0);
+              Oe >= be && (f(m.current, D.current, Oe, 0), Ye = !0);
+            }
+            if (Ye)
+              return;
+          }
+          if (Z.collapsed || Q.collapsed)
+            return;
+          f(m.current, D.current, I, U);
+        }
+      }, oe = () => {
+        v(!1), l?.(!1), document.removeEventListener("pointermove", K), document.removeEventListener("pointerup", oe);
+      };
+      document.addEventListener("pointermove", K), document.addEventListener("pointerup", oe);
+    },
+    [k, i, f, u, z, s, l]
+  ), G = i === "horizontal", b = ke(
+    "group absolute z-20 flex select-none items-center justify-center border-none bg-transparent transition-colors duration-150 overflow-visible",
+    G ? "cursor-col-resize" : "cursor-row-resize",
+    G ? "h-full" : "w-full",
+    !k && "hover:bg-gray-200/70 dark:hover:bg-gray-700/70",
+    !k && "active:bg-blue-300/60 dark:active:bg-blue-700/60",
+    P && "bg-blue-200/80 dark:bg-blue-800/60",
+    k && "cursor-not-allowed opacity-50",
+    "focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-opacity-50",
+    n
+  ), H = te(() => {
+    const p = (E) => {
+      if (!E)
+        return -1;
+      for (let R = 0; R < a.length; R += 1)
+        if (a[R].id === E)
+          return R;
+      return -1;
+    };
+    return {
+      left: p(X.left),
+      right: p(X.right)
+    };
+  }, [X.left, X.right, a]), he = G ? x.width : x.height, ce = te(() => {
+    const p = (E, R) => {
+      if (E > R)
+        return 0;
+      let _ = 0;
+      for (let V = E; V <= R; V += 1) {
+        const F = a[V];
+        if (!F)
+          continue;
+        const N = F.size ?? 0, T = Math.max(0, N);
+        _ += F.collapsed ? 0 : T;
+      }
+      return _;
+    };
+    return H.left >= 0 ? p(0, H.left) : H.right > 0 ? p(0, H.right - 1) : 0;
+  }, [H.left, H.right, a]), ge = te(() => !Number.isFinite(ce) || ce < 0 ? 0 : he > 0 && ce > he ? he : ce, [ce, he]), Pe = te(() => {
+    const p = {
+      position: "absolute",
+      zIndex: 20,
+      touchAction: "none"
+    };
+    return G ? (p.top = 0, p.left = `${ge}px`, p.transform = "translateX(-50%)", p.width = `${tt}px`, p.height = "100%") : (p.left = 0, p.top = `${ge}px`, p.transform = "translateY(-50%)", p.height = `${tt}px`, p.width = "100%"), p;
+  }, [ge, G]), ne = te(() => {
+    const p = qe(he), E = (L) => {
+      if (L < 0 || L >= a.length)
+        return !1;
+      const K = a[L];
+      return K ? K.collapsed ? !0 : K.size <= p : !1;
+    }, R = (L, K) => {
+      if (!E(L))
+        return 0;
+      let oe = 0;
+      for (let Y = L; Y >= 0 && Y < a.length && E(Y); Y += K)
+        oe += 1;
+      return oe;
+    }, _ = H.left, V = H.right, F = _ >= 0 ? R(_, -1) : 0, N = V >= 0 ? R(V, 1) : 0;
+    return {
+      groupSize: F + N + 1,
+      overlapIndex: F
+    };
+  }, [H.left, H.right, a, he]), de = te(() => {
+    if (ee)
+      return !0;
+    if (ne.groupSize <= 1)
+      return !1;
+    const p = ne.groupSize - 1;
+    return ne.overlapIndex > 0 && ne.overlapIndex < p;
+  }, [ne, ee]), fe = te(() => {
+    if (ne.groupSize <= 1 || de)
+      return 0;
+    const p = ne.groupSize > 1 ? 2 : 1;
+    if (p === 1)
+      return 0;
+    const E = ne.overlapIndex === 0 ? 0 : p - 1, R = (p - 1) / 2;
+    return (E - R) * Bt;
+  }, [ne, de]), xe = te(() => {
+    if (de)
+      return { display: "none" };
+    if (fe !== 0)
+      return G ? { transform: `translateX(${fe}px)` } : { transform: `translateY(${fe}px)` };
+  }, [fe, G, de]), ve = ke(
+    "flex items-center justify-center rounded-full bg-white text-slate-700 ring-1 ring-inset ring-white/80 backdrop-blur-sm transition-colors duration-150 shadow-[0_0_0_1px_rgba(255,255,255,0.85),0_1px_3px_rgba(15,23,42,0.18)]",
+    "dark:bg-slate-800/95 dark:text-slate-200 dark:ring-slate-500/60 dark:shadow-[0_0_0_1px_rgba(148,163,184,0.45),0_1px_3px_rgba(2,6,23,0.55)]",
+    G ? "h-12 w-[6px] px-[2px]" : "h-[6px] w-20 py-[2px]",
+    P && "bg-blue-200/80 ring-blue-300 shadow-[0_0_0_1px_rgba(191,219,254,0.65),0_1px_4px_rgba(59,130,246,0.45)] dark:bg-blue-900/70 dark:ring-blue-400 dark:shadow-[0_0_0_1px_rgba(147,197,253,0.5),0_1px_4px_rgba(59,130,246,0.55)]"
+  ), h = ke(
+    "rounded-full bg-slate-600 transition-colors duration-150 shadow-[0_0_0_1px_rgba(255,255,255,0.9)] dark:bg-slate-200 dark:shadow-[0_0_0_1px_rgba(15,23,42,0.55)]",
+    G ? "h-8 w-[2px]" : "h-[2px] w-16",
+    P && "bg-blue-500 dark:bg-blue-300",
+    !k && "group-hover:bg-slate-700 dark:group-hover:bg-slate-100"
+  ), g = pe(() => {
+    const p = S.current;
+    if (!p)
+      return;
+    let E = 0;
+    if (!de) {
+      const V = i === "horizontal" ? p.offsetWidth : p.offsetHeight;
+      let F = 0, N = 0;
+      if (typeof window < "u") {
+        const w = window.getComputedStyle(p);
+        i === "horizontal" ? (F = Number.parseFloat(w.marginLeft || "0"), N = Number.parseFloat(w.marginRight || "0")) : (F = Number.parseFloat(w.marginTop || "0"), N = Number.parseFloat(w.marginBottom || "0"));
+      }
+      E = [V, F, N].reduce((w, L) => Number.isFinite(L) ? w + L : w, 0);
+    }
+    (!Number.isFinite(E) || E < 0) && (E = 0);
+    const R = {
+      id: B,
+      thickness: E,
+      direction: i,
+      visible: !de && E > Nt,
+      startPanelId: X.left,
+      endPanelId: X.right
+    }, _ = O.current;
+    _ && Math.abs(_.thickness - R.thickness) <= 0.25 && _.visible === R.visible && _.direction === R.direction && _.startPanelId === R.startPanelId && _.endPanelId === R.endPanelId || (O.current = R, o(B, R));
+  }, [i, X.left, X.right, o, B, de]);
+  re(() => {
+    g();
+  }, [g]), re(() => {
+    const p = S.current;
+    if (!p)
+      return;
+    if (typeof ResizeObserver > "u") {
+      g();
+      return;
+    }
+    const E = new ResizeObserver(() => {
+      g();
+    });
+    return E.observe(p), () => {
+      E.disconnect();
+    };
+  }, [g]);
+  const M = te(() => {
+    const p = d ? { ...Pe, ...d } : Pe;
+    return de ? {
+      ...p,
+      display: "none",
+      pointerEvents: "none",
+      visibility: "hidden"
+    } : p;
+  }, [Pe, de, d]);
+  return /* @__PURE__ */ A(
+    "button",
+    {
+      type: "button",
+      ref: S,
+      className: b,
+      style: M,
+      onPointerDown: $,
+      disabled: k,
+      "aria-hidden": de || void 0,
+      "aria-label": `Resize ${G ? "columns" : "rows"} - Drag to collapse/expand panels`,
+      "data-resize-handle-id": B,
+      title: `ドラッグして${G ? "列" : "行"}をリサイズ、端まで移動して折りたたみ/展開`,
+      children: r || /* @__PURE__ */ A("div", { className: ve, style: xe, children: /* @__PURE__ */ A("span", { className: h }) })
+    }
+  );
+}), zi = (t) => document.querySelector(`[data-panel-id="${t}"]`), gi = (t) => document.querySelector(`[data-panel-group-id="${t}"]`), hi = (t) => document.querySelector(`[data-resize-handle-id="${t}"]`);
+export {
+  ui as Panel,
+  fi as PanelGroup,
+  pt as PanelGroupContext,
+  pi as PanelResizeHandle,
+  ze as clamp,
+  q as getConstraintInPixels,
+  Le as getContainerSize,
+  zi as getPanelElement,
+  gi as getPanelGroupElement,
+  hi as getResizeHandleElement,
+  Lt as loadLayout,
+  Xe as normalizeSizeConfig,
+  At as saveLayout,
+  di as usePanelControls,
+  Qe as usePanelGroup,
+  Ot as useResizablePanels
+};