@aiquants/resize-panels 1.6.0 → 1.7.2

package/dist/index-BzgId8aQ.js

@@ -0,0 +1,1972 @@
+import { createContext as It, useContext as Nt, useCallback as fe, useMemo as ee, useReducer as At, useState as Ee, useRef as H, useEffect as q, useLayoutEffect as Qe, memo as ot, useId as xt, Suspense as Dt, lazy as Lt } from "react";
+import { jsx as pe, jsxs as Le } from "react/jsx-runtime";
+import { twMerge as Ve } from "tailwind-merge";
+const Pt = It(null), st = () => {
+  const e = Nt(Pt);
+  if (!e)
+    throw new Error("usePanelGroup must be used within a PanelGroup");
+  return e;
+}, bt = (e, t = 0) => {
+  if (!Number.isFinite(e))
+    return e;
+  const n = 10 ** t, u = e * n, r = Math.floor(u), s = u - r, i = Number.EPSILON * Math.max(1, Math.abs(u));
+  return s < 0.5 - i ? r / n : s > 0.5 + i ? (r + 1) / n : (r % 2 === 0 ? r : r + 1) / n;
+}, Tt = 12, ft = 8, _t = 8, Ot = 8, pt = 10, Ct = 0.05, yt = 10, kt = 0.05, Gt = 20, Ht = 0.05, zt = 0, Mt = 6, ye = (e, t) => t <= 0 ? 0 : bt(e / t * 100, Mt), We = (e, t) => !e || t <= 0 ? 0 : e / 100 * t, Ut = (e, t = "percentage") => {
+  if (e !== void 0)
+    return typeof e == "number" ? { value: e, unit: t } : e;
+}, W = (e, t, n) => e ? typeof e == "number" ? e / 100 * n : e.unit === "pixels" ? e.value : e.value / 100 * n : t, ge = (e, t, n) => Math.min(Math.max(e, t), n), nt = (e) => {
+  if (!Number.isFinite(e) || e <= 0)
+    return zt;
+  const t = e * Ct, n = Math.min(Tt, yt, t);
+  return Math.max(zt, n);
+}, vt = (e, t, n, u = {}) => {
+  if (Math.abs(t) <= 0)
+    return t;
+  const r = u.enforceAutoMinSize ?? !1, s = e.map((a, c) => ({ panel: a, index: c })).filter(({ panel: a }) => !a.collapsed && (a.sizeUnit === "pixels" || a.originalPixelSize !== void 0));
+  if (s.length === 0)
+    return t;
+  const i = t > 0, p = [...s].sort((a, c) => {
+    const o = a.panel.pixelAdjustPriority ?? a.index + 1, m = c.panel.pixelAdjustPriority ?? c.index + 1;
+    return o === m ? i ? c.index - a.index : a.index - c.index : i ? m - o : o - m;
+  });
+  let h = t;
+  const z = (a) => {
+    for (const { index: c } of p) {
+      if (Math.abs(h) <= 0)
+        break;
+      const o = e[c];
+      if (!o || o.collapsed)
+        continue;
+      const m = W(o.minSize, 0, n), b = W(o.maxSize, n, n), C = r ? W(o.autoMinSize, 0, n) : 0, M = Math.max(m, C), E = o.preferredPixelSize !== void 0 ? ge(o.preferredPixelSize, M, b) : o.size, L = o.collapseFromStart || o.collapseFromEnd;
+      if (h > 0) {
+        if (Math.abs(o.size) <= 0 && (o.percentageSize ?? 0) <= 0)
+          continue;
+        const O = Math.max(o.size, E), ie = a ? Math.min(b, O) : b, Q = Math.max(0, ie - o.size);
+        if (Q <= 0)
+          continue;
+        const ze = Math.min(Q, h);
+        if (ze <= 0)
+          continue;
+        const T = o.size + ze, U = ye(T, n), w = L ? T : o.sizeBeforeCollapse, V = L ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? T : o.measuredPixelSizeBeforeCollapse;
+        e[c] = {
+          ...o,
+          size: T,
+          percentageSize: U,
+          sizeBeforeCollapse: w,
+          measuredPixelSizeBeforeCollapse: V,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, h -= ze;
+      } else {
+        const B = a ? E : M, O = Math.max(0, o.size - B);
+        if (O <= 0)
+          continue;
+        const ie = Math.min(O, Math.abs(h));
+        if (ie <= 0)
+          continue;
+        const Q = o.size - ie, ze = ye(Q, n), T = L ? Q : o.sizeBeforeCollapse, U = L ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? Q : o.measuredPixelSizeBeforeCollapse;
+        e[c] = {
+          ...o,
+          size: Q,
+          percentageSize: ze,
+          sizeBeforeCollapse: T,
+          measuredPixelSizeBeforeCollapse: U,
+          measuredPixelSize: void 0,
+          measuredPercentageSize: void 0
+        }, h += ie;
+      }
+    }
+  };
+  return z(!0), (i && h > 0 || !i && h < 0) && z(!1), h;
+}, qe = (e) => {
+  if (!e)
+    return 0;
+  const t = parseFloat(e);
+  return Number.isFinite(t) ? t : 0;
+}, Ge = (e, t) => {
+  const n = e.getBoundingClientRect(), u = typeof window < "u" ? window.getComputedStyle(e) : null, r = u ? qe(u.borderLeftWidth) + qe(u.borderRightWidth) : 0, s = u ? qe(u.borderTopWidth) + qe(u.borderBottomWidth) : 0;
+  if (t === "horizontal") {
+    const z = n.width > 0 ? n.width : e.offsetWidth, a = n.width > 0 ? Math.max(0, n.width - r) : e.clientWidth, c = e.offsetWidth > 0 ? e.offsetWidth : e.clientWidth + r;
+    return {
+      inner: a > 0 ? a : Math.max(0, e.clientWidth),
+      outer: z > 0 ? z : Math.max(0, c)
+    };
+  }
+  const i = n.height > 0 ? n.height : e.offsetHeight, p = n.height > 0 ? Math.max(0, n.height - s) : e.clientHeight, h = e.offsetHeight > 0 ? e.offsetHeight : e.clientHeight + s;
+  return {
+    inner: p > 0 ? p : Math.max(0, e.clientHeight),
+    outer: i > 0 ? i : Math.max(0, h)
+  };
+}, jt = (e, t) => {
+  try {
+    localStorage.setItem(`panel-layout-${e}`, JSON.stringify(t));
+  } catch (n) {
+    console.warn("Failed to save panel layout:", n);
+  }
+}, $t = (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 ke = /* @__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))(ke || {});
+const Ce = class Ce {
+  /**
+   * @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]", u = console) {
+    this.level = t, this.prefix = n, this.impl = u, Ce.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 Ce.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 Ce.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 Ce.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) {
+    Ce.instance.debug(t, ...n);
+  }
+  debug(t, ...n) {
+    this.level <= 0 && this.impl.debug(...this.formatMessage(t), ...n);
+  }
+  static info(t, ...n) {
+    Ce.instance.info(t, ...n);
+  }
+  info(t, ...n) {
+    this.level <= 1 && this.impl.info(...this.formatMessage(t), ...n);
+  }
+  static warn(t, ...n) {
+    Ce.instance.warn(t, ...n);
+  }
+  warn(t, ...n) {
+    this.level <= 2 && this.impl.warn(...this.formatMessage(t), ...n);
+  }
+  static error(t, ...n) {
+    Ce.instance.error(t, ...n);
+  }
+  error(t, ...n) {
+    this.level <= 3 && this.impl.error(...this.formatMessage(t), ...n);
+  }
+};
+Ce.instances = /* @__PURE__ */ new Set(), Ce.instance = new Ce(2, "[resize-panels]");
+let Ze = Ce;
+const ue = new Ze(ke.INFO, "[resize-panels]"), Ae = 1e-9, we = (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
+})), Ke = (e) => e ? we([e])[0] : null, Oe = (e) => e ? !!(e.collapseFromStart || e.collapseFromEnd) : !1, Ye = (e, t) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return e;
+  const n = e.map((h) => ({ ...h })), u = [];
+  for (let h = 0; h < n.length; h += 1) {
+    const z = n[h];
+    if (z.collapsed) {
+      n[h] = {
+        ...z,
+        size: 0,
+        percentageSize: 0
+      };
+      continue;
+    }
+    const a = Math.max(0, W(z.minSize, 0, t)), c = Math.max(0, W(z.autoMinSize, 0, t)), o = Math.max(a, c), m = Math.max(1e-3, o), b = W(z.maxSize, t, t), C = Math.max(o, b), M = z.sizeUnit === "pixels" || z.originalPixelSize !== void 0, E = Math.max(0, z.size);
+    let L = o;
+    if (M) {
+      const O = z.preferredPixelSize ?? z.size ?? z.originalPixelSize ?? o;
+      L = ge(O, o, C);
+    } else {
+      const O = z.preferredPercentageSize ?? z.percentageSize ?? ye(z.size, t), ie = We(O, t);
+      L = ge(ie, o, C);
+    }
+    const B = !M && (z.excludeFromAutoGrowth ?? !1) && E <= m;
+    u.push({
+      index: h,
+      isPixelPanel: M,
+      minSize: o,
+      maxSize: C,
+      preferredSize: L,
+      priority: z.pixelAdjustPriority ?? h + 1,
+      flexPriority: M ? void 0 : z.flexAdjustPriority,
+      excludeFromGrowth: B
+    });
+  }
+  if (u.length === 0)
+    return n;
+  const r = /* @__PURE__ */ new Map();
+  let s = 0;
+  for (const h of u)
+    r.set(h.index, h.minSize), s += h.minSize;
+  let i = t - s;
+  const p = (h, z) => {
+    if (z <= 0)
+      return 0;
+    const a = r.get(h.index) ?? h.minSize, c = Math.max(0, h.maxSize - a);
+    if (c <= 0)
+      return 0;
+    const o = Math.min(z, c);
+    return r.set(h.index, a + o), o;
+  };
+  if (i > 0) {
+    const h = (a) => {
+      for (; i > 1e-6; ) {
+        let o = 0;
+        const m = [];
+        for (const M of a) {
+          if (!M.isPixelPanel && M.excludeFromGrowth)
+            continue;
+          const E = r.get(M.index) ?? M.minSize, L = Math.min(M.preferredSize, M.maxSize), B = Math.max(0, L - E);
+          B > 1e-6 && (o += B, m.push({ descriptor: M, capacity: B }));
+        }
+        if (m.length === 0 || o <= 1e-6)
+          break;
+        let b = 0;
+        const C = i;
+        for (const M of m) {
+          if (i <= 1e-6)
+            break;
+          if (!M.descriptor.isPixelPanel && M.descriptor.excludeFromGrowth)
+            continue;
+          const E = C * M.capacity / o, L = Math.min(M.capacity, E);
+          if (L <= 0)
+            continue;
+          const B = p(M.descriptor, L);
+          B > 0 && (i -= B, b += B);
+        }
+        if (b <= 1e-6)
+          break;
+      }
+    }, z = u.filter((a) => a.isPixelPanel);
+    z.sort((a, c) => c.priority - a.priority);
+    for (const a of z) {
+      if (i <= 0)
+        break;
+      const c = r.get(a.index) ?? a.minSize, o = Math.min(a.preferredSize, a.maxSize), m = Math.max(0, o - c);
+      if (m <= 0)
+        continue;
+      const b = p(a, Math.min(m, i));
+      b > 0 && (i -= b);
+    }
+    if (i > 0) {
+      const a = u.filter((c) => !c.isPixelPanel);
+      if (a.length > 0) {
+        const c = a.filter((o) => o.flexPriority !== void 0 && !o.excludeFromGrowth);
+        if (c.length > 0) {
+          c.sort((o, m) => (m.flexPriority ?? 0) - (o.flexPriority ?? 0));
+          for (const o of c) {
+            if (i <= 0)
+              break;
+            if (o.excludeFromGrowth)
+              continue;
+            const m = r.get(o.index) ?? o.minSize, b = Math.min(o.preferredSize, o.maxSize), C = Math.max(0, b - m);
+            if (C <= 0)
+              continue;
+            const M = p(o, Math.min(C, i));
+            M > 0 && (i -= M);
+          }
+        }
+        if (i > 0) {
+          const o = c.length > 0 ? a.filter((m) => m.flexPriority === void 0 && !m.excludeFromGrowth) : a.filter((m) => !m.excludeFromGrowth);
+          o.length > 0 && h(o);
+        }
+      }
+    }
+  }
+  if (i > 0) {
+    let h = i;
+    for (; ; ) {
+      let z = 0;
+      const a = [];
+      for (const o of u) {
+        if (!o.isPixelPanel && o.excludeFromGrowth)
+          continue;
+        const m = r.get(o.index) ?? o.minSize, b = o.isPixelPanel ? Math.min(o.maxSize, o.preferredSize) : o.maxSize, C = Math.max(0, b - m);
+        C > 0 && (a.push(o), z += C);
+      }
+      if (z <= 0)
+        break;
+      const c = i;
+      for (const o of a) {
+        if (i <= 0)
+          break;
+        if (!o.isPixelPanel && o.excludeFromGrowth)
+          continue;
+        const m = r.get(o.index) ?? o.minSize, b = o.isPixelPanel ? Math.min(o.maxSize, o.preferredSize) : o.maxSize, C = Math.max(0, b - m);
+        if (C <= 0)
+          continue;
+        const M = c * C / z, E = p(o, Math.min(C, M));
+        E > 0 && (i -= E);
+      }
+      if (i <= 1e-6 || Math.abs(h - i) <= 1e-6)
+        break;
+      h = i;
+    }
+    i = Math.max(0, i);
+  }
+  for (const h of u) {
+    const z = r.get(h.index) ?? h.minSize, a = n[h.index], c = Oe(a), o = c ? z : a.sizeBeforeCollapse, m = c ? a.measuredPixelSizeBeforeCollapse ?? a.measuredPixelSize ?? z : a.measuredPixelSizeBeforeCollapse, b = t > 0 ? ye(z, t) : 0;
+    n[h.index] = {
+      ...a,
+      size: z,
+      percentageSize: b,
+      preferredPercentageSize: a.preferredPercentageSize,
+      preferredPixelSize: h.isPixelPanel ? a.preferredPixelSize ?? z : a.preferredPixelSize,
+      sizeBeforeCollapse: o,
+      measuredPixelSizeBeforeCollapse: m,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    };
+  }
+  return _e(n);
+}, _e = (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 u = 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 = ye(r.size, t), i = r.measuredPercentageSize, z = (i !== void 0 ? Math.abs(i - s) : 1 / 0) < 1e-4 && i !== void 0 ? i : s, a = bt(z, Mt), o = Math.abs((r.percentageSize ?? 0) - a) > 0 || r.percentageSize === void 0, m = r.sizeBeforeCollapse === void 0 || r.sizeBeforeCollapse !== r.size, b = Oe(r), C = b && m, M = r.measuredPixelSize ?? r.size, E = b && (r.measuredPixelSizeBeforeCollapse === void 0 || r.measuredPixelSizeBeforeCollapse !== M);
+    if (!(o || C || E))
+      return r;
+    n = !0;
+    const L = C ? r.size : r.sizeBeforeCollapse, B = E ? M : r.measuredPixelSizeBeforeCollapse;
+    return {
+      ...r,
+      percentageSize: a,
+      sizeBeforeCollapse: L,
+      measuredPixelSizeBeforeCollapse: B,
+      collapsedByDirection: r.collapsed ? r.collapsedByDirection ?? null : null
+    };
+  });
+  return n ? u : e;
+}, Je = (e, t) => {
+  if (t <= 0)
+    return !1;
+  const n = [];
+  let u = 0;
+  for (let a = 0; a < e.length; a += 1) {
+    const c = e[a];
+    !c || c.collapsed || (n.push(a), u += c.size);
+  }
+  if (n.length === 0)
+    return !1;
+  let r = t - u;
+  if (Math.abs(r) <= 0)
+    return !1;
+  let s = !1;
+  const i = (a) => {
+    const c = e[a], o = W(c.minSize, 0, t), m = W(c.autoMinSize, 0, t), b = Math.max(o, m), C = W(c.maxSize, t, t), M = c.sizeUnit === "percentage" && c.originalPixelSize === void 0;
+    return {
+      index: a,
+      minSize: b,
+      maxSize: C,
+      isFlexible: M
+    };
+  }, p = (a, c) => {
+    if (!Number.isFinite(c) || Math.abs(c) <= 0)
+      return;
+    const o = e[a];
+    if (!o)
+      return;
+    const m = Math.max(0, o.size + c);
+    if (Math.abs(m - o.size) <= 0)
+      return;
+    const b = ye(m, t), C = Oe(o), M = C ? m : o.sizeBeforeCollapse, E = C ? o.measuredPixelSizeBeforeCollapse ?? o.measuredPixelSize ?? m : o.measuredPixelSizeBeforeCollapse;
+    e[a] = {
+      ...o,
+      size: m,
+      percentageSize: b,
+      sizeBeforeCollapse: M,
+      measuredPixelSizeBeforeCollapse: E,
+      measuredPixelSize: void 0,
+      measuredPercentageSize: void 0
+    }, r -= c, s = !0;
+  }, h = (a) => {
+    for (const c of a) {
+      if (Math.abs(r) <= 0)
+        break;
+      const o = e[c.index];
+      if (!o || o.collapsed)
+        continue;
+      const m = o.size;
+      if (r > 0) {
+        const b = Math.max(0, c.maxSize - m);
+        if (b <= 0)
+          continue;
+        const C = Math.min(b, r);
+        if (C <= 0)
+          continue;
+        p(c.index, C);
+      } else {
+        const b = Math.max(0, m - c.minSize);
+        if (b <= 0)
+          continue;
+        const C = Math.min(b, Math.abs(r));
+        if (C <= 0)
+          continue;
+        p(c.index, -C);
+      }
+    }
+  }, z = n.map((a) => i(a)).filter((a) => a.isFlexible);
+  if (z.length > 0 && h(z), Math.abs(r) > 0) {
+    const a = r;
+    r = vt(e, r, t, { enforceAutoMinSize: !0 }), Math.abs(r - a) > 0 && (s = !0);
+  }
+  return s;
+}, ht = (e, t, n) => {
+  if (!(e.sizeUnit === "pixels" || e.originalPixelSize !== void 0) || e.pixelAdjustPriority !== void 0)
+    return e;
+  const r = t.filter((i, p) => p !== 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
+  };
+}, Wt = (e, t) => {
+  switch (t.type) {
+    case "REGISTER_PANEL": {
+      ue.debug("REGISTER_PANEL", t.panel);
+      const n = e.findIndex((s) => s.id === t.panel.id);
+      if (n >= 0) {
+        const s = [...e], i = e[n], p = {
+          ...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 = ht(p, e, n);
+        if (ue.debug("register panel (update)", {
+          panelId: h.id,
+          incoming: Ke(t.panel),
+          previous: Ke(i),
+          next: Ke(h)
+        }), s[n] = h, !h.collapsed) {
+          const z = s.reduce((a, c) => c.collapsed ? a : a + c.size, 0);
+          if (z > 0) {
+            const a = W(h.minSize, 0, z), c = Math.max(a, W(h.maxSize, z, z));
+            if (h.size < a - Ae || h.size > c + Ae)
+              return Ye(s, z);
+          }
+        }
+        return s;
+      }
+      const u = { ...t.panel }, r = ht(u, e);
+      return ue.debug("register panel (insert)", {
+        panelId: r.id,
+        incoming: Ke(r),
+        previousLength: e.length
+      }), [...e, r];
+    }
+    case "UNREGISTER_PANEL": {
+      ue.debug("UNREGISTER_PANEL", t.id);
+      const n = e.filter((r) => r.id !== t.id), u = _e(n);
+      return ue.enabledFor(ke.DEBUG) && ue.debug("unregister panel", {
+        panelId: t.id,
+        previous: we(e),
+        filtered: we(n),
+        next: we(u)
+      }), u;
+    }
+    case "RESIZE_PANELS": {
+      ue.debug("RESIZE_PANELS", t.leftId, t.rightId, t.leftSize, t.rightSize);
+      const n = e.findIndex((F) => F.id === t.leftId), u = e.findIndex((F) => F.id === t.rightId);
+      if (n === -1 || u === -1) return e;
+      const r = [...e], s = r[n], i = r[u];
+      if (s.collapsed || i.collapsed || t.leftSize === s.size && t.rightSize === i.size)
+        return e;
+      const p = t.containerSize ?? e.reduce((F, $) => F + $.size, 0), h = W(s.minSize, 0, p), z = W(s.maxSize, p, p), a = W(i.minSize, 0, p), c = W(i.maxSize, p, p), o = s.size + i.size, m = e.reduce((F, $) => $.collapsed ? F : F + $.size, 0), b = m - o, C = h + a, M = z + c, E = ge(t.leftSize + t.rightSize, C, M);
+      let L = p > 0 ? p - b : E;
+      Number.isFinite(L) || (L = E);
+      const B = ge(Math.max(E, L), C, M), O = (F) => ({
+        min: Math.max(h, F - c),
+        max: Math.min(z, F - a)
+      }), ie = (F) => ({
+        min: Math.max(a, F - z),
+        max: Math.min(c, F - h)
+      }), Q = Math.abs(t.leftSize - s.size), ze = Math.abs(t.rightSize - i.size), T = Q >= ze;
+      let U = s.size, w = i.size;
+      if (T) {
+        const F = O(B);
+        if (F.min > F.max + Ae)
+          return e;
+        const $ = ge(t.leftSize, F.min, F.max), le = B - $;
+        if (le < a - Ae || le > c + Ae)
+          return e;
+        U = $, w = ge(le, a, c);
+      } else {
+        const F = ie(B);
+        if (F.min > F.max + Ae)
+          return e;
+        const $ = ge(t.rightSize, F.min, F.max), le = B - $;
+        if (le < h - Ae || le > z + Ae)
+          return e;
+        w = $, U = ge(le, h, z);
+      }
+      const V = U + w;
+      if (Math.abs(B - V) > Ae)
+        return e;
+      const ce = m - s.size - i.size + V, k = p > 0 ? p : ce, j = k > 0 ? ye(U, k) : 0, te = k > 0 ? ye(w, k) : 0, G = s.sizeUnit === "pixels" || s.originalPixelSize !== void 0 ? U : s.preferredPixelSize, oe = i.sizeUnit === "pixels" || i.originalPixelSize !== void 0 ? w : i.preferredPixelSize, Be = W(s.autoMinSize, 0, p), me = W(i.autoMinSize, 0, p), de = Math.max(1e-3, Be), Ie = Math.max(1e-3, me), xe = s.sizeUnit === "percentage" && s.originalPixelSize === void 0, se = i.sizeUnit === "percentage" && i.originalPixelSize === void 0;
+      let ae = s.excludeFromAutoGrowth, Se = i.excludeFromAutoGrowth;
+      xe && (U <= de ? ae = !0 : U > de && (ae = !1)), se && (w <= Ie ? Se = !0 : w > Ie && (Se = !1));
+      const Pe = Oe(s), Me = Oe(i);
+      return r[n] = {
+        ...s,
+        size: U,
+        percentageSize: j,
+        preferredPercentageSize: j > 0 ? j : s.preferredPercentageSize,
+        preferredPixelSize: G,
+        sizeBeforeCollapse: Pe ? U : s.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: ae
+      }, r[u] = {
+        ...i,
+        size: w,
+        percentageSize: te,
+        preferredPercentageSize: te > 0 ? te : i.preferredPercentageSize,
+        preferredPixelSize: oe,
+        sizeBeforeCollapse: Me ? w : i.sizeBeforeCollapse,
+        measuredPixelSize: void 0,
+        measuredPercentageSize: void 0,
+        excludeFromAutoGrowth: Se
+      }, p > 0 && Je(r, p) ? _e(r) : r;
+    }
+    case "SET_PANELS": {
+      ue.debug("SET_PANELS", t.panels);
+      const n = ue.enabledFor(ke.DEBUG), u = t.panels.map((z) => {
+        const a = z.sizeUnit === "pixels" || z.originalPixelSize !== void 0, c = z.preferredPercentageSize !== void 0 ? z.preferredPercentageSize : z.percentageSize, o = z.preferredPixelSize !== void 0 ? z.preferredPixelSize : a ? z.size : z.preferredPixelSize;
+        return {
+          ...z,
+          preferredPercentageSize: c,
+          preferredPixelSize: o
+        };
+      }), r = we(e), s = n ? we(u) : null, i = _e(u), p = we(i);
+      let h = r.length === p.length;
+      if (h)
+        for (let z = 0; z < p.length; z += 1) {
+          const a = p[z], c = r[z];
+          if (!c) {
+            h = !1;
+            break;
+          }
+          if (!(c.id === a.id && c.size === a.size && c.percentageSize === a.percentageSize && c.preferredPercentageSize === a.preferredPercentageSize && c.sizeBeforeCollapse === a.sizeBeforeCollapse && c.percentageSizeBeforeCollapse === a.percentageSizeBeforeCollapse && c.preferredPercentageSizeBeforeCollapse === a.preferredPercentageSizeBeforeCollapse && c.measuredPercentageSize === a.measuredPercentageSize && c.excludeFromAutoGrowth === a.excludeFromAutoGrowth && c.collapsed === a.collapsed && c.collapseFromStart === a.collapseFromStart && c.collapseFromEnd === a.collapseFromEnd && c.collapsedByDirection === a.collapsedByDirection)) {
+            h = !1;
+            break;
+          }
+        }
+      return h ? (n && ue.debug("set panels skipped (no diff)", {
+        previous: r,
+        incoming: s,
+        next: p,
+        previousLength: r.length,
+        incomingLength: s?.length ?? u.length
+      }), e) : (n && ue.debug("set panels", {
+        previous: r,
+        incoming: s,
+        next: p,
+        previousLength: r.length,
+        incomingLength: s?.length ?? u.length
+      }), i);
+    }
+    case "CONTAINER_RESIZED": {
+      ue.debug("CONTAINER_RESIZED", t.containerSize);
+      const n = ue.enabledFor(ke.DEBUG);
+      if (t.containerSize <= 0)
+        return n && ue.debug("container resized skipped (non-positive size)", {
+          containerSize: t.containerSize,
+          panels: we(e)
+        }), e;
+      n && ue.debug("container resized (before)", {
+        containerSize: t.containerSize,
+        panels: we(e)
+      });
+      const u = Ye(e, t.containerSize);
+      if (n && ue.debug("container resized (after recalc)", {
+        containerSize: t.containerSize,
+        panels: we(u)
+      }), t.containerSize > 0 && Je(u, t.containerSize)) {
+        const r = _e(u);
+        return n && ue.debug("container resized (after reconcile)", {
+          containerSize: t.containerSize,
+          panels: we(r)
+        }), r;
+      }
+      return n && ue.debug("container resized (final)", {
+        containerSize: t.containerSize,
+        panels: we(u)
+      }), u;
+    }
+    case "COLLAPSE_PANEL": {
+      ue.debug("COLLAPSE_PANEL", t.id);
+      const n = e.findIndex((o) => o.id === t.id);
+      if (n === -1)
+        return e;
+      const u = e[n], r = t.from === "start" ? u.collapseFromStart : u.collapseFromEnd;
+      if (!(Oe(u) && r) || u.collapsed)
+        return e;
+      const i = u.size, p = u.measuredPixelSize ?? i, h = u.percentageSize ?? u.preferredPercentageSize ?? 0, z = {
+        ...u,
+        collapsed: !0,
+        collapsedByDirection: t.from,
+        sizeBeforeCollapse: i,
+        percentageSizeBeforeCollapse: h,
+        preferredPercentageSizeBeforeCollapse: u.preferredPercentageSize ?? h,
+        preferredPixelSizeBeforeCollapse: u.preferredPixelSize ?? i,
+        measuredPixelSizeBeforeCollapse: p,
+        size: 0,
+        percentageSize: 0,
+        preferredPercentageSize: u.preferredPercentageSize,
+        measuredPixelSize: u.measuredPixelSize !== void 0 ? 0 : u.measuredPixelSize,
+        measuredPercentageSize: u.measuredPercentageSize !== void 0 ? 0 : u.measuredPercentageSize
+      }, a = [...e];
+      a[n] = z;
+      const c = Ye(a, t.containerSize);
+      return t.containerSize > 0 && Je(c, t.containerSize) ? _e(c) : c;
+    }
+    case "EXPAND_PANEL": {
+      ue.debug("EXPAND_PANEL", t.id, t.targetSize);
+      const n = e.findIndex((B) => B.id === t.id);
+      if (n === -1)
+        return e;
+      const u = t.containerSize, r = e[n], s = t.from === "start" ? r.collapseFromStart : r.collapseFromEnd;
+      if (!(Oe(r) && s && r.collapsed) || r.collapsedByDirection && r.collapsedByDirection !== t.from)
+        return e;
+      const p = [t.targetSize, r.sizeBeforeCollapse, r.measuredPixelSizeBeforeCollapse, r.preferredPixelSizeBeforeCollapse, r.originalPixelSize].find((B) => B !== void 0) ?? 0, h = W(r.minSize, 0, u), z = W(r.maxSize, u, u), a = ge(p, h, z), c = ye(a, u), o = r.measuredPixelSizeBeforeCollapse ?? a, m = ye(o, u), b = r.preferredPercentageSizeBeforeCollapse ?? r.percentageSizeBeforeCollapse ?? c, C = r.preferredPixelSizeBeforeCollapse ?? r.preferredPixelSize ?? a, M = {
+        ...r,
+        collapsed: !1,
+        collapsedByDirection: null,
+        size: a,
+        percentageSize: c,
+        preferredPercentageSize: b,
+        preferredPixelSize: C,
+        sizeBeforeCollapse: a,
+        percentageSizeBeforeCollapse: void 0,
+        preferredPercentageSizeBeforeCollapse: void 0,
+        preferredPixelSizeBeforeCollapse: void 0,
+        measuredPixelSize: a,
+        measuredPixelSizeBeforeCollapse: o,
+        measuredPercentageSize: m
+      }, E = [...e];
+      E[n] = M;
+      const L = Ye(E, u);
+      return u > 0 && Je(L, u) ? _e(L) : L;
+    }
+    default:
+      return e;
+  }
+}, $e = new Ze(ke.INFO, "[resize-panels]"), Vt = ({ direction: e, style: t, onLayout: n, autoSaveId: u, showDebugInfo: r = !1 }) => {
+  const [s, i] = At(Wt, []), [p, h] = Ee({ width: 0, height: 0 }), [z, a] = Ee(!1), [c, o] = Ee(!1), [m, b] = Ee(null), [C, M] = Ee({}), [E, L] = Ee({}), B = H(null), O = H(n), ie = H(!1), Q = H(0), ze = H(p), T = H(p), U = H(z), w = H(m?.reason ?? null), V = H({}), ce = H(null), k = H(null), j = H(null), te = H({ width: 0, height: 0 }), G = H({ width: 0, height: 0 }), oe = H({}), Be = H({}), me = fe((d) => d.map((x) => ({ ...x })), []);
+  q(() => {
+    T.current = p;
+  }, [p]), q(() => {
+    U.current = z;
+  }, [z]), q(() => {
+    w.current = m?.reason ?? null;
+  }, [m?.reason]), q(() => {
+    if (m)
+      return;
+    const d = e === "horizontal" ? p.width : p.height;
+    !Number.isFinite(d) || d <= 4 || s.length !== 0 && (ce.current = me(s));
+  }, [m, s, e, p.width, p.height, me]);
+  const de = H(s);
+  q(() => {
+    de.current = s;
+  }, [s]), q(() => {
+    const d = k.current;
+    if (m) {
+      k.current = m;
+      return;
+    }
+    if (d && !m && ce.current) {
+      k.current = null;
+      const x = new Set(de.current.map((g) => g.id)), f = me(ce.current).filter((g) => x.has(g.id));
+      f.length > 0 && i({ type: "SET_PANELS", panels: f });
+      return;
+    }
+    k.current = m;
+  }, [m, me]), Qe(() => {
+    if (!B.current) return;
+    const d = new ResizeObserver((x) => {
+      for (const f of x) {
+        const g = f.target, y = g ? Ge(g, "horizontal") : null, I = g ? Ge(g, "vertical") : null, N = y ? y.inner : 0, v = I ? I.inner : 0, _ = f.contentRect.width, A = f.contentRect.height, P = N > 0 ? N : _, S = v > 0 ? v : A;
+        te.current = { width: P, height: S };
+        const D = G.current, Z = Math.abs(D.width - P) >= 0.5, K = Math.abs(D.height - S) >= 0.5;
+        Z || K ? (j.current && (clearTimeout(j.current), j.current = null), !z && P > 0 && S > 0 && a(!0), h({ width: P, height: S }), G.current = { width: P, height: S }) : (j.current && clearTimeout(j.current), j.current = setTimeout(() => {
+          const X = te.current;
+          h(X), G.current = X, j.current = null;
+        }, 150));
+      }
+    });
+    return d.observe(B.current), () => {
+      d.disconnect(), j.current && clearTimeout(j.current);
+    };
+  }, [z]), q(() => () => {
+    for (const d of Object.values(oe.current))
+      clearTimeout(d);
+  }, []), Qe(() => {
+    const d = ze.current, x = p, f = e === "horizontal" ? Math.abs(d.width - x.width) >= 0.5 : Math.abs(d.height - x.height) >= 0.5;
+    if (c && f) {
+      const g = e === "horizontal" ? x.width : x.height;
+      i({ type: "CONTAINER_RESIZED", containerSize: g, direction: e });
+    }
+    ze.current = x;
+  }, [p, c, e]);
+  const Ie = fe(() => {
+    $e.debug("panels[0]?.id", s[0]?.id);
+    const d = s.some((l) => {
+      if (l.collapsed || l.sizeUnit !== "percentage")
+        return !1;
+      const re = l.collapseFromStart || l.collapseFromEnd ? l.sizeBeforeCollapse ?? l.measuredPixelSizeBeforeCollapse ?? l.originalPixelSize ?? l.measuredPixelSize ?? 0 : l.measuredPixelSize ?? l.originalPixelSize ?? l.size, J = l.percentageSize !== void 0 && l.percentageSize > 0;
+      return l.size <= 0 && (re > 0 || J);
+    }), x = e === "horizontal" ? p.width : p.height, f = x > 0;
+    if (m || !f || !(s.length > 0 && (s.length !== Q.current || !c || d)))
+      return;
+    const I = s.filter((l) => !l.collapsed && (l.originalPixelSize !== void 0 || l.sizeUnit === "pixels")).reduce((l, R) => {
+      const re = R.preferredPixelSize ?? R.originalPixelSize ?? R.size;
+      return l + Math.max(0, re ?? 0);
+    }, 0), N = s.filter((l) => l.sizeUnit === "percentage" && !l.collapsed), v = N.map((l) => l.id), _ = N.map((l) => {
+      const R = l.preferredPercentageSize ?? l.percentageSize;
+      return R !== void 0 && R > 0 ? We(R, x) : l.size > 0 ? l.size : 0;
+    }), A = _.reduce((l, R) => l + R, 0), P = x - I, S = Math.max(0, P), D = S > 0, Z = s.map((l) => {
+      if (l.collapsed) {
+        const R = l.sizeBeforeCollapse ?? l.measuredPixelSizeBeforeCollapse ?? l.originalPixelSize ?? (l.sizeUnit === "pixels" ? l.size : void 0), re = l.sizeUnit === "percentage" && l.percentageSize !== void 0 ? We(l.percentageSize, x) : void 0, J = R ?? re ?? 0, ne = l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? J;
+        return {
+          ...l,
+          size: 0,
+          percentageSize: 0,
+          preferredPercentageSize: l.preferredPercentageSize,
+          sizeBeforeCollapse: J,
+          percentageSizeBeforeCollapse: l.percentageSizeBeforeCollapse ?? l.percentageSize ?? l.preferredPercentageSize ?? 0,
+          preferredPercentageSizeBeforeCollapse: l.preferredPercentageSizeBeforeCollapse ?? l.preferredPercentageSize ?? l.percentageSize ?? void 0,
+          preferredPixelSizeBeforeCollapse: l.preferredPixelSizeBeforeCollapse ?? l.preferredPixelSize ?? J,
+          measuredPixelSizeBeforeCollapse: ne
+        };
+      }
+      if (l.sizeUnit === "pixels" || l.originalPixelSize !== void 0) {
+        const R = l.size, re = x > 0 ? ye(R, x) : 0, J = {
+          ...l,
+          size: R,
+          percentageSize: re,
+          preferredPixelSize: l.preferredPixelSize ?? l.originalPixelSize ?? R,
+          preferredPercentageSize: l.preferredPercentageSize !== void 0 ? l.preferredPercentageSize : re > 0 ? re : void 0
+        };
+        if (l.collapseFromStart || l.collapseFromEnd) {
+          const ne = l.sizeBeforeCollapse ?? R, He = l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? ne;
+          J.sizeBeforeCollapse = ne, J.measuredPixelSizeBeforeCollapse = He, J.preferredPixelSizeBeforeCollapse = l.preferredPixelSizeBeforeCollapse ?? l.preferredPixelSize ?? ne;
+        }
+        return J;
+      }
+      if (l.sizeUnit === "percentage") {
+        const R = v.indexOf(l.id), re = R !== -1 ? _[R] : 0, J = W(l.minSize, 0, x), ne = W(l.maxSize, x, x), He = Math.max(
+          J,
+          l.sizeBeforeCollapse ?? 0,
+          l.measuredPixelSizeBeforeCollapse ?? 0,
+          l.measuredPixelSize ?? 0,
+          l.originalPixelSize ?? 0,
+          l.size > 0 ? l.size : 0,
+          l.percentageSize !== void 0 ? We(l.percentageSize, x) : 0,
+          1
+        ), Ue = re > 0 ? re : He;
+        let Re;
+        if (!D)
+          Re = J;
+        else if (R !== -1 && A > 0) {
+          const he = Ue / A, be = S * he;
+          Re = ge(be, J, ne);
+        } else {
+          const he = l.percentageSize !== void 0 ? We(l.percentageSize, x) : l.size, be = he > 0 ? he : Ue;
+          Re = ge(be, J, ne);
+        }
+        const Ne = x > 0 ? ye(Re, x) : 0, Fe = {
+          ...l,
+          size: Re,
+          percentageSize: Ne,
+          preferredPercentageSize: l.preferredPercentageSize !== void 0 ? l.preferredPercentageSize : Ne > 0 ? Ne : void 0
+        };
+        if (l.collapseFromStart || l.collapseFromEnd) {
+          const he = l.sizeBeforeCollapse ?? Re, be = l.measuredPixelSizeBeforeCollapse ?? l.measuredPixelSize ?? he;
+          Fe.sizeBeforeCollapse = he, Fe.measuredPixelSizeBeforeCollapse = be, Fe.preferredPixelSizeBeforeCollapse = l.preferredPixelSizeBeforeCollapse ?? l.preferredPixelSize ?? he;
+        }
+        return Fe;
+      }
+      return l;
+    }), K = [];
+    for (let l = 0; l < Z.length; l += 1) {
+      const R = Z[l];
+      R.sizeUnit === "percentage" && !R.collapsed && K.push(l);
+    }
+    const X = K.reduce((l, R) => l + Z[R].size, 0), Y = P - X;
+    Math.abs(Y) > 0 && vt(Z, Y, x, { enforceAutoMinSize: !0 }), i({ type: "SET_PANELS", panels: Z }), Q.current = s.length, o(!0);
+  }, [s, e, p.width, p.height, c, m]);
+  q(() => {
+    const d = e === "horizontal" ? p.width : p.height, x = d > 0, f = x && s.length > 0;
+    if (x && s.length === 0) {
+      m && b(null);
+      return;
+    }
+    const g = f ? s.reduce((A, P) => {
+      if (P.collapsed)
+        return A;
+      const S = W(P.minSize, 0, d);
+      return A + Math.max(0, S);
+    }, 0) : null, y = f ? s.reduce((A, P) => {
+      if (P.collapsed)
+        return A;
+      const S = W(P.maxSize, d, d);
+      return A + Math.max(0, S);
+    }, 0) : null, I = g ?? m?.totalMinimumSize ?? null, N = y ?? m?.totalMaximumSize ?? null;
+    if (!x) {
+      m && b((A) => !A || A.availableContainerSize === d ? A : {
+        reason: A.reason,
+        // totalMinimumSize: previous.totalMinimumSize,
+        // totalMaximumSize: previous.totalMaximumSize,
+        totalMinimumSize: null,
+        totalMaximumSize: null,
+        availableContainerSize: d
+      });
+      return;
+    }
+    const v = I !== null && I - d > Number.EPSILON, _ = N !== null && d - N > Number.EPSILON;
+    if (v || _) {
+      const P = {
+        reason: v ? "minimum-exceeded" : "maximum-insufficient",
+        totalMinimumSize: I,
+        totalMaximumSize: N,
+        availableContainerSize: d
+      };
+      b((S) => S && S.reason === P.reason && Math.abs((S.totalMinimumSize ?? 0) - (P.totalMinimumSize ?? 0)) <= Number.EPSILON && Math.abs((S.totalMaximumSize ?? 0) - (P.totalMaximumSize ?? 0)) <= Number.EPSILON && Math.abs(S.availableContainerSize - P.availableContainerSize) <= Number.EPSILON ? S : P);
+      return;
+    }
+    if (m) {
+      const A = m.reason === "minimum-exceeded", P = m.reason === "maximum-insufficient";
+      (!A || I !== null) && (!P || N !== null) && !v && !_ && b((X) => X && null);
+    }
+  }, [s, e, p.width, p.height, m]), q(() => {
+    Ie();
+  }, [Ie]), q(() => {
+    O.current = n;
+  }, [n]);
+  const xe = ee(() => s.map((d) => d.size), [s]), se = H(!1);
+  Qe(() => {
+    if (s.length === 0) {
+      se.current = !1;
+      return;
+    }
+    !se.current && (c || s.every((d) => d.collapsed || d.size > 0)) && (se.current = !0), se.current && O.current && O.current(xe);
+  }, [xe, s, c]), q(() => {
+    if (u && xe.length > 0 && se.current) {
+      const d = setTimeout(() => {
+        jt(u, xe);
+      }, 200);
+      return () => clearTimeout(d);
+    }
+  }, [u, xe]), q(() => {
+    if (!u || s.length === 0 || ie.current)
+      return;
+    const d = e === "horizontal" ? p.width : p.height;
+    if (d <= 0)
+      return;
+    const x = $t(u);
+    if (x && x.length === s.length) {
+      const f = s.map((g, y) => {
+        const I = W(g.minSize, 0, d), N = W(g.maxSize, d, d), v = ge(x[y], I, N), _ = ye(v, d), A = g.sizeUnit === "pixels" || g.originalPixelSize !== void 0 ? v : g.preferredPixelSize;
+        return {
+          ...g,
+          size: v,
+          percentageSize: _,
+          preferredPercentageSize: _ > 0 ? _ : g.preferredPercentageSize,
+          preferredPixelSize: A
+        };
+      });
+      i({ type: "SET_PANELS", panels: f }), ie.current = !0;
+    }
+  }, [u, s, p.width, p.height, e]);
+  const ae = fe((d) => {
+    const x = T.current, f = V.current, g = JSON.stringify({
+      id: d.id,
+      size: d.size ?? null,
+      percentageSize: d.percentageSize ?? null,
+      preferredPercentageSize: d.preferredPercentageSize ?? null,
+      preferredPixelSize: d.preferredPixelSize ?? null,
+      sizeUnit: d.sizeUnit,
+      originalPixelSize: d.originalPixelSize ?? null,
+      minSize: d.minSize ?? null,
+      maxSize: d.maxSize ?? null,
+      collapseFromStart: d.collapseFromStart,
+      collapseFromEnd: d.collapseFromEnd,
+      collapsed: d.collapsed ?? !1,
+      collapsedByDirection: d.collapsedByDirection ?? null,
+      sizeBeforeCollapse: d.sizeBeforeCollapse ?? null,
+      percentageSizeBeforeCollapse: d.percentageSizeBeforeCollapse ?? null,
+      preferredPercentageSizeBeforeCollapse: d.preferredPercentageSizeBeforeCollapse ?? null,
+      preferredPixelSizeBeforeCollapse: d.preferredPixelSizeBeforeCollapse ?? null,
+      pixelAdjustPriority: d.pixelAdjustPriority ?? null,
+      flexAdjustPriority: d.flexAdjustPriority ?? null,
+      autoMinSize: d.autoMinSize ?? null
+    });
+    if (f[d.id] === g) {
+      $e.debug("useResizablePanels.registerPanel skipped", {
+        panelId: d.id,
+        reason: "duplicate-registration"
+      });
+      return;
+    }
+    f[d.id] = g, $e.debug("useResizablePanels.registerPanel", {
+      panelId: d.id,
+      containerReady: U.current,
+      violationReason: w.current,
+      containerSize: {
+        width: x.width,
+        height: x.height
+      }
+    }), i({ type: "REGISTER_PANEL", panel: d });
+  }, []), Se = fe((d) => {
+    const x = T.current;
+    $e.debug("useResizablePanels.unregisterPanel", {
+      panelId: d,
+      containerReady: U.current,
+      violationReason: w.current,
+      containerSize: {
+        width: x.width,
+        height: x.height
+      }
+    }), i({ type: "UNREGISTER_PANEL", id: d }), delete V.current[d], oe.current[d] && (clearTimeout(oe.current[d]), delete oe.current[d]), delete Be.current[d], M((f) => {
+      if (!(d in f))
+        return f;
+      const g = { ...f };
+      return delete g[d], g;
+    });
+  }, []), Pe = fe(
+    (d, x, f, g) => {
+      const y = e === "horizontal" ? p.width : p.height, I = s.find((X) => X.id === d), N = s.find((X) => X.id === x);
+      if (!(I && N)) {
+        i({ type: "RESIZE_PANELS", leftId: d, rightId: x, leftSize: f, rightSize: g, containerSize: y });
+        return;
+      }
+      if (I.collapsed || N.collapsed)
+        return;
+      const v = W(I.minSize, 0, y), _ = W(I.maxSize, y, y), A = W(N.minSize, 0, y), P = W(N.maxSize, y, y);
+      let S = ge(f, v, _), D = ge(g, A, P);
+      const Z = S + D, K = f + g;
+      if (Math.abs(Z - K) > 1e-9) {
+        const X = K - Z;
+        if (X > 0) {
+          const Y = _ - S, l = P - D, R = Y + l;
+          if (R > 0) {
+            const re = Math.min(X * (Y / R), Y), J = Math.min(X - re, l);
+            S += re, D += J;
+          }
+        } else if (X < 0) {
+          const Y = Math.abs(X), l = S - v, R = D - A, re = l + R;
+          if (re > 0) {
+            const J = Math.min(Y * (l / re), l), ne = Math.min(Y - J, R);
+            S -= J, D -= ne;
+          }
+        }
+      }
+      S = ge(S, v, _), D = ge(D, A, P), Math.abs(S + D - K) > 1e-9 && $e.error("Total size after constraints should be close to the original total size.", { constrainedLeftSize: S, constrainedRightSize: D, originalTotalSize: K }), i({ type: "RESIZE_PANELS", leftId: d, rightId: x, leftSize: S, rightSize: D, containerSize: y });
+    },
+    [e, p.width, p.height, s]
+  ), Me = fe(
+    (d, x) => {
+      const f = e === "horizontal" ? p.width : p.height;
+      i({ type: "COLLAPSE_PANEL", id: d, from: x, containerSize: f });
+    },
+    [e, p.width, p.height]
+  ), F = fe(
+    (d, x, f) => {
+      const g = e === "horizontal" ? p.width : p.height;
+      i({ type: "EXPAND_PANEL", id: d, from: x, containerSize: g, targetSize: f });
+    },
+    [e, p.width, p.height]
+  ), $ = fe(
+    (d) => s.find((x) => x.id === d),
+    [s]
+  ), le = fe((d, x) => {
+    if (x === null) {
+      oe.current[d] && (clearTimeout(oe.current[d]), delete oe.current[d]), delete Be.current[d], M((f) => {
+        if (!(d in f))
+          return f;
+        const g = { ...f };
+        return delete g[d], g;
+      });
+      return;
+    }
+    M((f) => {
+      const g = f[d], y = g && Math.abs(g.pixelSize - x.pixelSize) < 0.1, I = g && Math.abs(g.percentageSize - x.percentageSize) < 0.01;
+      return y && I ? (oe.current[d] && clearTimeout(oe.current[d]), Be.current[d] = x, oe.current[d] = setTimeout(() => {
+        const N = Be.current[d];
+        N && M((v) => ({
+          ...v,
+          [d]: N
+        })), delete oe.current[d];
+      }, 200), f) : (oe.current[d] && (clearTimeout(oe.current[d]), delete oe.current[d]), {
+        ...f,
+        [d]: x
+      });
+    });
+  }, []), ve = fe((d, x) => {
+    L((f) => {
+      if (x === null) {
+        if (!(d in f))
+          return f;
+        const y = { ...f };
+        return delete y[d], y;
+      }
+      const g = f[d];
+      return g && Math.abs(g.thickness - x.thickness) <= 0.25 && g.visible === x.visible && g.direction === x.direction && g.startPanelId === x.startPanelId && g.endPanelId === x.endPanelId ? f : {
+        ...f,
+        [d]: x
+      };
+    });
+  }, []), De = ee(
+    () => ({
+      direction: e,
+      panels: s,
+      containerSize: p,
+      isContainerReady: z,
+      showDebugInfo: r,
+      registerPanel: ae,
+      unregisterPanel: Se,
+      resizePanels: Pe,
+      collapsePanel: Me,
+      expandPanel: F,
+      getPanel: $,
+      reportPanelMeasurement: le,
+      panelMeasurements: C,
+      reportHandleMeasurement: ve,
+      handleMeasurements: E,
+      layoutConstraintViolation: m
+    }),
+    [e, s, p, z, r, ae, Se, Pe, Me, F, $, le, C, ve, E, m]
+  ), Te = ee(
+    () => ({
+      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: B,
+    contextValue: De,
+    groupStyle: Te
+  };
+}, nr = (e) => {
+  const { getPanel: t, collapsePanel: n, expandPanel: u } = st(), r = t(e), s = fe(
+    (h) => {
+      n(e, h);
+    },
+    [n, e]
+  ), i = fe(
+    (h, z) => {
+      u(e, h, z);
+    },
+    [u, e]
+  ), p = fe(
+    (h, z) => {
+      r?.collapsed ? i(h, z) : s(h);
+    },
+    [r?.collapsed, s, i]
+  );
+  return ee(
+    () => ({
+      panel: r,
+      isCollapsed: r?.collapsed ?? !1,
+      canCollapseFromStart: r?.collapseFromStart ?? !1,
+      canCollapseFromEnd: r?.collapseFromEnd ?? !1,
+      collapse: s,
+      expand: i,
+      toggle: p
+    }),
+    [r, s, i, p]
+  );
+}, Zt = ({ panel: e, measuredPixelSize: t, measuredPercentageSize: n, containerAxisSize: u, containerLabel: r }) => {
+  const s = e?.size, i = typeof s == "number" && Number.isFinite(s) ? `${s.toFixed(3)}px` : "-", p = e?.percentageSize !== void 0 ? `${e.percentageSize.toFixed(3)}%` : "-", h = Number.isFinite(t) ? `${t.toFixed(3)}px` : "-", z = Number.isFinite(n) ? `${n.toFixed(3)}%` : "-", a = Number.isFinite(u) ? `${u.toFixed(3)}px` : "-", c = `${i} / ${p}`, o = `${h} / ${z}`, m = e?.sizeUnit === "pixels" ? "Fixed" : "Flexible", b = [m, `${r}: ${a}`, `size (state): ${c}`, `size (measured): ${o}`];
+  return {
+    stateValueDisplay: c,
+    measuredValueDisplay: o,
+    containerDisplay: a,
+    headlineLabel: m,
+    titleText: b.join(`
+`)
+  };
+}, Xt = ot(({ panel: e, measuredPixelSize: t, measuredPercentageSize: n, containerAxisSize: u, direction: r }) => {
+  const s = r === "horizontal" ? "container width" : "container height", { stateValueDisplay: i, measuredValueDisplay: p, containerDisplay: h, headlineLabel: z, titleText: a } = ee(
+    () => Zt({
+      panel: e,
+      measuredPixelSize: t,
+      measuredPercentageSize: n,
+      containerAxisSize: u,
+      containerLabel: s
+    }),
+    [e, t, n, u, s]
+  ), c = {
+    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%"
+  }, m = {
+    display: "flex",
+    justifyContent: "flex-start",
+    alignItems: "center",
+    gap: "6px",
+    fontSize: "10px",
+    color: "#ccc",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, b = {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    gap: "6px",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0",
+    width: "100%"
+  }, C = {
+    marginLeft: "auto",
+    fontVariantNumeric: "tabular-nums",
+    whiteSpace: "nowrap"
+  };
+  return /* @__PURE__ */ pe("div", { style: c, title: a, children: /* @__PURE__ */ Le("div", { style: o, children: [
+    /* @__PURE__ */ pe("div", { style: m, children: /* @__PURE__ */ pe("span", { children: z }) }),
+    /* @__PURE__ */ Le("div", { style: b, children: [
+      /* @__PURE__ */ pe("span", { children: s }),
+      /* @__PURE__ */ pe("span", { style: C, children: h })
+    ] }),
+    /* @__PURE__ */ Le("div", { style: b, children: [
+      /* @__PURE__ */ pe("span", { children: "size (state)" }),
+      /* @__PURE__ */ pe("span", { style: C, children: i })
+    ] }),
+    /* @__PURE__ */ Le("div", { style: b, children: [
+      /* @__PURE__ */ pe("span", { children: "size (measured)" }),
+      /* @__PURE__ */ pe("span", { style: C, children: p })
+    ] })
+  ] }) });
+}), et = new Ze(ke.INFO, "[resize-panels]"), qt = {
+  both: {
+    collapseFromStart: !0,
+    collapseFromEnd: !0
+  },
+  start: {
+    collapseFromStart: !0,
+    collapseFromEnd: !1
+  },
+  end: {
+    collapseFromStart: !1,
+    collapseFromEnd: !0
+  }
+}, Kt = (e) => {
+  if (!e)
+    return {
+      collapseFromStart: !1,
+      collapseFromEnd: !1
+    };
+  const t = qt[e.from];
+  if (!t)
+    throw new Error("Invalid collapsible configuration: unsupported 'from' value");
+  return t;
+}, gt = ({ ref: e, setState: t, panelIdRef: n, label: u, timerRef: r }) => (s) => {
+  if (!Number.isFinite(s))
+    return;
+  const i = s < 0 ? 0 : s, p = u === "pixel" ? 0.1 : 0.01;
+  if (Math.abs(e.current - i) < p) {
+    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, et.debug(`commit ${u}`, {
+    panelId: n.current,
+    [u]: i
+  }), t(i);
+}, or = ot(
+  ({ id: e, defaultSize: t = { value: 50, unit: "percentage" }, minSize: n, maxSize: u, autoMinSize: r, className: s, style: i, children: p, order: h = 0, collapsible: z, defaultCollapsed: a = !1, pixelAdjustPriority: c, flexAdjustPriority: o, contentOverflow: m = "auto" }) => {
+    const { direction: b, registerPanel: C, unregisterPanel: M, getPanel: E, showDebugInfo: L, isContainerReady: B, reportPanelMeasurement: O, containerSize: ie } = st(), Q = H(null), ze = xt(), T = H(e || `panel-${ze}`);
+    q(() => {
+      e && e !== T.current && et.warn("Panel id prop change after mount is ignored.", {
+        currentId: T.current,
+        attemptedId: e
+      });
+    }, [e]);
+    const U = ee(() => Kt(z), [z]), w = U.collapseFromStart || U.collapseFromEnd, V = ee(() => w ? U.collapseFromStart ? "start" : U.collapseFromEnd ? "end" : null : null, [w, U.collapseFromStart, U.collapseFromEnd]), ce = w && a, k = ee(() => Ut(t), [t]), j = k?.unit === "pixels", te = j ? void 0 : k?.value, G = E(T.current), oe = !!G?.collapsed, Be = (G?.size ?? 0) <= 0, me = oe || Be, de = H(G);
+    de.current = G;
+    const Ie = H(me);
+    Ie.current = me;
+    const [xe, se] = Ee(() => j && k ? k.value : G?.size !== void 0 ? G.size : 0), [ae, Se] = Ee(() => !j && k ? k.value : G?.percentageSize !== void 0 ? G.percentageSize : 0), Pe = H(xe), Me = H(ae), F = H(null), $ = H(null);
+    q(() => () => {
+      F.current && clearTimeout(F.current), $.current && clearTimeout($.current);
+    }, []);
+    const le = ee(
+      () => gt({
+        ref: Pe,
+        setState: se,
+        panelIdRef: T,
+        label: "pixel",
+        timerRef: F
+      }),
+      []
+    ), ve = ee(
+      () => gt({
+        ref: Me,
+        setState: Se,
+        panelIdRef: T,
+        label: "percentage",
+        timerRef: $
+      }),
+      []
+    ), De = fe(() => {
+      F.current && (clearTimeout(F.current), F.current = null), $.current && (clearTimeout($.current), $.current = null), Pe.current !== 0 && (Pe.current = 0, se(0)), Me.current !== 0 && (Me.current = 0, Se(0));
+    }, []);
+    q(() => {
+      if (!B)
+        return;
+      let P = 0;
+      if (j && k) {
+        let R = k.value;
+        n && typeof n == "object" && n.unit === "pixels" && (R = Math.max(R, n.value)), u && typeof u == "object" && u.unit === "pixels" && (R = Math.min(R, u.value)), P = R;
+      }
+      const S = ce, D = S ? V : null;
+      a && !w && et.warn("Panel defaultCollapsed is ignored because collapsible configuration is not provided.");
+      const Z = w && S && j ? P : void 0, K = w ? te : void 0, X = j ? P : void 0, Y = {
+        id: T.current,
+        size: S ? 0 : P,
+        percentageSize: S ? 0 : te,
+        preferredPercentageSize: te,
+        preferredPixelSize: X,
+        sizeUnit: k?.unit || "percentage",
+        originalPixelSize: j ? P : void 0,
+        minSize: n,
+        maxSize: u,
+        collapseFromStart: U.collapseFromStart,
+        collapseFromEnd: U.collapseFromEnd,
+        collapsedByDirection: D,
+        collapsed: S,
+        sizeBeforeCollapse: Z,
+        percentageSizeBeforeCollapse: K,
+        preferredPercentageSizeBeforeCollapse: w ? te : void 0,
+        preferredPixelSizeBeforeCollapse: w ? X : void 0,
+        pixelAdjustPriority: c,
+        flexAdjustPriority: o,
+        autoMinSize: r
+      };
+      C(Y);
+    }, [
+      r,
+      U.collapseFromEnd,
+      U.collapseFromStart,
+      a,
+      k,
+      o,
+      w,
+      B,
+      j,
+      u,
+      n,
+      c,
+      V,
+      te,
+      C,
+      ce
+    ]), q(() => () => {
+      M(T.current), O(T.current, null);
+    }, [M, O]);
+    const Te = G?.size ?? 0, d = fe(() => {
+      const P = Q.current;
+      if (!P) return;
+      const S = de.current;
+      if (!S)
+        return;
+      const D = P.parentElement;
+      if (!D) return;
+      const Z = P.getBoundingClientRect(), K = Ge(D, "horizontal"), X = Ge(D, "vertical"), Y = b === "horizontal" ? Z.width : Z.height, l = b === "horizontal" ? K.inner : X.inner, R = nt(l);
+      if (Ie.current) {
+        De();
+        return;
+      }
+      const re = S.size ?? 0, J = Math.max(2, R * 0.5);
+      if (re > R && Y < J) {
+        et.debug("skip noisy measurement", {
+          panelId: T.current,
+          expectedPanelSize: re,
+          measured: Y,
+          noiseThreshold: J
+        });
+        return;
+      }
+      if (Y > 0) {
+        le(Y), l > 0 && ve(Y / l * 100);
+        return;
+      }
+      S.size !== void 0 && le(S.size), S.percentageSize !== void 0 ? ve(S.percentageSize) : S.sizeUnit === "pixels" && S.size !== void 0 && l > 0 && ve(S.size / l * 100);
+    }, [ve, le, b, De]), x = H(!1);
+    q(() => {
+      !x.current && G && (x.current = !0, d());
+    }, [G, d]), q(() => {
+      const P = Q.current;
+      if (!P) return;
+      const S = new ResizeObserver(() => {
+        d();
+      });
+      S.observe(P), d();
+      const D = [], Z = new MutationObserver(() => {
+        (() => {
+          if (!Q.current) return !1;
+          const Y = Q.current.getBoundingClientRect();
+          return (b === "horizontal" ? Y.width : Y.height) !== Pe.current;
+        })() && setTimeout(d, 0);
+      }), K = P.parentElement;
+      return K && Z.observe(K, {
+        childList: !0,
+        attributes: !0,
+        attributeFilter: ["style", "class"]
+      }), () => {
+        S.disconnect(), Z.disconnect();
+        for (const X of D)
+          clearTimeout(X);
+      };
+    }, [b, d]);
+    const f = G?.size, g = G?.percentageSize, y = G?.sizeUnit;
+    q(() => {
+      if (G) {
+        if (me) {
+          De();
+          return;
+        }
+        if (f !== void 0 && le(f), g !== void 0)
+          ve(g);
+        else if (y === "pixels" && f !== void 0) {
+          const P = Q.current, S = P?.parentElement;
+          if (P && S) {
+            const { width: D, height: Z } = P.getBoundingClientRect(), K = S.clientWidth, X = S.clientHeight, Y = b === "horizontal" ? D : Z, l = b === "horizontal" ? K : X;
+            if (Y > 0 && l > 0) {
+              const R = Y / l * 100;
+              ve(R);
+            }
+          }
+        }
+      }
+    }, [ve, le, G, g, f, y, b, me, De]), q(() => {
+      O(T.current, {
+        pixelSize: xe,
+        percentageSize: ae
+      });
+    }, [O, xe, ae]);
+    const I = () => me ? "0px" : G?.originalPixelSize !== void 0 ? `${Te}px` : G?.percentageSize !== void 0 ? `${G.percentageSize}%` : `${Te}px`, N = G?.sizeUnit === "percentage" && !G?.collapsed ? 1 : 0, v = {
+      flexBasis: I(),
+      flexGrow: 0,
+      flexShrink: N,
+      overflow: "hidden",
+      position: "relative",
+      boxSizing: "border-box",
+      minHeight: "0px",
+      minWidth: "0px",
+      ...i
+    };
+    b === "horizontal" ? (v.height = "100%", v.minWidth = 0) : (v.width = "100%", v.minHeight = 0), me && (b === "horizontal" ? (v.width = "0px", v.minWidth = "0px") : (v.height = "0px", v.minHeight = "0px"), v.flexGrow = 0, v.flexShrink = 0, v.pointerEvents = "none", v.visibility = "hidden", oe && (v.display = "none"));
+    const _ = b === "horizontal" ? ie.width : ie.height, A = ee(
+      () => ({
+        position: "absolute",
+        inset: "0px",
+        overflow: m,
+        display: "flex",
+        flexDirection: "column",
+        width: "100%",
+        height: "100%",
+        minWidth: "0px",
+        minHeight: "0px"
+      }),
+      [m]
+    );
+    return /* @__PURE__ */ Le(
+      "div",
+      {
+        ref: Q,
+        className: Ve("panel", s),
+        style: v,
+        "data-panel-id": T.current,
+        "data-panel-size": Te,
+        "data-panel-size-unit": G?.sizeUnit || "percentage",
+        "data-panel-pixel-size": G?.sizeUnit === "pixels" ? G?.originalPixelSize : null,
+        "data-panel-order": h,
+        "data-panel-collapsible": w,
+        "data-panel-collapse-start": U.collapseFromStart,
+        "data-panel-collapse-end": U.collapseFromEnd,
+        "data-panel-collapsed": G?.collapsed,
+        "aria-hidden": me,
+        children: [
+          /* @__PURE__ */ pe("div", { style: A, children: p }),
+          L && /* @__PURE__ */ pe(Xt, { panel: G, measuredPixelSize: xe, measuredPercentageSize: ae, containerAxisSize: _, direction: b })
+        ]
+      }
+    );
+  }
+), Yt = Lt(() => import("./GlobalDebugOverlay-DYCR0FIu.js").then((e) => ({ default: e.GlobalDebugOverlayGate })));
+let mt = 0;
+const Jt = () => (mt += 1, `panel-group-${mt}`), Qt = (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.", u = 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: u };
+}, er = (e, t) => {
+  let n = !1;
+  const u = 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 ? u : e;
+}, St = (e, t, n) => {
+  const u = Ge(e, "horizontal"), r = Ge(e, "vertical"), s = e.getBoundingClientRect(), i = u.inner > 0 ? u.inner : t ?? s.width, p = r.inner > 0 ? r.inner : n ?? s.height;
+  return { width: i, height: p };
+}, sr = (e) => {
+  const { id: t, className: n, style: u, children: r, direction: s } = e, { groupRef: i, contextValue: p, groupStyle: h } = Vt(e), [z, a] = Ee({ width: 0, height: 0 }), c = p.layoutConstraintViolation, o = !!c, m = ee(() => {
+    if (!c)
+      return null;
+    const { summary: w, detail: V } = Qt(c);
+    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__ */ pe("span", { children: w }),
+          /* @__PURE__ */ pe("span", { className: "text-slate-500 text-xs dark:text-slate-400", children: V })
+        ]
+      }
+    );
+  }, [c]), C = H(t ?? Jt()).current, M = t ?? C, E = p.showDebugInfo && p.panels.length > 0, L = E ? p.panels : [], B = E ? p.panelMeasurements : {}, O = ee(() => {
+    if (!E)
+      return [];
+    const w = Object.values(p.handleMeasurements);
+    return w.length <= 1 ? w : w.slice().sort((V, ce) => V.id.localeCompare(ce.id));
+  }, [p.handleMeasurements, E]), ie = p.containerSize, Q = z.width > 0 ? z.width : ie.width, ze = z.height > 0 ? z.height : ie.height;
+  Qe(() => {
+    if (!E) {
+      a({ width: 0, height: 0 });
+      return;
+    }
+    if (typeof window > "u" || typeof ResizeObserver > "u")
+      return;
+    const w = i.current;
+    if (!w)
+      return;
+    const V = (k) => {
+      a((j) => j.width === k.width && j.height === k.height ? j : k);
+    }, ce = new ResizeObserver((k) => {
+      for (const j of k) {
+        if (j.target !== w)
+          continue;
+        const te = St(w, j.contentRect.width, j.contentRect.height);
+        V(te);
+      }
+    });
+    return ce.observe(w), V(St(w)), () => {
+      ce.disconnect();
+    };
+  }, [i, E]);
+  const T = ee(() => er(L, B), [L, B]);
+  q(() => {
+    if (!E)
+      return;
+    let w = !1, V = null;
+    return import("./debugOverlayStore-Cntyxboe.js").then((ce) => {
+      w || (V = ce, ce.enableDebugOverlayGroup(C));
+    }), () => {
+      w = !0, V && (V.disableDebugOverlayGroup(C), V.removeDebugOverlayGroup(C));
+    };
+  }, [E, C]), q(() => {
+    if (!E)
+      return;
+    let w = !1;
+    return import("./debugOverlayStore-Cntyxboe.js").then((V) => {
+      w || V.updateDebugOverlayGroup(C, {
+        displayName: M,
+        direction: s,
+        containerSize: {
+          width: Q,
+          height: ze
+        },
+        panels: T,
+        handles: O
+      });
+    }), () => {
+      w = !0;
+    };
+  }, [E, C, M, s, Q, ze, T, O]);
+  const U = ee(() => {
+    const w = {
+      ...h,
+      ...u
+    };
+    return w.position || (w.position = "relative"), w;
+  }, [h, u]);
+  return /* @__PURE__ */ Le(Pt.Provider, { value: p, children: [
+    /* @__PURE__ */ Le("div", { ref: i, className: Ve("panel-group", s === "horizontal" ? "flex-row" : "flex-col", n), style: U, "data-panel-group-id": t, "data-panel-group-direction": s, children: [
+      r,
+      o && m ? /* @__PURE__ */ pe(
+        "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: m
+        }
+      ) : null
+    ] }),
+    E && /* @__PURE__ */ pe(Dt, { fallback: null, children: /* @__PURE__ */ pe(Yt, { groupId: C }) })
+  ] });
+}, ar = ot(({ id: e, disabled: t = !1, className: n, style: u, children: r, onDragging: s }) => {
+  const { direction: i, resizePanels: p, getPanel: h, collapsePanel: z, expandPanel: a, panels: c, reportHandleMeasurement: o, containerSize: m, layoutConstraintViolation: b } = st(), [C, M] = Ee(!1), E = H(null), L = H(null), B = H(""), O = H(""), ie = H(null), [Q, ze] = Ee(!1), [T, U] = Ee({ left: null, right: null }), w = xt(), V = H(e ?? `resize-handle-${w}`), ce = H(null), k = e ?? V.current, j = !!b, te = t || j, G = fe(() => {
+    const f = E.current;
+    if (!f) return;
+    const g = f.parentElement;
+    if (!g) return;
+    L.current = g, typeof window < "u" && ze(window.getComputedStyle(g).direction === "rtl");
+    const y = Array.from(g.children), I = y.indexOf(f);
+    let N = null, v = null;
+    for (let P = I - 1; P >= 0; P -= 1) {
+      const S = y[P];
+      if (S.dataset.panelId) {
+        N = S;
+        break;
+      }
+    }
+    for (let P = I + 1; P < y.length; P += 1) {
+      const S = y[P];
+      if (S.dataset.panelId) {
+        v = S;
+        break;
+      }
+    }
+    const _ = N?.dataset.panelId || "", A = v?.dataset.panelId || "";
+    _ === B.current && A === O.current || (B.current = _, O.current = A, U({
+      left: _ || null,
+      right: A || null
+    }));
+  }, []), oe = ee(() => c.map((f) => f.id).join("|"), [c]);
+  q(() => {
+    G();
+  }, [G, oe]), q(() => {
+    if (k === V.current)
+      return;
+    const f = V.current;
+    V.current = k, ce.current = null, f !== k && o(f, null);
+  }, [o, k]), q(() => {
+    const f = V.current;
+    return () => {
+      o(f, null);
+    };
+  }, [o]), q(() => () => {
+    ie.current?.();
+  }, []);
+  const Be = fe(
+    (f) => {
+      if (te || !L.current || ie.current) return;
+      f.preventDefault(), f.stopPropagation();
+      const g = L.current, { inner: y } = Ge(g, i), I = { x: f.clientX, y: f.clientY }, N = h(B.current), v = h(O.current);
+      if (!(N && v)) return;
+      const _ = N.size, A = v.size;
+      let P = 0;
+      const S = Ot;
+      M(!0), s?.(!0);
+      const D = f.pointerId, Z = f.currentTarget, K = i === "horizontal" && typeof window < "u" && window.getComputedStyle(g).direction === "rtl";
+      Z.setPointerCapture(D);
+      const X = (ne) => {
+        if (ne.pointerId !== D || !E.current) return;
+        ne.preventDefault(), ne.stopPropagation();
+        const He = performance.now();
+        if (He - P < S) return;
+        P = He;
+        const Ue = i === "horizontal" ? ne.clientX - I.x : ne.clientY - I.y, Re = K ? -Ue : Ue;
+        if (Re === 0)
+          return;
+        const Ne = _ + Re, Fe = A - Re, he = h(B.current), be = h(O.current);
+        if (he && be && B.current && O.current) {
+          const tt = W(he.minSize, 0, y), rt = W(be.minSize, 0, y), at = tt, lt = rt, ct = Math.min(y * Ct, yt), dt = Math.min(y * kt, Gt), wt = be.collapseFromStart, Et = be.collapsedByDirection ?? "start";
+          if (wt && !be.collapsed && Fe <= Math.max(rt * 0.3, ct)) {
+            z(O.current, "start");
+            return;
+          }
+          const Bt = he.collapseFromEnd, Rt = he.collapsedByDirection ?? "end";
+          if (Bt && !he.collapsed && Ne <= Math.max(tt * 0.3, ct)) {
+            z(B.current, "end");
+            return;
+          }
+          if (be.collapsed && Fe > Math.max(rt * 0.3, dt)) {
+            a(O.current, Et, Fe);
+            return;
+          }
+          if (he.collapsed && Ne > Math.max(tt * 0.3, dt)) {
+            a(B.current, Rt, Ne);
+            return;
+          }
+          if (y > 0) {
+            const ut = he.size + be.size, Xe = nt(y);
+            let it = !1;
+            if (at <= Xe && Ne <= Xe && _ !== 0) {
+              const je = Math.max(0, ut - 0);
+              je >= lt && (p(B.current, O.current, 0, je), it = !0);
+            } else if (lt <= Xe && Fe <= Xe && A !== 0) {
+              const je = Math.max(0, ut - 0);
+              je >= at && (p(B.current, O.current, je, 0), it = !0);
+            }
+            if (it)
+              return;
+          }
+          if (he.collapsed || be.collapsed)
+            return;
+          p(B.current, O.current, Ne, Fe);
+        }
+      };
+      let Y = !0;
+      const l = () => {
+        Y && (Y = !1, ie.current = null, M(!1), s?.(!1), document.removeEventListener("pointermove", X), document.removeEventListener("pointerup", R), document.removeEventListener("pointercancel", re), Z.removeEventListener("lostpointercapture", J), Z.hasPointerCapture?.(D) && Z.releasePointerCapture(D));
+      }, R = (ne) => {
+        ne.pointerId === D && l();
+      }, re = (ne) => {
+        ne.pointerId === D && l();
+      }, J = (ne) => {
+        ne.pointerId === D && l();
+      };
+      document.addEventListener("pointermove", X), document.addEventListener("pointerup", R), document.addEventListener("pointercancel", re), Z.addEventListener("lostpointercapture", J), ie.current = l;
+    },
+    [te, i, p, h, z, a, s]
+  ), me = fe(
+    (f) => {
+      if (te) return;
+      const g = i === "horizontal", y = g ? "ArrowLeft" : "ArrowUp", I = g ? "ArrowRight" : "ArrowDown";
+      if (f.key !== y && f.key !== I) return;
+      f.preventDefault(), f.stopPropagation();
+      let N = (f.key === I ? 1 : -1) * (f.shiftKey ? pt * 5 : pt);
+      g && typeof window < "u" && L.current !== null && window.getComputedStyle(L.current).direction === "rtl" && (N = -N);
+      const _ = h(B.current), A = h(O.current);
+      !(_ && A) || _.collapsed || A.collapsed || p(B.current, O.current, _.size + N, A.size - N);
+    },
+    [te, i, h, p]
+  ), de = i === "horizontal", xe = Ve(
+    "group absolute z-20 flex select-none items-center justify-center border-none bg-transparent transition-colors duration-150 overflow-visible",
+    de ? "cursor-col-resize" : "cursor-row-resize",
+    de ? "h-full" : "w-full",
+    !te && "hover:bg-gray-200/70 dark:hover:bg-gray-700/70",
+    !te && "active:bg-blue-300/60 dark:active:bg-blue-700/60",
+    C && "bg-blue-200/80 dark:bg-blue-800/60",
+    te && "cursor-not-allowed opacity-50",
+    "focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-opacity-50",
+    n
+  ), se = ee(() => {
+    const f = (g) => {
+      if (!g)
+        return -1;
+      for (let y = 0; y < c.length; y += 1)
+        if (c[y].id === g)
+          return y;
+      return -1;
+    };
+    return {
+      left: f(T.left),
+      right: f(T.right)
+    };
+  }, [T.left, T.right, c]), ae = de ? m.width : m.height, Se = ee(() => {
+    const f = (g, y) => {
+      if (g > y)
+        return 0;
+      let I = 0;
+      for (let N = g; N <= y; N += 1) {
+        const v = c[N];
+        if (!v)
+          continue;
+        const _ = v.size ?? 0, A = Math.max(0, _);
+        I += v.collapsed ? 0 : A;
+      }
+      return I;
+    };
+    return se.left >= 0 ? f(0, se.left) : se.right > 0 ? f(0, se.right - 1) : 0;
+  }, [se.left, se.right, c]), Pe = ee(() => !Number.isFinite(Se) || Se < 0 ? 0 : ae > 0 && Se > ae ? ae : Se, [Se, ae]), Me = ee(() => {
+    const f = {
+      position: "absolute",
+      zIndex: 20,
+      touchAction: "none"
+    };
+    return de ? (f.top = 0, f.left = Q && ae > 0 ? `${ae - Pe}px` : `${Pe}px`, f.transform = "translateX(-50%)", f.width = `${ft}px`, f.height = "100%") : (f.left = 0, f.top = `${Pe}px`, f.transform = "translateY(-50%)", f.height = `${ft}px`, f.width = "100%"), f;
+  }, [Pe, de, Q, ae]), F = ee(() => {
+    const f = nt(ae), g = (S) => {
+      if (S < 0 || S >= c.length)
+        return !1;
+      const D = c[S];
+      return D ? D.collapsed ? !0 : D.size <= f : !1;
+    }, y = (S, D) => {
+      if (!g(S))
+        return 0;
+      let Z = 0;
+      for (let K = S; K >= 0 && K < c.length && g(K); K += D)
+        Z += 1;
+      return Z;
+    }, I = se.left, N = se.right, v = I >= 0 ? y(I, -1) : 0, _ = N >= 0 ? y(N, 1) : 0;
+    return {
+      groupSize: v + _ + 1,
+      overlapIndex: v
+    };
+  }, [se.left, se.right, c, ae]), $ = ee(() => {
+    if (j)
+      return !0;
+    if (F.groupSize <= 1)
+      return !1;
+    const f = F.groupSize - 1;
+    return F.overlapIndex > 0 && F.overlapIndex < f;
+  }, [F, j]), le = ee(() => {
+    if (F.groupSize <= 1 || $)
+      return 0;
+    const f = F.groupSize > 1 ? 2 : 1;
+    if (f === 1)
+      return 0;
+    const g = F.overlapIndex === 0 ? 0 : f - 1, y = (f - 1) / 2;
+    return (g - y) * _t;
+  }, [F, $]), ve = ee(() => {
+    if ($)
+      return { display: "none" };
+    if (le !== 0)
+      return de ? { transform: `translateX(${le}px)` } : { transform: `translateY(${le}px)` };
+  }, [le, de, $]), De = Ve(
+    "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)]",
+    de ? "h-12 w-[6px] px-[2px]" : "h-[6px] w-20 py-[2px]",
+    C && "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)]"
+  ), Te = Ve(
+    "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)]",
+    de ? "h-8 w-[2px]" : "h-[2px] w-16",
+    C && "bg-blue-500 dark:bg-blue-300",
+    !te && "group-hover:bg-slate-700 dark:group-hover:bg-slate-100"
+  ), d = fe(() => {
+    const f = E.current;
+    if (!f)
+      return;
+    let g = 0;
+    if (!$) {
+      const N = i === "horizontal" ? f.offsetWidth : f.offsetHeight;
+      let v = 0, _ = 0;
+      if (typeof window < "u") {
+        const P = window.getComputedStyle(f);
+        i === "horizontal" ? (v = Number.parseFloat(P.marginLeft || "0"), _ = Number.parseFloat(P.marginRight || "0")) : (v = Number.parseFloat(P.marginTop || "0"), _ = Number.parseFloat(P.marginBottom || "0"));
+      }
+      g = [N, v, _].reduce((P, S) => Number.isFinite(S) ? P + S : P, 0);
+    }
+    (!Number.isFinite(g) || g < 0) && (g = 0);
+    const y = {
+      id: k,
+      thickness: g,
+      direction: i,
+      visible: !$ && g > Ht,
+      startPanelId: T.left,
+      endPanelId: T.right
+    }, I = ce.current;
+    I && Math.abs(I.thickness - y.thickness) <= 0.25 && I.visible === y.visible && I.direction === y.direction && I.startPanelId === y.startPanelId && I.endPanelId === y.endPanelId || (ce.current = y, o(k, y));
+  }, [i, T.left, T.right, o, k, $]);
+  q(() => {
+    d();
+  }, [d]), q(() => {
+    const f = E.current;
+    if (!f)
+      return;
+    if (typeof ResizeObserver > "u") {
+      d();
+      return;
+    }
+    const g = new ResizeObserver(() => {
+      d();
+    });
+    return g.observe(f), () => {
+      g.disconnect();
+    };
+  }, [d]);
+  const x = ee(() => {
+    const f = u ? { ...Me, ...u } : Me;
+    return $ ? {
+      ...f,
+      display: "none",
+      pointerEvents: "none",
+      visibility: "hidden"
+    } : f;
+  }, [Me, $, u]);
+  return /* @__PURE__ */ pe(
+    "button",
+    {
+      type: "button",
+      ref: E,
+      className: xe,
+      style: x,
+      onPointerDown: Be,
+      onKeyDown: me,
+      disabled: te,
+      "aria-hidden": $ || void 0,
+      "aria-label": `Resize ${de ? "columns" : "rows"} - Drag or use arrow keys to resize, drag to the edge to collapse/expand panels`,
+      "data-resize-handle-id": k,
+      title: `ドラッグして${de ? "列" : "行"}をリサイズ、端まで移動して折りたたみ/展開`,
+      children: r || /* @__PURE__ */ pe("div", { className: De, style: ve, children: /* @__PURE__ */ pe("span", { className: Te }) })
+    }
+  );
+}), lr = (e) => document.querySelector(`[data-panel-id="${e}"]`), cr = (e) => document.querySelector(`[data-panel-group-id="${e}"]`), dr = (e) => document.querySelector(`[data-resize-handle-id="${e}"]`);
+export {
+  Tt as P,
+  or as a,
+  sr as b,
+  Pt as c,
+  ar as d,
+  ge as e,
+  Ge as f,
+  W as g,
+  lr as h,
+  cr as i,
+  dr as j,
+  st as k,
+  $t as l,
+  Vt as m,
+  Ut as n,
+  jt as s,
+  nr as u
+};