@koide-labs/ui 0.0.15 → 0.1.1

package/dist/tooltip-oCp-elli.js

@@ -0,0 +1,765 @@
+import { jsx as M, jsxs as ne } from "react/jsx-runtime";
+import { c as ce } from "./clsx-OuTLNxxd.js";
+import { textify as we } from "./-utils.js";
+import { R as Oe, P as Me, c as D, d as Ie, e as Ne, f as De, p as J, t as Ae } from "./transitions.module-D9mMAtfI.js";
+import { Surface as _e } from "./components/surface/surface.js";
+import * as a from "react";
+import { u as N } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { f as z } from "./formatErrorMessage-BqPuTBN-.js";
+import { c as F, n as pe, b as G, a as de, e as fe, t as se, q as Le, i as ke } from "./createBaseUIEventDetails-CCSfZ2vM.js";
+import * as Ve from "react-dom";
+import { E as Fe, a as Be, u as $ } from "./useRenderElement-DngNDu_P.js";
+import { p as He, b as Ue, c as ze, u as $e, a as je, d as We } from "./useSyncedFloatingRootContext-BB1vwkV-.js";
+import { g as ge, a as re, i as me, f as Ye } from "./floating-ui.utils.dom-cbi420Pg.js";
+import { f as Xe, b as Ge } from "./detectBrowser-Bl8Ki_1I.js";
+import { T as qe, u as Ke } from "./useTimeout-BNni6aw5.js";
+import { c as Je, P as Qe } from "./FloatingPortal-BQsQhvIr.js";
+import { h as he, f as q, d as ie, j as Ze, m as et, e as tt } from "./element-u5WgOZX1.js";
+import { u as U } from "./useStableCallback-DKZHlUAT.js";
+import { b as ot } from "./event-B89-Ng5h.js";
+import { u as nt } from "./useBaseUiId-B7WyxtIE.js";
+import { g as st, a as rt, s as it, b as at } from "./safePolygon-DnkzOIur.js";
+import { F as ut } from "./FloatingPortalLite-_ECdFE7b.js";
+import { a as lt, b as ct, g as ye } from "./getDisabledMountTransitionStyles-E2x-_lte.js";
+import { a as pt, u as dt, t as ft } from "./useOpenChangeComplete-BHd-N7Ig.js";
+import { u as gt } from "./useAnimationFrame-DvK1s63A.js";
+import { t as ae } from "./floating-ui.utils-DUVaIF3G.js";
+import { u as mt } from "./DirectionContext-C2o_MF_i.js";
+import './tooltip.css';const ve = /* @__PURE__ */ a.createContext({
+  hasProvider: !1,
+  timeoutMs: 0,
+  delayRef: {
+    current: 0
+  },
+  initialDelayRef: {
+    current: 0
+  },
+  timeout: new qe(),
+  currentIdRef: {
+    current: null
+  },
+  currentContextRef: {
+    current: null
+  }
+});
+process.env.NODE_ENV !== "production" && (ve.displayName = "FloatingDelayGroupContext");
+function ht(n, e = {
+  open: !1
+}) {
+  const t = "rootStore" in n ? n.rootStore : n, r = t.useState("floatingId"), {
+    enabled: g = !0,
+    open: u
+  } = e, c = a.useContext(ve), {
+    currentIdRef: l,
+    delayRef: p,
+    timeoutMs: d,
+    initialDelayRef: f,
+    currentContextRef: s,
+    hasProvider: i,
+    timeout: o
+  } = c, [v, y] = a.useState(!1);
+  return N(() => {
+    function C() {
+      y(!1), s.current?.setIsInstantPhase(!1), l.current = null, s.current = null, p.current = f.current;
+    }
+    if (g && l.current && !u && l.current === r) {
+      if (y(!1), d) {
+        const m = r;
+        return o.start(d, () => {
+          t.select("open") || l.current && l.current !== m || C();
+        }), () => {
+          o.clear();
+        };
+      }
+      C();
+    }
+  }, [g, u, r, l, p, d, f, s, o, t]), N(() => {
+    if (!g || !u)
+      return;
+    const C = s.current, m = l.current;
+    o.clear(), s.current = {
+      onOpenChange: t.setOpen,
+      setIsInstantPhase: y
+    }, l.current = r, p.current = {
+      open: 0,
+      close: st(f.current, "close")
+    }, m !== null && m !== r ? (y(!0), C?.setIsInstantPhase(!0), C?.onOpenChange(!1, F(pe))) : (y(!1), C?.setIsInstantPhase(!1));
+  }, [g, u, r, t, l, p, d, f, s, o]), N(() => () => {
+    s.current = null;
+  }, [s]), a.useMemo(() => ({
+    hasProvider: i,
+    delayRef: p,
+    isInstantPhase: v
+  }), [i, p, v]);
+}
+function yt(n, e) {
+  let t = null, r = null, g = !1;
+  return {
+    contextElement: n || void 0,
+    getBoundingClientRect() {
+      const u = n?.getBoundingClientRect() || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      }, c = e.axis === "x" || e.axis === "both", l = e.axis === "y" || e.axis === "both", p = ["mouseenter", "mousemove"].includes(e.dataRef.current.openEvent?.type || "") && e.pointerType !== "touch";
+      let d = u.width, f = u.height, s = u.x, i = u.y;
+      return t == null && e.x && c && (t = u.x - e.x), r == null && e.y && l && (r = u.y - e.y), s -= t || 0, i -= r || 0, d = 0, f = 0, !g || p ? (d = e.axis === "y" ? u.width : 0, f = e.axis === "x" ? u.height : 0, s = c && e.x != null ? e.x : s, i = l && e.y != null ? e.y : i) : g && !p && (f = e.axis === "x" ? u.height : f, d = e.axis === "y" ? u.width : d), g = !0, {
+        width: d,
+        height: f,
+        x: s,
+        y: i,
+        top: i,
+        right: s + d,
+        bottom: i + f,
+        left: s
+      };
+    }
+  };
+}
+function ue(n) {
+  return n != null && n.clientX != null;
+}
+function vt(n, e = {}) {
+  const t = "rootStore" in n ? n.rootStore : n, r = t.useState("open"), g = t.useState("floatingElement"), u = t.useState("domReferenceElement"), c = t.context.dataRef, {
+    enabled: l = !0,
+    axis: p = "both",
+    x: d = null,
+    y: f = null
+  } = e, s = a.useRef(!1), i = a.useRef(null), [o, v] = a.useState(), [y, C] = a.useState([]), m = U((P, T) => {
+    s.current || c.current.openEvent && !ue(c.current.openEvent) || t.set("positionReference", yt(u, {
+      x: P,
+      y: T,
+      axis: p,
+      dataRef: c,
+      pointerType: o
+    }));
+  }), h = U((P) => {
+    d != null || f != null || (r ? i.current || C([]) : m(P.clientX, P.clientY));
+  }), w = ot(o) ? g : r, E = a.useCallback(() => {
+    if (!w || !l || d != null || f != null)
+      return;
+    const P = ge(g);
+    function T(b) {
+      const x = he(b);
+      q(g, x) ? (P.removeEventListener("mousemove", T), i.current = null) : m(b.clientX, b.clientY);
+    }
+    if (!c.current.openEvent || ue(c.current.openEvent)) {
+      P.addEventListener("mousemove", T);
+      const b = () => {
+        P.removeEventListener("mousemove", T), i.current = null;
+      };
+      return i.current = b, b;
+    }
+    t.set("positionReference", u);
+  }, [w, l, d, f, g, c, u, t, m]);
+  a.useEffect(() => E(), [E, y]), a.useEffect(() => {
+    l && !g && (s.current = !1);
+  }, [l, g]), a.useEffect(() => {
+    !l && r && (s.current = !0);
+  }, [l, r]), N(() => {
+    l && (d != null || f != null) && (s.current = !1, m(d, f));
+  }, [l, d, f, m]);
+  const R = a.useMemo(() => {
+    function P(T) {
+      v(T.pointerType);
+    }
+    return {
+      onPointerDown: P,
+      onPointerEnter: P,
+      onMouseMove: h,
+      onMouseEnter: h
+    };
+  }, [h]);
+  return a.useMemo(() => l ? {
+    reference: R
+  } : {}, [l, R]);
+}
+const X = Xe && Ge;
+function Pt(n, e = {}) {
+  const t = "rootStore" in n ? n.rootStore : n, {
+    events: r,
+    dataRef: g
+  } = t.context, {
+    enabled: u = !0,
+    visibleOnly: c = !0
+  } = e, l = a.useRef(!1), p = Ke(), d = a.useRef(!0);
+  a.useEffect(() => {
+    const s = t.select("domReferenceElement");
+    if (!u)
+      return;
+    const i = ge(s);
+    function o() {
+      !t.select("open") && me(s) && s === ie(tt(s)) && (l.current = !0);
+    }
+    function v() {
+      d.current = !0;
+    }
+    function y() {
+      d.current = !1;
+    }
+    return i.addEventListener("blur", o), X && (i.addEventListener("keydown", v, !0), i.addEventListener("pointerdown", y, !0)), () => {
+      i.removeEventListener("blur", o), X && (i.removeEventListener("keydown", v, !0), i.removeEventListener("pointerdown", y, !0));
+    };
+  }, [t, u]), a.useEffect(() => {
+    if (!u)
+      return;
+    function s(i) {
+      (i.reason === de || i.reason === fe) && (l.current = !0);
+    }
+    return r.on("openchange", s), () => {
+      r.off("openchange", s);
+    };
+  }, [r, u]);
+  const f = a.useMemo(() => ({
+    onMouseLeave() {
+      l.current = !1;
+    },
+    onFocus(s) {
+      if (l.current)
+        return;
+      const i = he(s.nativeEvent);
+      if (c && re(i)) {
+        if (X && !s.relatedTarget) {
+          if (!d.current && !Ze(i))
+            return;
+        } else if (!et(i))
+          return;
+      }
+      t.setOpen(!0, F(G, s.nativeEvent, s.currentTarget));
+    },
+    onBlur(s) {
+      l.current = !1;
+      const i = s.relatedTarget, o = s.nativeEvent, v = re(i) && i.hasAttribute(Je("focus-guard")) && i.getAttribute("data-type") === "outside";
+      p.start(0, () => {
+        const y = t.select("domReferenceElement"), C = ie(y ? y.ownerDocument : document);
+        !i && C === y || q(g.current.floatingContext?.refs.floating.current, C) || q(y, C) || v || t.context.triggerElements.hasElement(s.relatedTarget) || t.setOpen(!1, F(G, o));
+      });
+    }
+  }), [g, t, c, p]);
+  return a.useMemo(() => u ? {
+    reference: f,
+    trigger: f
+  } : {}, [u, f]);
+}
+function le(n) {
+  const e = Ye(n);
+  let t = parseFloat(e.width) || 0, r = parseFloat(e.height) || 0;
+  const g = me(n), u = g ? n.offsetWidth : t, c = g ? n.offsetHeight : r;
+  return (ae(t) !== u || ae(r) !== c) && (t = u, r = c), {
+    width: t,
+    height: r
+  };
+}
+const Tt = typeof ResizeObserver < "u", Ct = () => !0;
+function bt(n) {
+  const {
+    popupElement: e,
+    positionerElement: t,
+    content: r,
+    mounted: g,
+    enabled: u = Ct,
+    onMeasureLayout: c,
+    onMeasureLayoutComplete: l,
+    side: p,
+    direction: d
+  } = n, f = a.useRef(!0), s = pt(e, !0, !1), i = gt(), o = a.useRef(null), v = U(c), y = U(l), C = a.useMemo(() => {
+    let m = p === "top", h = p === "left";
+    return d === "rtl" ? (m = m || p === "inline-end", h = h || p === "inline-end") : (m = m || p === "inline-start", h = h || p === "inline-start"), m ? {
+      position: "absolute",
+      [p === "top" ? "bottom" : "top"]: "0",
+      [h ? "right" : "left"]: "0"
+    } : Fe;
+  }, [p, d]);
+  N(() => {
+    if (!g || !u() || !Tt) {
+      f.current = !0, o.current = null;
+      return;
+    }
+    if (!e || !t)
+      return;
+    Object.entries(C).forEach(([x, O]) => {
+      e.style.setProperty(x, O);
+    });
+    const m = new ResizeObserver((x) => {
+      const O = x[0];
+      O && (o.current === null ? o.current = {
+        width: Math.ceil(O.borderBoxSize[0].inlineSize),
+        height: Math.ceil(O.borderBoxSize[0].blockSize)
+      } : (o.current.width = Math.ceil(O.borderBoxSize[0].inlineSize), o.current.height = Math.ceil(O.borderBoxSize[0].blockSize)));
+    });
+    m.observe(e), e.style.setProperty("--popup-width", "auto"), e.style.setProperty("--popup-height", "auto");
+    const h = V(e, "position", "static"), w = V(e, "transform", "none"), E = V(e, "scale", "1"), R = V(t, "--available-width", "max-content"), P = V(t, "--available-height", "max-content");
+    if (v?.(), f.current || o.current === null) {
+      t.style.setProperty("--positioner-width", "max-content"), t.style.setProperty("--positioner-height", "max-content");
+      const x = le(e);
+      return t.style.setProperty("--positioner-width", `${x.width}px`), t.style.setProperty("--positioner-height", `${x.height}px`), h(), w(), E(), R(), P(), y?.(null, x), f.current = !1, () => {
+        m.disconnect();
+      };
+    }
+    e.style.setProperty("--popup-width", "auto"), e.style.setProperty("--popup-height", "auto"), t.style.setProperty("--positioner-width", "max-content"), t.style.setProperty("--positioner-height", "max-content");
+    const T = le(e);
+    e.style.setProperty("--popup-width", `${o.current.width}px`), e.style.setProperty("--popup-height", `${o.current.height}px`), h(), w(), R(), P(), y?.(o.current, T), t.style.setProperty("--positioner-width", `${T.width}px`), t.style.setProperty("--positioner-height", `${T.height}px`);
+    const b = new AbortController();
+    return i.request(() => {
+      e.style.setProperty("--popup-width", `${T.width}px`), e.style.setProperty("--popup-height", `${T.height}px`), s(() => {
+        e.style.setProperty("--popup-width", "auto"), e.style.setProperty("--popup-height", "auto");
+      }, b.signal);
+    }), () => {
+      m.disconnect(), b.abort(), i.cancel();
+    };
+  }, [r, e, t, s, i, u, g, v, y, C]);
+}
+function V(n, e, t) {
+  const r = n.style.getPropertyValue(e);
+  return n.style.setProperty(e, t), () => {
+    n.style.setProperty(e, r);
+  };
+}
+const Q = /* @__PURE__ */ a.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Q.displayName = "TooltipRootContext");
+function B(n) {
+  const e = a.useContext(Q);
+  if (e === void 0 && !n)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : z(72));
+  return e;
+}
+const xt = {
+  ...He,
+  disabled: D((n) => n.disabled),
+  instantType: D((n) => n.instantType),
+  isInstantPhase: D((n) => n.isInstantPhase),
+  trackCursorAxis: D((n) => n.trackCursorAxis),
+  disableHoverablePopup: D((n) => n.disableHoverablePopup),
+  lastOpenChangeReason: D((n) => n.openChangeReason),
+  closeDelay: D((n) => n.closeDelay)
+};
+class Z extends Oe {
+  constructor(e) {
+    super({
+      ...St(),
+      ...e
+    }, {
+      popupRef: /* @__PURE__ */ a.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new Me()
+    }, xt);
+  }
+  setOpen = (e, t) => {
+    const r = t.reason, g = r === se, u = e && r === G, c = !e && (r === de || r === fe);
+    if (t.preventUnmountOnClose = () => {
+      this.set("preventUnmountingOnClose", !0);
+    }, this.context.onOpenChange?.(e, t), t.isCanceled)
+      return;
+    const l = () => {
+      const p = {
+        open: e,
+        openChangeReason: r
+      };
+      u ? p.instantType = "focus" : c ? p.instantType = "dismiss" : r === se && (p.instantType = void 0);
+      const d = t.trigger?.id ?? null;
+      (d || e) && (p.activeTriggerId = d, p.activeTriggerElement = t.trigger ?? null), this.update(p);
+    };
+    g ? Ve.flushSync(l) : l();
+  };
+  static useStore(e, t) {
+    const r = Be(() => e ?? new Z(t)).current, g = Ue({
+      popupStore: r,
+      onOpenChange: r.setOpen
+    });
+    return r.state.floatingRootContext = g, r;
+  }
+}
+function St() {
+  return {
+    ...ze(),
+    disabled: !1,
+    instantType: void 0,
+    isInstantPhase: !1,
+    trackCursorAxis: "none",
+    disableHoverablePopup: !1,
+    openChangeReason: null,
+    closeDelay: 0
+  };
+}
+function Et(n) {
+  const {
+    disabled: e = !1,
+    defaultOpen: t = !1,
+    open: r,
+    disableHoverablePopup: g = !1,
+    trackCursorAxis: u = "none",
+    actionsRef: c,
+    onOpenChange: l,
+    onOpenChangeComplete: p,
+    handle: d,
+    triggerId: f,
+    defaultTriggerId: s = null,
+    children: i
+  } = n, o = Z.useStore(d?.store, {
+    open: r ?? t,
+    activeTriggerId: f !== void 0 ? f : s
+  });
+  o.useControlledProp("open", r, t), o.useControlledProp("activeTriggerId", f, s), o.useContextCallback("onOpenChange", l), o.useContextCallback("onOpenChangeComplete", p);
+  const v = o.useState("open"), y = o.useState("activeTriggerId"), C = o.useState("payload");
+  o.useSyncedValues({
+    trackCursorAxis: u,
+    disableHoverablePopup: g
+  });
+  const m = !e && v;
+  N(() => {
+    v && e && o.setOpen(!1, F(Le));
+  }, [v, e, o]), o.useSyncedValue("disabled", e), $e(o);
+  const {
+    forceUnmount: h,
+    transitionStatus: w
+  } = je(m, o), E = o.useState("isInstantPhase"), R = o.useState("instantType"), P = o.useState("lastOpenChangeReason"), T = a.useRef(null);
+  N(() => {
+    w === "ending" && P === pe || w !== "ending" && E ? (R !== "delay" && (T.current = R), o.set("instantType", "delay")) : T.current !== null && (o.set("instantType", T.current), T.current = null);
+  }, [w, E, P, R, o]), N(() => {
+    m && y == null && o.set("payload", void 0);
+  }, [o, y, m]);
+  const b = a.useCallback(() => {
+    o.setOpen(!1, Rt(o, ke));
+  }, [o]);
+  a.useImperativeHandle(c, () => ({
+    unmount: h,
+    close: b
+  }), [h, b]);
+  const x = o.useState("floatingRootContext"), O = Pt(x, {
+    enabled: !e
+  }), S = Ie(x, {
+    enabled: !e,
+    referencePress: !0
+  }), k = vt(x, {
+    enabled: !e && u !== "none",
+    axis: u === "none" ? void 0 : u
+  }), {
+    getReferenceProps: I,
+    getFloatingProps: A,
+    getTriggerProps: _
+  } = Ne([O, S, k]), L = a.useMemo(() => I(), [I]), j = a.useMemo(() => _(), [_]), oe = a.useMemo(() => A(), [A]);
+  return o.useSyncedValues({
+    floatingRootContext: x,
+    activeTriggerProps: L,
+    inactiveTriggerProps: j,
+    popupProps: oe
+  }), /* @__PURE__ */ M(Q.Provider, {
+    value: o,
+    children: typeof i == "function" ? i({
+      payload: C
+    }) : i
+  });
+}
+function Rt(n, e) {
+  const t = F(e);
+  return t.preventUnmountOnClose = () => {
+    n.set("preventUnmountingOnClose", !0);
+  }, t;
+}
+const Pe = /* @__PURE__ */ a.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Pe.displayName = "TooltipProviderContext");
+function wt() {
+  return a.useContext(Pe);
+}
+const Ot = 600, Te = /* @__PURE__ */ a.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: g,
+    handle: u,
+    payload: c,
+    disabled: l,
+    delay: p,
+    closeDelay: d,
+    id: f,
+    ...s
+  } = e, i = B(!0), o = u?.store ?? i;
+  if (!o)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : z(82));
+  const v = nt(f), y = o.useState("isTriggerActive", v), C = o.useState("floatingRootContext"), m = o.useState("isOpenedByTrigger", v), h = a.useRef(null), w = p ?? Ot, E = d ?? 0, {
+    registerTrigger: R,
+    isMountedByThisTrigger: P
+  } = We(v, h, o, {
+    payload: c,
+    closeDelay: E
+  }), T = wt(), {
+    delayRef: b,
+    isInstantPhase: x,
+    hasProvider: O
+  } = ht(C, {
+    open: m
+  });
+  o.useSyncedValue("isInstantPhase", x);
+  const S = o.useState("disabled"), k = l ?? S, I = o.useState("trackCursorAxis"), A = o.useState("disableHoverablePopup"), _ = rt(C, {
+    enabled: !k,
+    mouseOnly: !0,
+    move: !1,
+    handleClose: !A && I !== "both" ? it() : null,
+    restMs() {
+      const W = T?.delay, H = typeof b.current == "object" ? b.current.open : void 0;
+      let Y = w;
+      return O && (H !== 0 ? Y = p ?? W ?? w : Y = 0), Y;
+    },
+    delay() {
+      const W = typeof b.current == "object" ? b.current.close : void 0;
+      let H = E;
+      return d == null && O && (H = W), {
+        close: H
+      };
+    },
+    triggerElementRef: h,
+    isActiveTrigger: y
+  }), L = a.useMemo(() => ({
+    open: m
+  }), [m]), j = o.useState("triggerProps", P);
+  return $("button", e, {
+    state: L,
+    ref: [t, R, h],
+    props: [_, j, {
+      id: v
+    }, s],
+    stateAttributesMapping: De
+  });
+});
+process.env.NODE_ENV !== "production" && (Te.displayName = "TooltipTrigger");
+const ee = /* @__PURE__ */ a.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ee.displayName = "TooltipPortalContext");
+function Mt() {
+  const n = a.useContext(ee);
+  if (n === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Portal> is missing." : z(70));
+  return n;
+}
+const Ce = /* @__PURE__ */ a.forwardRef(function(e, t) {
+  const {
+    keepMounted: r = !1,
+    ...g
+  } = e;
+  return B().useState("mounted") || r ? /* @__PURE__ */ M(ee.Provider, {
+    value: r,
+    children: /* @__PURE__ */ M(ut, {
+      ref: t,
+      ...g
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (Ce.displayName = "TooltipPortal");
+const te = /* @__PURE__ */ a.createContext(void 0);
+process.env.NODE_ENV !== "production" && (te.displayName = "TooltipPositionerContext");
+function be() {
+  const n = a.useContext(te);
+  if (n === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : z(71));
+  return n;
+}
+const xe = /* @__PURE__ */ a.forwardRef(function(e, t) {
+  const {
+    render: r,
+    className: g,
+    anchor: u,
+    positionMethod: c = "absolute",
+    side: l = "top",
+    align: p = "center",
+    sideOffset: d = 0,
+    alignOffset: f = 0,
+    collisionBoundary: s = "clipping-ancestors",
+    collisionPadding: i = 5,
+    arrowPadding: o = 5,
+    sticky: v = !1,
+    disableAnchorTracking: y = !1,
+    collisionAvoidance: C = Qe,
+    ...m
+  } = e, h = B(), w = Mt(), E = h.useState("open"), R = h.useState("mounted"), P = h.useState("trackCursorAxis"), T = h.useState("disableHoverablePopup"), b = h.useState("floatingRootContext"), x = h.useState("instantType"), O = h.useState("transitionStatus"), S = lt({
+    anchor: u,
+    positionMethod: c,
+    floatingRootContext: b,
+    mounted: R,
+    side: l,
+    sideOffset: d,
+    align: p,
+    alignOffset: f,
+    collisionBoundary: s,
+    collisionPadding: i,
+    sticky: v,
+    arrowPadding: o,
+    disableAnchorTracking: y,
+    keepMounted: w,
+    collisionAvoidance: C,
+    adaptiveOrigin: ct
+  }), k = a.useMemo(() => {
+    const L = {};
+    return (!E || P === "both" || T) && (L.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !R,
+      style: {
+        ...S.positionerStyles,
+        ...L
+      }
+    };
+  }, [E, P, T, R, S.positionerStyles]), I = a.useMemo(() => ({
+    open: E,
+    side: S.side,
+    align: S.align,
+    anchorHidden: S.anchorHidden,
+    instant: P !== "none" ? "tracking-cursor" : x
+  }), [E, S.side, S.align, S.anchorHidden, P, x]), A = a.useMemo(() => ({
+    ...I,
+    arrowRef: S.arrowRef,
+    arrowStyles: S.arrowStyles,
+    arrowUncentered: S.arrowUncentered
+  }), [I, S.arrowRef, S.arrowStyles, S.arrowUncentered]), _ = $("div", e, {
+    state: I,
+    props: [k, ye(O), m],
+    ref: [t, h.useStateSetter("positionerElement")],
+    stateAttributesMapping: J
+  });
+  return /* @__PURE__ */ M(te.Provider, {
+    value: A,
+    children: _
+  });
+});
+process.env.NODE_ENV !== "production" && (xe.displayName = "TooltipPositioner");
+const It = {
+  ...J,
+  ...ft
+}, Se = /* @__PURE__ */ a.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: g,
+    ...u
+  } = e, c = B(), {
+    side: l,
+    align: p
+  } = be(), d = c.useState("open"), f = c.useState("mounted"), s = c.useState("instantType"), i = c.useState("transitionStatus"), o = c.useState("popupProps"), v = c.useState("payload"), y = c.useState("popupElement"), C = c.useState("positionerElement"), m = c.useState("floatingRootContext"), h = mt();
+  dt({
+    open: d,
+    ref: c.context.popupRef,
+    onComplete() {
+      d && c.context.onOpenChangeComplete?.(!0);
+    }
+  });
+  function w() {
+    m.context.events.emit("measure-layout");
+  }
+  function E(O, S) {
+    m.context.events.emit("measure-layout-complete", {
+      previousDimensions: O,
+      nextDimensions: S
+    });
+  }
+  const R = a.useCallback(() => c.context.triggerElements.size > 1, [c]);
+  bt({
+    popupElement: y,
+    positionerElement: C,
+    mounted: f,
+    content: v,
+    enabled: R,
+    onMeasureLayout: w,
+    onMeasureLayoutComplete: E,
+    side: l,
+    direction: h
+  });
+  const P = c.useState("disabled"), T = c.useState("closeDelay");
+  at(m, {
+    enabled: !P,
+    closeDelay: T
+  });
+  const b = a.useMemo(() => ({
+    open: d,
+    side: l,
+    align: p,
+    instant: s,
+    transitionStatus: i
+  }), [d, l, p, s, i]);
+  return $("div", e, {
+    state: b,
+    ref: [t, c.context.popupRef, c.useStateSetter("popupElement")],
+    props: [o, ye(i), u],
+    stateAttributesMapping: It
+  });
+});
+process.env.NODE_ENV !== "production" && (Se.displayName = "TooltipPopup");
+const Ee = /* @__PURE__ */ a.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: g,
+    ...u
+  } = e, l = B().useState("instantType"), {
+    open: p,
+    arrowRef: d,
+    side: f,
+    align: s,
+    arrowUncentered: i,
+    arrowStyles: o
+  } = be(), v = a.useMemo(() => ({
+    open: p,
+    side: f,
+    align: s,
+    uncentered: i,
+    instant: l
+  }), [p, f, s, i, l]);
+  return $("div", e, {
+    state: v,
+    ref: [t, d],
+    props: [{
+      style: o,
+      "aria-hidden": !0
+    }, u],
+    stateAttributesMapping: J
+  });
+});
+process.env.NODE_ENV !== "production" && (Ee.displayName = "TooltipArrow");
+const Nt = "_tooltip_1v2fg_2", Dt = "_tooltip__arrow_1v2fg_11", K = {
+  tooltip: Nt,
+  tooltip__arrow: Dt,
+  "tooltip__arrow-icon": "_tooltip__arrow-icon_1v2fg_36"
+};
+function At({
+  children: n,
+  trigger: e,
+  align: t,
+  side: r,
+  className: g,
+  ...u
+}) {
+  return /* @__PURE__ */ ne(Et, { ...u, children: [
+    e ? /* @__PURE__ */ M(Te, { render: e }) : null,
+    /* @__PURE__ */ M(Ce, { children: /* @__PURE__ */ M(xe, { align: t, side: r, sideOffset: 8, children: /* @__PURE__ */ ne(
+      Se,
+      {
+        render: /* @__PURE__ */ M(_e, { background: "highest" }),
+        className: ce(
+          K.tooltip,
+          Ae.transition_scale,
+          g
+        ),
+        children: [
+          /* @__PURE__ */ M(Ee, { className: K.tooltip__arrow, children: /* @__PURE__ */ M(Re, {}) }),
+          we(n)
+        ]
+      }
+    ) }) })
+  ] });
+}
+function Re(n) {
+  return /* @__PURE__ */ M(
+    "svg",
+    {
+      width: "10",
+      height: "5",
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      className: ce(K["tooltip__arrow-icon"], n.className),
+      children: /* @__PURE__ */ M("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+}
+const ro = Object.assign(At, {
+  Arrow: Re
+});
+export {
+  ro as T,
+  K as t,
+  bt as u
+};