@konstructio/ui 0.1.2-alpha.11 → 0.1.2-alpha.111

package/dist/dist-D-yS0HN8.js

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

package/dist/dist-D5Q2IYuC.js

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

package/dist/dist-D70ZJkHf.js

@@ -0,0 +1,29 @@
+import { n } from "./dist-D-yS0HN8.js";
+import * as t from "react";
+var o = Object.defineProperty, f = (e, r) => o(e, "name", {
+  value: r,
+  configurable: !0
+}), s = t[" useId ".trim().toString()] || (() => {
+}), c = 0;
+function i(e) {
+  const [r, a] = t.useState(s());
+  return n(() => {
+    e || a((u) => u ?? String(c++));
+  }, [e]), e || (r ? `radix-${r}` : "");
+}
+f(i, "useId");
+var d = Object.defineProperty, m = (e, r) => d(e, "name", {
+  value: r,
+  configurable: !0
+});
+function _(e) {
+  const r = t.useRef(e);
+  return t.useEffect(() => {
+    r.current = e;
+  }), t.useMemo(() => ((...a) => r.current?.(...a)), []);
+}
+m(_, "useCallbackRef");
+export {
+  i as n,
+  _ as t
+};

package/dist/dist-DX0sBG3Q.js

@@ -0,0 +1,31 @@
+import { t as i } from "./dist-CCdbu9GU.js";
+import * as t from "react";
+import { jsx as o } from "react/jsx-runtime";
+var n = Object.defineProperty, d = (r, e) => n(r, "name", {
+  value: e,
+  configurable: !0
+}), l = Object.freeze({
+  position: "absolute",
+  border: 0,
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+}), f = /* @__PURE__ */ t.forwardRef(/* @__PURE__ */ d(function(e, a) {
+  return /* @__PURE__ */ o(i.span, {
+    ...e,
+    ref: a,
+    style: {
+      ...l,
+      ...e.style
+    }
+  });
+}, "VisuallyHidden")), p = f;
+export {
+  f as n,
+  p as t
+};