@aiquants/resize-panels 1.8.1 → 1.9.0

package/dist/index-B6YGX2DH.js

@@ -0,0 +1,2009 @@
+import { createContext as er, useContext as tr, useCallback as ge, useMemo as j, useReducer as rr, useState as Te, useRef as _, useEffect as K, useLayoutEffect as St, memo as yt, useId as Ut, Suspense as ir, lazy as nr } from "react";
+import { jsx as me, jsxs as Ze } from "react/jsx-runtime";
+import { twMerge as at } from "tailwind-merge";
+const jt = er(null), Mt = () => {
+  const e = tr(jt);
+  if (!e)
+    throw new Error("usePanelGroup must be used within a PanelGroup");
+  return e;
+}, vt = (e, t = 0) => {
+  if (!Number.isFinite(e))
+    return e;
+  const n = 10 ** t, d = e * n, r = Math.floor(d), s = d - r, i = Number.EPSILON * Math.max(1, Math.abs(d));
+  return s < 0.5 - i ? r / n : s > 0.5 + i ? (r + 1) / n : (r % 2 === 0 ? r : r + 1) / n;
+}, or = 12, sr = 8, ar = 6, lr = 48, cr = 80, dr = 2, ur = 32, fr = 64, pr = 8, hr = 8, _t = 10, Wt = 0.05, Vt = 10, zr = 0.05, gr = 20, mr = 0.05, kt = 0, Zt = 6, Fe = (e, t) => t <= 0 ? 0 : vt(e / t * 100, Zt), st = (e, t) => !e || t <= 0 ? 0 : e / 100 * t, Sr = (e, t = "percentage") => {
+  if (e !== void 0)
+    return typeof e == "number" ? { value: e, unit: t } : e;
+}, G = (e, t, n) => e ? typeof e == "number" ? e / 100 * n : e.unit === "pixels" ? e.value : e.value / 100 * n : t, ye = (e, t, n) => Math.min(Math.max(e, t), n), Ct = (e) => {
+  if (!Number.isFinite(e) || e <= 0)
+    return kt;
+  const t = e * Wt, n = Math.min(or, Vt, t);
+  return Math.max(kt, n);
+}, Kt = (e, t, n, d = {}) => {
+  if (Math.abs(t) <= 0)
+    return t;
+  const r = d.enforceAutoMinSize ?? !1, s = e.map((a, u) => ({ panel: a, index: u })).filter(({ panel: a }) => !a.collapsed && (a.sizeUnit === "pixels" || a.originalPixelSize !== void 0));
+  if (s.length === 0)
+    return t;
+  const i = t > 0, f = [...s].sort((a, u) => {
+    const l = a.panel.pixelAdjustPriority ?? a.index + 1, z = u.panel.pixelAdjustPriority ?? u.index + 1;
+    return l === z ? i ? u.index - a.index : a.index - u.index : i ? z - l : l - z;
+  });
+  let h = t;
+  const p = (a) => {
+    for (const { index: u } of f) {
+      if (Math.abs(h) <= 0)
+        break;
+      const l = e[u];
+      if (!l || l.collapsed)
+        continue;
+      const z = G(l.minSize, 0, n), m = G(l.maxSize, n, n), x = r ? G(l.autoMinSize, 0, n) : 0, b = Math.max(z, x), N = l.preferredPixelSize !== void 0 ? ye(l.preferredPixelSize, b, m) : l.size, k = l.collapseFromStart || l.collapseFromEnd;
+      if (h > 0) {
+        if (Math.abs(l.size) <= 0 && (l.percentageSize ?? 0) <= 0)
+          continue;
+        const W = Math.max(l.size, N), ce = a ? Math.min(m, W) : m, te = Math.max(0, ce - l.size);
+        if (te <= 0)
+          continue;
+        const oe = Math.min(te, h);
+        if (oe <= 0)
+          continue;
+        const $ = l.size + oe, A = Fe($, n), y = k ? $ : l.sizeBeforeCollapse, D = k ? l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? $ : l.measuredPixelSizeBeforeCollapse;
+        e[u] = {
+          ...l,
+          size: $,
+          percentageSize: A,
+          sizeBeforeCollapse: y,
+          measuredPixelSizeBeforeCollapse: D,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, h -= oe;
+      } else {
+        const I = a ? N : b, W = Math.max(0, l.size - I);
+        if (W <= 0)
+          continue;
+        const ce = Math.min(W, Math.abs(h));
+        if (ce <= 0)
+          continue;
+        const te = l.size - ce, oe = Fe(te, n), $ = k ? te : l.sizeBeforeCollapse, A = k ? l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? te : l.measuredPixelSizeBeforeCollapse;
+        e[u] = {
+          ...l,
+          size: te,
+          percentageSize: oe,
+          sizeBeforeCollapse: $,
+          measuredPixelSizeBeforeCollapse: A,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, h += ce;
+      }
+    }
+  };
+  return p(!0), (i && h > 0 || !i && h < 0) && p(!1), h;
+}, ht = (e) => {
+  if (!e)
+    return 0;
+  const t = parseFloat(e);
+  return Number.isFinite(t) ? t : 0;
+}, Ye = (e, t) => {
+  const n = e.getBoundingClientRect(), d = typeof window < "u" ? window.getComputedStyle(e) : null, r = d ? ht(d.borderLeftWidth) + ht(d.borderRightWidth) : 0, s = d ? ht(d.borderTopWidth) + ht(d.borderBottomWidth) : 0;
+  if (t === "horizontal") {
+    const p = n.width > 0 ? n.width : e.offsetWidth, a = n.width > 0 ? Math.max(0, n.width - r) : e.clientWidth, u = e.offsetWidth > 0 ? e.offsetWidth : e.clientWidth + r;
+    return {
+      inner: a > 0 ? a : Math.max(0, e.clientWidth),
+      outer: p > 0 ? p : Math.max(0, u)
+    };
+  }
+  const i = n.height > 0 ? n.height : e.offsetHeight, f = n.height > 0 ? Math.max(0, n.height - s) : e.clientHeight, h = e.offsetHeight > 0 ? e.offsetHeight : e.clientHeight + s;
+  return {
+    inner: f > 0 ? f : Math.max(0, e.clientHeight),
+    outer: i > 0 ? i : Math.max(0, h)
+  };
+}, xr = (e, t) => {
+  try {
+    localStorage.setItem(`panel-layout-${e}`, JSON.stringify(t));
+  } catch (n) {
+    console.warn("Failed to save panel layout:", n);
+  }
+}, Pr = (e) => {
+  try {
+    const t = localStorage.getItem(`panel-layout-${e}`);
+    return t ? JSON.parse(t) : null;
+  } catch (t) {
+    return console.warn("Failed to load panel layout:", t), null;
+  }
+};
+var qe = /* @__PURE__ */ ((e) => (e[e.DEBUG = 0] = "DEBUG", e[e.INFO = 1] = "INFO", e[e.WARN = 2] = "WARN", e[e.ERROR = 3] = "ERROR", e[e.NONE = 4] = "NONE", e))(qe || {});
+const Ne = class Ne {
+  /**
+   * @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(t = 2, n = "[resize-panels]", d = console) {
+    this.level = t, this.prefix = n, this.impl = d, Ne.instances.add(this);
+  }
+  /**
+   * @method setLevel
+   * @description Updates the log level for every constructed logger (module-level loggers included).
+   * @description 生成済みのすべてのロガー (モジュールレベルのロガーを含む) のログレベルを更新します。
+   * @param {LogLevel} level - The new log level.
+   */
+  static setLevel(t) {
+    for (const n of Ne.instances)
+      n.setLevel(t);
+  }
+  /**
+   * @method setLevel
+   * @description Updates the current log level.
+   * @description 現在のログレベルを更新します。
+   * @param {LogLevel} level - The new log level.
+   */
+  setLevel(t) {
+    this.level = t;
+  }
+  /**
+   * @method setImplementation
+   * @description Updates the logger implementation for every constructed logger.
+   * @description 生成済みのすべてのロガーの実装を更新します。
+   * @param {ILogger} impl - The new logger implementation.
+   */
+  static setImplementation(t) {
+    for (const n of Ne.instances)
+      n.setImplementation(t);
+  }
+  /**
+   * @method setImplementation
+   * @description Updates the logger implementation.
+   * @description ロガーの実装を更新します。
+   * @param {ILogger} impl - The new logger implementation.
+   */
+  setImplementation(t) {
+    this.impl = t;
+  }
+  /**
+   * @method setPrefix
+   * @description Updates the log prefix for every constructed logger.
+   * @description 生成済みのすべてのロガーのログのプレフィックスを更新します。
+   * @param {string} prefix - The new prefix.
+   */
+  static setPrefix(t) {
+    for (const n of Ne.instances)
+      n.setPrefix(t);
+  }
+  /**
+   * @method setPrefix
+   * @description Updates the log prefix.
+   * @description ログのプレフィックスを更新します。
+   * @param {string} prefix - The new prefix.
+   */
+  setPrefix(t) {
+    this.prefix = t;
+  }
+  /**
+   * @method enabledFor
+   * @description Returns whether messages at the given level would be emitted.
+   * @description 指定レベルのメッセージが出力対象かどうかを返します。
+   * 高コストなログ引数 (スナップショット等) の組み立てを抑制中に省略するために使用します。
+   * @param {LogLevel} level - The message level to test.
+   */
+  enabledFor(t) {
+    return this.level <= t;
+  }
+  formatMessage(t) {
+    return typeof t == "string" ? [`${this.prefix} ${t}`] : [this.prefix, t];
+  }
+  static debug(t, ...n) {
+    Ne.instance.debug(t, ...n);
+  }
+  debug(t, ...n) {
+    this.level <= 0 && this.impl.debug(...this.formatMessage(t), ...n);
+  }
+  static info(t, ...n) {
+    Ne.instance.info(t, ...n);
+  }
+  info(t, ...n) {
+    this.level <= 1 && this.impl.info(...this.formatMessage(t), ...n);
+  }
+  static warn(t, ...n) {
+    Ne.instance.warn(t, ...n);
+  }
+  warn(t, ...n) {
+    this.level <= 2 && this.impl.warn(...this.formatMessage(t), ...n);
+  }
+  static error(t, ...n) {
+    Ne.instance.error(t, ...n);
+  }
+  error(t, ...n) {
+    this.level <= 3 && this.impl.error(...this.formatMessage(t), ...n);
+  }
+};
+Ne.instances = /* @__PURE__ */ new Set(), Ne.instance = new Ne(2, "[resize-panels]");
+let lt = Ne;
+const pe = new lt(qe.INFO, "[resize-panels]"), Ue = 1e-9, Le = (e) => e.map((t) => ({
+  id: t.id,
+  size: t.size,
+  percentageSize: t.percentageSize,
+  preferredPercentageSize: t.preferredPercentageSize,
+  sizeBeforeCollapse: t.sizeBeforeCollapse,
+  percentageSizeBeforeCollapse: t.percentageSizeBeforeCollapse,
+  preferredPercentageSizeBeforeCollapse: t.preferredPercentageSizeBeforeCollapse,
+  measuredPercentageSize: t.measuredPercentageSize,
+  excludeFromAutoGrowth: t.excludeFromAutoGrowth ?? !1,
+  collapsed: t.collapsed ?? !1,
+  collapseFromStart: t.collapseFromStart,
+  collapseFromEnd: t.collapseFromEnd,
+  collapsedByDirection: t.collapsedByDirection ?? null
+})), zt = (e) => e ? Le([e])[0] : null, Xe = (e) => e ? !!(e.collapseFromStart || e.collapseFromEnd) : !1, gt = (e, t) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return e;
+  const n = e.map((h) => ({ ...h })), d = [];
+  for (let h = 0; h < n.length; h += 1) {
+    const p = n[h];
+    if (p.collapsed) {
+      n[h] = {
+        ...p,
+        size: 0,
+        percentageSize: 0
+      };
+      continue;
+    }
+    const a = Math.max(0, G(p.minSize, 0, t)), u = Math.max(0, G(p.autoMinSize, 0, t)), l = Math.max(a, u), z = Math.max(1e-3, l), m = G(p.maxSize, t, t), x = Math.max(l, m), b = p.sizeUnit === "pixels" || p.originalPixelSize !== void 0, N = Math.max(0, p.size);
+    let k = l;
+    if (b) {
+      const W = p.preferredPixelSize ?? p.size ?? p.originalPixelSize ?? l;
+      k = ye(W, l, x);
+    } else {
+      const W = p.preferredPercentageSize ?? p.percentageSize ?? Fe(p.size, t), ce = st(W, t);
+      k = ye(ce, l, x);
+    }
+    const I = !b && (p.excludeFromAutoGrowth ?? !1) && N <= z;
+    d.push({
+      index: h,
+      isPixelPanel: b,
+      minSize: l,
+      maxSize: x,
+      preferredSize: k,
+      priority: p.pixelAdjustPriority ?? h + 1,
+      flexPriority: b ? void 0 : p.flexAdjustPriority,
+      excludeFromGrowth: I
+    });
+  }
+  if (d.length === 0)
+    return n;
+  const r = /* @__PURE__ */ new Map();
+  let s = 0;
+  for (const h of d)
+    r.set(h.index, h.minSize), s += h.minSize;
+  let i = t - s;
+  const f = (h, p) => {
+    if (p <= 0)
+      return 0;
+    const a = r.get(h.index) ?? h.minSize, u = Math.max(0, h.maxSize - a);
+    if (u <= 0)
+      return 0;
+    const l = Math.min(p, u);
+    return r.set(h.index, a + l), l;
+  };
+  if (i > 0) {
+    const h = (a) => {
+      for (; i > 1e-6; ) {
+        let l = 0;
+        const z = [];
+        for (const b of a) {
+          if (!b.isPixelPanel && b.excludeFromGrowth)
+            continue;
+          const N = r.get(b.index) ?? b.minSize, k = Math.min(b.preferredSize, b.maxSize), I = Math.max(0, k - N);
+          I > 1e-6 && (l += I, z.push({ descriptor: b, capacity: I }));
+        }
+        if (z.length === 0 || l <= 1e-6)
+          break;
+        let m = 0;
+        const x = i;
+        for (const b of z) {
+          if (i <= 1e-6)
+            break;
+          if (!b.descriptor.isPixelPanel && b.descriptor.excludeFromGrowth)
+            continue;
+          const N = x * b.capacity / l, k = Math.min(b.capacity, N);
+          if (k <= 0)
+            continue;
+          const I = f(b.descriptor, k);
+          I > 0 && (i -= I, m += I);
+        }
+        if (m <= 1e-6)
+          break;
+      }
+    }, p = d.filter((a) => a.isPixelPanel);
+    p.sort((a, u) => u.priority - a.priority);
+    for (const a of p) {
+      if (i <= 0)
+        break;
+      const u = r.get(a.index) ?? a.minSize, l = Math.min(a.preferredSize, a.maxSize), z = Math.max(0, l - u);
+      if (z <= 0)
+        continue;
+      const m = f(a, Math.min(z, i));
+      m > 0 && (i -= m);
+    }
+    if (i > 0) {
+      const a = d.filter((u) => !u.isPixelPanel);
+      if (a.length > 0) {
+        const u = a.filter((l) => l.flexPriority !== void 0 && !l.excludeFromGrowth);
+        if (u.length > 0) {
+          u.sort((l, z) => (z.flexPriority ?? 0) - (l.flexPriority ?? 0));
+          for (const l of u) {
+            if (i <= 0)
+              break;
+            if (l.excludeFromGrowth)
+              continue;
+            const z = r.get(l.index) ?? l.minSize, m = Math.min(l.preferredSize, l.maxSize), x = Math.max(0, m - z);
+            if (x <= 0)
+              continue;
+            const b = f(l, Math.min(x, i));
+            b > 0 && (i -= b);
+          }
+        }
+        if (i > 0) {
+          const l = u.length > 0 ? a.filter((z) => z.flexPriority === void 0 && !z.excludeFromGrowth) : a.filter((z) => !z.excludeFromGrowth);
+          l.length > 0 && h(l);
+        }
+      }
+    }
+  }
+  if (i > 0) {
+    let h = i;
+    for (; ; ) {
+      let p = 0;
+      const a = [];
+      for (const l of d) {
+        if (!l.isPixelPanel && l.excludeFromGrowth)
+          continue;
+        const z = r.get(l.index) ?? l.minSize, m = l.isPixelPanel ? Math.min(l.maxSize, l.preferredSize) : l.maxSize, x = Math.max(0, m - z);
+        x > 0 && (a.push(l), p += x);
+      }
+      if (p <= 0)
+        break;
+      const u = i;
+      for (const l of a) {
+        if (i <= 0)
+          break;
+        if (!l.isPixelPanel && l.excludeFromGrowth)
+          continue;
+        const z = r.get(l.index) ?? l.minSize, m = l.isPixelPanel ? Math.min(l.maxSize, l.preferredSize) : l.maxSize, x = Math.max(0, m - z);
+        if (x <= 0)
+          continue;
+        const b = u * x / p, N = f(l, Math.min(x, b));
+        N > 0 && (i -= N);
+      }
+      if (i <= 1e-6 || Math.abs(h - i) <= 1e-6)
+        break;
+      h = i;
+    }
+    i = Math.max(0, i);
+  }
+  for (const h of d) {
+    const p = r.get(h.index) ?? h.minSize, a = n[h.index], u = Xe(a), l = u ? p : a.sizeBeforeCollapse, z = u ? a.measuredPixelSizeBeforeCollapse ?? a.measuredPixelSize ?? p : a.measuredPixelSizeBeforeCollapse, m = t > 0 ? Fe(p, t) : 0;
+    n[h.index] = {
+      ...a,
+      size: p,
+      percentageSize: m,
+      preferredPercentageSize: a.preferredPercentageSize,
+      preferredPixelSize: h.isPixelPanel ? a.preferredPixelSize ?? p : a.preferredPixelSize,
+      sizeBeforeCollapse: l,
+      measuredPixelSizeBeforeCollapse: z,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    };
+  }
+  return Ke(n);
+}, Ke = (e) => {
+  let t = 0;
+  for (const r of e)
+    r.collapsed || (t += Math.max(r.size, 0));
+  if (t <= 0) {
+    let r = !1;
+    const s = e.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 ? s : e;
+  }
+  let n = !1;
+  const d = e.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 s = Fe(r.size, t), i = r.measuredPercentageSize, p = (i !== void 0 ? Math.abs(i - s) : 1 / 0) < 1e-4 && i !== void 0 ? i : s, a = vt(p, Zt), l = Math.abs((r.percentageSize ?? 0) - a) > 0 || r.percentageSize === void 0, z = r.sizeBeforeCollapse === void 0 || r.sizeBeforeCollapse !== r.size, m = Xe(r), x = m && z, b = r.measuredPixelSize ?? r.size, N = m && (r.measuredPixelSizeBeforeCollapse === void 0 || r.measuredPixelSizeBeforeCollapse !== b);
+    if (!(l || x || N))
+      return r;
+    n = !0;
+    const k = x ? r.size : r.sizeBeforeCollapse, I = N ? b : r.measuredPixelSizeBeforeCollapse;
+    return {
+      ...r,
+      percentageSize: a,
+      sizeBeforeCollapse: k,
+      measuredPixelSizeBeforeCollapse: I,
+      collapsedByDirection: r.collapsed ? r.collapsedByDirection ?? null : null
+    };
+  });
+  return n ? d : e;
+}, mt = (e, t) => {
+  if (t <= 0)
+    return !1;
+  const n = [];
+  let d = 0;
+  for (let a = 0; a < e.length; a += 1) {
+    const u = e[a];
+    !u || u.collapsed || (n.push(a), d += u.size);
+  }
+  if (n.length === 0)
+    return !1;
+  let r = t - d;
+  if (Math.abs(r) <= 0)
+    return !1;
+  let s = !1;
+  const i = (a) => {
+    const u = e[a], l = G(u.minSize, 0, t), z = G(u.autoMinSize, 0, t), m = Math.max(l, z), x = G(u.maxSize, t, t), b = u.sizeUnit === "percentage" && u.originalPixelSize === void 0;
+    return {
+      index: a,
+      minSize: m,
+      maxSize: x,
+      isFlexible: b
+    };
+  }, f = (a, u) => {
+    if (!Number.isFinite(u) || Math.abs(u) <= 0)
+      return;
+    const l = e[a];
+    if (!l)
+      return;
+    const z = Math.max(0, l.size + u);
+    if (Math.abs(z - l.size) <= 0)
+      return;
+    const m = Fe(z, t), x = Xe(l), b = x ? z : l.sizeBeforeCollapse, N = x ? l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? z : l.measuredPixelSizeBeforeCollapse;
+    e[a] = {
+      ...l,
+      size: z,
+      percentageSize: m,
+      sizeBeforeCollapse: b,
+      measuredPixelSizeBeforeCollapse: N,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    }, r -= u, s = !0;
+  }, h = (a) => {
+    for (const u of a) {
+      if (Math.abs(r) <= 0)
+        break;
+      const l = e[u.index];
+      if (!l || l.collapsed)
+        continue;
+      const z = l.size;
+      if (r > 0) {
+        const m = Math.max(0, u.maxSize - z);
+        if (m <= 0)
+          continue;
+        const x = Math.min(m, r);
+        if (x <= 0)
+          continue;
+        f(u.index, x);
+      } else {
+        const m = Math.max(0, z - u.minSize);
+        if (m <= 0)
+          continue;
+        const x = Math.min(m, Math.abs(r));
+        if (x <= 0)
+          continue;
+        f(u.index, -x);
+      }
+    }
+  }, p = n.map((a) => i(a)).filter((a) => a.isFlexible);
+  if (p.length > 0 && h(p), Math.abs(r) > 0) {
+    const a = r;
+    r = Kt(e, r, t, { enforceAutoMinSize: !0 }), Math.abs(r - a) > 0 && (s = !0);
+  }
+  return s;
+}, Ot = (e, t, n) => {
+  if (!(e.sizeUnit === "pixels" || e.originalPixelSize !== void 0) || e.pixelAdjustPriority !== void 0)
+    return e;
+  const r = t.filter((i, f) => f !== n && (i.sizeUnit === "pixels" || i.originalPixelSize !== void 0)).map((i) => i.pixelAdjustPriority).filter((i) => i !== void 0), s = r.length > 0 ? Math.max(...r) + 1 : 1;
+  return {
+    ...e,
+    pixelAdjustPriority: s
+  };
+}, br = (e, t) => {
+  switch (t.type) {
+    case "REGISTER_PANEL": {
+      pe.debug("REGISTER_PANEL", t.panel);
+      const n = e.findIndex((s) => s.id === t.panel.id);
+      if (n >= 0) {
+        const s = [...e], i = e[n], f = {
+          ...i,
+          minSize: t.panel.minSize,
+          maxSize: t.panel.maxSize,
+          collapseFromStart: t.panel.collapseFromStart,
+          collapseFromEnd: t.panel.collapseFromEnd,
+          collapsedByDirection: t.panel.collapsedByDirection !== void 0 ? t.panel.collapsedByDirection : i.collapsedByDirection,
+          sizeUnit: t.panel.sizeUnit,
+          originalPixelSize: t.panel.originalPixelSize,
+          preferredPercentageSize: t.panel.preferredPercentageSize !== void 0 ? t.panel.preferredPercentageSize : i.preferredPercentageSize,
+          preferredPercentageSizeBeforeCollapse: t.panel.preferredPercentageSizeBeforeCollapse !== void 0 ? t.panel.preferredPercentageSizeBeforeCollapse : i.preferredPercentageSizeBeforeCollapse,
+          percentageSizeBeforeCollapse: t.panel.percentageSizeBeforeCollapse !== void 0 ? t.panel.percentageSizeBeforeCollapse : i.percentageSizeBeforeCollapse,
+          pixelAdjustPriority: t.panel.pixelAdjustPriority !== void 0 ? t.panel.pixelAdjustPriority : i.pixelAdjustPriority,
+          flexAdjustPriority: t.panel.flexAdjustPriority !== void 0 ? t.panel.flexAdjustPriority : i.flexAdjustPriority,
+          autoMinSize: t.panel.autoMinSize !== void 0 ? t.panel.autoMinSize : i.autoMinSize,
+          excludeFromAutoGrowth: t.panel.excludeFromAutoGrowth !== void 0 ? t.panel.excludeFromAutoGrowth : i.excludeFromAutoGrowth
+        }, h = Ot(f, e, n);
+        if (pe.debug("register panel (update)", {
+          panelId: h.id,
+          incoming: zt(t.panel),
+          previous: zt(i),
+          next: zt(h)
+        }), s[n] = h, !h.collapsed) {
+          const p = s.reduce((a, u) => u.collapsed ? a : a + u.size, 0);
+          if (p > 0) {
+            const a = G(h.minSize, 0, p), u = Math.max(a, G(h.maxSize, p, p));
+            if (h.size < a - Ue || h.size > u + Ue)
+              return gt(s, p);
+          }
+        }
+        return s;
+      }
+      const d = { ...t.panel }, r = Ot(d, e);
+      return pe.debug("register panel (insert)", {
+        panelId: r.id,
+        incoming: zt(r),
+        previousLength: e.length
+      }), [...e, r];
+    }
+    case "UNREGISTER_PANEL": {
+      pe.debug("UNREGISTER_PANEL", t.id);
+      const n = e.filter((r) => r.id !== t.id), d = Ke(n);
+      return pe.enabledFor(qe.DEBUG) && pe.debug("unregister panel", {
+        panelId: t.id,
+        previous: Le(e),
+        filtered: Le(n),
+        next: Le(d)
+      }), d;
+    }
+    case "RESIZE_PANELS": {
+      pe.debug("RESIZE_PANELS", t.leftId, t.rightId, t.leftSize, t.rightSize);
+      const n = e.findIndex((C) => C.id === t.leftId), d = e.findIndex((C) => C.id === t.rightId);
+      if (n === -1 || d === -1) return e;
+      const r = [...e], s = r[n], i = r[d];
+      if (s.collapsed || i.collapsed || t.leftSize === s.size && t.rightSize === i.size)
+        return e;
+      const f = t.containerSize ?? e.reduce((C, ie) => C + ie.size, 0), h = G(s.minSize, 0, f), p = G(s.maxSize, f, f), a = G(i.minSize, 0, f), u = G(i.maxSize, f, f), l = s.size + i.size, z = e.reduce((C, ie) => ie.collapsed ? C : C + ie.size, 0), m = z - l, x = h + a, b = p + u, N = ye(t.leftSize + t.rightSize, x, b);
+      let k = f > 0 ? f - m : N;
+      Number.isFinite(k) || (k = N);
+      const I = ye(Math.max(N, k), x, b), W = (C) => ({
+        min: Math.max(h, C - u),
+        max: Math.min(p, C - a)
+      }), ce = (C) => ({
+        min: Math.max(a, C - p),
+        max: Math.min(u, C - h)
+      }), te = Math.abs(t.leftSize - s.size), oe = Math.abs(t.rightSize - i.size), $ = te >= oe;
+      let A = s.size, y = i.size;
+      if ($) {
+        const C = W(I);
+        if (C.min > C.max + Ue)
+          return e;
+        const ie = ye(t.leftSize, C.min, C.max), Se = I - ie;
+        if (Se < a - Ue || Se > u + Ue)
+          return e;
+        A = ie, y = ye(Se, a, u);
+      } else {
+        const C = ce(I);
+        if (C.min > C.max + Ue)
+          return e;
+        const ie = ye(t.rightSize, C.min, C.max), Se = I - ie;
+        if (Se < h - Ue || Se > p + Ue)
+          return e;
+        y = ie, A = ye(Se, h, p);
+      }
+      const D = A + y;
+      if (Math.abs(I - D) > Ue)
+        return e;
+      const V = z - s.size - i.size + D, H = f > 0 ? f : V, L = H > 0 ? Fe(A, H) : 0, Me = H > 0 ? Fe(y, H) : 0, F = s.sizeUnit === "pixels" || s.originalPixelSize !== void 0 ? A : s.preferredPixelSize, de = i.sizeUnit === "pixels" || i.originalPixelSize !== void 0 ? y : i.preferredPixelSize, Ge = G(s.autoMinSize, 0, f), fe = G(i.autoMinSize, 0, f), Ae = Math.max(1e-3, Ge), Pe = Math.max(1e-3, fe), ve = s.sizeUnit === "percentage" && s.originalPixelSize === void 0, se = i.sizeUnit === "percentage" && i.originalPixelSize === void 0;
+      let Ee = s.excludeFromAutoGrowth, _e = i.excludeFromAutoGrowth;
+      ve && (A <= Ae ? Ee = !0 : A > Ae && (Ee = !1)), se && (y <= Pe ? _e = !0 : y > Pe && (_e = !1));
+      const ke = Xe(s), $e = Xe(i);
+      return r[n] = {
+        ...s,
+        size: A,
+        percentageSize: L,
+        preferredPercentageSize: L > 0 ? L : s.preferredPercentageSize,
+        preferredPixelSize: F,
+        sizeBeforeCollapse: ke ? A : s.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: Ee
+      }, r[d] = {
+        ...i,
+        size: y,
+        percentageSize: Me,
+        preferredPercentageSize: Me > 0 ? Me : i.preferredPercentageSize,
+        preferredPixelSize: de,
+        sizeBeforeCollapse: $e ? y : i.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: _e
+      }, f > 0 && mt(r, f) ? Ke(r) : r;
+    }
+    case "SET_PANELS": {
+      pe.debug("SET_PANELS", t.panels);
+      const n = pe.enabledFor(qe.DEBUG), d = t.panels.map((p) => {
+        const a = p.sizeUnit === "pixels" || p.originalPixelSize !== void 0, u = p.preferredPercentageSize !== void 0 ? p.preferredPercentageSize : p.percentageSize, l = p.preferredPixelSize !== void 0 ? p.preferredPixelSize : a ? p.size : p.preferredPixelSize;
+        return {
+          ...p,
+          preferredPercentageSize: u,
+          preferredPixelSize: l
+        };
+      }), r = Le(e), s = n ? Le(d) : null, i = Ke(d), f = Le(i);
+      let h = r.length === f.length;
+      if (h)
+        for (let p = 0; p < f.length; p += 1) {
+          const a = f[p], u = r[p];
+          if (!u) {
+            h = !1;
+            break;
+          }
+          if (!(u.id === a.id && u.size === a.size && u.percentageSize === a.percentageSize && u.preferredPercentageSize === a.preferredPercentageSize && u.sizeBeforeCollapse === a.sizeBeforeCollapse && u.percentageSizeBeforeCollapse === a.percentageSizeBeforeCollapse && u.preferredPercentageSizeBeforeCollapse === a.preferredPercentageSizeBeforeCollapse && u.measuredPercentageSize === a.measuredPercentageSize && u.excludeFromAutoGrowth === a.excludeFromAutoGrowth && u.collapsed === a.collapsed && u.collapseFromStart === a.collapseFromStart && u.collapseFromEnd === a.collapseFromEnd && u.collapsedByDirection === a.collapsedByDirection)) {
+            h = !1;
+            break;
+          }
+        }
+      return h ? (n && pe.debug("set panels skipped (no diff)", {
+        previous: r,
+        incoming: s,
+        next: f,
+        previousLength: r.length,
+        incomingLength: s?.length ?? d.length
+      }), e) : (n && pe.debug("set panels", {
+        previous: r,
+        incoming: s,
+        next: f,
+        previousLength: r.length,
+        incomingLength: s?.length ?? d.length
+      }), i);
+    }
+    case "CONTAINER_RESIZED": {
+      pe.debug("CONTAINER_RESIZED", t.containerSize);
+      const n = pe.enabledFor(qe.DEBUG);
+      if (t.containerSize <= 0)
+        return n && pe.debug("container resized skipped (non-positive size)", {
+          containerSize: t.containerSize,
+          panels: Le(e)
+        }), e;
+      n && pe.debug("container resized (before)", {
+        containerSize: t.containerSize,
+        panels: Le(e)
+      });
+      const d = gt(e, t.containerSize);
+      if (n && pe.debug("container resized (after recalc)", {
+        containerSize: t.containerSize,
+        panels: Le(d)
+      }), t.containerSize > 0 && mt(d, t.containerSize)) {
+        const r = Ke(d);
+        return n && pe.debug("container resized (after reconcile)", {
+          containerSize: t.containerSize,
+          panels: Le(r)
+        }), r;
+      }
+      return n && pe.debug("container resized (final)", {
+        containerSize: t.containerSize,
+        panels: Le(d)
+      }), d;
+    }
+    case "COLLAPSE_PANEL": {
+      pe.debug("COLLAPSE_PANEL", t.id);
+      const n = e.findIndex((l) => l.id === t.id);
+      if (n === -1)
+        return e;
+      const d = e[n], r = t.from === "start" ? d.collapseFromStart : d.collapseFromEnd;
+      if (!(Xe(d) && r) || d.collapsed)
+        return e;
+      const i = d.size, f = d.measuredPixelSize ?? i, h = d.percentageSize ?? d.preferredPercentageSize ?? 0, p = {
+        ...d,
+        collapsed: !0,
+        collapsedByDirection: t.from,
+        sizeBeforeCollapse: i,
+        percentageSizeBeforeCollapse: h,
+        preferredPercentageSizeBeforeCollapse: d.preferredPercentageSize ?? h,
+        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
+      }, a = [...e];
+      a[n] = p;
+      const u = gt(a, t.containerSize);
+      return t.containerSize > 0 && mt(u, t.containerSize) ? Ke(u) : u;
+    }
+    case "EXPAND_PANEL": {
+      pe.debug("EXPAND_PANEL", t.id, t.targetSize);
+      const n = e.findIndex((I) => I.id === t.id);
+      if (n === -1)
+        return e;
+      const d = t.containerSize, r = e[n], s = t.from === "start" ? r.collapseFromStart : r.collapseFromEnd;
+      if (!(Xe(r) && s && r.collapsed) || r.collapsedByDirection && r.collapsedByDirection !== t.from)
+        return e;
+      const f = [t.targetSize, r.sizeBeforeCollapse, r.measuredPixelSizeBeforeCollapse, r.preferredPixelSizeBeforeCollapse, r.originalPixelSize].find((I) => I !== void 0) ?? 0, h = G(r.minSize, 0, d), p = G(r.maxSize, d, d), a = ye(f, h, p), u = Fe(a, d), l = r.measuredPixelSizeBeforeCollapse ?? a, z = Fe(l, d), m = r.preferredPercentageSizeBeforeCollapse ?? r.percentageSizeBeforeCollapse ?? u, x = r.preferredPixelSizeBeforeCollapse ?? r.preferredPixelSize ?? a, b = {
+        ...r,
+        collapsed: !1,
+        collapsedByDirection: null,
+        size: a,
+        percentageSize: u,
+        preferredPercentageSize: m,
+        preferredPixelSize: x,
+        sizeBeforeCollapse: a,
+        percentageSizeBeforeCollapse: void 0,
+        preferredPercentageSizeBeforeCollapse: void 0,
+        preferredPixelSizeBeforeCollapse: void 0,
+        measuredPixelSize: a,
+        measuredPixelSizeBeforeCollapse: l,
+        measuredPercentageSize: z
+      }, N = [...e];
+      N[n] = b;
+      const k = gt(N, d);
+      return d > 0 && mt(k, d) ? Ke(k) : k;
+    }
+    default:
+      return e;
+  }
+}, nt = new lt(qe.INFO, "[resize-panels]"), Cr = ({ direction: e, style: t, onLayout: n, autoSaveId: d, showDebugInfo: r = !1 }) => {
+  const [s, i] = rr(br, []), [f, h] = Te({ width: 0, height: 0 }), [p, a] = Te(!1), [u, l] = Te(!1), [z, m] = Te(null), [x, b] = Te({}), [N, k] = Te({}), I = _(null), W = _(n), ce = _(!1), te = _(0), oe = _(f), $ = _(f), A = _(p), y = _(z?.reason ?? null), D = _({}), V = _(null), H = _(null), L = _(null), Me = _({ width: 0, height: 0 }), F = _({ width: 0, height: 0 }), de = _({}), Ge = _({}), fe = ge((c) => c.map((g) => ({ ...g })), []);
+  K(() => {
+    $.current = f;
+  }, [f]), K(() => {
+    A.current = p;
+  }, [p]), K(() => {
+    y.current = z?.reason ?? null;
+  }, [z?.reason]), K(() => {
+    if (z)
+      return;
+    const c = e === "horizontal" ? f.width : f.height;
+    !Number.isFinite(c) || c <= 4 || s.length !== 0 && (V.current = fe(s));
+  }, [z, s, e, f.width, f.height, fe]);
+  const Ae = _(s);
+  K(() => {
+    Ae.current = s;
+  }, [s]), K(() => {
+    const c = H.current;
+    if (z) {
+      H.current = z;
+      return;
+    }
+    if (c && !z && V.current) {
+      H.current = null;
+      const g = new Set(Ae.current.map((v) => v.id)), M = fe(V.current).filter((v) => g.has(v.id));
+      M.length > 0 && i({ type: "SET_PANELS", panels: M });
+      return;
+    }
+    H.current = z;
+  }, [z, fe]), St(() => {
+    if (!I.current) return;
+    const c = new ResizeObserver((g) => {
+      for (const M of g) {
+        const v = M.target, Y = v ? Ye(v, "horizontal") : null, ae = v ? Ye(v, "vertical") : null, re = Y ? Y.inner : 0, T = ae ? ae.inner : 0, he = M.contentRect.width, Z = M.contentRect.height, E = re > 0 ? re : he, S = T > 0 ? T : Z;
+        Me.current = { width: E, height: S };
+        const O = F.current, X = Math.abs(O.width - E) >= 0.5, Q = Math.abs(O.height - S) >= 0.5;
+        X || Q ? (L.current && (clearTimeout(L.current), L.current = null), !p && E > 0 && S > 0 && a(!0), h({ width: E, height: S }), F.current = { width: E, height: S }) : (L.current && clearTimeout(L.current), L.current = setTimeout(() => {
+          const U = Me.current;
+          h(U), F.current = U, L.current = null;
+        }, 150));
+      }
+    });
+    return c.observe(I.current), () => {
+      c.disconnect(), L.current && clearTimeout(L.current);
+    };
+  }, [p]), K(() => () => {
+    for (const c of Object.values(de.current))
+      clearTimeout(c);
+  }, []), St(() => {
+    const c = oe.current, g = f, M = e === "horizontal" ? Math.abs(c.width - g.width) >= 0.5 : Math.abs(c.height - g.height) >= 0.5;
+    if (u && M) {
+      const v = e === "horizontal" ? g.width : g.height;
+      i({ type: "CONTAINER_RESIZED", containerSize: v, direction: e });
+    }
+    oe.current = g;
+  }, [f, u, e]);
+  const Pe = ge(() => {
+    nt.debug("panels[0]?.id", s[0]?.id);
+    const c = s.some((o) => {
+      if (o.collapsed || o.sizeUnit !== "percentage")
+        return !1;
+      const J = o.collapseFromStart || o.collapseFromEnd ? o.sizeBeforeCollapse ?? o.measuredPixelSizeBeforeCollapse ?? o.originalPixelSize ?? o.measuredPixelSize ?? 0 : o.measuredPixelSize ?? o.originalPixelSize ?? o.size, ee = o.percentageSize !== void 0 && o.percentageSize > 0;
+      return o.size <= 0 && (J > 0 || ee);
+    }), g = e === "horizontal" ? f.width : f.height, M = g > 0;
+    if (z || !M || !(s.length > 0 && (s.length !== te.current || !u || c)))
+      return;
+    const ae = s.filter((o) => !o.collapsed && (o.originalPixelSize !== void 0 || o.sizeUnit === "pixels")).reduce((o, w) => {
+      const J = w.preferredPixelSize ?? w.originalPixelSize ?? w.size;
+      return o + Math.max(0, J ?? 0);
+    }, 0), re = s.filter((o) => o.sizeUnit === "percentage" && !o.collapsed), T = re.map((o) => o.id), he = re.map((o) => {
+      const w = o.preferredPercentageSize ?? o.percentageSize;
+      return w !== void 0 && w > 0 ? st(w, g) : o.size > 0 ? o.size : 0;
+    }), Z = he.reduce((o, w) => o + w, 0), E = g - ae, S = Math.max(0, E), O = S > 0, X = s.map((o) => {
+      if (o.collapsed) {
+        const w = o.sizeBeforeCollapse ?? o.measuredPixelSizeBeforeCollapse ?? o.originalPixelSize ?? (o.sizeUnit === "pixels" ? o.size : void 0), J = o.sizeUnit === "percentage" && o.percentageSize !== void 0 ? st(o.percentageSize, g) : void 0, ee = w ?? J ?? 0, Re = o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? ee;
+        return {
+          ...o,
+          size: 0,
+          percentageSize: 0,
+          preferredPercentageSize: o.preferredPercentageSize,
+          sizeBeforeCollapse: ee,
+          percentageSizeBeforeCollapse: o.percentageSizeBeforeCollapse ?? o.percentageSize ?? o.preferredPercentageSize ?? 0,
+          preferredPercentageSizeBeforeCollapse: o.preferredPercentageSizeBeforeCollapse ?? o.preferredPercentageSize ?? o.percentageSize ?? void 0,
+          preferredPixelSizeBeforeCollapse: o.preferredPixelSizeBeforeCollapse ?? o.preferredPixelSize ?? ee,
+          measuredPixelSizeBeforeCollapse: Re
+        };
+      }
+      if (o.sizeUnit === "pixels" || o.originalPixelSize !== void 0) {
+        const w = o.size, J = g > 0 ? Fe(w, g) : 0, ee = {
+          ...o,
+          size: w,
+          percentageSize: J,
+          preferredPixelSize: o.preferredPixelSize ?? o.originalPixelSize ?? w,
+          preferredPercentageSize: o.preferredPercentageSize !== void 0 ? o.preferredPercentageSize : J > 0 ? J : void 0
+        };
+        if (o.collapseFromStart || o.collapseFromEnd) {
+          const Re = o.sizeBeforeCollapse ?? w, Qe = o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? Re;
+          ee.sizeBeforeCollapse = Re, ee.measuredPixelSizeBeforeCollapse = Qe, ee.preferredPixelSizeBeforeCollapse = o.preferredPixelSizeBeforeCollapse ?? o.preferredPixelSize ?? Re;
+        }
+        return ee;
+      }
+      if (o.sizeUnit === "percentage") {
+        const w = T.indexOf(o.id), J = w !== -1 ? he[w] : 0, ee = G(o.minSize, 0, g), Re = G(o.maxSize, g, g), Qe = Math.max(
+          ee,
+          o.sizeBeforeCollapse ?? 0,
+          o.measuredPixelSizeBeforeCollapse ?? 0,
+          o.measuredPixelSize ?? 0,
+          o.originalPixelSize ?? 0,
+          o.size > 0 ? o.size : 0,
+          o.percentageSize !== void 0 ? st(o.percentageSize, g) : 0,
+          1
+        ), ct = J > 0 ? J : Qe;
+        let De;
+        if (!O)
+          De = ee;
+        else if (w !== -1 && Z > 0) {
+          const R = ct / Z, B = S * R;
+          De = ye(B, ee, Re);
+        } else {
+          const R = o.percentageSize !== void 0 ? st(o.percentageSize, g) : o.size, B = R > 0 ? R : ct;
+          De = ye(B, ee, Re);
+        }
+        const et = g > 0 ? Fe(De, g) : 0, P = {
+          ...o,
+          size: De,
+          percentageSize: et,
+          preferredPercentageSize: o.preferredPercentageSize !== void 0 ? o.preferredPercentageSize : et > 0 ? et : void 0
+        };
+        if (o.collapseFromStart || o.collapseFromEnd) {
+          const R = o.sizeBeforeCollapse ?? De, B = o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? R;
+          P.sizeBeforeCollapse = R, P.measuredPixelSizeBeforeCollapse = B, P.preferredPixelSizeBeforeCollapse = o.preferredPixelSizeBeforeCollapse ?? o.preferredPixelSize ?? R;
+        }
+        return P;
+      }
+      return o;
+    }), Q = [];
+    for (let o = 0; o < X.length; o += 1) {
+      const w = X[o];
+      w.sizeUnit === "percentage" && !w.collapsed && Q.push(o);
+    }
+    const U = Q.reduce((o, w) => o + X[w].size, 0), q = E - U;
+    Math.abs(q) > 0 && Kt(X, q, g, { enforceAutoMinSize: !0 }), i({ type: "SET_PANELS", panels: X }), te.current = s.length, l(!0);
+  }, [s, e, f.width, f.height, u, z]);
+  K(() => {
+    const c = e === "horizontal" ? f.width : f.height, g = c > 0, M = g && s.length > 0;
+    if (g && s.length === 0) {
+      z && m(null);
+      return;
+    }
+    const v = M ? s.reduce((Z, E) => {
+      if (E.collapsed)
+        return Z;
+      const S = G(E.minSize, 0, c);
+      return Z + Math.max(0, S);
+    }, 0) : null, Y = M ? s.reduce((Z, E) => {
+      if (E.collapsed)
+        return Z;
+      const S = G(E.maxSize, c, c);
+      return Z + Math.max(0, S);
+    }, 0) : null, ae = v ?? z?.totalMinimumSize ?? null, re = Y ?? z?.totalMaximumSize ?? null;
+    if (!g) {
+      z && m((Z) => !Z || Z.availableContainerSize === c ? Z : {
+        reason: Z.reason,
+        // totalMinimumSize: previous.totalMinimumSize,
+        // totalMaximumSize: previous.totalMaximumSize,
+        totalMinimumSize: null,
+        totalMaximumSize: null,
+        availableContainerSize: c
+      });
+      return;
+    }
+    const T = ae !== null && ae - c > Number.EPSILON, he = re !== null && c - re > Number.EPSILON;
+    if (T || he) {
+      const E = {
+        reason: T ? "minimum-exceeded" : "maximum-insufficient",
+        totalMinimumSize: ae,
+        totalMaximumSize: re,
+        availableContainerSize: c
+      };
+      m((S) => S && S.reason === E.reason && Math.abs((S.totalMinimumSize ?? 0) - (E.totalMinimumSize ?? 0)) <= Number.EPSILON && Math.abs((S.totalMaximumSize ?? 0) - (E.totalMaximumSize ?? 0)) <= Number.EPSILON && Math.abs(S.availableContainerSize - E.availableContainerSize) <= Number.EPSILON ? S : E);
+      return;
+    }
+    if (z) {
+      const Z = z.reason === "minimum-exceeded", E = z.reason === "maximum-insufficient";
+      (!Z || ae !== null) && (!E || re !== null) && !T && !he && m((U) => U && null);
+    }
+  }, [s, e, f.width, f.height, z]), K(() => {
+    Pe();
+  }, [Pe]), K(() => {
+    W.current = n;
+  }, [n]);
+  const ve = j(() => s.map((c) => c.size), [s]), se = _(!1);
+  St(() => {
+    if (s.length === 0) {
+      se.current = !1;
+      return;
+    }
+    !se.current && (u || s.every((c) => c.collapsed || c.size > 0)) && (se.current = !0), se.current && W.current && W.current(ve);
+  }, [ve, s, u]), K(() => {
+    if (d && ve.length > 0 && se.current) {
+      const c = setTimeout(() => {
+        xr(d, ve);
+      }, 200);
+      return () => clearTimeout(c);
+    }
+  }, [d, ve]), K(() => {
+    if (!d || s.length === 0 || ce.current)
+      return;
+    const c = e === "horizontal" ? f.width : f.height;
+    if (c <= 0)
+      return;
+    const g = Pr(d);
+    if (g && g.length === s.length) {
+      const M = s.map((v, Y) => {
+        const ae = G(v.minSize, 0, c), re = G(v.maxSize, c, c), T = ye(g[Y], ae, re), he = Fe(T, c), Z = v.sizeUnit === "pixels" || v.originalPixelSize !== void 0 ? T : v.preferredPixelSize;
+        return {
+          ...v,
+          size: T,
+          percentageSize: he,
+          preferredPercentageSize: he > 0 ? he : v.preferredPercentageSize,
+          preferredPixelSize: Z
+        };
+      });
+      i({ type: "SET_PANELS", panels: M }), ce.current = !0;
+    }
+  }, [d, s, f.width, f.height, e]);
+  const Ee = ge((c) => {
+    const g = $.current, M = D.current, v = JSON.stringify({
+      id: c.id,
+      size: c.size ?? null,
+      percentageSize: c.percentageSize ?? null,
+      preferredPercentageSize: c.preferredPercentageSize ?? null,
+      preferredPixelSize: c.preferredPixelSize ?? null,
+      sizeUnit: c.sizeUnit,
+      originalPixelSize: c.originalPixelSize ?? null,
+      minSize: c.minSize ?? null,
+      maxSize: c.maxSize ?? null,
+      collapseFromStart: c.collapseFromStart,
+      collapseFromEnd: c.collapseFromEnd,
+      collapsed: c.collapsed ?? !1,
+      collapsedByDirection: c.collapsedByDirection ?? null,
+      sizeBeforeCollapse: c.sizeBeforeCollapse ?? null,
+      percentageSizeBeforeCollapse: c.percentageSizeBeforeCollapse ?? null,
+      preferredPercentageSizeBeforeCollapse: c.preferredPercentageSizeBeforeCollapse ?? null,
+      preferredPixelSizeBeforeCollapse: c.preferredPixelSizeBeforeCollapse ?? null,
+      pixelAdjustPriority: c.pixelAdjustPriority ?? null,
+      flexAdjustPriority: c.flexAdjustPriority ?? null,
+      autoMinSize: c.autoMinSize ?? null
+    });
+    if (M[c.id] === v) {
+      nt.debug("useResizablePanels.registerPanel skipped", {
+        panelId: c.id,
+        reason: "duplicate-registration"
+      });
+      return;
+    }
+    M[c.id] = v, nt.debug("useResizablePanels.registerPanel", {
+      panelId: c.id,
+      containerReady: A.current,
+      violationReason: y.current,
+      containerSize: {
+        width: g.width,
+        height: g.height
+      }
+    }), i({ type: "REGISTER_PANEL", panel: c });
+  }, []), _e = ge((c) => {
+    const g = $.current;
+    nt.debug("useResizablePanels.unregisterPanel", {
+      panelId: c,
+      containerReady: A.current,
+      violationReason: y.current,
+      containerSize: {
+        width: g.width,
+        height: g.height
+      }
+    }), i({ type: "UNREGISTER_PANEL", id: c }), delete D.current[c], de.current[c] && (clearTimeout(de.current[c]), delete de.current[c]), delete Ge.current[c], b((M) => {
+      if (!(c in M))
+        return M;
+      const v = { ...M };
+      return delete v[c], v;
+    });
+  }, []), ke = ge(
+    (c, g, M, v) => {
+      const Y = e === "horizontal" ? f.width : f.height, ae = s.find((U) => U.id === c), re = s.find((U) => U.id === g);
+      if (!(ae && re)) {
+        i({ type: "RESIZE_PANELS", leftId: c, rightId: g, leftSize: M, rightSize: v, containerSize: Y });
+        return;
+      }
+      if (ae.collapsed || re.collapsed)
+        return;
+      const T = G(ae.minSize, 0, Y), he = G(ae.maxSize, Y, Y), Z = G(re.minSize, 0, Y), E = G(re.maxSize, Y, Y);
+      let S = ye(M, T, he), O = ye(v, Z, E);
+      const X = S + O, Q = M + v;
+      if (Math.abs(X - Q) > 1e-9) {
+        const U = Q - X;
+        if (U > 0) {
+          const q = he - S, o = E - O, w = q + o;
+          if (w > 0) {
+            const J = Math.min(U * (q / w), q), ee = Math.min(U - J, o);
+            S += J, O += ee;
+          }
+        } else if (U < 0) {
+          const q = Math.abs(U), o = S - T, w = O - Z, J = o + w;
+          if (J > 0) {
+            const ee = Math.min(q * (o / J), o), Re = Math.min(q - ee, w);
+            S -= ee, O -= Re;
+          }
+        }
+      }
+      S = ye(S, T, he), O = ye(O, Z, E), Math.abs(S + O - Q) > 1e-9 && nt.error("Total size after constraints should be close to the original total size.", { constrainedLeftSize: S, constrainedRightSize: O, originalTotalSize: Q }), i({ type: "RESIZE_PANELS", leftId: c, rightId: g, leftSize: S, rightSize: O, containerSize: Y });
+    },
+    [e, f.width, f.height, s]
+  ), $e = ge(
+    (c, g) => {
+      const M = e === "horizontal" ? f.width : f.height;
+      i({ type: "COLLAPSE_PANEL", id: c, from: g, containerSize: M });
+    },
+    [e, f.width, f.height]
+  ), C = ge(
+    (c, g, M) => {
+      const v = e === "horizontal" ? f.width : f.height;
+      i({ type: "EXPAND_PANEL", id: c, from: g, containerSize: v, targetSize: M });
+    },
+    [e, f.width, f.height]
+  ), ie = ge(
+    (c) => s.find((g) => g.id === c),
+    [s]
+  ), Se = ge((c, g) => {
+    if (g === null) {
+      de.current[c] && (clearTimeout(de.current[c]), delete de.current[c]), delete Ge.current[c], b((M) => {
+        if (!(c in M))
+          return M;
+        const v = { ...M };
+        return delete v[c], v;
+      });
+      return;
+    }
+    b((M) => {
+      const v = M[c], Y = v && Math.abs(v.pixelSize - g.pixelSize) < 0.1, ae = v && Math.abs(v.percentageSize - g.percentageSize) < 0.01;
+      return Y && ae ? (de.current[c] && clearTimeout(de.current[c]), Ge.current[c] = g, de.current[c] = setTimeout(() => {
+        const re = Ge.current[c];
+        re && b((T) => ({
+          ...T,
+          [c]: re
+        })), delete de.current[c];
+      }, 200), M) : (de.current[c] && (clearTimeout(de.current[c]), delete de.current[c]), {
+        ...M,
+        [c]: g
+      });
+    });
+  }, []), ue = ge((c, g) => {
+    k((M) => {
+      if (g === null) {
+        if (!(c in M))
+          return M;
+        const Y = { ...M };
+        return delete Y[c], Y;
+      }
+      const v = M[c];
+      return v && Math.abs(v.thickness - g.thickness) <= 0.25 && v.visible === g.visible && v.direction === g.direction && v.startPanelId === g.startPanelId && v.endPanelId === g.endPanelId ? M : {
+        ...M,
+        [c]: g
+      };
+    });
+  }, []), we = j(
+    () => ({
+      direction: e,
+      panels: s,
+      containerSize: f,
+      isContainerReady: p,
+      showDebugInfo: r,
+      registerPanel: Ee,
+      unregisterPanel: _e,
+      resizePanels: ke,
+      collapsePanel: $e,
+      expandPanel: C,
+      getPanel: ie,
+      reportPanelMeasurement: Se,
+      panelMeasurements: x,
+      reportHandleMeasurement: ue,
+      handleMeasurements: N,
+      layoutConstraintViolation: z
+    }),
+    [e, s, f, p, r, Ee, _e, ke, $e, C, ie, Se, x, ue, N, z]
+  ), Oe = j(
+    () => ({
+      display: "flex",
+      flexDirection: e === "horizontal" ? "row" : "column",
+      alignItems: "stretch",
+      width: "100%",
+      height: "100%",
+      minWidth: "0px",
+      minHeight: "0px",
+      position: "relative",
+      overflow: "hidden",
+      // リサイズハンドルのはみ出しでスクロールバーを表示させない
+      ...t
+    }),
+    [e, t]
+  );
+  return {
+    groupRef: I,
+    contextValue: we,
+    groupStyle: Oe
+  };
+}, _r = (e) => {
+  const { getPanel: t, collapsePanel: n, expandPanel: d } = Mt(), r = t(e), s = ge(
+    (h) => {
+      n(e, h);
+    },
+    [n, e]
+  ), i = ge(
+    (h, p) => {
+      d(e, h, p);
+    },
+    [d, e]
+  ), f = ge(
+    (h, p) => {
+      r?.collapsed ? i(h, p) : s(h);
+    },
+    [r?.collapsed, s, i]
+  );
+  return j(
+    () => ({
+      panel: r,
+      isCollapsed: r?.collapsed ?? !1,
+      canCollapseFromStart: r?.collapseFromStart ?? !1,
+      canCollapseFromEnd: r?.collapseFromEnd ?? !1,
+      collapse: s,
+      expand: i,
+      toggle: f
+    }),
+    [r, s, i, f]
+  );
+}, yr = ({ panel: e, measuredPixelSize: t, measuredPercentageSize: n, containerAxisSize: d, containerLabel: r }) => {
+  const s = e?.size, i = typeof s == "number" && Number.isFinite(s) ? `${s.toFixed(3)}px` : "-", f = e?.percentageSize !== void 0 ? `${e.percentageSize.toFixed(3)}%` : "-", h = Number.isFinite(t) ? `${t.toFixed(3)}px` : "-", p = Number.isFinite(n) ? `${n.toFixed(3)}%` : "-", a = Number.isFinite(d) ? `${d.toFixed(3)}px` : "-", u = `${i} / ${f}`, l = `${h} / ${p}`, z = e?.sizeUnit === "pixels" ? "Fixed" : "Flexible", m = [z, `${r}: ${a}`, `size (state): ${u}`, `size (measured): ${l}`];
+  return {
+    stateValueDisplay: u,
+    measuredValueDisplay: l,
+    containerDisplay: a,
+    headlineLabel: z,
+    titleText: m.join(`
+`)
+  };
+}, Mr = yt(({ panel: e, measuredPixelSize: t, measuredPercentageSize: n, containerAxisSize: d, direction: r }) => {
+  const s = r === "horizontal" ? "container width" : "container height", { stateValueDisplay: i, measuredValueDisplay: f, containerDisplay: h, headlineLabel: p, titleText: a } = j(
+    () => yr({
+      panel: e,
+      measuredPixelSize: t,
+      measuredPercentageSize: n,
+      containerAxisSize: d,
+      containerLabel: s
+    }),
+    [e, t, n, d, s]
+  ), u = {
+    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"
+  }, l = {
+    display: "flex",
+    flexDirection: "column",
+    gap: "1px",
+    minWidth: "0",
+    width: "100%"
+  }, z = {
+    display: "flex",
+    justifyContent: "flex-start",
+    alignItems: "center",
+    gap: "6px",
+    fontSize: "10px",
+    color: "#ccc",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, m = {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    gap: "6px",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, x = {
+    marginLeft: "auto",
+    fontVariantNumeric: "tabular-nums",
+    whiteSpace: "nowrap"
+  };
+  return /* @__PURE__ */ me("div", { style: u, title: a, children: /* @__PURE__ */ Ze("div", { style: l, children: [
+    /* @__PURE__ */ me("div", { style: z, children: /* @__PURE__ */ me("span", { children: p }) }),
+    /* @__PURE__ */ Ze("div", { style: m, children: [
+      /* @__PURE__ */ me("span", { children: s }),
+      /* @__PURE__ */ me("span", { style: x, children: h })
+    ] }),
+    /* @__PURE__ */ Ze("div", { style: m, children: [
+      /* @__PURE__ */ me("span", { children: "size (state)" }),
+      /* @__PURE__ */ me("span", { style: x, children: i })
+    ] }),
+    /* @__PURE__ */ Ze("div", { style: m, children: [
+      /* @__PURE__ */ me("span", { children: "size (measured)" }),
+      /* @__PURE__ */ me("span", { style: x, children: f })
+    ] })
+  ] }) });
+}), xt = new lt(qe.INFO, "[resize-panels]"), vr = {
+  both: {
+    collapseFromStart: !0,
+    collapseFromEnd: !0
+  },
+  start: {
+    collapseFromStart: !0,
+    collapseFromEnd: !1
+  },
+  end: {
+    collapseFromStart: !1,
+    collapseFromEnd: !0
+  }
+}, wr = (e) => {
+  if (!e)
+    return {
+      collapseFromStart: !1,
+      collapseFromEnd: !1
+    };
+  const t = vr[e.from];
+  if (!t)
+    throw new Error("Invalid collapsible configuration: unsupported 'from' value");
+  return t;
+}, Ht = ({ ref: e, setState: t, panelIdRef: n, label: d, timerRef: r }) => (s) => {
+  if (!Number.isFinite(s))
+    return;
+  const i = s < 0 ? 0 : s, f = d === "pixel" ? 0.1 : 0.01;
+  if (Math.abs(e.current - i) < f) {
+    r && (r.current && clearTimeout(r.current), r.current = setTimeout(() => {
+      e.current = i, t(i), r.current = null;
+    }, 200));
+    return;
+  }
+  r?.current && (clearTimeout(r.current), r.current = null), e.current = i, xt.debug(`commit ${d}`, {
+    panelId: n.current,
+    [d]: i
+  }), t(i);
+}, kr = yt(
+  ({ id: e, defaultSize: t = { value: 50, unit: "percentage" }, minSize: n, maxSize: d, autoMinSize: r, className: s, style: i, children: f, order: h = 0, collapsible: p, defaultCollapsed: a = !1, pixelAdjustPriority: u, flexAdjustPriority: l, contentOverflow: z = "auto" }) => {
+    const { direction: m, registerPanel: x, unregisterPanel: b, getPanel: N, showDebugInfo: k, isContainerReady: I, reportPanelMeasurement: W, containerSize: ce } = Mt(), te = _(null), oe = Ut(), $ = _(e || `panel-${oe}`);
+    K(() => {
+      e && e !== $.current && xt.warn("Panel id prop change after mount is ignored.", {
+        currentId: $.current,
+        attemptedId: e
+      });
+    }, [e]);
+    const A = j(() => wr(p), [p]), y = A.collapseFromStart || A.collapseFromEnd, D = j(() => y ? A.collapseFromStart ? "start" : A.collapseFromEnd ? "end" : null : null, [y, A.collapseFromStart, A.collapseFromEnd]), V = y && a, H = j(() => Sr(t), [t]), L = H?.unit === "pixels", Me = L ? void 0 : H?.value, F = N($.current), de = !!F?.collapsed, Ge = (F?.size ?? 0) <= 0, fe = de || Ge, Ae = _(F);
+    Ae.current = F;
+    const Pe = _(fe);
+    Pe.current = fe;
+    const [ve, se] = Te(() => L && H ? H.value : F?.size !== void 0 ? F.size : 0), [Ee, _e] = Te(() => !L && H ? H.value : F?.percentageSize !== void 0 ? F.percentageSize : 0), ke = _(ve), $e = _(Ee), C = _(null), ie = _(null);
+    K(() => () => {
+      C.current && clearTimeout(C.current), ie.current && clearTimeout(ie.current);
+    }, []);
+    const Se = j(
+      () => Ht({
+        ref: ke,
+        setState: se,
+        panelIdRef: $,
+        label: "pixel",
+        timerRef: C
+      }),
+      []
+    ), ue = j(
+      () => Ht({
+        ref: $e,
+        setState: _e,
+        panelIdRef: $,
+        label: "percentage",
+        timerRef: ie
+      }),
+      []
+    ), we = ge(() => {
+      C.current && (clearTimeout(C.current), C.current = null), ie.current && (clearTimeout(ie.current), ie.current = null), ke.current !== 0 && (ke.current = 0, se(0)), $e.current !== 0 && ($e.current = 0, _e(0));
+    }, []);
+    K(() => {
+      if (!I)
+        return;
+      let E = 0;
+      if (L && H) {
+        let w = H.value;
+        n && typeof n == "object" && n.unit === "pixels" && (w = Math.max(w, n.value)), d && typeof d == "object" && d.unit === "pixels" && (w = Math.min(w, d.value)), E = w;
+      }
+      const S = V, O = S ? D : null;
+      a && !y && xt.warn("Panel defaultCollapsed is ignored because collapsible configuration is not provided.");
+      const X = y && S && L ? E : void 0, Q = y ? Me : void 0, U = L ? E : void 0, q = {
+        id: $.current,
+        size: S ? 0 : E,
+        percentageSize: S ? 0 : Me,
+        preferredPercentageSize: Me,
+        preferredPixelSize: U,
+        sizeUnit: H?.unit || "percentage",
+        originalPixelSize: L ? E : void 0,
+        minSize: n,
+        maxSize: d,
+        collapseFromStart: A.collapseFromStart,
+        collapseFromEnd: A.collapseFromEnd,
+        collapsedByDirection: O,
+        collapsed: S,
+        sizeBeforeCollapse: X,
+        percentageSizeBeforeCollapse: Q,
+        preferredPercentageSizeBeforeCollapse: y ? Me : void 0,
+        preferredPixelSizeBeforeCollapse: y ? U : void 0,
+        pixelAdjustPriority: u,
+        flexAdjustPriority: l,
+        autoMinSize: r
+      };
+      x(q);
+    }, [
+      r,
+      A.collapseFromEnd,
+      A.collapseFromStart,
+      a,
+      H,
+      l,
+      y,
+      I,
+      L,
+      d,
+      n,
+      u,
+      D,
+      Me,
+      x,
+      V
+    ]), K(() => () => {
+      b($.current), W($.current, null);
+    }, [b, W]);
+    const Oe = F?.size ?? 0, c = ge(() => {
+      const E = te.current;
+      if (!E) return;
+      const S = Ae.current;
+      if (!S)
+        return;
+      const O = E.parentElement;
+      if (!O) return;
+      const X = E.getBoundingClientRect(), Q = Ye(O, "horizontal"), U = Ye(O, "vertical"), q = m === "horizontal" ? X.width : X.height, o = m === "horizontal" ? Q.inner : U.inner, w = Ct(o);
+      if (Pe.current) {
+        we();
+        return;
+      }
+      const J = S.size ?? 0, ee = Math.max(2, w * 0.5);
+      if (J > w && q < ee) {
+        xt.debug("skip noisy measurement", {
+          panelId: $.current,
+          expectedPanelSize: J,
+          measured: q,
+          noiseThreshold: ee
+        });
+        return;
+      }
+      if (q > 0) {
+        Se(q), o > 0 && ue(q / o * 100);
+        return;
+      }
+      S.size !== void 0 && Se(S.size), S.percentageSize !== void 0 ? ue(S.percentageSize) : S.sizeUnit === "pixels" && S.size !== void 0 && o > 0 && ue(S.size / o * 100);
+    }, [ue, Se, m, we]), g = _(!1);
+    K(() => {
+      !g.current && F && (g.current = !0, c());
+    }, [F, c]), K(() => {
+      const E = te.current;
+      if (!E) return;
+      const S = new ResizeObserver(() => {
+        c();
+      });
+      S.observe(E), c();
+      const O = [], X = new MutationObserver(() => {
+        (() => {
+          if (!te.current) return !1;
+          const q = te.current.getBoundingClientRect();
+          return (m === "horizontal" ? q.width : q.height) !== ke.current;
+        })() && setTimeout(c, 0);
+      }), Q = E.parentElement;
+      return Q && X.observe(Q, {
+        childList: !0,
+        attributes: !0,
+        attributeFilter: ["style", "class"]
+      }), () => {
+        S.disconnect(), X.disconnect();
+        for (const U of O)
+          clearTimeout(U);
+      };
+    }, [m, c]);
+    const M = F?.size, v = F?.percentageSize, Y = F?.sizeUnit;
+    K(() => {
+      if (F) {
+        if (fe) {
+          we();
+          return;
+        }
+        if (M !== void 0 && Se(M), v !== void 0)
+          ue(v);
+        else if (Y === "pixels" && M !== void 0) {
+          const E = te.current, S = E?.parentElement;
+          if (E && S) {
+            const { width: O, height: X } = E.getBoundingClientRect(), Q = S.clientWidth, U = S.clientHeight, q = m === "horizontal" ? O : X, o = m === "horizontal" ? Q : U;
+            if (q > 0 && o > 0) {
+              const w = q / o * 100;
+              ue(w);
+            }
+          }
+        }
+      }
+    }, [ue, Se, F, v, M, Y, m, fe, we]), K(() => {
+      W($.current, {
+        pixelSize: ve,
+        percentageSize: Ee
+      });
+    }, [W, ve, Ee]);
+    const ae = () => fe ? "0px" : F?.originalPixelSize !== void 0 ? `${Oe}px` : F?.percentageSize !== void 0 ? `${F.percentageSize}%` : `${Oe}px`, re = F?.sizeUnit === "percentage" && !F?.collapsed ? 1 : 0, T = {
+      flexBasis: ae(),
+      flexGrow: 0,
+      flexShrink: re,
+      overflow: "hidden",
+      position: "relative",
+      boxSizing: "border-box",
+      minHeight: "0px",
+      minWidth: "0px",
+      ...i
+    };
+    m === "horizontal" ? (T.height = "100%", T.minWidth = 0) : (T.width = "100%", T.minHeight = 0), fe && (m === "horizontal" ? (T.width = "0px", T.minWidth = "0px") : (T.height = "0px", T.minHeight = "0px"), T.flexGrow = 0, T.flexShrink = 0, T.pointerEvents = "none", T.visibility = "hidden", de && (T.display = "none"));
+    const he = m === "horizontal" ? ce.width : ce.height, Z = j(
+      () => ({
+        position: "absolute",
+        inset: "0px",
+        overflow: z,
+        display: "flex",
+        flexDirection: "column",
+        width: "100%",
+        height: "100%",
+        minWidth: "0px",
+        minHeight: "0px"
+      }),
+      [z]
+    );
+    return /* @__PURE__ */ Ze(
+      "div",
+      {
+        ref: te,
+        className: at("panel", s),
+        style: T,
+        "data-panel-id": $.current,
+        "data-panel-size": Oe,
+        "data-panel-size-unit": F?.sizeUnit || "percentage",
+        "data-panel-pixel-size": F?.sizeUnit === "pixels" ? F?.originalPixelSize : null,
+        "data-panel-order": h,
+        "data-panel-collapsible": y,
+        "data-panel-collapse-start": A.collapseFromStart,
+        "data-panel-collapse-end": A.collapseFromEnd,
+        "data-panel-collapsed": F?.collapsed,
+        "aria-hidden": fe,
+        children: [
+          /* @__PURE__ */ me("div", { style: Z, children: f }),
+          k && /* @__PURE__ */ me(Mr, { panel: F, measuredPixelSize: ve, measuredPercentageSize: Ee, containerAxisSize: he, direction: m })
+        ]
+      }
+    );
+  }
+), Er = nr(() => import("./GlobalDebugOverlay-Do70T2l6.js").then((e) => ({ default: e.GlobalDebugOverlayGate })));
+let Gt = 0;
+const Br = () => (Gt += 1, `panel-group-${Gt}`), Rr = (e) => {
+  const t = e.reason === "minimum-exceeded", n = t ? "Layout unavailable: minimum panel sizes exceed the container." : "Layout unavailable: panels cannot fill the container with their maximum sizes.", d = t ? `Min required: ${Math.ceil(e.totalMinimumSize ?? 0)}px | Available: ${Math.floor(e.availableContainerSize)}px` : `Max total: ${Math.floor(e.totalMaximumSize ?? 0)}px | Needed: ${Math.floor(e.availableContainerSize)}px`;
+  return { summary: n, detail: d };
+}, Ir = (e, t) => {
+  let n = !1;
+  const d = e.map((r) => {
+    const s = t[r.id];
+    return !s || r.measuredPixelSize === s.pixelSize && r.measuredPercentageSize === s.percentageSize ? r : (n = !0, {
+      ...r,
+      measuredPixelSize: s.pixelSize,
+      measuredPercentageSize: s.percentageSize
+    });
+  });
+  return n ? d : e;
+}, $t = (e, t, n) => {
+  const d = Ye(e, "horizontal"), r = Ye(e, "vertical"), s = e.getBoundingClientRect(), i = d.inner > 0 ? d.inner : t ?? s.width, f = r.inner > 0 ? r.inner : n ?? s.height;
+  return { width: i, height: f };
+}, Or = (e) => {
+  const { id: t, className: n, style: d, children: r, direction: s } = e, { groupRef: i, contextValue: f, groupStyle: h } = Cr(e), [p, a] = Te({ width: 0, height: 0 }), u = f.layoutConstraintViolation, l = !!u, z = j(() => {
+    if (!u)
+      return null;
+    const { summary: y, detail: D } = Rr(u);
+    return /* @__PURE__ */ Ze(
+      "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__ */ me("span", { children: y }),
+          /* @__PURE__ */ me("span", { className: "text-slate-500 text-xs dark:text-slate-400", children: D })
+        ]
+      }
+    );
+  }, [u]), x = _(t ?? Br()).current, b = t ?? x, N = f.showDebugInfo && f.panels.length > 0, k = N ? f.panels : [], I = N ? f.panelMeasurements : {}, W = j(() => {
+    if (!N)
+      return [];
+    const y = Object.values(f.handleMeasurements);
+    return y.length <= 1 ? y : y.slice().sort((D, V) => D.id.localeCompare(V.id));
+  }, [f.handleMeasurements, N]), ce = f.containerSize, te = p.width > 0 ? p.width : ce.width, oe = p.height > 0 ? p.height : ce.height;
+  St(() => {
+    if (!N) {
+      a({ width: 0, height: 0 });
+      return;
+    }
+    if (typeof window > "u" || typeof ResizeObserver > "u")
+      return;
+    const y = i.current;
+    if (!y)
+      return;
+    const D = (H) => {
+      a((L) => L.width === H.width && L.height === H.height ? L : H);
+    }, V = new ResizeObserver((H) => {
+      for (const L of H) {
+        if (L.target !== y)
+          continue;
+        const Me = $t(y, L.contentRect.width, L.contentRect.height);
+        D(Me);
+      }
+    });
+    return V.observe(y), D($t(y)), () => {
+      V.disconnect();
+    };
+  }, [i, N]);
+  const $ = j(() => Ir(k, I), [k, I]);
+  K(() => {
+    if (!N)
+      return;
+    let y = !1, D = null;
+    return import("./debugOverlayStore-Cntyxboe.js").then((V) => {
+      y || (D = V, V.enableDebugOverlayGroup(x));
+    }), () => {
+      y = !0, D && (D.disableDebugOverlayGroup(x), D.removeDebugOverlayGroup(x));
+    };
+  }, [N, x]), K(() => {
+    if (!N)
+      return;
+    let y = !1;
+    return import("./debugOverlayStore-Cntyxboe.js").then((D) => {
+      y || D.updateDebugOverlayGroup(x, {
+        displayName: b,
+        direction: s,
+        containerSize: {
+          width: te,
+          height: oe
+        },
+        panels: $,
+        handles: W
+      });
+    }), () => {
+      y = !0;
+    };
+  }, [N, x, b, s, te, oe, $, W]);
+  const A = j(() => {
+    const y = {
+      ...h,
+      ...d
+    };
+    return y.position || (y.position = "relative"), y;
+  }, [h, d]);
+  return /* @__PURE__ */ Ze(jt.Provider, { value: f, children: [
+    /* @__PURE__ */ Ze("div", { ref: i, className: at("panel-group", s === "horizontal" ? "flex-row" : "flex-col", n), style: A, "data-panel-group-id": t, "data-panel-group-direction": s, children: [
+      r,
+      l && z ? /* @__PURE__ */ me(
+        "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: z
+        }
+      ) : null
+    ] }),
+    N && /* @__PURE__ */ me(ir, { fallback: null, children: /* @__PURE__ */ me(Er, { groupId: x }) })
+  ] });
+}, Nr = {
+  display: "none",
+  pointerEvents: "none",
+  visibility: "hidden"
+}, Fr = {
+  display: "none"
+}, ot = (e, t) => typeof e != "number" || !Number.isFinite(e) || e <= 0 ? t : e, Ar = (e) => {
+  const t = Math.round(e);
+  return t % 2 === 0 ? t : t + 1;
+}, Hr = yt((e) => {
+  const { id: t, disabled: n = !1, className: d, style: r, children: s, onDragging: i, thickness: f, indicator: h = !0, indicatorThickness: p, indicatorLength: a, indicatorBarThickness: u, indicatorBarLength: l, title: z } = e, { direction: m, resizePanels: x, getPanel: b, collapsePanel: N, expandPanel: k, panels: I, reportHandleMeasurement: W, containerSize: ce, layoutConstraintViolation: te } = Mt(), [oe, $] = Te(!1), A = _(null), y = _(null), D = _(""), V = _(""), H = _(null), [L, Me] = Te(!1), [F, de] = Te({ left: null, right: null }), Ge = Ut(), fe = _(t ?? `resize-handle-${Ge}`), Ae = _(null), Pe = t ?? fe.current, ve = !!te, se = n || ve, Ee = ge(() => {
+    const P = A.current;
+    if (!P) return;
+    const R = P.parentElement;
+    if (!R) return;
+    y.current = R, typeof window < "u" && Me(window.getComputedStyle(R).direction === "rtl");
+    const B = Array.from(R.children), ne = B.indexOf(P);
+    let le = null, be = null;
+    for (let ze = ne - 1; ze >= 0; ze -= 1) {
+      const Ce = B[ze];
+      if (Ce.dataset.panelId) {
+        le = Ce;
+        break;
+      }
+    }
+    for (let ze = ne + 1; ze < B.length; ze += 1) {
+      const Ce = B[ze];
+      if (Ce.dataset.panelId) {
+        be = Ce;
+        break;
+      }
+    }
+    const xe = le?.dataset.panelId || "", Be = be?.dataset.panelId || "";
+    xe === D.current && Be === V.current || (D.current = xe, V.current = Be, de({
+      left: xe || null,
+      right: Be || null
+    }));
+  }, []), _e = j(() => I.map((P) => P.id).join("|"), [I]);
+  K(() => {
+    Ee();
+  }, [Ee, _e]), K(() => {
+    if (Pe === fe.current)
+      return;
+    const P = fe.current;
+    fe.current = Pe, Ae.current = null, P !== Pe && W(P, null);
+  }, [W, Pe]), K(() => {
+    const P = fe.current;
+    return () => {
+      W(P, null);
+    };
+  }, [W]), K(() => () => {
+    H.current?.();
+  }, []);
+  const ke = ge(
+    (P) => {
+      if (se || !y.current || H.current) return;
+      P.preventDefault(), P.stopPropagation();
+      const R = y.current, { inner: B } = Ye(R, m), ne = { x: P.clientX, y: P.clientY }, le = b(D.current), be = b(V.current);
+      if (!(le && be)) return;
+      const xe = le.size, Be = be.size;
+      let ze = 0;
+      const Ce = hr;
+      $(!0), i?.(!0);
+      const Ie = P.pointerId, je = P.currentTarget, Je = m === "horizontal" && typeof window < "u" && window.getComputedStyle(R).direction === "rtl";
+      je.setPointerCapture(Ie);
+      const Et = (He) => {
+        if (He.pointerId !== Ie || !A.current) return;
+        He.preventDefault(), He.stopPropagation();
+        const Ft = performance.now();
+        if (Ft - ze < Ce) return;
+        ze = Ft;
+        const At = m === "horizontal" ? He.clientX - ne.x : He.clientY - ne.y, Pt = Je ? -At : At;
+        if (Pt === 0)
+          return;
+        const tt = xe + Pt, rt = Be - Pt, We = b(D.current), Ve = b(V.current);
+        if (We && Ve && D.current && V.current) {
+          const ut = G(We.minSize, 0, B), ft = G(Ve.minSize, 0, B), Dt = Math.min(B * Wt, Vt), Lt = Math.min(B * zr, gr), Xt = Ve.collapseFromStart, qt = Ve.collapsedByDirection ?? "start";
+          if (Xt && !Ve.collapsed && rt <= Math.max(ft * 0.3, Dt)) {
+            N(V.current, "start");
+            return;
+          }
+          const Yt = We.collapseFromEnd, Jt = We.collapsedByDirection ?? "end";
+          if (Yt && !We.collapsed && tt <= Math.max(ut * 0.3, Dt)) {
+            N(D.current, "end");
+            return;
+          }
+          if (Ve.collapsed && rt > Math.max(ft * 0.3, Lt)) {
+            k(V.current, qt, rt);
+            return;
+          }
+          if (We.collapsed && tt > Math.max(ut * 0.3, Lt)) {
+            k(D.current, Jt, tt);
+            return;
+          }
+          if (B > 0) {
+            const Tt = We.size + Ve.size, pt = Ct(B);
+            let bt = !1;
+            if (ut <= pt && tt <= pt && xe !== 0) {
+              const it = Math.max(0, Tt - 0);
+              it >= ft && (x(D.current, V.current, 0, it), bt = !0);
+            } else if (ft <= pt && rt <= pt && Be !== 0) {
+              const it = Math.max(0, Tt - 0);
+              it >= ut && (x(D.current, V.current, it, 0), bt = !0);
+            }
+            if (bt)
+              return;
+          }
+          if (We.collapsed || Ve.collapsed)
+            return;
+          x(D.current, V.current, tt, rt);
+        }
+      };
+      let Bt = !0;
+      const dt = () => {
+        Bt && (Bt = !1, H.current = null, $(!1), i?.(!1), document.removeEventListener("pointermove", Et), document.removeEventListener("pointerup", Rt), document.removeEventListener("pointercancel", It), je.removeEventListener("lostpointercapture", Nt), je.hasPointerCapture?.(Ie) && je.releasePointerCapture(Ie));
+      }, Rt = (He) => {
+        He.pointerId === Ie && dt();
+      }, It = (He) => {
+        He.pointerId === Ie && dt();
+      }, Nt = (He) => {
+        He.pointerId === Ie && dt();
+      };
+      document.addEventListener("pointermove", Et), document.addEventListener("pointerup", Rt), document.addEventListener("pointercancel", It), je.addEventListener("lostpointercapture", Nt), H.current = dt;
+    },
+    [se, m, x, b, N, k, i]
+  ), $e = ge(
+    (P) => {
+      if (se) return;
+      const R = m === "horizontal", B = R ? "ArrowLeft" : "ArrowUp", ne = R ? "ArrowRight" : "ArrowDown";
+      if (P.key !== B && P.key !== ne) return;
+      P.preventDefault(), P.stopPropagation();
+      let le = (P.key === ne ? 1 : -1) * (P.shiftKey ? _t * 5 : _t);
+      R && typeof window < "u" && y.current !== null && window.getComputedStyle(y.current).direction === "rtl" && (le = -le);
+      const xe = b(D.current), Be = b(V.current);
+      !(xe && Be) || xe.collapsed || Be.collapsed || x(D.current, V.current, xe.size + le, Be.size - le);
+    },
+    [se, m, b, x]
+  ), C = m === "horizontal", ie = C ? "cursor-col-resize" : "cursor-row-resize", Se = j(
+    () => at(
+      "group absolute z-20 flex select-none items-center justify-center border-none bg-transparent transition-colors duration-150 overflow-visible",
+      ie,
+      C ? "h-full" : "w-full",
+      !se && "hover:bg-gray-200/70 dark:hover:bg-gray-700/70",
+      !se && "active:bg-blue-300/60 dark:active:bg-blue-700/60",
+      oe && "bg-blue-200/80 dark:bg-blue-800/60",
+      se && "cursor-not-allowed opacity-50",
+      "focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-opacity-50",
+      d
+    ),
+    [ie, C, se, oe, d]
+  ), ue = j(() => {
+    const P = (R) => {
+      if (!R)
+        return -1;
+      for (let B = 0; B < I.length; B += 1)
+        if (I[B].id === R)
+          return B;
+      return -1;
+    };
+    return {
+      left: P(F.left),
+      right: P(F.right)
+    };
+  }, [F.left, F.right, I]), we = C ? ce.width : ce.height, Oe = j(() => {
+    const P = (R, B) => {
+      if (R > B)
+        return 0;
+      let ne = 0;
+      for (let le = R; le <= B; le += 1) {
+        const be = I[le];
+        if (!be)
+          continue;
+        const xe = be.size ?? 0, Be = Math.max(0, xe);
+        ne += be.collapsed ? 0 : Be;
+      }
+      return ne;
+    };
+    return ue.left >= 0 ? P(0, ue.left) : ue.right > 0 ? P(0, ue.right - 1) : 0;
+  }, [ue.left, ue.right, I]), c = j(() => !Number.isFinite(Oe) || Oe < 0 ? 0 : we > 0 && Oe > we ? we : Oe, [Oe, we]), g = typeof h == "object" && h !== null ? h : void 0, M = h === !1 || g?.visible === !1, v = ot(f, sr), Y = C ? lr : cr, ae = C ? ur : fr, re = ot(p ?? g?.thickness, ar), T = ot(a ?? g?.length, Y), he = ot(u ?? g?.barThickness, dr), Z = ot(l ?? g?.barLength, ae), E = Math.max(1, v), S = Math.min(E, Math.max(1, re)), O = Math.max(1, T), X = Math.min(S, Math.max(1, he)), Q = Math.min(O, Math.max(1, Z)), U = j(
+    () => ({
+      "--rp-handle-thickness": `${E}px`,
+      "--rp-indicator-thickness": `${S}px`,
+      "--rp-indicator-length": `${O}px`,
+      "--rp-indicator-bar-thickness": `${X}px`,
+      "--rp-indicator-bar-length": `${Q}px`
+    }),
+    [E, S, O, X, Q]
+  ), q = j(() => {
+    const P = C && L && we > 0 ? we - c : c, R = vt(P - E / 2, 0), B = {
+      position: "absolute",
+      zIndex: 20,
+      touchAction: "none",
+      ...U
+    };
+    return C ? (B.top = 0, B.left = `${R}px`, B.width = `${E}px`, B.height = "100%") : (B.left = 0, B.top = `${R}px`, B.height = `${E}px`, B.width = "100%"), B;
+  }, [c, C, L, we, E, U]), o = j(() => {
+    const P = Ct(we), R = (Ce) => {
+      if (Ce < 0 || Ce >= I.length)
+        return !1;
+      const Ie = I[Ce];
+      return Ie ? Ie.collapsed ? !0 : Ie.size <= P : !1;
+    }, B = (Ce, Ie) => {
+      if (!R(Ce))
+        return 0;
+      let je = 0;
+      for (let Je = Ce; Je >= 0 && Je < I.length && R(Je); Je += Ie)
+        je += 1;
+      return je;
+    }, ne = ue.left, le = ue.right, be = ne >= 0 ? B(ne, -1) : 0, xe = le >= 0 ? B(le, 1) : 0;
+    return {
+      groupSize: be + xe + 1,
+      overlapIndex: be
+    };
+  }, [ue.left, ue.right, I, we]), w = j(() => {
+    if (ve)
+      return !0;
+    if (o.groupSize <= 1)
+      return !1;
+    const P = o.groupSize - 1;
+    return o.overlapIndex > 0 && o.overlapIndex < P;
+  }, [o, ve]), J = j(() => {
+    if (o.groupSize <= 1 || w)
+      return 0;
+    const P = o.groupSize > 1 ? 2 : 1;
+    if (P === 1)
+      return 0;
+    const R = Ar(Math.max(pr, S + 4)), B = o.overlapIndex === 0 ? 0 : P - 1, ne = (P - 1) / 2, le = (B - ne) * R;
+    return C && L ? -le : le;
+  }, [o, w, S, C, L]), ee = j(() => {
+    if (w || M)
+      return Fr;
+    const P = C ? S : O, R = C ? O : S, B = {
+      width: `${P}px`,
+      height: `${R}px`,
+      flexShrink: 0
+    };
+    return J !== 0 && (B.transform = C ? `translateX(${J}px)` : `translateY(${J}px)`), B;
+  }, [w, M, C, S, O, J]), Re = j(() => {
+    const P = C ? X : Q, R = C ? Q : X;
+    return {
+      width: `${P}px`,
+      height: `${R}px`,
+      flexShrink: 0
+    };
+  }, [C, X, Q]), Qe = j(
+    () => at(
+      "pointer-events-none 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)]",
+      oe && "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)]",
+      g?.className
+    ),
+    [oe, g?.className]
+  ), ct = j(
+    () => at(
+      "pointer-events-none 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)]",
+      oe && "bg-blue-500 dark:bg-blue-300",
+      !se && "group-hover:bg-slate-700 dark:group-hover:bg-slate-100",
+      g?.barClassName
+    ),
+    [oe, se, g?.barClassName]
+  ), De = ge(() => {
+    const P = A.current;
+    if (!P)
+      return;
+    let R = 0;
+    if (!w) {
+      const le = m === "horizontal" ? P.offsetWidth : P.offsetHeight;
+      let be = 0, xe = 0;
+      if (typeof window < "u") {
+        const ze = window.getComputedStyle(P);
+        m === "horizontal" ? (be = Number.parseFloat(ze.marginLeft || "0"), xe = Number.parseFloat(ze.marginRight || "0")) : (be = Number.parseFloat(ze.marginTop || "0"), xe = Number.parseFloat(ze.marginBottom || "0"));
+      }
+      R = [le, be, xe].reduce((ze, Ce) => Number.isFinite(Ce) ? ze + Ce : ze, 0);
+    }
+    (!Number.isFinite(R) || R < 0) && (R = 0);
+    const B = {
+      id: Pe,
+      thickness: R,
+      direction: m,
+      visible: !w && R > mr,
+      startPanelId: F.left,
+      endPanelId: F.right
+    }, ne = Ae.current;
+    ne && Math.abs(ne.thickness - B.thickness) <= 0.25 && ne.visible === B.visible && ne.direction === B.direction && ne.startPanelId === B.startPanelId && ne.endPanelId === B.endPanelId || (Ae.current = B, W(Pe, B));
+  }, [m, F.left, F.right, W, Pe, w]);
+  K(() => {
+    De();
+  }, [De]), K(() => {
+    const P = A.current;
+    if (!P)
+      return;
+    if (typeof ResizeObserver > "u") {
+      De();
+      return;
+    }
+    const R = new ResizeObserver(() => {
+      De();
+    });
+    return R.observe(P), () => {
+      R.disconnect();
+    };
+  }, [De]);
+  const et = j(() => {
+    const P = r ? { ...q, ...r } : q;
+    return w ? {
+      ...P,
+      ...Nr
+    } : P;
+  }, [q, w, r]);
+  return /* @__PURE__ */ me(
+    "button",
+    {
+      type: "button",
+      ref: A,
+      className: Se,
+      style: et,
+      onPointerDown: ke,
+      onKeyDown: $e,
+      disabled: se,
+      "aria-hidden": w || void 0,
+      "aria-label": `Resize ${C ? "columns" : "rows"} - Drag or use arrow keys to resize, drag to the edge to collapse/expand panels`,
+      "data-resize-handle-id": Pe,
+      title: z ?? `Resize ${C ? "columns" : "rows"} - Drag or use arrow keys to resize, drag to the edge to collapse/expand panels`,
+      children: s || !M && /* @__PURE__ */ me("div", { className: Qe, style: ee, "data-resize-handle-indicator": "", "aria-hidden": "true", children: /* @__PURE__ */ me("span", { className: ct, style: Re, "data-resize-handle-indicator-bar": "", "aria-hidden": "true" }) })
+    }
+  );
+}), wt = (e) => typeof CSS < "u" && typeof CSS.escape == "function" ? CSS.escape(e) : e.replace(/["\\]/g, "\\$&"), Gr = (e) => typeof document > "u" ? null : document.querySelector(`[data-panel-id="${wt(e)}"]`), $r = (e) => typeof document > "u" ? null : document.querySelector(`[data-panel-group-id="${wt(e)}"]`), Ur = (e) => typeof document > "u" ? null : document.querySelector(`[data-resize-handle-id="${wt(e)}"]`);
+export {
+  or as P,
+  kr as a,
+  Or as b,
+  jt as c,
+  Hr as d,
+  ye as e,
+  Ye as f,
+  G as g,
+  Gr as h,
+  $r as i,
+  Ur as j,
+  Mt as k,
+  Pr as l,
+  Cr as m,
+  Sr as n,
+  xr as s,
+  _r as u
+};