@konstructio/ui 0.1.2-alpha.101 → 0.1.2-alpha.103

package/dist/dist-CVDFmWf2.js

@@ -0,0 +1,358 @@
+import { a as G, r as z } from "./dist-DqKFpce5.js";
+import { t as J } from "./dist-CVy-ulDZ.js";
+import { t as Q } from "./dist-CTvBzxW8.js";
+import { i as W, n as Z, r as w, t as ee } from "./dist-D4FePjTS.js";
+import { t as te } from "./dist-BuFiu480.js";
+import { r as oe, t as re } from "./dist-j7FOUrFU.js";
+import { t as j } from "./dist-DISvWx7U.js";
+import { a as F, i as ne, n as ae, r as se, t as ie } from "./dist-C2aTw0m62.js";
+import * as a from "react";
+import { jsx as h, jsxs as le } from "react/jsx-runtime";
+var ce = Object.defineProperty, d = (r, e) => ce(r, "name", {
+  value: e,
+  configurable: !0
+}), [I, Se] = W("Tooltip", [F]), _ = F(), ue = "TooltipProvider", pe = 700, k = "tooltip.open", [de, S] = I(ue), fe = /* @__PURE__ */ d((r) => {
+  const { __scopeTooltip: e, delayDuration: t = pe, skipDelayDuration: o = 300, disableHoverableContent: s = !1, children: n } = r, i = a.useRef(!0), f = a.useRef(!1), u = a.useRef(0);
+  return a.useEffect(() => {
+    const c = u.current;
+    return () => window.clearTimeout(c);
+  }, []), /* @__PURE__ */ h(de, {
+    scope: e,
+    isOpenDelayedRef: i,
+    delayDuration: t,
+    onOpen: a.useCallback(() => {
+      o <= 0 || (window.clearTimeout(u.current), i.current = !1);
+    }, [o]),
+    onClose: a.useCallback(() => {
+      o <= 0 || (window.clearTimeout(u.current), u.current = window.setTimeout(() => i.current = !0, o));
+    }, [o]),
+    isPointerInTransitRef: f,
+    onPointerInTransitChange: a.useCallback((c) => {
+      f.current = c;
+    }, []),
+    disableHoverableContent: s,
+    children: n
+  });
+}, "TooltipProvider"), A = "Tooltip", [ve, R] = I(A), Te = /* @__PURE__ */ d((r) => {
+  const { __scopeTooltip: e, children: t, open: o, defaultOpen: s, onOpenChange: n, disableHoverableContent: i, delayDuration: f } = r, u = S(A, r.__scopeTooltip), c = _(e), [p, T] = a.useState(null), [v, g] = a.useState(void 0), x = te(), l = a.useRef(0), m = i ?? u.disableHoverableContent, C = f ?? u.delayDuration, b = a.useRef(!1), [P, y] = ee({
+    prop: o,
+    defaultProp: s ?? !1,
+    onChange: /* @__PURE__ */ d((H) => {
+      H ? (u.onOpen(), document.dispatchEvent(new CustomEvent(k))) : u.onClose(), n?.(H);
+    }, "onChange"),
+    caller: A
+  }), L = a.useMemo(() => P ? b.current ? "delayed-open" : "instant-open" : "closed", [P]), O = a.useCallback(() => {
+    window.clearTimeout(l.current), l.current = 0, b.current = !1, y(!0);
+  }, [y]), D = a.useCallback(() => {
+    window.clearTimeout(l.current), l.current = 0, y(!1);
+  }, [y]), M = a.useCallback(() => {
+    window.clearTimeout(l.current), l.current = window.setTimeout(() => {
+      b.current = !0, y(!0), l.current = 0;
+    }, C);
+  }, [C, y]);
+  return a.useEffect(() => () => {
+    l.current && (window.clearTimeout(l.current), l.current = 0);
+  }, []), /* @__PURE__ */ h(ne, {
+    ...c,
+    children: /* @__PURE__ */ h(ve, {
+      scope: e,
+      contentId: v ?? x,
+      setContentId: g,
+      open: P,
+      stateAttribute: L,
+      trigger: p,
+      onTriggerChange: T,
+      onTriggerEnter: a.useCallback(() => {
+        u.isOpenDelayedRef.current ? M() : O();
+      }, [
+        u.isOpenDelayedRef,
+        M,
+        O
+      ]),
+      onTriggerLeave: a.useCallback(() => {
+        m ? D() : (window.clearTimeout(l.current), l.current = 0);
+      }, [D, m]),
+      onOpen: O,
+      onClose: D,
+      disableHoverableContent: m,
+      children: t
+    })
+  });
+}, "Tooltip"), N = "TooltipTrigger", he = /* @__PURE__ */ a.forwardRef(/* @__PURE__ */ d(function(e, t) {
+  const { __scopeTooltip: o, ...s } = e, n = R(N, o), i = S(N, o), f = _(o), u = G(t, a.useRef(null), n.onTriggerChange), c = a.useRef(!1), p = a.useRef(!1), T = a.useCallback(() => c.current = !1, []);
+  return a.useEffect(() => () => document.removeEventListener("pointerup", T), [T]), /* @__PURE__ */ h(ie, {
+    asChild: !0,
+    ...f,
+    children: /* @__PURE__ */ h(J.button, {
+      "aria-describedby": n.open ? n.contentId : void 0,
+      "data-state": n.stateAttribute,
+      ...s,
+      ref: u,
+      onPointerMove: w(e.onPointerMove, (v) => {
+        v.pointerType !== "touch" && !p.current && !i.isPointerInTransitRef.current && (n.onTriggerEnter(), p.current = !0);
+      }),
+      onPointerLeave: w(e.onPointerLeave, () => {
+        n.onTriggerLeave(), p.current = !1;
+      }),
+      onPointerDown: w(e.onPointerDown, () => {
+        n.open && n.onClose(), c.current = !0, document.addEventListener("pointerup", T, { once: !0 });
+      }),
+      onFocus: w(e.onFocus, () => {
+        c.current || n.onOpen();
+      }),
+      onBlur: w(e.onBlur, n.onClose),
+      onClick: w(e.onClick, n.onClose)
+    })
+  });
+}, "TooltipTrigger")), B = "TooltipPortal", [ge, me] = I(B, { forceMount: void 0 }), Ce = /* @__PURE__ */ d((r) => {
+  const { __scopeTooltip: e, forceMount: t, children: o, container: s } = r, n = R(B, e);
+  return /* @__PURE__ */ h(ge, {
+    scope: e,
+    forceMount: t,
+    children: /* @__PURE__ */ h(j, {
+      present: t || n.open,
+      children: /* @__PURE__ */ h(re, {
+        asChild: !0,
+        container: s,
+        children: o
+      })
+    })
+  });
+}, "TooltipPortal"), E = "TooltipContent", xe = /* @__PURE__ */ a.forwardRef(/* @__PURE__ */ d(function(e, t) {
+  const o = me(E, e.__scopeTooltip), { forceMount: s = o.forceMount, side: n = "top", ...i } = e, f = R(E, e.__scopeTooltip);
+  return /* @__PURE__ */ h(j, {
+    present: s || f.open,
+    children: f.disableHoverableContent ? /* @__PURE__ */ h(U, {
+      side: n,
+      ...i,
+      ref: t
+    }) : /* @__PURE__ */ h(ye, {
+      side: n,
+      ...i,
+      ref: t
+    })
+  });
+}, "TooltipContent")), ye = /* @__PURE__ */ a.forwardRef(/* @__PURE__ */ d(function(e, t) {
+  const o = R(E, e.__scopeTooltip), s = S(E, e.__scopeTooltip), n = a.useRef(null), i = G(t, n), [f, u] = a.useState(null), { trigger: c, onClose: p } = o, T = n.current, { onPointerInTransitChange: v } = s, g = a.useCallback(() => {
+    u(null), v(!1);
+  }, [v]), x = a.useCallback((l, m) => {
+    const C = l.currentTarget, b = {
+      x: l.clientX,
+      y: l.clientY
+    }, P = $(b, Y(b, C.getBoundingClientRect())), y = q(m.getBoundingClientRect()), L = K([...P, ...y]);
+    u(L), v(!0);
+  }, [v]);
+  return a.useEffect(() => () => g(), [g]), a.useEffect(() => {
+    if (c && T) {
+      const l = /* @__PURE__ */ d((C) => x(C, T), "handleTriggerLeave"), m = /* @__PURE__ */ d((C) => x(C, c), "handleContentLeave");
+      return c.addEventListener("pointerleave", l), T.addEventListener("pointerleave", m), () => {
+        c.removeEventListener("pointerleave", l), T.removeEventListener("pointerleave", m);
+      };
+    }
+  }, [
+    c,
+    T,
+    x,
+    g
+  ]), a.useEffect(() => {
+    if (f) {
+      const l = /* @__PURE__ */ d((m) => {
+        const C = m.target, b = {
+          x: m.clientX,
+          y: m.clientY
+        }, P = c?.contains(C) || T?.contains(C), y = !X(b, f);
+        P ? g() : y && (g(), p());
+      }, "handleTrackPointerGrace");
+      return document.addEventListener("pointermove", l), () => document.removeEventListener("pointermove", l);
+    }
+  }, [
+    c,
+    T,
+    f,
+    p,
+    g
+  ]), /* @__PURE__ */ h(U, {
+    ...e,
+    ref: i
+  });
+}, "TooltipContentHoverable")), be = z("TooltipContent"), U = /* @__PURE__ */ a.forwardRef(/* @__PURE__ */ d(function(e, t) {
+  const { __scopeTooltip: o, children: s, "aria-label": n, id: i, onEscapeKeyDown: f, onPointerDownOutside: u, ...c } = e, p = R(E, o), T = _(o), { onClose: v } = p;
+  a.useEffect(() => (document.addEventListener(k, v), () => document.removeEventListener(k, v)), [v]), a.useEffect(() => {
+    if (p.trigger) {
+      const x = /* @__PURE__ */ d((l) => {
+        l.target instanceof Node && l.target.contains(p.trigger) && v();
+      }, "handleScroll");
+      return window.addEventListener("scroll", x, { capture: !0 }), () => window.removeEventListener("scroll", x, { capture: !0 });
+    }
+  }, [p.trigger, v]);
+  const { setContentId: g } = p;
+  return Z(() => (g(i), () => {
+    g(void 0);
+  }), [i, g]), /* @__PURE__ */ h(oe, {
+    asChild: !0,
+    disableOutsidePointerEvents: !1,
+    onEscapeKeyDown: f,
+    onPointerDownOutside: u,
+    onFocusOutside: (x) => x.preventDefault(),
+    onDismiss: v,
+    children: /* @__PURE__ */ le(se, {
+      "data-state": p.stateAttribute,
+      role: n ? void 0 : "tooltip",
+      id: n ? void 0 : p.contentId,
+      ...T,
+      ...c,
+      ref: t,
+      style: {
+        ...c.style,
+        "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+      },
+      children: [/* @__PURE__ */ h(be, { children: s }), n ? /* @__PURE__ */ h(Q, {
+        id: p.contentId,
+        role: "tooltip",
+        children: n
+      }) : null]
+    })
+  });
+}, "TooltipContentImpl")), Pe = /* @__PURE__ */ a.forwardRef(/* @__PURE__ */ d(function(e, t) {
+  const { __scopeTooltip: o, ...s } = e, n = _(o);
+  return /* @__PURE__ */ h(ae, {
+    ...n,
+    ...s,
+    ref: t
+  });
+}, "TooltipArrow"));
+function Y(r, e) {
+  const t = Math.abs(e.top - r.y), o = Math.abs(e.bottom - r.y), s = Math.abs(e.right - r.x), n = Math.abs(e.left - r.x);
+  switch (Math.min(t, o, s, n)) {
+    case n:
+      return "left";
+    case s:
+      return "right";
+    case t:
+      return "top";
+    case o:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+d(Y, "getExitSideFromRect");
+function $(r, e, t = 5) {
+  const o = [];
+  switch (e) {
+    case "top":
+      o.push({
+        x: r.x - t,
+        y: r.y + t
+      }, {
+        x: r.x + t,
+        y: r.y + t
+      });
+      break;
+    case "bottom":
+      o.push({
+        x: r.x - t,
+        y: r.y - t
+      }, {
+        x: r.x + t,
+        y: r.y - t
+      });
+      break;
+    case "left":
+      o.push({
+        x: r.x + t,
+        y: r.y - t
+      }, {
+        x: r.x + t,
+        y: r.y + t
+      });
+      break;
+    case "right":
+      o.push({
+        x: r.x - t,
+        y: r.y - t
+      }, {
+        x: r.x - t,
+        y: r.y + t
+      });
+      break;
+  }
+  return o;
+}
+d($, "getPaddedExitPoints");
+function q(r) {
+  const { top: e, right: t, bottom: o, left: s } = r;
+  return [
+    {
+      x: s,
+      y: e
+    },
+    {
+      x: t,
+      y: e
+    },
+    {
+      x: t,
+      y: o
+    },
+    {
+      x: s,
+      y: o
+    }
+  ];
+}
+d(q, "getPointsFromRect");
+function X(r, e) {
+  const { x: t, y: o } = r;
+  let s = !1;
+  for (let n = 0, i = e.length - 1; n < e.length; i = n++) {
+    const f = e[n], u = e[i], c = f.x, p = f.y, T = u.x, v = u.y;
+    p > o != v > o && t < (T - c) * (o - p) / (v - p) + c && (s = !s);
+  }
+  return s;
+}
+d(X, "isPointInPolygon");
+function K(r) {
+  const e = r.slice();
+  return e.sort((t, o) => t.x < o.x ? -1 : t.x > o.x ? 1 : t.y < o.y ? -1 : t.y > o.y ? 1 : 0), V(e);
+}
+d(K, "getHull");
+function V(r) {
+  if (r.length <= 1) return r.slice();
+  const e = [];
+  for (let o = 0; o < r.length; o++) {
+    const s = r[o];
+    for (; e.length >= 2; ) {
+      const n = e[e.length - 1], i = e[e.length - 2];
+      if ((n.x - i.x) * (s.y - i.y) >= (n.y - i.y) * (s.x - i.x)) e.pop();
+      else break;
+    }
+    e.push(s);
+  }
+  e.pop();
+  const t = [];
+  for (let o = r.length - 1; o >= 0; o--) {
+    const s = r[o];
+    for (; t.length >= 2; ) {
+      const n = t[t.length - 1], i = t[t.length - 2];
+      if ((n.x - i.x) * (s.y - i.y) >= (n.y - i.y) * (s.x - i.x)) t.pop();
+      else break;
+    }
+    t.push(s);
+  }
+  return t.pop(), e.length === 1 && t.length === 1 && e[0].x === t[0].x && e[0].y === t[0].y ? e : e.concat(t);
+}
+d(V, "getHullPresorted");
+var Me = fe, He = Te, Ne = he, Ge = Ce, je = xe, Fe = Pe;
+export {
+  He as a,
+  Me as i,
+  je as n,
+  Ne as o,
+  Ge as r,
+  Fe as t
+};

package/dist/dist-D4FePjTS.js

@@ -0,0 +1,194 @@
+import * as r from "react";
+import { jsx as A } from "react/jsx-runtime";
+function Y(e, o = []) {
+  let t = [];
+  function i(c, s) {
+    const l = r.createContext(s);
+    l.displayName = c + "Context";
+    const u = t.length;
+    t = [...t, s];
+    const a = (d) => {
+      const { scope: w, children: m, ...v } = d, E = w?.[e]?.[u] || l, C = r.useMemo(() => v, Object.values(v));
+      return /* @__PURE__ */ A(E.Provider, {
+        value: C,
+        children: m
+      });
+    };
+    a.displayName = c + "Provider";
+    function f(d, w, m = {}) {
+      const { optional: v = !1 } = m, E = w?.[e]?.[u] || l, C = r.useContext(E);
+      if (C) return C;
+      if (s !== void 0) return s;
+      if (!v)
+        throw new Error(`\`${d}\` must be used within \`${c}\``);
+    }
+    return [a, f];
+  }
+  const n = () => {
+    const c = t.map((s) => r.createContext(s));
+    return function(l) {
+      const u = l?.[e] || c;
+      return r.useMemo(() => ({ [`__scope${e}`]: {
+        ...l,
+        [e]: u
+      } }), [l, u]);
+    };
+  };
+  return n.scopeName = e, [i, I(n, ...o)];
+}
+function I(...e) {
+  const o = e[0];
+  if (e.length === 1) return o;
+  const t = () => {
+    const i = e.map((n) => ({
+      useScope: n(),
+      scopeName: n.scopeName
+    }));
+    return function(c) {
+      const s = i.reduce((l, { useScope: u, scopeName: a }) => {
+        const f = u(c)[`__scope${a}`];
+        return {
+          ...l,
+          ...f
+        };
+      }, {});
+      return r.useMemo(() => ({ [`__scope${o.scopeName}`]: s }), [s]);
+    };
+  };
+  return t.scopeName = o.scopeName, t;
+}
+var j = Object.defineProperty, p = (e, o) => j(e, "name", {
+  value: o,
+  configurable: !0
+}), x = !!(typeof window < "u" && window.document && window.document.createElement);
+function F(e, o, { checkForDefaultPrevented: t = !0 } = {}) {
+  return /* @__PURE__ */ p(function(n) {
+    if (e?.(n), t === !1 || !n || !n.defaultPrevented) return o?.(n);
+  }, "handleEvent");
+}
+p(F, "composeEventHandlers");
+function N(e) {
+  if (!x) throw new Error("Cannot access window outside of the DOM");
+  return e?.ownerDocument?.defaultView ?? window;
+}
+p(N, "getOwnerWindow");
+function S(e) {
+  if (!x) throw new Error("Cannot access document outside of the DOM");
+  return e?.ownerDocument ?? document;
+}
+p(S, "getOwnerDocument");
+function y(e, o = !1) {
+  const { activeElement: t } = S(e);
+  if (!t?.nodeName) return null;
+  if (O(t) && t.contentDocument) return y(t.contentDocument.body, o);
+  if (o) {
+    const i = t.getAttribute("aria-activedescendant");
+    if (i) {
+      const n = S(t).getElementById(i);
+      if (n) return n;
+    }
+  }
+  return t;
+}
+p(y, "getActiveElement");
+function O(e) {
+  return e.tagName === "IFRAME";
+}
+p(O, "isFrame");
+var P = globalThis?.document ? r.useLayoutEffect : () => {
+}, $ = r[" useEffectEvent ".trim().toString()], b = r[" useInsertionEffect ".trim().toString()];
+function T(e) {
+  if (typeof $ == "function") return $(e);
+  const o = r.useRef(() => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  return typeof b == "function" ? b(() => {
+    o.current = e;
+  }) : P(() => {
+    o.current = e;
+  }), r.useMemo(() => ((...t) => o.current?.(...t)), []);
+}
+var U = Object.defineProperty, h = (e, o) => U(e, "name", {
+  value: o,
+  configurable: !0
+}), H = r[" useInsertionEffect ".trim().toString()] || P;
+function B({ prop: e, defaultProp: o, onChange: t = /* @__PURE__ */ h(() => {
+}, "onChange"), caller: i }) {
+  const [n, c, s] = D({
+    defaultProp: o,
+    onChange: t
+  }), l = e !== void 0;
+  return [l ? e : n, r.useCallback((a) => {
+    if (l) {
+      const f = M(a) ? a(e) : a;
+      f !== e && s.current?.(f);
+    } else c(a);
+  }, [
+    l,
+    e,
+    c,
+    s
+  ])];
+}
+h(B, "useControllableState");
+function D({ defaultProp: e, onChange: o }) {
+  const [t, i] = r.useState(e), n = r.useRef(t), c = r.useRef(o);
+  return H(() => {
+    c.current = o;
+  }, [o]), r.useEffect(() => {
+    n.current !== t && (c.current?.(t), n.current = t);
+  }, [t, n]), [
+    t,
+    i,
+    c
+  ];
+}
+h(D, "useUncontrolledState");
+function M(e) {
+  return typeof e == "function";
+}
+h(M, "isFunction");
+var _ = /* @__PURE__ */ Symbol("RADIX:SYNC_STATE");
+function L(e, o, t, i) {
+  const { prop: n, defaultProp: c, onChange: s, caller: l } = o, u = n !== void 0, a = T(s), f = [{
+    ...t,
+    state: c
+  }];
+  i && f.push(i);
+  const [d, w] = r.useReducer((C, g) => {
+    if (g.type === _) return {
+      ...C,
+      state: g.state
+    };
+    const R = e(C, g);
+    return u && !Object.is(R.state, C.state) && a(R.state), R;
+  }, ...f), m = d.state, v = r.useRef(m);
+  r.useEffect(() => {
+    v.current !== m && (v.current = m, u || a(m));
+  }, [
+    m,
+    v,
+    u
+  ]);
+  const E = r.useMemo(() => n !== void 0 ? {
+    ...d,
+    state: n
+  } : d, [d, n]);
+  return r.useEffect(() => {
+    u && !Object.is(n, d.state) && w({
+      type: _,
+      state: n
+    });
+  }, [
+    n,
+    d.state,
+    u
+  ]), [E, w];
+}
+h(L, "useControllableStateReducer");
+export {
+  Y as i,
+  P as n,
+  F as r,
+  B as t
+};

package/dist/dist-DISvWx7U.js

@@ -0,0 +1,99 @@
+import { n as y } from "./dist-D4FePjTS.js";
+import * as o from "react";
+var P = Object.defineProperty, f = (n, e) => P(n, "name", {
+  value: e,
+  configurable: !0
+});
+function g(n, e) {
+  return o.useReducer((t, r) => e[t][r] ?? t, n);
+}
+f(g, "useStateMachine");
+var h = /* @__PURE__ */ f((n) => {
+  const { present: e, children: t } = n, r = M(e), s = typeof t == "function" ? t({ present: r.isPresent }) : o.Children.only(t), u = O(r.ref, v(s));
+  return typeof t == "function" || r.isPresent ? o.cloneElement(s, { ref: u }) : null;
+}, "Presence");
+function M(n) {
+  const [e, t] = o.useState(), r = o.useRef(null), s = o.useRef(n), u = o.useRef("none"), i = o.useRef(void 0), [a, l] = g(n ? "mounted" : "unmounted", {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: { MOUNT: "mounted" }
+  });
+  return o.useEffect(() => {
+    a === "mounted" ? (u.current = i.current ?? N(r.current), i.current = void 0) : u.current = "none";
+  }, [a]), y(() => {
+    const c = r.current, m = s.current;
+    if (m !== n) {
+      const d = u.current, p = N(c);
+      n ? (i.current = p, l("MOUNT")) : p === "none" || c?.display === "none" ? l("UNMOUNT") : l(m && d !== p ? "ANIMATION_OUT" : "UNMOUNT"), s.current = n;
+    }
+  }, [n, l]), y(() => {
+    if (e) {
+      let c;
+      const m = e.ownerDocument.defaultView ?? window, d = /* @__PURE__ */ f((R) => {
+        const E = N(r.current).includes(CSS.escape(R.animationName));
+        if (R.target === e && E && (l("ANIMATION_END"), !s.current)) {
+          const T = e.style.animationFillMode;
+          e.style.animationFillMode = "forwards", c = m.setTimeout(() => {
+            e.style.animationFillMode === "forwards" && (e.style.animationFillMode = T);
+          });
+        }
+      }, "handleAnimationEnd"), p = /* @__PURE__ */ f((R) => {
+        R.target === e && (u.current = N(r.current));
+      }, "handleAnimationStart");
+      return e.addEventListener("animationstart", p), e.addEventListener("animationcancel", d), e.addEventListener("animationend", d), () => {
+        m.clearTimeout(c), e.removeEventListener("animationstart", p), e.removeEventListener("animationcancel", d), e.removeEventListener("animationend", d);
+      };
+    } else l("ANIMATION_END");
+  }, [e, l]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(a),
+    ref: o.useCallback((c) => {
+      if (c) {
+        const m = getComputedStyle(c);
+        r.current = m, i.current = N(m);
+      } else r.current = null;
+      t(c);
+    }, [])
+  };
+}
+f(M, "usePresence");
+function A(n, e) {
+  if (typeof n == "function") return n(e);
+  n != null && (n.current = e);
+}
+f(A, "setRef");
+function O(...n) {
+  const e = o.useRef(n);
+  return e.current = n, o.useCallback((t) => {
+    const r = e.current;
+    let s = !1;
+    const u = r.map((i) => {
+      const a = A(i, t);
+      return !s && typeof a == "function" && (s = !0), a;
+    });
+    if (s) return () => {
+      for (let i = 0; i < u.length; i++) {
+        const a = u[i];
+        typeof a == "function" ? a() : A(r[i], null);
+      }
+    };
+  }, []);
+}
+f(O, "useStableComposedRefs");
+function N(n) {
+  return n?.animationName || "none";
+}
+f(N, "getAnimationName");
+function v(n) {
+  let e = Object.getOwnPropertyDescriptor(n.props, "ref")?.get, t = e && "isReactWarning" in e && e.isReactWarning;
+  return t ? n.ref : (e = Object.getOwnPropertyDescriptor(n, "ref")?.get, t = e && "isReactWarning" in e && e.isReactWarning, t ? n.props.ref : n.props.ref || n.ref);
+}
+f(v, "getElementRef");
+export {
+  h as t
+};