@dooherceg/tiptap-controlled-editor-with-table 0.0.7 → 0.0.8

package/dist/node_modules/@floating-ui/react/dist/floating-ui.react.js

@@ -0,0 +1,932 @@
+import * as n from "react";
+import { enableFocusInside as pe, isOutsideEvent as te, getPreviousTabbable as Ae, getNextTabbable as Ke, useModernLayoutEffect as B, disableFocusInside as He, isSafari as Pe, useLatestRef as z, useEffectEvent as $, getDocument as U, isMouseLikePointerType as ae, activeElement as ge, contains as Q, getTarget as j, isTypeableElement as $e, matchesFocusVisible as Be, getFloatingFocusElement as We, isMac as Ye, getNodeChildren as ne, isReactEvent as Ve, isRootElement as Xe, isEventTargetWithin as oe } from "./floating-ui.react.utils.js";
+import { jsxs as Ge, jsx as J } from "react/jsx-runtime";
+import { isNode as Ue, isElement as D, getWindow as je, getOverflowAncestors as re, isHTMLElement as Ie, isWebKit as qe, isLastTraversableNode as se, getParentNode as Je, getComputedStyle as Qe } from "../../utils/dist/floating-ui.utils.dom.js";
+import * as Ze from "react-dom";
+import { useFloating as ze } from "../../react-dom/dist/floating-ui.react-dom.js";
+import { arrow as St, flip as Dt, hide as Ot, limitShift as kt, offset as _t, shift as Nt, size as At } from "../../react-dom/dist/floating-ui.react-dom.js";
+function ht(e) {
+  const c = n.useRef(void 0), i = n.useCallback((t) => {
+    const s = e.map((o) => {
+      if (o != null) {
+        if (typeof o == "function") {
+          const r = o, u = r(t);
+          return typeof u == "function" ? u : () => {
+            r(null);
+          };
+        }
+        return o.current = t, () => {
+          o.current = null;
+        };
+      }
+    });
+    return () => {
+      s.forEach((o) => o?.());
+    };
+  }, e);
+  return n.useMemo(() => e.every((t) => t == null) ? null : (t) => {
+    c.current && (c.current(), c.current = void 0), t != null && (c.current = i(t));
+  }, e);
+}
+const et = "data-floating-ui-focusable", Re = "active", Ee = "selected", tt = {
+  ...n
+};
+let be = !1, nt = 0;
+const he = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + nt++
+);
+function ot() {
+  const [e, c] = n.useState(() => be ? he() : void 0);
+  return B(() => {
+    e == null && c(he());
+  }, []), n.useEffect(() => {
+    be = !0;
+  }, []), e;
+}
+const rt = tt.useId, de = rt || ot;
+let fe;
+process.env.NODE_ENV !== "production" && (fe = /* @__PURE__ */ new Set());
+function st() {
+  for (var e, c = arguments.length, i = new Array(c), t = 0; t < c; t++)
+    i[t] = arguments[t];
+  const s = "Floating UI: " + i.join(" ");
+  if (!((e = fe) != null && e.has(s))) {
+    var o;
+    (o = fe) == null || o.add(s), console.error(s);
+  }
+}
+function ut() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(c, i) {
+      var t;
+      (t = e.get(c)) == null || t.forEach((s) => s(i));
+    },
+    on(c, i) {
+      e.has(c) || e.set(c, /* @__PURE__ */ new Set()), e.get(c).add(i);
+    },
+    off(c, i) {
+      var t;
+      (t = e.get(c)) == null || t.delete(i);
+    }
+  };
+}
+const ct = /* @__PURE__ */ n.createContext(null), it = /* @__PURE__ */ n.createContext(null), me = () => {
+  var e;
+  return ((e = n.useContext(ct)) == null ? void 0 : e.id) || null;
+}, ve = () => n.useContext(it);
+function Z(e) {
+  return "data-floating-ui-" + e;
+}
+function N(e) {
+  e.current !== -1 && (clearTimeout(e.current), e.current = -1);
+}
+const ye = /* @__PURE__ */ Z("safe-polygon");
+function ue(e, c, i) {
+  if (i && !ae(i))
+    return 0;
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "function") {
+    const t = e();
+    return typeof t == "number" ? t : t?.[c];
+  }
+  return e?.[c];
+}
+function ce(e) {
+  return typeof e == "function" ? e() : e;
+}
+function yt(e, c) {
+  c === void 0 && (c = {});
+  const {
+    open: i,
+    onOpenChange: t,
+    dataRef: s,
+    events: o,
+    elements: r
+  } = e, {
+    enabled: u = !0,
+    delay: f = 0,
+    handleClose: m = null,
+    mouseOnly: g = !1,
+    restMs: w = 0,
+    move: E = !0
+  } = c, a = ve(), R = me(), d = z(m), y = z(f), x = z(i), b = z(w), C = n.useRef(), L = n.useRef(-1), k = n.useRef(), A = n.useRef(-1), X = n.useRef(!0), _ = n.useRef(!1), G = n.useRef(() => {
+  }), H = n.useRef(!1), Y = $(() => {
+    var v;
+    const l = (v = s.current.openEvent) == null ? void 0 : v.type;
+    return l?.includes("mouse") && l !== "mousedown";
+  });
+  n.useEffect(() => {
+    if (!u) return;
+    function v(l) {
+      let {
+        open: h
+      } = l;
+      h || (N(L), N(A), X.current = !0, H.current = !1);
+    }
+    return o.on("openchange", v), () => {
+      o.off("openchange", v);
+    };
+  }, [u, o]), n.useEffect(() => {
+    if (!u || !d.current || !i) return;
+    function v(h) {
+      Y() && t(!1, h, "hover");
+    }
+    const l = U(r.floating).documentElement;
+    return l.addEventListener("mouseleave", v), () => {
+      l.removeEventListener("mouseleave", v);
+    };
+  }, [r.floating, i, t, u, d, Y]);
+  const V = n.useCallback(function(v, l, h) {
+    l === void 0 && (l = !0), h === void 0 && (h = "hover");
+    const P = ue(y.current, "close", C.current);
+    P && !k.current ? (N(L), L.current = window.setTimeout(() => t(!1, v, h), P)) : l && (N(L), t(!1, v, h));
+  }, [y, t]), K = $(() => {
+    G.current(), k.current = void 0;
+  }), p = $(() => {
+    if (_.current) {
+      const v = U(r.floating).body;
+      v.style.pointerEvents = "", v.removeAttribute(ye), _.current = !1;
+    }
+  }), I = $(() => s.current.openEvent ? ["click", "mousedown"].includes(s.current.openEvent.type) : !1);
+  n.useEffect(() => {
+    if (!u) return;
+    function v(M) {
+      if (N(L), X.current = !1, g && !ae(C.current) || ce(b.current) > 0 && !ue(y.current, "open"))
+        return;
+      const T = ue(y.current, "open", C.current);
+      T ? L.current = window.setTimeout(() => {
+        x.current || t(!0, M, "hover");
+      }, T) : i || t(!0, M, "hover");
+    }
+    function l(M) {
+      if (I()) {
+        p();
+        return;
+      }
+      G.current();
+      const T = U(r.floating);
+      if (N(A), H.current = !1, d.current && s.current.floatingContext) {
+        i || N(L), k.current = d.current({
+          ...s.current.floatingContext,
+          tree: a,
+          x: M.clientX,
+          y: M.clientY,
+          onClose() {
+            p(), K(), I() || V(M, !0, "safe-polygon");
+          }
+        });
+        const F = k.current;
+        T.addEventListener("mousemove", F), G.current = () => {
+          T.removeEventListener("mousemove", F);
+        };
+        return;
+      }
+      (C.current === "touch" ? !Q(r.floating, M.relatedTarget) : !0) && V(M);
+    }
+    function h(M) {
+      I() || s.current.floatingContext && (d.current == null || d.current({
+        ...s.current.floatingContext,
+        tree: a,
+        x: M.clientX,
+        y: M.clientY,
+        onClose() {
+          p(), K(), I() || V(M);
+        }
+      })(M));
+    }
+    function P() {
+      N(L);
+    }
+    function O(M) {
+      I() || V(M, !1);
+    }
+    if (D(r.domReference)) {
+      const M = r.domReference, T = r.floating;
+      return i && M.addEventListener("mouseleave", h), E && M.addEventListener("mousemove", v, {
+        once: !0
+      }), M.addEventListener("mouseenter", v), M.addEventListener("mouseleave", l), T && (T.addEventListener("mouseleave", h), T.addEventListener("mouseenter", P), T.addEventListener("mouseleave", O)), () => {
+        i && M.removeEventListener("mouseleave", h), E && M.removeEventListener("mousemove", v), M.removeEventListener("mouseenter", v), M.removeEventListener("mouseleave", l), T && (T.removeEventListener("mouseleave", h), T.removeEventListener("mouseenter", P), T.removeEventListener("mouseleave", O));
+      };
+    }
+  }, [r, u, e, g, E, V, K, p, t, i, x, a, y, d, s, I, b]), B(() => {
+    var v;
+    if (u && i && (v = d.current) != null && (v = v.__options) != null && v.blockPointerEvents && Y()) {
+      _.current = !0;
+      const h = r.floating;
+      if (D(r.domReference) && h) {
+        var l;
+        const P = U(r.floating).body;
+        P.setAttribute(ye, "");
+        const O = r.domReference, M = a == null || (l = a.nodesRef.current.find((T) => T.id === R)) == null || (l = l.context) == null ? void 0 : l.elements.floating;
+        return M && (M.style.pointerEvents = ""), P.style.pointerEvents = "none", O.style.pointerEvents = "auto", h.style.pointerEvents = "auto", () => {
+          P.style.pointerEvents = "", O.style.pointerEvents = "", h.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [u, i, R, r, a, d, Y]), B(() => {
+    i || (C.current = void 0, H.current = !1, K(), p());
+  }, [i, K, p]), n.useEffect(() => () => {
+    K(), N(L), N(A), p();
+  }, [u, r.domReference, K, p]);
+  const S = n.useMemo(() => {
+    function v(l) {
+      C.current = l.pointerType;
+    }
+    return {
+      onPointerDown: v,
+      onPointerEnter: v,
+      onMouseMove(l) {
+        const {
+          nativeEvent: h
+        } = l;
+        function P() {
+          !X.current && !x.current && t(!0, h, "hover");
+        }
+        g && !ae(C.current) || i || ce(b.current) === 0 || H.current && l.movementX ** 2 + l.movementY ** 2 < 2 || (N(A), C.current === "touch" ? P() : (H.current = !0, A.current = window.setTimeout(P, ce(b.current))));
+      }
+    };
+  }, [g, t, i, x, b]);
+  return n.useMemo(() => u ? {
+    reference: S
+  } : {}, [u, S]);
+}
+const Ce = () => {
+}, lt = /* @__PURE__ */ n.createContext({
+  delay: 0,
+  initialDelay: 0,
+  timeoutMs: 0,
+  currentId: null,
+  setCurrentId: Ce,
+  setState: Ce,
+  isInstantPhase: !1
+});
+function Ct(e) {
+  const {
+    children: c,
+    delay: i,
+    timeoutMs: t = 0
+  } = e, [s, o] = n.useReducer((f, m) => ({
+    ...f,
+    ...m
+  }), {
+    delay: i,
+    timeoutMs: t,
+    initialDelay: i,
+    currentId: null,
+    isInstantPhase: !1
+  }), r = n.useRef(null), u = n.useCallback((f) => {
+    o({
+      currentId: f
+    });
+  }, []);
+  return B(() => {
+    s.currentId ? r.current === null ? r.current = s.currentId : s.isInstantPhase || o({
+      isInstantPhase: !0
+    }) : (s.isInstantPhase && o({
+      isInstantPhase: !1
+    }), r.current = null);
+  }, [s.currentId, s.isInstantPhase]), /* @__PURE__ */ J(lt.Provider, {
+    value: n.useMemo(() => ({
+      ...s,
+      setState: o,
+      setCurrentId: u
+    }), [s, u]),
+    children: c
+  });
+}
+const Le = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "fixed",
+  whiteSpace: "nowrap",
+  width: "1px",
+  top: 0,
+  left: 0
+}, we = /* @__PURE__ */ n.forwardRef(function(c, i) {
+  const [t, s] = n.useState();
+  B(() => {
+    Pe() && s("button");
+  }, []);
+  const o = {
+    ref: i,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role: t,
+    "aria-hidden": t ? void 0 : !0,
+    [Z("focus-guard")]: "",
+    style: Le
+  };
+  return /* @__PURE__ */ J("span", {
+    ...c,
+    ...o
+  });
+}), Te = /* @__PURE__ */ n.createContext(null), Me = /* @__PURE__ */ Z("portal");
+function at(e) {
+  e === void 0 && (e = {});
+  const {
+    id: c,
+    root: i
+  } = e, t = de(), s = ft(), [o, r] = n.useState(null), u = n.useRef(null);
+  return B(() => () => {
+    o?.remove(), queueMicrotask(() => {
+      u.current = null;
+    });
+  }, [o]), B(() => {
+    if (!t || u.current) return;
+    const f = c ? document.getElementById(c) : null;
+    if (!f) return;
+    const m = document.createElement("div");
+    m.id = t, m.setAttribute(Me, ""), f.appendChild(m), u.current = m, r(m);
+  }, [c, t]), B(() => {
+    if (i === null || !t || u.current) return;
+    let f = i || s?.portalNode;
+    f && !Ue(f) && (f = f.current), f = f || document.body;
+    let m = null;
+    c && (m = document.createElement("div"), m.id = c, f.appendChild(m));
+    const g = document.createElement("div");
+    g.id = t, g.setAttribute(Me, ""), f = m || f, f.appendChild(g), u.current = g, r(g);
+  }, [c, i, t, s]), o;
+}
+function wt(e) {
+  const {
+    children: c,
+    id: i,
+    root: t,
+    preserveTabOrder: s = !0
+  } = e, o = at({
+    id: i,
+    root: t
+  }), [r, u] = n.useState(null), f = n.useRef(null), m = n.useRef(null), g = n.useRef(null), w = n.useRef(null), E = r?.modal, a = r?.open, R = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!r && // Guards are only for non-modal focus management.
+    !r.modal && // Don't render if unmount is transitioning.
+    r.open && s && !!(t || o)
+  );
+  return n.useEffect(() => {
+    if (!o || !s || E)
+      return;
+    function d(y) {
+      o && te(y) && (y.type === "focusin" ? pe : He)(o);
+    }
+    return o.addEventListener("focusin", d, !0), o.addEventListener("focusout", d, !0), () => {
+      o.removeEventListener("focusin", d, !0), o.removeEventListener("focusout", d, !0);
+    };
+  }, [o, s, E]), n.useEffect(() => {
+    o && (a || pe(o));
+  }, [a, o]), /* @__PURE__ */ Ge(Te.Provider, {
+    value: n.useMemo(() => ({
+      preserveTabOrder: s,
+      beforeOutsideRef: f,
+      afterOutsideRef: m,
+      beforeInsideRef: g,
+      afterInsideRef: w,
+      portalNode: o,
+      setFocusManagerState: u
+    }), [s, o]),
+    children: [R && o && /* @__PURE__ */ J(we, {
+      "data-type": "outside",
+      ref: f,
+      onFocus: (d) => {
+        if (te(d, o)) {
+          var y;
+          (y = g.current) == null || y.focus();
+        } else {
+          const x = r ? r.domReference : null, b = Ae(x);
+          b?.focus();
+        }
+      }
+    }), R && o && /* @__PURE__ */ J("span", {
+      "aria-owns": o.id,
+      style: Le
+    }), o && /* @__PURE__ */ Ze.createPortal(c, o), R && o && /* @__PURE__ */ J(we, {
+      "data-type": "outside",
+      ref: m,
+      onFocus: (d) => {
+        if (te(d, o)) {
+          var y;
+          (y = w.current) == null || y.focus();
+        } else {
+          const x = r ? r.domReference : null, b = Ke(x);
+          b?.focus(), r?.closeOnFocusOut && r?.onOpenChange(!1, d.nativeEvent, "focus-out");
+        }
+      }
+    })]
+  });
+}
+const ft = () => n.useContext(Te), dt = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, mt = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, xe = (e) => {
+  var c, i;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (c = e?.escapeKey) != null ? c : !1,
+    outsidePress: typeof e == "boolean" ? e : (i = e?.outsidePress) != null ? i : !0
+  };
+};
+function Mt(e, c) {
+  c === void 0 && (c = {});
+  const {
+    open: i,
+    onOpenChange: t,
+    elements: s,
+    dataRef: o
+  } = e, {
+    enabled: r = !0,
+    escapeKey: u = !0,
+    outsidePress: f = !0,
+    outsidePressEvent: m = "pointerdown",
+    referencePress: g = !1,
+    referencePressEvent: w = "pointerdown",
+    ancestorScroll: E = !1,
+    bubbles: a,
+    capture: R
+  } = c, d = ve(), y = $(typeof f == "function" ? f : () => !1), x = typeof f == "function" ? y : f, b = n.useRef(!1), {
+    escapeKey: C,
+    outsidePress: L
+  } = xe(a), {
+    escapeKey: k,
+    outsidePress: A
+  } = xe(R), X = n.useRef(!1), _ = $((p) => {
+    var I;
+    if (!i || !r || !u || p.key !== "Escape" || X.current)
+      return;
+    const S = (I = o.current.floatingContext) == null ? void 0 : I.nodeId, v = d ? ne(d.nodesRef.current, S) : [];
+    if (!C && (p.stopPropagation(), v.length > 0)) {
+      let l = !0;
+      if (v.forEach((h) => {
+        var P;
+        if ((P = h.context) != null && P.open && !h.context.dataRef.current.__escapeKeyBubbles) {
+          l = !1;
+          return;
+        }
+      }), !l)
+        return;
+    }
+    t(!1, Ve(p) ? p.nativeEvent : p, "escape-key");
+  }), G = $((p) => {
+    var I;
+    const S = () => {
+      var v;
+      _(p), (v = j(p)) == null || v.removeEventListener("keydown", S);
+    };
+    (I = j(p)) == null || I.addEventListener("keydown", S);
+  }), H = $((p) => {
+    var I;
+    const S = o.current.insideReactTree;
+    o.current.insideReactTree = !1;
+    const v = b.current;
+    if (b.current = !1, m === "click" && v || S || typeof x == "function" && !x(p))
+      return;
+    const l = j(p), h = "[" + Z("inert") + "]", P = U(s.floating).querySelectorAll(h);
+    let O = D(l) ? l : null;
+    for (; O && !se(O); ) {
+      const F = Je(O);
+      if (se(F) || !D(F))
+        break;
+      O = F;
+    }
+    if (P.length && D(l) && !Xe(l) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !Q(l, s.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(P).every((F) => !Q(O, F)))
+      return;
+    if (Ie(l) && K) {
+      const F = se(l), W = Qe(l), q = /auto|scroll/, Fe = F || q.test(W.overflowX), Se = F || q.test(W.overflowY), De = Fe && l.clientWidth > 0 && l.scrollWidth > l.clientWidth, Oe = Se && l.clientHeight > 0 && l.scrollHeight > l.clientHeight, ke = W.direction === "rtl", _e = Oe && (ke ? p.offsetX <= l.offsetWidth - l.clientWidth : p.offsetX > l.clientWidth), Ne = De && p.offsetY > l.clientHeight;
+      if (_e || Ne)
+        return;
+    }
+    const M = (I = o.current.floatingContext) == null ? void 0 : I.nodeId, T = d && ne(d.nodesRef.current, M).some((F) => {
+      var W;
+      return oe(p, (W = F.context) == null ? void 0 : W.elements.floating);
+    });
+    if (oe(p, s.floating) || oe(p, s.domReference) || T)
+      return;
+    const ee = d ? ne(d.nodesRef.current, M) : [];
+    if (ee.length > 0) {
+      let F = !0;
+      if (ee.forEach((W) => {
+        var q;
+        if ((q = W.context) != null && q.open && !W.context.dataRef.current.__outsidePressBubbles) {
+          F = !1;
+          return;
+        }
+      }), !F)
+        return;
+    }
+    t(!1, p, "outside-press");
+  }), Y = $((p) => {
+    var I;
+    const S = () => {
+      var v;
+      H(p), (v = j(p)) == null || v.removeEventListener(m, S);
+    };
+    (I = j(p)) == null || I.addEventListener(m, S);
+  });
+  n.useEffect(() => {
+    if (!i || !r)
+      return;
+    o.current.__escapeKeyBubbles = C, o.current.__outsidePressBubbles = L;
+    let p = -1;
+    function I(P) {
+      t(!1, P, "ancestor-scroll");
+    }
+    function S() {
+      window.clearTimeout(p), X.current = !0;
+    }
+    function v() {
+      p = window.setTimeout(
+        () => {
+          X.current = !1;
+        },
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        qe() ? 5 : 0
+      );
+    }
+    const l = U(s.floating);
+    u && (l.addEventListener("keydown", k ? G : _, k), l.addEventListener("compositionstart", S), l.addEventListener("compositionend", v)), x && l.addEventListener(m, A ? Y : H, A);
+    let h = [];
+    return E && (D(s.domReference) && (h = re(s.domReference)), D(s.floating) && (h = h.concat(re(s.floating))), !D(s.reference) && s.reference && s.reference.contextElement && (h = h.concat(re(s.reference.contextElement)))), h = h.filter((P) => {
+      var O;
+      return P !== ((O = l.defaultView) == null ? void 0 : O.visualViewport);
+    }), h.forEach((P) => {
+      P.addEventListener("scroll", I, {
+        passive: !0
+      });
+    }), () => {
+      u && (l.removeEventListener("keydown", k ? G : _, k), l.removeEventListener("compositionstart", S), l.removeEventListener("compositionend", v)), x && l.removeEventListener(m, A ? Y : H, A), h.forEach((P) => {
+        P.removeEventListener("scroll", I);
+      }), window.clearTimeout(p);
+    };
+  }, [o, s, u, x, m, i, t, E, r, C, L, _, k, G, H, A, Y]), n.useEffect(() => {
+    o.current.insideReactTree = !1;
+  }, [o, x, m]);
+  const V = n.useMemo(() => ({
+    onKeyDown: _,
+    ...g && {
+      [dt[w]]: (p) => {
+        t(!1, p.nativeEvent, "reference-press");
+      },
+      ...w !== "click" && {
+        onClick(p) {
+          t(!1, p.nativeEvent, "reference-press");
+        }
+      }
+    }
+  }), [_, t, g, w]), K = n.useMemo(() => ({
+    onKeyDown: _,
+    onMouseDown() {
+      b.current = !0;
+    },
+    onMouseUp() {
+      b.current = !0;
+    },
+    [mt[m]]: () => {
+      o.current.insideReactTree = !0;
+    }
+  }), [_, m, o]);
+  return n.useMemo(() => r ? {
+    reference: V,
+    floating: K
+  } : {}, [r, V, K]);
+}
+function vt(e) {
+  const {
+    open: c = !1,
+    onOpenChange: i,
+    elements: t
+  } = e, s = de(), o = n.useRef({}), [r] = n.useState(() => ut()), u = me() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const a = t.reference;
+    a && !D(a) && st("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [f, m] = n.useState(t.reference), g = $((a, R, d) => {
+    o.current.openEvent = a ? R : void 0, r.emit("openchange", {
+      open: a,
+      event: R,
+      reason: d,
+      nested: u
+    }), i?.(a, R, d);
+  }), w = n.useMemo(() => ({
+    setPositionReference: m
+  }), []), E = n.useMemo(() => ({
+    reference: f || t.reference || null,
+    floating: t.floating || null,
+    domReference: t.reference
+  }), [f, t.reference, t.floating]);
+  return n.useMemo(() => ({
+    dataRef: o,
+    open: c,
+    onOpenChange: g,
+    elements: E,
+    events: r,
+    floatingId: s,
+    refs: w
+  }), [c, g, E, r, s, w]);
+}
+function xt(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: c
+  } = e, i = vt({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), t = e.rootContext || i, s = t.elements, [o, r] = n.useState(null), [u, f] = n.useState(null), g = s?.domReference || o, w = n.useRef(null), E = ve();
+  B(() => {
+    g && (w.current = g);
+  }, [g]);
+  const a = ze({
+    ...e,
+    elements: {
+      ...s,
+      ...u && {
+        reference: u
+      }
+    }
+  }), R = n.useCallback((C) => {
+    const L = D(C) ? {
+      getBoundingClientRect: () => C.getBoundingClientRect(),
+      getClientRects: () => C.getClientRects(),
+      contextElement: C
+    } : C;
+    f(L), a.refs.setReference(L);
+  }, [a.refs]), d = n.useCallback((C) => {
+    (D(C) || C === null) && (w.current = C, r(C)), (D(a.refs.reference.current) || a.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    C !== null && !D(C)) && a.refs.setReference(C);
+  }, [a.refs]), y = n.useMemo(() => ({
+    ...a.refs,
+    setReference: d,
+    setPositionReference: R,
+    domReference: w
+  }), [a.refs, d, R]), x = n.useMemo(() => ({
+    ...a.elements,
+    domReference: g
+  }), [a.elements, g]), b = n.useMemo(() => ({
+    ...a,
+    ...t,
+    refs: y,
+    elements: x,
+    nodeId: c
+  }), [a, y, x, c, t]);
+  return B(() => {
+    t.dataRef.current.floatingContext = b;
+    const C = E?.nodesRef.current.find((L) => L.id === c);
+    C && (C.context = b);
+  }), n.useMemo(() => ({
+    ...a,
+    context: b,
+    refs: y,
+    elements: x
+  }), [a, y, x, b]);
+}
+function ie() {
+  return Ye() && Pe();
+}
+function Pt(e, c) {
+  c === void 0 && (c = {});
+  const {
+    open: i,
+    onOpenChange: t,
+    events: s,
+    dataRef: o,
+    elements: r
+  } = e, {
+    enabled: u = !0,
+    visibleOnly: f = !0
+  } = c, m = n.useRef(!1), g = n.useRef(-1), w = n.useRef(!0);
+  n.useEffect(() => {
+    if (!u) return;
+    const a = je(r.domReference);
+    function R() {
+      !i && Ie(r.domReference) && r.domReference === ge(U(r.domReference)) && (m.current = !0);
+    }
+    function d() {
+      w.current = !0;
+    }
+    function y() {
+      w.current = !1;
+    }
+    return a.addEventListener("blur", R), ie() && (a.addEventListener("keydown", d, !0), a.addEventListener("pointerdown", y, !0)), () => {
+      a.removeEventListener("blur", R), ie() && (a.removeEventListener("keydown", d, !0), a.removeEventListener("pointerdown", y, !0));
+    };
+  }, [r.domReference, i, u]), n.useEffect(() => {
+    if (!u) return;
+    function a(R) {
+      let {
+        reason: d
+      } = R;
+      (d === "reference-press" || d === "escape-key") && (m.current = !0);
+    }
+    return s.on("openchange", a), () => {
+      s.off("openchange", a);
+    };
+  }, [s, u]), n.useEffect(() => () => {
+    N(g);
+  }, []);
+  const E = n.useMemo(() => ({
+    onMouseLeave() {
+      m.current = !1;
+    },
+    onFocus(a) {
+      if (m.current) return;
+      const R = j(a.nativeEvent);
+      if (f && D(R)) {
+        if (ie() && !a.relatedTarget) {
+          if (!w.current && !$e(R))
+            return;
+        } else if (!Be(R))
+          return;
+      }
+      t(!0, a.nativeEvent, "focus");
+    },
+    onBlur(a) {
+      m.current = !1;
+      const R = a.relatedTarget, d = a.nativeEvent, y = D(R) && R.hasAttribute(Z("focus-guard")) && R.getAttribute("data-type") === "outside";
+      g.current = window.setTimeout(() => {
+        var x;
+        const b = ge(r.domReference ? r.domReference.ownerDocument : document);
+        !R && b === r.domReference || Q((x = o.current.floatingContext) == null ? void 0 : x.refs.floating.current, b) || Q(r.domReference, b) || y || t(!1, d, "focus");
+      });
+    }
+  }), [o, r.domReference, t, f]);
+  return n.useMemo(() => u ? {
+    reference: E
+  } : {}, [u, E]);
+}
+function le(e, c, i) {
+  const t = /* @__PURE__ */ new Map(), s = i === "item";
+  let o = e;
+  if (s && e) {
+    const {
+      [Re]: r,
+      [Ee]: u,
+      ...f
+    } = e;
+    o = f;
+  }
+  return {
+    ...i === "floating" && {
+      tabIndex: -1,
+      [et]: ""
+    },
+    ...o,
+    ...c.map((r) => {
+      const u = r ? r[i] : null;
+      return typeof u == "function" ? e ? u(e) : null : u;
+    }).concat(e).reduce((r, u) => (u && Object.entries(u).forEach((f) => {
+      let [m, g] = f;
+      if (!(s && [Re, Ee].includes(m)))
+        if (m.indexOf("on") === 0) {
+          if (t.has(m) || t.set(m, []), typeof g == "function") {
+            var w;
+            (w = t.get(m)) == null || w.push(g), r[m] = function() {
+              for (var E, a = arguments.length, R = new Array(a), d = 0; d < a; d++)
+                R[d] = arguments[d];
+              return (E = t.get(m)) == null ? void 0 : E.map((y) => y(...R)).find((y) => y !== void 0);
+            };
+          }
+        } else
+          r[m] = g;
+    }), r), {})
+  };
+}
+function It(e) {
+  e === void 0 && (e = []);
+  const c = e.map((u) => u?.reference), i = e.map((u) => u?.floating), t = e.map((u) => u?.item), s = n.useCallback(
+    (u) => le(u, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    c
+  ), o = n.useCallback(
+    (u) => le(u, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    i
+  ), r = n.useCallback(
+    (u) => le(u, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+  return n.useMemo(() => ({
+    getReferenceProps: s,
+    getFloatingProps: o,
+    getItemProps: r
+  }), [s, o, r]);
+}
+const pt = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", !1]]);
+function Lt(e, c) {
+  var i, t;
+  c === void 0 && (c = {});
+  const {
+    open: s,
+    elements: o,
+    floatingId: r
+  } = e, {
+    enabled: u = !0,
+    role: f = "dialog"
+  } = c, m = de(), g = ((i = o.domReference) == null ? void 0 : i.id) || m, w = n.useMemo(() => {
+    var b;
+    return ((b = We(o.floating)) == null ? void 0 : b.id) || r;
+  }, [o.floating, r]), E = (t = pt.get(f)) != null ? t : f, R = me() != null, d = n.useMemo(() => E === "tooltip" || f === "label" ? {
+    ["aria-" + (f === "label" ? "labelledby" : "describedby")]: s ? w : void 0
+  } : {
+    "aria-expanded": s ? "true" : "false",
+    "aria-haspopup": E === "alertdialog" ? "dialog" : E,
+    "aria-controls": s ? w : void 0,
+    ...E === "listbox" && {
+      role: "combobox"
+    },
+    ...E === "menu" && {
+      id: g
+    },
+    ...E === "menu" && R && {
+      role: "menuitem"
+    },
+    ...f === "select" && {
+      "aria-autocomplete": "none"
+    },
+    ...f === "combobox" && {
+      "aria-autocomplete": "list"
+    }
+  }, [E, w, R, s, g, f]), y = n.useMemo(() => {
+    const b = {
+      id: w,
+      ...E && {
+        role: E
+      }
+    };
+    return E === "tooltip" || f === "label" ? b : {
+      ...b,
+      ...E === "menu" && {
+        "aria-labelledby": g
+      }
+    };
+  }, [E, w, g, f]), x = n.useCallback((b) => {
+    let {
+      active: C,
+      selected: L
+    } = b;
+    const k = {
+      role: "option",
+      ...C && {
+        id: w + "-fui-option"
+      }
+    };
+    switch (f) {
+      case "select":
+      case "combobox":
+        return {
+          ...k,
+          "aria-selected": L
+        };
+    }
+    return {};
+  }, [w, f]);
+  return n.useMemo(() => u ? {
+    reference: d,
+    floating: y,
+    item: x
+  } : {}, [u, d, y, x]);
+}
+export {
+  Ct as FloatingDelayGroup,
+  wt as FloatingPortal,
+  St as arrow,
+  Dt as flip,
+  re as getOverflowAncestors,
+  Ot as hide,
+  kt as limitShift,
+  _t as offset,
+  Nt as shift,
+  At as size,
+  Mt as useDismiss,
+  xt as useFloating,
+  me as useFloatingParentNodeId,
+  at as useFloatingPortalNode,
+  vt as useFloatingRootContext,
+  ve as useFloatingTree,
+  Pt as useFocus,
+  yt as useHover,
+  de as useId,
+  It as useInteractions,
+  ht as useMergeRefs,
+  Lt as useRole
+};