react-panel-layout 0.4.2 → 0.5.1

package/dist/GridLayout-BzrIDrC9.js

@@ -0,0 +1,1465 @@
+import { jsxs as H, Fragment as N, jsx as h } from "react/jsx-runtime";
+import * as i from "react";
+import { F as Pt, e as yt, a as Lt, b as Mt, f as Dt, d as Ut } from "./FloatingPanelFrame-6W5OexYe.js";
+import { C as jt, D as Kt, o as Zt, p as qt, q as Jt, r as Qt, s as te, G as Y, t as T, u as ee, v as ne, w as oe, R as ut, x as re, y as Q } from "./styles-CA2_zLZt.js";
+import { a as se, u as ie } from "./usePivot-BvOGxLQQ.js";
+import { createPortal as ae } from "react-dom";
+import { u as It } from "./useIsomorphicLayoutEffect-DhmEnmZ_.js";
+const ce = () => {
+  const t = /* @__PURE__ */ new Map();
+  return (e) => {
+    if (!e)
+      return;
+    const n = t.get(e);
+    if (n !== void 0)
+      return n;
+    const o = t.size;
+    return t.set(e, o), o;
+  };
+}, ue = ce(), tt = /* @__PURE__ */ new Map(), le = (t) => {
+  const e = `ovs-threshold:${t.threshold}-rootMargin:${t.rootMargin}-root:${ue(t.root)}`;
+  if (tt.has(e))
+    return tt.get(e);
+  const n = new class {
+    #t = /* @__PURE__ */ new Map();
+    #e = new IntersectionObserver((o) => {
+      o.forEach((r) => {
+        const s = this.#t.get(r.target);
+        s && s(r);
+      });
+    }, t);
+    observe(o, r) {
+      return this.#t.set(o, r), this.#e.observe(o), () => {
+        this.#t.delete(o), this.#e.unobserve(o);
+      };
+    }
+  }();
+  return tt.set(e, n), n;
+}, lt = Object.freeze({
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+});
+function de(t, { threshold: e = 0, rootMargin: n = "0px", root: o = null }) {
+  const [r, s] = i.useState(null);
+  return i.useEffect(() => {
+    const u = t.current;
+    return u ? le({
+      threshold: e,
+      rootMargin: n,
+      root: o
+    }).observe(u, (a) => {
+      s({
+        isIntersecting: a.isIntersecting,
+        boundingClientRect: a.boundingClientRect,
+        intersectionRatio: a.intersectionRatio,
+        intersectionRect: a.intersectionRect,
+        rootBounds: a.rootBounds,
+        target: a.target,
+        time: a.time
+      });
+    }) : void 0;
+  }, [t, e, n, o]), i.useMemo(() => ({
+    isIntersecting: r?.isIntersecting ?? !1,
+    boundingClientRect: r?.boundingClientRect ?? lt,
+    intersectionRatio: r?.intersectionRatio ?? 0,
+    intersectionRect: r?.intersectionRect ?? lt,
+    rootBounds: r?.rootBounds ?? null,
+    target: r?.target ?? t.current,
+    time: r?.time ?? 0
+  }), [r, t]);
+}
+const dt = {
+  position: "fixed",
+  inset: 0,
+  background: jt
+}, fe = {
+  willChange: "transform"
+}, ft = {
+  left: {
+    top: 0,
+    bottom: 0,
+    left: 0,
+    transform: "translateX(-100%)"
+  },
+  right: {
+    top: 0,
+    bottom: 0,
+    right: 0,
+    transform: "translateX(100%)"
+  },
+  top: {
+    top: 0,
+    left: 0,
+    right: 0,
+    transform: "translateY(-100%)"
+  },
+  bottom: {
+    bottom: 0,
+    left: 0,
+    right: 0,
+    transform: "translateY(100%)"
+  }
+}, ge = (t, e, n) => t === "none" ? void 0 : `transform ${e ?? Kt} ${n ?? Zt}`, pe = (t, e) => t ? e : !1, he = ({ chrome: t, frameStyle: e, header: n, dismissible: o, onClose: r, children: s }) => t ? /* @__PURE__ */ H(Pt, { style: e, children: [
+  /* @__PURE__ */ h(me, { header: n, dismissible: o, onClose: r }),
+  /* @__PURE__ */ h(
+    yt,
+    {
+      style: { padding: qt, flex: 1, display: "flex", flexDirection: "column" },
+      children: s
+    }
+  )
+] }) : /* @__PURE__ */ h(N, { children: s }), me = ({ header: t, dismissible: e, onClose: n }) => {
+  if (!t)
+    return null;
+  const o = t.showCloseButton ?? !0, r = pe(e, o);
+  return /* @__PURE__ */ h(i.Activity, { mode: t ? "visible" : "hidden", children: /* @__PURE__ */ H(
+    Lt,
+    {
+      style: { padding: `${Qt} ${te}`, gap: Jt },
+      children: [
+        /* @__PURE__ */ h(i.Activity, { mode: t ? "visible" : "hidden", children: /* @__PURE__ */ h(Mt, { children: t.title }) }),
+        /* @__PURE__ */ h(i.Activity, { mode: r ? "visible" : "hidden", children: /* @__PURE__ */ h(
+          Dt,
+          {
+            onClick: n,
+            "aria-label": "Close drawer",
+            style: { marginLeft: "auto" }
+          }
+        ) })
+      ]
+    }
+  ) });
+}, we = ({
+  id: t,
+  config: e,
+  isOpen: n,
+  onClose: o,
+  children: r,
+  zIndex: s,
+  width: u,
+  height: c,
+  position: a
+}) => {
+  const {
+    dismissible: l = !0,
+    header: g,
+    chrome: f = !0,
+    inline: m = !1,
+    transitionMode: w = "css",
+    transitionDuration: C,
+    transitionEasing: z
+  } = e, L = i.useCallback(
+    (I, R) => I || (R ? R.left !== void 0 ? "left" : R.right !== void 0 ? "right" : R.top !== void 0 ? "top" : R.bottom !== void 0 ? "bottom" : "right" : "right"),
+    []
+  )(e.anchor, a), x = {
+    left: "translateX(0)",
+    right: "translateX(0)",
+    top: "translateY(0)",
+    bottom: "translateY(0)"
+  }, $ = i.useMemo(() => {
+    const I = ge(w, C, z), R = {
+      ...fe,
+      ...m ? { position: "absolute" } : { position: "fixed" },
+      ...ft[L],
+      transform: n ? x[L] : ft[L].transform,
+      transition: I
+    };
+    return s !== void 0 && (R.zIndex = s), u !== void 0 && (R.width = typeof u == "number" ? `${u}px` : u), c !== void 0 && (R.height = typeof c == "number" ? `${c}px` : c), R;
+  }, [c, m, n, L, C, z, w, u, s]), M = g?.title ?? e.ariaLabel ?? "Drawer", D = i.useMemo(() => {
+    const I = m ? { ...dt, position: "absolute" } : dt, R = w === "none" ? void 0 : `opacity ${C ?? "220ms"} ease`;
+    return {
+      ...I,
+      opacity: n ? 1 : 0,
+      pointerEvents: n ? "auto" : "none",
+      transition: R,
+      zIndex: s !== void 0 ? s - 1 : void 0
+    };
+  }, [m, n, C, w, s]), A = i.useMemo(() => {
+    const I = L === "left" || L === "right", R = { borderRadius: 0 };
+    return I && (R.height = "100%"), R;
+  }, [L]);
+  return /* @__PURE__ */ H(N, { children: [
+    /* @__PURE__ */ h("div", { style: D, onClick: l ? o : void 0 }),
+    /* @__PURE__ */ h(
+      "div",
+      {
+        "data-layer-id": t,
+        "data-placement": L,
+        style: $,
+        role: "dialog",
+        "aria-modal": l ? !0 : void 0,
+        "aria-hidden": n ? void 0 : !0,
+        "aria-label": M,
+        children: /* @__PURE__ */ h(
+          he,
+          {
+            chrome: f,
+            frameStyle: A,
+            header: g,
+            dismissible: l,
+            onClose: o,
+            children: r
+          }
+        )
+      }
+    )
+  ] });
+}, be = (t, e) => new Promise((n) => {
+  let o = !1;
+  const r = () => {
+    o || (o = !0, t.removeEventListener("transitionend", s), n());
+  }, s = (u) => {
+    u.target === t && r();
+  };
+  t.addEventListener("transitionend", s), setTimeout(r, e + 50);
+}), Tt = async (t, e, n, o) => {
+  switch (e) {
+    case "none":
+      t();
+      return;
+    case "css":
+      t(), n && await be(n, o);
+      return;
+  }
+}, Vn = (t) => {
+  const [e, n] = i.useState({}), o = i.useRef(t);
+  o.current = t;
+  const r = i.useCallback(
+    async (a, l, g) => {
+      const { mode: f = "none", element: m, duration: w = 300 } = g ?? {};
+      await Tt(() => {
+        n((y) => y[a] === l ? y : { ...y, [a]: l });
+      }, f, m?.current, w);
+      const z = o.current;
+      l ? z?.onOpen?.(a) : z?.onClose?.(a), z?.onTransitionEnd?.(a, l);
+    },
+    []
+  ), s = i.useCallback((a) => e[a] ?? !1, [e]), u = i.useCallback(
+    (a, l) => r(a, !0, l),
+    [r]
+  ), c = i.useCallback(
+    (a, l) => r(a, !1, l),
+    [r]
+  );
+  return { state: s, open: u, close: c };
+}, ve = (t) => {
+  if (!t)
+    return 300;
+  const e = t.match(/(\d+)/);
+  return e ? parseInt(e[1], 10) : 300;
+}, Se = (t) => {
+  const [e, n] = i.useState(() => {
+    const a = {};
+    return t.forEach((l) => {
+      l.drawer && (a[l.id] = l.drawer.defaultOpen ?? !1);
+    }), a;
+  }), o = i.useMemo(() => {
+    const a = /* @__PURE__ */ new Map();
+    return t.forEach((l) => a.set(l.id, l)), a;
+  }, [t]), r = i.useCallback(
+    async (a, l, g) => {
+      const f = o.get(a);
+      if (!f?.drawer)
+        return;
+      const m = g?.mode ?? f.drawer.transitionMode ?? "css", w = g?.duration ?? ve(f.drawer.transitionDuration), C = g?.element?.current;
+      await Tt(() => {
+        f.drawer?.open === void 0 && n((y) => y[a] === l ? y : { ...y, [a]: l }), f.drawer?.onStateChange?.(l);
+      }, m, C, w);
+    },
+    [o]
+  ), s = i.useCallback(
+    (a) => {
+      const l = o.get(a);
+      return l?.drawer?.open !== void 0 ? l.drawer.open : e[a] ?? !1;
+    },
+    [o, e]
+  ), u = i.useCallback(
+    (a, l) => r(a, !0, l),
+    [r]
+  ), c = i.useCallback(
+    (a, l) => r(a, !1, l),
+    [r]
+  );
+  return { state: s, open: u, close: c };
+}, Ce = ({ layers: t }) => {
+  const e = Se(t), n = i.useMemo(() => t.filter((r) => r.drawer), [t]), o = i.useMemo(() => {
+    const r = /* @__PURE__ */ new Map();
+    return n.forEach((s) => {
+      r.set(s.id, () => e.close(s.id));
+    }), r;
+  }, [n, e.close]);
+  return /* @__PURE__ */ h(N, { children: n.map((r) => {
+    if (!r.drawer)
+      return null;
+    const s = e.state(r.id), u = o.get(r.id);
+    return u ? /* @__PURE__ */ h(
+      we,
+      {
+        id: r.id,
+        config: r.drawer,
+        isOpen: s,
+        onClose: u,
+        zIndex: r.zIndex,
+        width: r.width,
+        height: r.height,
+        position: r.position,
+        children: r.component
+      },
+      r.id
+    ) : null;
+  }) });
+}, xt = i.createContext(null), ze = ({ value: t, children: e }) => /* @__PURE__ */ h(xt.Provider, { value: t, children: e }), kt = () => {
+  const t = i.useContext(xt);
+  if (!t)
+    throw new Error("useGridLayoutContext must be used within a GridLayoutProvider.");
+  return t;
+}, At = i.createContext(null), Ht = () => {
+  const t = i.useContext(At);
+  if (!t)
+    throw new Error("usePanelSystem must be used within a PanelSystemProvider.");
+  return t;
+}, Ee = ({ config: t, layers: e, style: n, children: o }) => {
+  const r = i.useMemo(() => {
+    const l = /* @__PURE__ */ new Map();
+    return e.forEach((g) => {
+      l.set(g.id, g);
+    }), l;
+  }, [e]), s = i.useCallback(
+    (l) => r.get(l)?.component ?? null,
+    [r]
+  ), u = i.useMemo(() => e.map((l) => l.id), [e]), { getCachedContent: c } = se({
+    resolveContent: s,
+    validIds: u
+  }), a = i.useMemo(
+    () => ({
+      config: t,
+      style: n,
+      layers: {
+        defs: e,
+        layerById: r
+      },
+      getCachedContent: c
+    }),
+    [t, n, e, r, c]
+  );
+  return /* @__PURE__ */ h(At.Provider, { value: a, children: o });
+}, Nt = i.createContext(null), $t = ({ layerId: t, children: e }) => {
+  const n = i.useMemo(() => ({ layerId: t }), [t]);
+  return /* @__PURE__ */ h(Nt.Provider, { value: n, children: e });
+}, Xn = () => {
+  const t = i.useContext(Nt);
+  if (!t)
+    throw new Error("useLayerInstance must be used within a LayerInstanceProvider.");
+  return t;
+}, gt = (t, e, n) => {
+  if (typeof t == "number" && Number.isFinite(t))
+    return t;
+  throw new Error(`Popup layer "${n}" requires a numeric "${e}" value.`);
+}, Ft = (t, e) => {
+  if (!t)
+    throw new Error(`Popup layer "${e}" must define position (left/top).`);
+  return {
+    left: gt(t.left, "left", e),
+    top: gt(t.top, "top", e)
+  };
+}, V = (t) => `${Math.round(t)}`, G = (t) => {
+  if (t !== void 0)
+    return t ? "yes" : "no";
+}, Re = (t, e, n, o, r) => {
+  const s = {}, u = Ft(e, t);
+  if (typeof n != "number" || typeof o != "number")
+    throw new Error(`Popup layer "${t}" requires numeric width/height.`);
+  s.width = V(n), s.height = V(o), s.left = V(u.left), s.top = V(u.top);
+  const c = r?.features;
+  if (c) {
+    const a = G(c.toolbar), l = G(c.menubar), g = G(c.location), f = G(c.status), m = G(c.resizable), w = G(c.scrollbars);
+    a !== void 0 && (s.toolbar = a), l !== void 0 && (s.menubar = l), g !== void 0 && (s.location = g), f !== void 0 && (s.status = f), m !== void 0 && (s.resizable = m), w !== void 0 && (s.scrollbars = w);
+  }
+  return Object.entries(s).map(([a, l]) => `${a}=${l}`).join(",");
+}, pt = (t, e, n, o, r) => {
+  const s = Ft(n, e);
+  if (typeof o != "number" || typeof r != "number")
+    throw new Error(`Popup layer "${e}" requires numeric width/height.`);
+  t.moveTo(Math.round(s.left), Math.round(s.top)), t.resizeTo(Math.round(o), Math.round(r));
+}, Pe = ({ layer: t }) => {
+  const e = t.floating;
+  if (!e)
+    throw new Error(`Layer "${t.id}" is missing floating configuration required for popup mode.`);
+  if ((e.mode ?? "embedded") !== "popup")
+    throw new Error(`PopupLayerPortal received layer "${t.id}" that is not configured for popup mode.`);
+  const o = i.useRef(null), r = i.useRef(null), [s, u] = i.useState(!1);
+  return i.useEffect(() => {
+    if (typeof window > "u")
+      return;
+    const c = Re(t.id, t.position, t.width, t.height, e.popup), a = e.popup?.name ?? t.id, l = ye(
+      a,
+      c,
+      {
+        position: t.position,
+        size: { width: t.width, height: t.height }
+      },
+      e.popup
+    );
+    if (!l)
+      throw new Error(`Failed to open popup window for layer "${t.id}".`);
+    const g = l;
+    r.current = g, e.popup?.focus !== !1 && g.focus(), g.document.title || (g.document.title = t.id), g.document.body.innerHTML = "";
+    const f = g.document.createElement("div");
+    f.dataset.layerId = t.id, g.document.body.appendChild(f), o.current = f, u(!0), pt(g, t.id, t.position, t.width, t.height);
+    const m = () => {
+      r.current = null, o.current = null, u(!1);
+    };
+    return g.addEventListener("beforeunload", m), () => {
+      g.removeEventListener("beforeunload", m), e.popup?.closeOnUnmount !== !1 && g.close(), r.current = null, o.current = null, u(!1);
+    };
+  }, [
+    e.popup?.closeOnUnmount,
+    e.popup?.features?.location,
+    e.popup?.features?.menubar,
+    e.popup?.features?.resizable,
+    e.popup?.features?.scrollbars,
+    e.popup?.features?.status,
+    e.popup?.features?.toolbar,
+    e.popup?.focus,
+    e.popup?.name,
+    t.id
+  ]), i.useEffect(() => {
+    const c = r.current;
+    c && pt(c, t.id, t.position, t.width, t.height);
+  }, [t.position?.left, t.position?.top, t.height, t.width, t.id]), !s || !o.current ? null : ae(/* @__PURE__ */ h($t, { layerId: t.id, children: t.component }), o.current);
+}, ye = (t, e, n, o) => {
+  const r = o?.createWindow;
+  return r ? r({ name: t, features: e, bounds: n }) : window.open("", t, e);
+}, Le = ({ onClick: t }) => /* @__PURE__ */ h(Ut, { children: /* @__PURE__ */ h(Dt, { onClick: t, "aria-label": "Close window", "data-drag-ignore": "true" }) }), Me = ({ header: t, draggable: e, onClose: n }) => {
+  if (!t)
+    return null;
+  const o = t.showCloseButton ?? !1;
+  return /* @__PURE__ */ H(Lt, { ...e ? { "data-drag-handle": "true" } : {}, style: { cursor: e ? "grab" : void 0 }, children: [
+    t.title ? /* @__PURE__ */ h(Mt, { children: t.title }) : null,
+    o ? /* @__PURE__ */ h(Le, { onClick: n }) : null
+  ] });
+}, De = ({ header: t, draggable: e, chrome: n, onClose: o, children: r }) => n ? /* @__PURE__ */ H(Pt, { style: { height: "100%", width: "100%" }, children: [
+  /* @__PURE__ */ h(Me, { header: t, draggable: e, onClose: o }),
+  /* @__PURE__ */ h(yt, { style: { flex: 1, display: "flex", flexDirection: "column" }, children: r })
+] }) : /* @__PURE__ */ h(N, { children: r }), _t = ({ id: t, config: e, onClose: n, children: o }) => {
+  const r = e.chrome ?? !1, s = e.draggable ?? !1, u = e.header?.title ?? e.ariaLabel ?? "Floating window";
+  return /* @__PURE__ */ h("div", { "data-floating-window": t, role: "dialog", "aria-label": u, style: { height: "100%", width: "100%" }, children: /* @__PURE__ */ h(De, { header: e.header, draggable: s, chrome: r, onClose: n, children: o }) });
+};
+_t.displayName = "FloatingWindow";
+const Gt = {
+  position: "absolute",
+  pointerEvents: "auto",
+  boxSizing: "border-box",
+  background: "transparent",
+  border: "none"
+}, Ie = {
+  ...Gt,
+  width: T,
+  height: T,
+  zIndex: 2
+}, Te = {
+  ...Gt,
+  zIndex: 1
+}, xe = {
+  "top-left": {
+    top: 0,
+    left: 0,
+    transform: "translate(-50%, -50%)",
+    cursor: "nwse-resize"
+  },
+  "top-right": {
+    top: 0,
+    right: 0,
+    transform: "translate(50%, -50%)",
+    cursor: "nesw-resize"
+  },
+  "bottom-left": {
+    bottom: 0,
+    left: 0,
+    transform: "translate(-50%, 50%)",
+    cursor: "nesw-resize"
+  },
+  "bottom-right": {
+    bottom: 0,
+    right: 0,
+    transform: "translate(50%, 50%)",
+    cursor: "nwse-resize"
+  }
+}, ke = {
+  left: {
+    top: T,
+    bottom: T,
+    left: 0,
+    width: Y,
+    transform: "translateX(-50%)",
+    cursor: "ew-resize"
+  },
+  right: {
+    top: T,
+    bottom: T,
+    right: 0,
+    width: Y,
+    transform: "translateX(50%)",
+    cursor: "ew-resize"
+  },
+  top: {
+    left: T,
+    right: T,
+    top: 0,
+    height: Y,
+    transform: "translateY(-50%)",
+    cursor: "ns-resize"
+  },
+  bottom: {
+    left: T,
+    right: T,
+    bottom: 0,
+    height: Y,
+    transform: "translateY(50%)",
+    cursor: "ns-resize"
+  }
+}, Ae = [
+  { key: "top-left", variant: "corner", horizontal: "left", vertical: "top" },
+  { key: "top-right", variant: "corner", horizontal: "right", vertical: "top" },
+  { key: "bottom-left", variant: "corner", horizontal: "left", vertical: "bottom" },
+  { key: "bottom-right", variant: "corner", horizontal: "right", vertical: "bottom" },
+  { key: "left", variant: "edge", horizontal: "left" },
+  { key: "right", variant: "edge", horizontal: "right" },
+  { key: "top", variant: "edge", vertical: "top" },
+  { key: "bottom", variant: "edge", vertical: "bottom" }
+], He = ({ layerId: t, onPointerDown: e }) => /* @__PURE__ */ h(N, { children: Ae.map((n) => {
+  const o = n.variant === "corner" ? Ie : Te, r = n.variant === "corner" ? xe[n.key] : ke[n.key], s = { ...o, ...r }, u = n.variant === "corner" ? { "data-resize-corner": n.key } : { "data-resize-edge": n.key };
+  return /* @__PURE__ */ h(
+    "div",
+    {
+      role: "presentation",
+      "aria-hidden": "true",
+      style: s,
+      ...u,
+      "data-layer-id": t,
+      onPointerDown: (c) => e(n, c)
+    },
+    n.key
+  );
+}) }), Ne = ({ pivot: t }) => {
+  const { Outlet: e } = ie({
+    items: t.items,
+    activeId: t.activeId,
+    defaultActiveId: t.defaultActiveId,
+    onActiveChange: t.onActiveChange,
+    transitionMode: t.transitionMode
+  });
+  return /* @__PURE__ */ h(e, {});
+}, Wt = i.memo(({ layer: t, onClose: e }) => {
+  const { getCachedContent: n } = Ht(), o = t.pivot ? /* @__PURE__ */ h(Ne, { pivot: t.pivot }) : /* @__PURE__ */ h(N, { children: n(t.id) });
+  return t.floating?.chrome ? /* @__PURE__ */ h(_t, { id: t.id, config: t.floating, onClose: e, children: o }) : o;
+});
+Wt.displayName = "LayerContentRenderer";
+const Ot = i.memo(({ layerId: t, isResizable: e, onPointerDown: n }) => e ? /* @__PURE__ */ h(He, { layerId: t, onPointerDown: n }) : null);
+Ot.displayName = "LayerResizeHandles";
+const $e = (t, e) => t ? "auto" : e ? "visible" : "hidden", Bt = i.memo(({ layer: t, handleLayerPointerDown: e }) => {
+  const { getLayerRenderState: n } = kt(), { style: o, isResizable: r, isResizing: s, onResizeHandlePointerDown: u } = n(t), c = i.useMemo(() => {
+    const g = {};
+    return t.gridArea && (g.gridArea = t.gridArea), t.gridRow && (g.gridRow = t.gridRow), t.gridColumn && (g.gridColumn = t.gridColumn), g;
+  }, [t.gridArea, t.gridRow, t.gridColumn]), a = i.useMemo(() => {
+    const g = !!t.floating, f = $e(t.scrollable, g), m = {
+      ...o,
+      ...c,
+      minWidth: 0,
+      minHeight: 0,
+      overflow: f
+    };
+    return r ? { ...m, position: "relative" } : m;
+  }, [o, c, r, t.scrollable, t.floating]), l = i.useCallback(() => {
+    t.floating?.onClose?.();
+  }, [t.floating]);
+  return /* @__PURE__ */ H(
+    "div",
+    {
+      "data-layer-id": t.id,
+      "data-draggable": !!t.floating?.draggable,
+      "data-resizable": r,
+      "data-resizing": s,
+      style: a,
+      onPointerDown: e,
+      children: [
+        /* @__PURE__ */ h($t, { layerId: t.id, children: /* @__PURE__ */ h(Wt, { layer: t, onClose: l }) }),
+        /* @__PURE__ */ h(Ot, { layerId: t.id, isResizable: r, onPointerDown: u })
+      ]
+    }
+  );
+});
+Bt.displayName = "EmbeddedLayer";
+const Fe = ({ layers: t }) => {
+  const { handleLayerPointerDown: e } = kt();
+  return /* @__PURE__ */ h(N, { children: t.map((n) => {
+    const o = n.floating?.mode ?? "embedded";
+    return n.floating && o === "popup" ? /* @__PURE__ */ h(Pe, { layer: n }, n.id) : /* @__PURE__ */ h(Bt, { layer: n, handleLayerPointerDown: e }, n.id);
+  }) });
+};
+function W(t) {
+  const e = i.useRef(t);
+  return e.current = t, i.useCallback((...n) => {
+    const o = e.current;
+    if (o)
+      return o(...n);
+  }, []);
+}
+function et(t, e) {
+  const n = W(e.onMove), o = W(e.onUp), r = W(e.onCancel);
+  i.useEffect(() => {
+    if (t)
+      return e.onMove && document.addEventListener("pointermove", n, { passive: !1 }), e.onUp && document.addEventListener("pointerup", o), e.onCancel && document.addEventListener("pointercancel", r), () => {
+        e.onMove && document.removeEventListener("pointermove", n), e.onUp && document.removeEventListener("pointerup", o), e.onCancel && document.removeEventListener("pointercancel", r);
+      };
+  }, [t, e.onMove, e.onUp, e.onCancel, n, o, r]);
+}
+function _e(t, e, n) {
+  i.useEffect(() => {
+    const o = t.current;
+    if (!(!e || !o || n === void 0))
+      return o.setPointerCapture(n), () => {
+        o.hasPointerCapture && o.hasPointerCapture(n) && o.releasePointerCapture(n);
+      };
+  }, [t, e, n]);
+}
+function Ge(t, e, n = ["pointerdown", "pointermove", "pointerup"]) {
+  i.useEffect(() => {
+    const o = t.current;
+    if (!e || !o)
+      return;
+    const r = (s) => {
+      s.preventDefault();
+    };
+    return n.forEach((s) => {
+      o.addEventListener(s, r, { passive: !1 });
+    }), () => {
+      n.forEach((s) => {
+        o.removeEventListener(s, r);
+      });
+    };
+  }, [t, e, n]);
+}
+function We(t, e, n) {
+  const { onMove: o, onUp: r, onCancel: s, pointerId: u, capturePointer: c = !0, preventDefaults: a = !0 } = n;
+  et(e, { onMove: o, onUp: r, onCancel: s }), _e(t, e ? c : !1, u), Ge(t, e ? a : !1);
+}
+const Oe = (t) => {
+  const e = i.useRef(null), n = i.useRef(null), o = i.useRef(0), [r, s] = i.useState(!1), u = W((f) => {
+    t.onResize?.(f);
+  }), c = i.useCallback(
+    (f) => t.axis === "x" ? f.clientX : f.clientY,
+    [t.axis]
+  ), a = i.useCallback(
+    (f) => {
+      f.preventDefault(), e.current = f.currentTarget, n.current = f.pointerId, o.current = c(f), s(!0);
+    },
+    [c]
+  ), l = i.useCallback(
+    (f) => {
+      const m = c(f), w = m - o.current;
+      w !== 0 && (o.current = m, u(w));
+    },
+    [c, u]
+  ), g = i.useCallback(() => {
+    s(!1), n.current = null;
+  }, []);
+  return We(e, r, {
+    onMove: l,
+    onUp: g,
+    pointerId: n.current ?? void 0,
+    capturePointer: !0,
+    preventDefaults: !1
+  }), {
+    ref: e,
+    onPointerDown: a,
+    isDragging: r
+  };
+}, Be = ({
+  element: t,
+  component: e
+}) => i.forwardRef(({ children: n, ...o }, r) => t ? i.cloneElement(
+  t,
+  { ...o, ref: r },
+  n ?? t.props.children
+) : e ? /* @__PURE__ */ h(e, { ...o, ref: r, children: n }) : /* @__PURE__ */ h("div", { ...o, ref: r, children: n }));
+function Ye({
+  element: t,
+  component: e
+}) {
+  return i.useMemo(
+    () => Be({
+      element: t,
+      component: e
+    }),
+    [e, t]
+  );
+}
+const Ve = {
+  position: "absolute",
+  zIndex: re
+}, Xe = {
+  vertical: {
+    width: ut,
+    height: "100%",
+    top: 0,
+    cursor: "col-resize"
+  },
+  horizontal: {
+    width: "100%",
+    height: ut,
+    left: 0,
+    cursor: "row-resize"
+  }
+}, Ue = {
+  idle: oe,
+  hovered: ne,
+  dragging: ee
+}, je = ({
+  direction: t,
+  onResize: e,
+  component: n,
+  element: o,
+  children: r
+}) => {
+  const s = t === "vertical" ? "x" : "y", { ref: u, isDragging: c, onPointerDown: a } = Oe({ axis: s, onResize: e }), [l, g] = i.useState(!1), f = i.useCallback(() => {
+    g(!0);
+  }, []), m = i.useCallback(() => {
+    g(!1);
+  }, []), w = Ye({
+    element: o,
+    component: n
+  }), C = i.useMemo(() => c ? "dragging" : l ? "hovered" : "idle", [c, l]), z = i.useMemo(() => ({
+    ...Ve,
+    ...Xe[t],
+    backgroundColor: Ue[C],
+    touchAction: "none"
+  }), [t, C]);
+  return /* @__PURE__ */ h(
+    w,
+    {
+      ref: u,
+      style: z,
+      role: "separator",
+      "aria-orientation": t,
+      "aria-hidden": void 0,
+      "data-resize-handle": "true",
+      "data-direction": t,
+      "data-is-dragging": c ? "true" : void 0,
+      onPointerDown: a,
+      onPointerEnter: f,
+      onPointerLeave: m,
+      children: r
+    }
+  );
+}, ht = {
+  position: "absolute",
+  pointerEvents: "auto"
+}, mt = ({
+  direction: t,
+  trackIndex: e,
+  align: n,
+  gap: o,
+  span: r,
+  onResize: s
+}) => {
+  const u = t === "col" ? "vertical" : "horizontal", c = i.useCallback(
+    (g) => {
+      const f = n === "start" ? -g : g;
+      s(t, e, f);
+    },
+    [n, t, e, s]
+  ), a = i.useMemo(() => t === "col" ? {
+    gridColumn: `${e + 1} / ${e + 2}`,
+    gridRow: `${r.start} / ${r.end}`
+  } : {
+    gridRow: `${e + 1} / ${e + 2}`,
+    gridColumn: `${r.start} / ${r.end}`
+  }, [t, e, r]), l = i.useMemo(() => {
+    const f = Math.max(0, o) / 2 + Q / 2;
+    return t === "col" ? {
+      ...ht,
+      width: Q,
+      height: "100%",
+      top: 0,
+      bottom: 0,
+      ...n === "start" ? { left: -f } : { right: -f }
+    } : {
+      ...ht,
+      width: "100%",
+      height: Q,
+      left: 0,
+      right: 0,
+      ...n === "start" ? { top: -f } : { bottom: -f }
+    };
+  }, [n, t, o]);
+  return /* @__PURE__ */ h("div", { "data-resizable": "true", style: { ...a, position: "relative", pointerEvents: "none" }, children: /* @__PURE__ */ h("div", { "data-direction": u, "data-align": n, "data-handle": "true", style: l, children: /* @__PURE__ */ h(je, { direction: u, onResize: c }) }) });
+}, Ke = (t) => {
+  const e = /* @__PURE__ */ new Map();
+  t.forEach((o, r) => {
+    o.forEach((s, u) => {
+      if (!s || s === ".")
+        return;
+      const c = e.get(s);
+      if (c) {
+        const l = {
+          rowStart: Math.min(c.rowStart, r),
+          rowEnd: Math.max(c.rowEnd, r),
+          colStart: Math.min(c.colStart, u),
+          colEnd: Math.max(c.colEnd, u)
+        };
+        e.set(s, l);
+        return;
+      }
+      const a = {
+        rowStart: r,
+        rowEnd: r,
+        colStart: u,
+        colEnd: u
+      };
+      e.set(s, a);
+    });
+  });
+  const n = /* @__PURE__ */ new Map();
+  return e.forEach((o, r) => {
+    const s = o.rowStart + 1, u = o.rowEnd + 2, c = o.colStart + 1, a = o.colEnd + 2, l = {
+      gridArea: r,
+      gridRow: `${s} / ${u}`,
+      gridColumn: `${c} / ${a}`
+    };
+    n.set(r, l);
+  }), n;
+}, Ze = (t, e) => {
+  if ((t.positionMode ?? "grid") !== "grid")
+    return t;
+  const o = t.gridArea ?? t.id, r = e.get(o);
+  if (!r)
+    return t;
+  const s = !t.gridArea, u = !t.gridRow, c = !t.gridColumn;
+  return !s && !u && !c ? t : {
+    ...t,
+    gridArea: s ? r.gridArea : t.gridArea,
+    gridRow: u ? r.gridRow : t.gridRow,
+    gridColumn: c ? r.gridColumn : t.gridColumn
+  };
+}, qe = (t, e) => {
+  const n = i.useMemo(() => Ke(t.areas), [t.areas]), o = i.useMemo(() => e.map((c) => Ze(c, n)), [e, n]), r = i.useMemo(
+    () => o.filter((c) => c.visible !== !1),
+    [o]
+  ), s = i.useMemo(
+    () => r.filter((c) => !c.drawer),
+    [r]
+  ), u = i.useMemo(() => {
+    const c = /* @__PURE__ */ new Map();
+    return o.forEach((a) => {
+      c.set(a.id, a);
+    }), c;
+  }, [o]);
+  return {
+    normalizedLayers: o,
+    visibleLayers: r,
+    regularLayers: s,
+    layerById: u
+  };
+}, Je = (t) => {
+  if (!t)
+    return { rowGap: 0, columnGap: 0 };
+  const e = t.split(/\s+/).map((o) => o.trim()).filter(Boolean), n = (o) => {
+    const r = o.match(/^(-?\d+(?:\.\d+)?)px$/);
+    return r ? Number.parseFloat(r[1]) : 0;
+  };
+  if (e.length === 1) {
+    const o = n(e[0]);
+    return { rowGap: o, columnGap: o };
+  }
+  return {
+    rowGap: n(e[0]),
+    columnGap: n(e[1])
+  };
+}, Qe = (t, e) => {
+  if (!t)
+    return [];
+  const n = getComputedStyle(t);
+  return (e === "col" ? n.gridTemplateColumns : n.gridTemplateRows).split(/\s+/).map((r) => parseFloat(r)).filter((r) => !Number.isNaN(r));
+}, Yt = (t, e = Number.NEGATIVE_INFINITY, n = Number.POSITIVE_INFINITY) => Math.min(Math.max(t, e), n), Un = (t, e) => typeof t != "number" || !Number.isFinite(t) ? e : t, K = (t, e) => `${t}-${e}`, tn = (t, e, n, o) => {
+  const r = K(n, o), s = e[r];
+  return s !== void 0 ? `minmax(${t.minSize ?? 0}px, ${s}px)` : t.size;
+}, wt = (t, e, n) => t.map((o, r) => tn(o, e, n, r)).join(" "), X = (t, e) => t.reduce((n, o, r) => (o.resizable && o.size.endsWith("px") && (n[K(e, r)] = parseInt(o.size, 10)), n), {}), en = ({
+  trackSizes: t,
+  track: e,
+  direction: n,
+  trackIndex: o,
+  containerRef: r
+}) => {
+  const s = K(n, o), u = t[s];
+  if (u !== void 0)
+    return u;
+  const a = Qe(r?.current ?? null, n)[o];
+  return a !== void 0 && a > 0 ? a : e.size.endsWith("px") ? Number.parseInt(e.size, 10) : 300;
+}, nn = (t, e) => t.reduce((n, o, r) => r === e ? n : o.size.includes("fr") ? n + 100 : n + (o.minSize ?? 50), 0), on = ({
+  track: t,
+  tracks: e,
+  trackIndex: n,
+  direction: o,
+  containerRef: r,
+  gapSizes: s
+}) => {
+  if (!r?.current)
+    return t.maxSize;
+  const u = o === "col" ? r.current.offsetWidth : r.current.offsetHeight, c = nn(e, n), a = e.length - 1, l = o === "col" ? s.columnGap : s.rowGap, g = a * l, f = u - c - g;
+  return t.maxSize !== void 0 ? Math.min(t.maxSize, f) : f;
+}, rn = (t, e, n) => Yt(t, e ?? Number.NEGATIVE_INFINITY, n ?? Number.POSITIVE_INFINITY), bt = (t, e) => {
+  const n = t.length, o = [];
+  for (let u = 0; u < n; u++) {
+    const c = t[u], a = c[e], l = c[e + 1];
+    a !== l && o.push(u);
+  }
+  if (o.length === 0)
+    return { start: 1, end: n + 1 };
+  const r = Math.min(...o), s = Math.max(...o);
+  return { start: r + 1, end: s + 2 };
+}, vt = (t, e) => {
+  const n = t[e], o = t[e + 1], r = n?.length ?? 0, s = [];
+  for (let a = 0; a < r; a++) {
+    const l = n?.[a], g = o?.[a];
+    l !== g && s.push(a);
+  }
+  if (s.length === 0)
+    return { start: 1, end: r + 1 };
+  const u = Math.min(...s), c = Math.max(...s);
+  return { start: u + 1, end: c + 2 };
+}, sn = (t, e) => {
+  if (t.length === 0)
+    return [];
+  const n = e.length;
+  if (t.length === 1)
+    return t[0]?.resizable ? [{ trackIndex: 0, align: "end", span: { start: 1, end: n + 1 } }] : [];
+  const o = [];
+  return Array.from({ length: t.length - 1 }, (s, u) => u).forEach((s) => {
+    const u = t[s];
+    if (t[s + 1]?.resizable) {
+      const a = bt(e, s);
+      o.push({ trackIndex: s + 1, align: "start", span: a });
+      return;
+    }
+    if (u?.resizable) {
+      const a = bt(e, s);
+      o.push({ trackIndex: s, align: "end", span: a });
+    }
+  }), o;
+}, an = (t, e) => {
+  if (t.length === 0)
+    return [];
+  const n = e[0]?.length ?? 0;
+  if (t.length === 1)
+    return t[0]?.resizable ? [{ trackIndex: 0, align: "end", span: { start: 1, end: n + 1 } }] : [];
+  const o = [];
+  return Array.from({ length: t.length - 1 }, (s, u) => u).forEach((s) => {
+    const u = t[s];
+    if (t[s + 1]?.resizable) {
+      const a = vt(e, s);
+      o.push({ trackIndex: s + 1, align: "start", span: a });
+      return;
+    }
+    if (u?.resizable) {
+      const a = vt(e, s);
+      o.push({ trackIndex: s, align: "end", span: a });
+    }
+  }), o;
+}, cn = (t) => t !== void 0 ? { gap: t } : {}, un = (t, e) => {
+  const n = Object.keys(e), o = {};
+  for (const g of n)
+    o[g] = t[g] ?? e[g];
+  const r = Object.keys(t), s = r.length !== n.length, u = r.some(
+    (g) => !Object.prototype.hasOwnProperty.call(o, g)
+  ), c = s ? !0 : u, a = n.some((g) => t[g] !== o[g]);
+  return (c ? !0 : a) ? o : null;
+}, ln = (t, e, n) => {
+  const [o, r] = i.useState(() => ({
+    ...X(t.columns, "col"),
+    ...X(t.rows, "row")
+  }));
+  It(() => {
+    const f = {
+      ...X(t.columns, "col"),
+      ...X(t.rows, "row")
+    };
+    r((m) => un(m, f) ?? m);
+  }, [t.columns, t.rows]);
+  const s = i.useMemo(() => t.areas.map((f) => `"${f.join(" ")}"`).join(" "), [t.areas]), u = i.useMemo(() => Je(t.gap), [t.gap]), c = i.useMemo(
+    () => sn(t.columns, t.areas),
+    [t.columns, t.areas]
+  ), a = i.useMemo(
+    () => an(t.rows, t.areas),
+    [t.rows, t.areas]
+  ), l = i.useMemo(() => ({
+    ...t.style,
+    ...e,
+    gridTemplateAreas: s,
+    gridTemplateRows: wt(t.rows, o, "row"),
+    gridTemplateColumns: wt(t.columns, o, "col"),
+    ...cn(t.gap)
+  }), [s, t.columns, t.gap, t.rows, t.style, e, o]), g = i.useCallback(
+    (f, m, w) => {
+      const C = f === "row" ? t.rows : t.columns, z = C[m];
+      if (!z || !z.resizable)
+        return;
+      const y = en({
+        trackSizes: o,
+        track: z,
+        direction: f,
+        trackIndex: m,
+        containerRef: n
+      }), L = on({
+        track: z,
+        tracks: C,
+        trackIndex: m,
+        direction: f,
+        containerRef: n,
+        gapSizes: u
+      }), x = K(f, m);
+      r(($) => {
+        const M = y + w, D = rn(M, z.minSize, L);
+        return { ...$, [x]: D };
+      });
+    },
+    [t.columns, t.rows, o, n, u]
+  );
+  return {
+    columnHandles: c,
+    rowHandles: a,
+    gapSizes: u,
+    gridStyle: l,
+    handleResize: g
+  };
+}, dn = (t) => t.positionMode ? t.positionMode : t.floating ? (t.floating.mode ?? "embedded") === "embedded" ? "absolute" : "relative" : "grid", fn = (t) => ({ position: t === "grid" ? "relative" : t }), gn = (t, e) => e !== "grid" ? {} : {
+  gridArea: t.gridArea,
+  gridRow: t.gridRow,
+  gridColumn: t.gridColumn
+}, pn = (t) => t ? {
+  top: t.top,
+  right: t.right,
+  bottom: t.bottom,
+  left: t.left
+} : {}, hn = (t) => t !== void 0 ? { zIndex: t } : {}, mn = (t, e) => ({
+  width: t,
+  height: e
+}), wn = (t, e) => t.pointerEvents !== void 0 ? typeof t.pointerEvents == "boolean" ? { pointerEvents: t.pointerEvents ? "auto" : "none" } : { pointerEvents: t.pointerEvents } : e === "absolute" || e === "fixed" ? { pointerEvents: "auto" } : {}, bn = (t) => t.floating ? t.floating.position ?? t.floating.defaultPosition ?? t.position : t.position, vn = (t) => {
+  if (t.floating) {
+    const e = t.floating.size ?? t.floating.defaultSize;
+    if (e)
+      return {
+        width: e.width,
+        height: e.height
+      };
+  }
+  return {
+    width: t.width,
+    height: t.height
+  };
+}, Sn = (t) => t.floating?.zIndex !== void 0 ? t.floating.zIndex : t.zIndex, Cn = (t) => {
+  const e = dn(t), n = bn(t), o = vn(t), r = Sn(t);
+  return {
+    ...t.style,
+    ...fn(e),
+    ...gn(t, e),
+    ...pn(n),
+    ...hn(r),
+    ...mn(o.width, o.height),
+    ...wn(t, e)
+  };
+}, zn = (t) => {
+  const e = t.floating;
+  return e ? e.mode ?? "embedded" : null;
+}, _ = (t) => zn(t) !== "embedded" ? null : t.floating ?? null, St = (t) => t instanceof HTMLElement ? ["INPUT", "TEXTAREA", "SELECT", "BUTTON"].includes(t.tagName) : !1, Ct = (t, e, n) => {
+  const o = e ?? Number.NEGATIVE_INFINITY, r = n ?? Number.POSITIVE_INFINITY;
+  return Yt(t, o, r);
+}, zt = (t, e, n) => {
+  if (typeof t == "number" && Number.isFinite(t))
+    return t;
+  throw new Error(
+    `Floating layer "${n}" must provide a numeric "${e}" value when draggable mode is enabled.`
+  );
+}, Et = (t) => {
+  const e = _(t);
+  if (!e)
+    throw new Error(`Floating layer "${t.id}" is missing floating configuration required for dragging.`);
+  const n = e.position ?? e.defaultPosition ?? t.position;
+  if (!n)
+    throw new Error(`Floating layer "${t.id}" must define position with left and top values.`);
+  return {
+    left: zt(n.left, "left", t.id),
+    top: zt(n.top, "top", t.id)
+  };
+}, En = (t) => {
+  const e = _(t);
+  return e ? e.constraints ?? {} : {};
+}, Rn = (t, e, n) => t ? t === "left" ? e - n : e + n : e, Pn = (t, e, n) => t ? t === "top" ? e - n : e + n : e, yn = (t, e, n) => !t || t === "right" ? e : e + n, Ln = (t, e, n) => !t || t === "bottom" ? e : e + n, nt = (t, e) => t ? t.dataset.layerId === e ? t : nt(t.parentElement, e) : null, ot = (t, e, n) => !t || n?.(t) ? null : e(t) ? t : ot(t.parentElement, e, n), Mn = (t) => t instanceof HTMLElement ? ot(
+  t,
+  (e) => e.dataset.dragHandle === "true",
+  (e) => e.dataset.dragIgnore === "true"
+) : null, Rt = (t) => t instanceof HTMLElement ? ot(
+  t,
+  (e) => e.dataset.resizeCorner !== void 0 || e.dataset.resizeEdge !== void 0
+) !== null : !1, U = (t) => {
+  const e = _(t);
+  return e ? e.resizable === !0 : !1;
+}, j = (t) => {
+  if (!_(t))
+    return null;
+  const n = Tn(t);
+  if (!n)
+    throw new Error(`Floating layer "${t.id}" must define width and height when resizable or draggable.`);
+  return {
+    width: n.width,
+    height: n.height
+  };
+}, Dn = (t, e, n) => {
+  const o = t.filter(U).reduce((f, m) => {
+    if (n === m.id) {
+      const C = e[m.id];
+      if (C)
+        return f[m.id] = C, f;
+    }
+    const w = j(m);
+    return w && (f[m.id] = w), f;
+  }, {}), r = Object.keys(e), s = Object.keys(o), u = r.length !== s.length, c = r.some((f) => !Object.prototype.hasOwnProperty.call(o, f)), a = u ? !0 : c, l = s.some((f) => {
+    const m = e[f], w = o[f];
+    return !m || !w ? !0 : m.width !== w.width || m.height !== w.height;
+  });
+  return {
+    sizes: o,
+    changed: a ? !0 : l
+  };
+}, In = ({
+  layers: t,
+  layerById: e,
+  isRootLevel: n
+}) => {
+  const [o, r] = i.useState(null), [s, u] = i.useState(null), [c, a] = i.useState({}), [l, g] = i.useState({}), f = i.useRef(null), m = i.useRef(null), w = W((p, d) => {
+    e.get(p)?.floating?.onMove?.(d);
+  }), C = W((p, d) => {
+    e.get(p)?.floating?.onResize?.(d);
+  });
+  It(() => {
+    const { sizes: p, changed: d } = Dn(t, l, s);
+    d && g(p);
+  }, [t, s]);
+  const z = i.useCallback(
+    (p, d, b, v) => {
+      const S = Et(d), P = c[p] ?? { x: 0, y: 0 }, E = {
+        pointerStartX: v.clientX,
+        pointerStartY: v.clientY,
+        initialTranslationX: P.x,
+        initialTranslationY: P.y,
+        baseLeft: S.left,
+        baseTop: S.top,
+        layerId: p,
+        pointerId: v.pointerId,
+        target: b
+      };
+      if (E.target.setPointerCapture)
+        try {
+          E.target.setPointerCapture(E.pointerId);
+        } catch {
+        }
+      f.current = E, r(p);
+    },
+    [c]
+  ), y = i.useCallback(
+    (p) => {
+      const d = p.target, b = Mn(d);
+      if (!b)
+        return;
+      const v = b.closest("[data-layer-id]")?.getAttribute("data-layer-id");
+      if (!v)
+        return;
+      const S = e.get(v);
+      if (!S)
+        return;
+      const P = _(S);
+      if (!(!P || P.draggable !== !0) && !St(p.target) && !Rt(p.target) && b) {
+        const E = nt(b, v);
+        if (!E)
+          return;
+        z(v, S, E, p);
+        return;
+      }
+    },
+    [z, e]
+  ), L = i.useCallback(
+    (p, d) => {
+      const b = e.get(p), v = b ? _(b) : null;
+      if (!b || !v || v.draggable !== !0 || St(d.target) || Rt(d.target))
+        return;
+      const S = nt(d.currentTarget, p);
+      S && z(p, b, S, d);
+    },
+    [z, e]
+  ), x = i.useCallback(
+    (p, d, b) => {
+      const v = e.get(p);
+      if (!v || !U(v))
+        return;
+      const S = l[p] ?? j(v);
+      if (!S)
+        return;
+      const P = Et(v), E = En(v), k = c[p] ?? { x: 0, y: 0 };
+      if (b.stopPropagation(), b.preventDefault(), b.currentTarget.setPointerCapture)
+        try {
+          b.currentTarget.setPointerCapture(b.pointerId);
+        } catch {
+        }
+      m.current = {
+        layerId: p,
+        pointerId: b.pointerId,
+        horizontalEdge: d.horizontal,
+        verticalEdge: d.vertical,
+        startX: b.clientX,
+        startY: b.clientY,
+        startWidth: S.width,
+        startHeight: S.height,
+        startPosition: k,
+        baseLeft: P.left,
+        baseTop: P.top,
+        minWidth: E.minWidth,
+        maxWidth: E.maxWidth,
+        minHeight: E.minHeight,
+        maxHeight: E.maxHeight,
+        target: b.currentTarget
+      }, u(p);
+    },
+    [e, c, l]
+  ), $ = i.useCallback(
+    (p) => {
+      const d = f.current;
+      if (!d)
+        return;
+      const b = p.clientX - d.pointerStartX, v = p.clientY - d.pointerStartY, S = {
+        x: d.initialTranslationX + b,
+        y: d.initialTranslationY + v
+      };
+      a((P) => ({ ...P, [d.layerId]: S })), w(d.layerId, {
+        left: d.baseLeft + S.x,
+        top: d.baseTop + S.y
+      });
+    },
+    [w]
+  ), M = i.useCallback(
+    (p) => {
+      const d = m.current;
+      if (!d || d.pointerId !== p.pointerId || !e.get(d.layerId))
+        return;
+      const v = p.clientX - d.startX, S = p.clientY - d.startY, P = Rn(d.horizontalEdge, d.startWidth, v), E = Pn(d.verticalEdge, d.startHeight, S), k = Ct(P, d.minWidth, d.maxWidth), F = Ct(E, d.minHeight, d.maxHeight), O = d.startWidth - k, Z = d.startHeight - F, it = yn(
+        d.horizontalEdge,
+        d.startPosition.x,
+        O
+      ), Xt = Ln(d.verticalEdge, d.startPosition.y, Z), q = l[d.layerId], at = { width: k, height: F };
+      (!q || q.width !== k || q.height !== F) && (g((J) => ({
+        ...J,
+        [d.layerId]: at
+      })), C(d.layerId, at));
+      const ct = c[d.layerId] ?? { x: 0, y: 0 }, B = { x: it, y: Xt };
+      (ct.x !== B.x || ct.y !== B.y) && (a((J) => ({
+        ...J,
+        [d.layerId]: B
+      })), w(d.layerId, {
+        left: d.baseLeft + B.x,
+        top: d.baseTop + B.y
+      }));
+    },
+    [e, c, l, w, C]
+  ), D = i.useCallback((p) => {
+    const d = f.current;
+    if (d) {
+      if (d.pointerId === p.pointerId && d.target.releasePointerCapture)
+        try {
+          d.target.releasePointerCapture(d.pointerId);
+        } catch {
+        }
+      f.current = null;
+    }
+    r(null);
+  }, []), A = i.useCallback((p) => {
+    const d = m.current;
+    if (d) {
+      if (d.pointerId === p.pointerId && d.target.releasePointerCapture)
+        try {
+          d.target.releasePointerCapture(d.pointerId);
+        } catch {
+        }
+      m.current = null;
+    }
+    u(null);
+  }, []);
+  et(o !== null, {
+    onMove: $,
+    onUp: D,
+    onCancel: D
+  }), et(s !== null, {
+    onMove: M,
+    onUp: A,
+    onCancel: A
+  });
+  const I = i.useCallback(
+    (p) => {
+      const d = Cn(p), b = _(p);
+      if (!b || b.draggable !== !0)
+        return d;
+      const v = c[p.id], S = o === p.id, P = s === p.id, E = v ? { transform: `translate(${v.x}px, ${v.y}px)` } : {}, k = l[p.id], F = U(p) ? j(p) : null, O = k ?? F, Z = O ? { width: `${O.width}px`, height: `${O.height}px` } : {};
+      return {
+        ...d,
+        ...Z,
+        ...E,
+        ...S || P ? { cursor: "grabbing" } : {}
+      };
+    },
+    [o, c, l, s]
+  ), R = i.useCallback(
+    (p) => {
+      if (!U(p))
+        return { isResizable: !1 };
+      const b = l[p.id], v = j(p);
+      return (b ?? v) !== null ? { isResizable: !0, onPointerDown: (k, F) => {
+        x(p.id, k, F);
+      } } : { isResizable: !1 };
+    },
+    [x, l]
+  ), rt = i.useCallback(
+    (p) => {
+      const { isResizable: d, onPointerDown: b } = R(p), v = I(p), S = s === p.id;
+      return {
+        style: v,
+        isResizable: d,
+        isResizing: S,
+        onResizeHandlePointerDown: (P, E) => {
+          b && b(P, E);
+        }
+      };
+    },
+    [I, R, s]
+  ), st = i.useCallback(
+    (p) => ({
+      "data-drag-handle": "true",
+      role: "button",
+      "aria-roledescription": "Drag handle",
+      "aria-label": "Drag layer",
+      onPointerDown: (d) => {
+        L(p, d);
+      }
+    }),
+    [L]
+  );
+  return {
+    providerValue: i.useMemo(
+      () => ({
+        handleLayerPointerDown: y,
+        getLayerRenderState: rt,
+        getLayerHandleProps: st,
+        isRootLevel: n
+      }),
+      [st, rt, y, n]
+    ),
+    draggingLayerId: o,
+    resizingLayerId: s
+  };
+}, Tn = (t) => {
+  if (t.floating) {
+    const e = t.floating.size ?? t.floating.defaultSize;
+    if (e)
+      return { width: e.width, height: e.height };
+  }
+  if (typeof t.width == "number" && typeof t.height == "number")
+    return { width: t.width, height: t.height };
+}, Vt = {
+  display: "grid",
+  width: "100%",
+  height: "100%",
+  overflow: "hidden"
+}, xn = {
+  touchAction: "none",
+  WebkitTouchCallout: "none",
+  WebkitUserSelect: "none",
+  userSelect: "none"
+}, kn = {
+  ...Vt,
+  overflow: "visible",
+  height: "auto",
+  minHeight: "100%"
+}, An = (t) => t ? kn : Vt, jn = ({ config: t, layers: e, style: n, root: o = !1 }) => {
+  const r = i.useRef(null), { isIntersecting: s } = de(r, { threshold: 0 });
+  return /* @__PURE__ */ h(Ee, { config: t, layers: e, style: n, children: /* @__PURE__ */ h(Hn, { gridRef: r, isIntersecting: s, isRoot: o }) });
+}, Hn = ({ gridRef: t, isIntersecting: e, isRoot: n }) => {
+  const { config: o, style: r, layers: s } = Ht(), { normalizedLayers: u, visibleLayers: c, regularLayers: a, layerById: l } = qe(o, s.defs), { columnHandles: g, rowHandles: f, gapSizes: m, gridStyle: w, handleResize: C } = ln(o, r, t), { providerValue: z, draggingLayerId: y, resizingLayerId: L } = In({
+    layers: u,
+    layerById: l,
+    isRootLevel: n
+  }), x = y ? !0 : !!L, $ = i.useMemo(() => ({
+    ...An(n),
+    ...w,
+    ...x ? xn : {}
+  }), [w, x, n]);
+  return /* @__PURE__ */ H(N, { children: [
+    /* @__PURE__ */ H(
+      "div",
+      {
+        ref: t,
+        style: $,
+        "data-dragging": !!y,
+        "data-resizing": !!L,
+        "data-visible": e,
+        children: [
+          /* @__PURE__ */ h(ze, { value: z, children: /* @__PURE__ */ h(Fe, { layers: a }) }),
+          g.map(({ trackIndex: M, align: D, span: A }) => /* @__PURE__ */ h(
+            mt,
+            {
+              direction: "col",
+              trackIndex: M,
+              align: D,
+              gap: m.columnGap,
+              span: A,
+              onResize: C
+            },
+            `col-${M}:${D}`
+          )),
+          f.map(({ trackIndex: M, align: D, span: A }) => /* @__PURE__ */ h(
+            mt,
+            {
+              direction: "row",
+              trackIndex: M,
+              align: D,
+              gap: m.rowGap,
+              span: A,
+              onResize: C
+            },
+            `row-${M}:${D}`
+          ))
+        ]
+      }
+    ),
+    /* @__PURE__ */ h(Ce, { layers: c })
+  ] });
+};
+export {
+  we as D,
+  _t as F,
+  jn as G,
+  je as R,
+  Xn as a,
+  kt as b,
+  W as c,
+  Ye as d,
+  Yt as e,
+  Ce as f,
+  Vn as g,
+  Tt as r,
+  Un as t,
+  Oe as u
+};
+//# sourceMappingURL=GridLayout-BzrIDrC9.js.map