laif-ds 0.2.5 → 0.2.7

package/dist/dist/node_modules/@radix-ui/react-popover/dist/index.js

@@ -0,0 +1,241 @@
+"use client";
+import * as i from "react";
+import { composeEventHandlers as m } from "../../primitive/dist/index.js";
+import { useComposedRefs as O } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as M } from "../../react-context/dist/index.js";
+import { DismissableLayer as K } from "../../react-dismissable-layer/dist/index.js";
+import { useFocusGuards as j } from "../../react-focus-guards/dist/index.js";
+import { FocusScope as L } from "../../react-focus-scope/dist/index.js";
+import { useId as B } from "../../react-id/dist/index.js";
+import { createPopperScope as A, Root as G, Anchor as _, Content as H, Arrow as J } from "../../react-popper/dist/index.js";
+import { Portal as Q } from "../../react-portal/dist/index.js";
+import { Presence as b } from "../../react-presence/dist/index.js";
+import { Primitive as F } from "../../react-primitive/dist/index.js";
+import { createSlot as U } from "../../react-slot/dist/index.js";
+import { useControllableState as X } from "../../react-use-controllable-state/dist/index.js";
+import { hideOthers as Y } from "../../../aria-hidden/dist/es2015/index.js";
+import Z from "../../../react-remove-scroll/dist/es2015/Combination.js";
+import { jsx as p } from "react/jsx-runtime";
+var C = "Popover", [y, Oe] = M(C, [
+  A
+]), h = A(), [q, u] = y(C), D = (e) => {
+  const {
+    __scopePopover: n,
+    children: t,
+    open: a,
+    defaultOpen: o,
+    onOpenChange: r,
+    modal: s = !1
+  } = e, c = h(n), f = i.useRef(null), [v, P] = i.useState(!1), [g, l] = X({
+    prop: a,
+    defaultProp: o ?? !1,
+    onChange: r,
+    caller: C
+  });
+  return /* @__PURE__ */ p(G, { ...c, children: /* @__PURE__ */ p(
+    q,
+    {
+      scope: n,
+      contentId: B(),
+      triggerRef: f,
+      open: g,
+      onOpenChange: l,
+      onOpenToggle: i.useCallback(() => l((w) => !w), [l]),
+      hasCustomAnchor: v,
+      onCustomAnchorAdd: i.useCallback(() => P(!0), []),
+      onCustomAnchorRemove: i.useCallback(() => P(!1), []),
+      modal: s,
+      children: t
+    }
+  ) });
+};
+D.displayName = C;
+var x = "PopoverAnchor", z = i.forwardRef(
+  (e, n) => {
+    const { __scopePopover: t, ...a } = e, o = u(x, t), r = h(t), { onCustomAnchorAdd: s, onCustomAnchorRemove: c } = o;
+    return i.useEffect(() => (s(), () => c()), [s, c]), /* @__PURE__ */ p(_, { ...r, ...a, ref: n });
+  }
+);
+z.displayName = x;
+var E = "PopoverTrigger", k = i.forwardRef(
+  (e, n) => {
+    const { __scopePopover: t, ...a } = e, o = u(E, t), r = h(t), s = O(n, o.triggerRef), c = /* @__PURE__ */ p(
+      F.button,
+      {
+        type: "button",
+        "aria-haspopup": "dialog",
+        "aria-expanded": o.open,
+        "aria-controls": o.contentId,
+        "data-state": $(o.open),
+        ...a,
+        ref: s,
+        onClick: m(e.onClick, o.onOpenToggle)
+      }
+    );
+    return o.hasCustomAnchor ? c : /* @__PURE__ */ p(_, { asChild: !0, ...r, children: c });
+  }
+);
+k.displayName = E;
+var R = "PopoverPortal", [V, W] = y(R, {
+  forceMount: void 0
+}), I = (e) => {
+  const { __scopePopover: n, forceMount: t, children: a, container: o } = e, r = u(R, n);
+  return /* @__PURE__ */ p(V, { scope: n, forceMount: t, children: /* @__PURE__ */ p(b, { present: t || r.open, children: /* @__PURE__ */ p(Q, { asChild: !0, container: o, children: a }) }) });
+};
+I.displayName = R;
+var d = "PopoverContent", S = i.forwardRef(
+  (e, n) => {
+    const t = W(d, e.__scopePopover), { forceMount: a = t.forceMount, ...o } = e, r = u(d, e.__scopePopover);
+    return /* @__PURE__ */ p(b, { present: a || r.open, children: r.modal ? /* @__PURE__ */ p(oe, { ...o, ref: n }) : /* @__PURE__ */ p(re, { ...o, ref: n }) });
+  }
+);
+S.displayName = d;
+var ee = U("PopoverContent.RemoveScroll"), oe = i.forwardRef(
+  (e, n) => {
+    const t = u(d, e.__scopePopover), a = i.useRef(null), o = O(n, a), r = i.useRef(!1);
+    return i.useEffect(() => {
+      const s = a.current;
+      if (s) return Y(s);
+    }, []), /* @__PURE__ */ p(Z, { as: ee, allowPinchZoom: !0, children: /* @__PURE__ */ p(
+      N,
+      {
+        ...e,
+        ref: o,
+        trapFocus: t.open,
+        disableOutsidePointerEvents: !0,
+        onCloseAutoFocus: m(e.onCloseAutoFocus, (s) => {
+          s.preventDefault(), r.current || t.triggerRef.current?.focus();
+        }),
+        onPointerDownOutside: m(
+          e.onPointerDownOutside,
+          (s) => {
+            const c = s.detail.originalEvent, f = c.button === 0 && c.ctrlKey === !0, v = c.button === 2 || f;
+            r.current = v;
+          },
+          { checkForDefaultPrevented: !1 }
+        ),
+        onFocusOutside: m(
+          e.onFocusOutside,
+          (s) => s.preventDefault(),
+          { checkForDefaultPrevented: !1 }
+        )
+      }
+    ) });
+  }
+), re = i.forwardRef(
+  (e, n) => {
+    const t = u(d, e.__scopePopover), a = i.useRef(!1), o = i.useRef(!1);
+    return /* @__PURE__ */ p(
+      N,
+      {
+        ...e,
+        ref: n,
+        trapFocus: !1,
+        disableOutsidePointerEvents: !1,
+        onCloseAutoFocus: (r) => {
+          e.onCloseAutoFocus?.(r), r.defaultPrevented || (a.current || t.triggerRef.current?.focus(), r.preventDefault()), a.current = !1, o.current = !1;
+        },
+        onInteractOutside: (r) => {
+          e.onInteractOutside?.(r), r.defaultPrevented || (a.current = !0, r.detail.originalEvent.type === "pointerdown" && (o.current = !0));
+          const s = r.target;
+          t.triggerRef.current?.contains(s) && r.preventDefault(), r.detail.originalEvent.type === "focusin" && o.current && r.preventDefault();
+        }
+      }
+    );
+  }
+), N = i.forwardRef(
+  (e, n) => {
+    const {
+      __scopePopover: t,
+      trapFocus: a,
+      onOpenAutoFocus: o,
+      onCloseAutoFocus: r,
+      disableOutsidePointerEvents: s,
+      onEscapeKeyDown: c,
+      onPointerDownOutside: f,
+      onFocusOutside: v,
+      onInteractOutside: P,
+      ...g
+    } = e, l = u(d, t), w = h(t);
+    return j(), /* @__PURE__ */ p(
+      L,
+      {
+        asChild: !0,
+        loop: !0,
+        trapped: a,
+        onMountAutoFocus: o,
+        onUnmountAutoFocus: r,
+        children: /* @__PURE__ */ p(
+          K,
+          {
+            asChild: !0,
+            disableOutsidePointerEvents: s,
+            onInteractOutside: P,
+            onEscapeKeyDown: c,
+            onPointerDownOutside: f,
+            onFocusOutside: v,
+            onDismiss: () => l.onOpenChange(!1),
+            children: /* @__PURE__ */ p(
+              H,
+              {
+                "data-state": $(l.open),
+                role: "dialog",
+                id: l.contentId,
+                ...w,
+                ...g,
+                ref: n,
+                style: {
+                  ...g.style,
+                  "--radix-popover-content-transform-origin": "var(--radix-popper-transform-origin)",
+                  "--radix-popover-content-available-width": "var(--radix-popper-available-width)",
+                  "--radix-popover-content-available-height": "var(--radix-popper-available-height)",
+                  "--radix-popover-trigger-width": "var(--radix-popper-anchor-width)",
+                  "--radix-popover-trigger-height": "var(--radix-popper-anchor-height)"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+), T = "PopoverClose", te = i.forwardRef(
+  (e, n) => {
+    const { __scopePopover: t, ...a } = e, o = u(T, t);
+    return /* @__PURE__ */ p(
+      F.button,
+      {
+        type: "button",
+        ...a,
+        ref: n,
+        onClick: m(e.onClick, () => o.onOpenChange(!1))
+      }
+    );
+  }
+);
+te.displayName = T;
+var ne = "PopoverArrow", ae = i.forwardRef(
+  (e, n) => {
+    const { __scopePopover: t, ...a } = e, o = h(t);
+    return /* @__PURE__ */ p(J, { ...o, ...a, ref: n });
+  }
+);
+ae.displayName = ne;
+function $(e) {
+  return e ? "open" : "closed";
+}
+var Ae = D, _e = k, be = I, Fe = S;
+export {
+  Fe as Content,
+  D as Popover,
+  z as PopoverAnchor,
+  ae as PopoverArrow,
+  te as PopoverClose,
+  S as PopoverContent,
+  I as PopoverPortal,
+  k as PopoverTrigger,
+  be as Portal,
+  Ae as Root,
+  _e as Trigger,
+  Oe as createPopoverScope
+};

package/dist/dist/node_modules/@radix-ui/react-popper/dist/index.js

@@ -0,0 +1,219 @@
+"use client";
+import * as s from "react";
+import { useFloating as ce, offset as me, shift as he, flip as ge, size as ue, arrow as we, hide as ye, limitShift as xe } from "../../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+import { Root as Pe } from "../../react-arrow/dist/index.js";
+import { useComposedRefs as k } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as ve } from "../../react-context/dist/index.js";
+import { Primitive as D } from "../../react-primitive/dist/index.js";
+import { useCallbackRef as $e } from "../../react-use-callback-ref/dist/index.js";
+import { useLayoutEffect as N } from "../../react-use-layout-effect/dist/index.js";
+import { useSize as be } from "../../react-use-size/dist/index.js";
+import { jsx as c } from "react/jsx-runtime";
+import { autoUpdate as Ae } from "../../../@floating-ui/dom/dist/floating-ui.dom.js";
+var A = "Popper", [W, Fe] = ve(A), [Se, X] = W(A), Y = (r) => {
+  const { __scopePopper: i, children: o } = r, [a, e] = s.useState(null);
+  return /* @__PURE__ */ c(Se, { scope: i, anchor: a, onAnchorChange: e, children: o });
+};
+Y.displayName = A;
+var j = "PopperAnchor", B = s.forwardRef(
+  (r, i) => {
+    const { __scopePopper: o, virtualRef: a, ...e } = r, t = X(j, o), m = s.useRef(null), n = k(i, m);
+    return s.useEffect(() => {
+      t.onAnchorChange(a?.current || m.current);
+    }), a ? null : /* @__PURE__ */ c(D.div, { ...e, ref: n });
+  }
+);
+B.displayName = j;
+var S = "PopperContent", [Ce, Re] = W(S), F = s.forwardRef(
+  (r, i) => {
+    const {
+      __scopePopper: o,
+      side: a = "bottom",
+      sideOffset: e = 0,
+      align: t = "center",
+      alignOffset: m = 0,
+      arrowPadding: n = 0,
+      avoidCollisions: l = !0,
+      collisionBoundary: g = [],
+      collisionPadding: p = 0,
+      sticky: w = "partial",
+      hideWhenDetached: y = !1,
+      updatePositionStrategy: d = "optimized",
+      onPlaced: f,
+      ...C
+    } = r, T = X(S, o), [$, U] = s.useState(null), q = k(i, (u) => U(u)), [b, G] = s.useState(null), R = be(b), J = R?.width ?? 0, O = R?.height ?? 0, K = a + (t !== "center" ? "-" + t : ""), Q = typeof p == "number" ? p : { top: 0, right: 0, bottom: 0, left: 0, ...p }, _ = Array.isArray(g) ? g : [g], V = _.length > 0, x = {
+      padding: Q,
+      boundary: _.filter(_e),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: V
+    }, { refs: Z, floatingStyles: H, placement: ee, isPositioned: P, middlewareData: h } = ce({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: K,
+      whileElementsMounted: (...u) => Ae(...u, {
+        animationFrame: d === "always"
+      }),
+      elements: {
+        reference: T.anchor
+      },
+      middleware: [
+        me({ mainAxis: e + O, alignmentAxis: m }),
+        l && he({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: w === "partial" ? xe() : void 0,
+          ...x
+        }),
+        l && ge({ ...x }),
+        ue({
+          ...x,
+          apply: ({ elements: u, rects: se, availableWidth: pe, availableHeight: le }) => {
+            const { width: de, height: fe } = se.reference, v = u.floating.style;
+            v.setProperty("--radix-popper-available-width", `${pe}px`), v.setProperty("--radix-popper-available-height", `${le}px`), v.setProperty("--radix-popper-anchor-width", `${de}px`), v.setProperty("--radix-popper-anchor-height", `${fe}px`);
+          }
+        }),
+        b && we({ element: b, padding: n }),
+        He({ arrowWidth: J, arrowHeight: O }),
+        y && ye({ strategy: "referenceHidden", ...x })
+      ]
+    }), [z, re] = M(ee), E = $e(f);
+    N(() => {
+      P && E?.();
+    }, [P, E]);
+    const te = h.arrow?.x, oe = h.arrow?.y, ae = h.arrow?.centerOffset !== 0, [ie, ne] = s.useState();
+    return N(() => {
+      $ && ne(window.getComputedStyle($).zIndex);
+    }, [$]), /* @__PURE__ */ c(
+      "div",
+      {
+        ref: Z.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...H,
+          transform: P ? H.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: ie,
+          "--radix-popper-transform-origin": [
+            h.transformOrigin?.x,
+            h.transformOrigin?.y
+          ].join(" "),
+          // hide the content if using the hide middleware and should be hidden
+          // set visibility to hidden and disable pointer events so the UI behaves
+          // as if the PopperContent isn't there at all
+          ...h.hide?.referenceHidden && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: r.dir,
+        children: /* @__PURE__ */ c(
+          Ce,
+          {
+            scope: o,
+            placedSide: z,
+            onArrowChange: G,
+            arrowX: te,
+            arrowY: oe,
+            shouldHideArrow: ae,
+            children: /* @__PURE__ */ c(
+              D.div,
+              {
+                "data-side": z,
+                "data-align": re,
+                ...C,
+                ref: q,
+                style: {
+                  ...C.style,
+                  // if the PopperContent hasn't been placed yet (not all measurements done)
+                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                  animation: P ? void 0 : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+F.displayName = S;
+var L = "PopperArrow", Oe = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, I = s.forwardRef(function(r, i) {
+  const { __scopePopper: o, ...a } = r, e = Re(L, o), t = Oe[e.placedSide];
+  return (
+    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
+    // doesn't report size as we'd expect on SVG elements.
+    // it reports their bounding box which is effectively the largest path inside the SVG.
+    /* @__PURE__ */ c(
+      "span",
+      {
+        ref: e.onArrowChange,
+        style: {
+          position: "absolute",
+          left: e.arrowX,
+          top: e.arrowY,
+          [t]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[e.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[e.placedSide],
+          visibility: e.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ c(
+          Pe,
+          {
+            ...a,
+            ref: i,
+            style: {
+              ...a.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+I.displayName = L;
+function _e(r) {
+  return r !== null;
+}
+var He = (r) => ({
+  name: "transformOrigin",
+  options: r,
+  fn(i) {
+    const { placement: o, rects: a, middlewareData: e } = i, t = e.arrow?.centerOffset !== 0, m = t ? 0 : r.arrowWidth, n = t ? 0 : r.arrowHeight, [l, g] = M(o), p = { start: "0%", center: "50%", end: "100%" }[g], w = (e.arrow?.x ?? 0) + m / 2, y = (e.arrow?.y ?? 0) + n / 2;
+    let d = "", f = "";
+    return l === "bottom" ? (d = t ? p : `${w}px`, f = `${-n}px`) : l === "top" ? (d = t ? p : `${w}px`, f = `${a.floating.height + n}px`) : l === "right" ? (d = `${-n}px`, f = t ? p : `${y}px`) : l === "left" && (d = `${a.floating.width + n}px`, f = t ? p : `${y}px`), { data: { x: d, y: f } };
+  }
+});
+function M(r) {
+  const [i, o = "center"] = r.split("-");
+  return [i, o];
+}
+var Le = Y, Ie = B, Me = F, Te = I;
+export {
+  Ie as Anchor,
+  Te as Arrow,
+  Me as Content,
+  Y as Popper,
+  B as PopperAnchor,
+  I as PopperArrow,
+  F as PopperContent,
+  Le as Root,
+  Fe as createPopperScope
+};

package/dist/dist/node_modules/@radix-ui/react-portal/dist/index.js

@@ -0,0 +1,16 @@
+"use client";
+import * as r from "react";
+import f from "react-dom";
+import { Primitive as l } from "../../react-primitive/dist/index.js";
+import { useLayoutEffect as c } from "../../react-use-layout-effect/dist/index.js";
+import { jsx as n } from "react/jsx-runtime";
+var u = "Portal", p = r.forwardRef((o, a) => {
+  const { container: e, ...i } = o, [s, m] = r.useState(!1);
+  c(() => m(!0), []);
+  const t = e || s && globalThis?.document?.body;
+  return t ? f.createPortal(/* @__PURE__ */ n(l.div, { ...i, ref: a }), t) : null;
+});
+p.displayName = u;
+export {
+  p as Portal
+};

package/dist/dist/node_modules/@radix-ui/react-presence/dist/index.js

@@ -0,0 +1,71 @@
+"use client";
+import * as i from "react";
+import { useComposedRefs as y } from "../../react-compose-refs/dist/index.js";
+import { useLayoutEffect as N } from "../../react-use-layout-effect/dist/index.js";
+function E(n, e) {
+  return i.useReducer((t, r) => e[t][r] ?? t, n);
+}
+var g = (n) => {
+  const { present: e, children: t } = n, r = v(e), s = typeof t == "function" ? t({ present: r.isPresent }) : i.Children.only(t), c = y(r.ref, R(s));
+  return typeof t == "function" || r.isPresent ? i.cloneElement(s, { ref: c }) : null;
+};
+g.displayName = "Presence";
+function v(n) {
+  const [e, t] = i.useState(), r = i.useRef(null), s = i.useRef(n), c = i.useRef("none"), O = n ? "mounted" : "unmounted", [p, u] = E(O, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  return i.useEffect(() => {
+    const o = f(r.current);
+    c.current = p === "mounted" ? o : "none";
+  }, [p]), N(() => {
+    const o = r.current, m = s.current;
+    if (m !== n) {
+      const a = c.current, d = f(o);
+      n ? u("MOUNT") : d === "none" || o?.display === "none" ? u("UNMOUNT") : u(m && a !== d ? "ANIMATION_OUT" : "UNMOUNT"), s.current = n;
+    }
+  }, [n, u]), N(() => {
+    if (e) {
+      let o;
+      const m = e.ownerDocument.defaultView ?? window, a = (l) => {
+        const T = f(r.current).includes(l.animationName);
+        if (l.target === e && T && (u("ANIMATION_END"), !s.current)) {
+          const M = e.style.animationFillMode;
+          e.style.animationFillMode = "forwards", o = m.setTimeout(() => {
+            e.style.animationFillMode === "forwards" && (e.style.animationFillMode = M);
+          });
+        }
+      }, d = (l) => {
+        l.target === e && (c.current = f(r.current));
+      };
+      return e.addEventListener("animationstart", d), e.addEventListener("animationcancel", a), e.addEventListener("animationend", a), () => {
+        m.clearTimeout(o), e.removeEventListener("animationstart", d), e.removeEventListener("animationcancel", a), e.removeEventListener("animationend", a);
+      };
+    } else
+      u("ANIMATION_END");
+  }, [e, u]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(p),
+    ref: i.useCallback((o) => {
+      r.current = o ? getComputedStyle(o) : null, t(o);
+    }, [])
+  };
+}
+function f(n) {
+  return n?.animationName || "none";
+}
+function R(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);
+}
+export {
+  g as Presence
+};

package/dist/dist/node_modules/@radix-ui/react-primitive/dist/index.js

@@ -0,0 +1,37 @@
+"use client";
+import * as u from "react";
+import * as c from "react-dom";
+import { createSlot as f } from "../../react-slot/dist/index.js";
+import { jsx as l } from "react/jsx-runtime";
+var p = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+], h = p.reduce((r, t) => {
+  const i = f(`Primitive.${t}`), e = u.forwardRef((o, a) => {
+    const { asChild: s, ...m } = o, n = s ? i : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ l(n, { ...m, ref: a });
+  });
+  return e.displayName = `Primitive.${t}`, { ...r, [t]: e };
+}, {});
+function w(r, t) {
+  r && c.flushSync(() => r.dispatchEvent(t));
+}
+export {
+  h as Primitive,
+  w as dispatchDiscreteCustomEvent
+};

package/dist/dist/node_modules/@radix-ui/react-slot/dist/index.js

@@ -0,0 +1,59 @@
+"use client";
+import * as i from "react";
+import { composeRefs as y } from "../../react-compose-refs/dist/index.js";
+import { jsx as f, Fragment as h } from "react/jsx-runtime";
+// @__NO_SIDE_EFFECTS__
+function g(r) {
+  const n = /* @__PURE__ */ R(r), t = i.forwardRef((o, e) => {
+    const { children: l, ...a } = o, s = i.Children.toArray(l), d = s.find(S);
+    if (d) {
+      const c = d.props.children, m = s.map((p) => p === d ? i.Children.count(c) > 1 ? i.Children.only(null) : i.isValidElement(c) ? c.props.children : null : p);
+      return /* @__PURE__ */ f(n, { ...a, ref: e, children: i.isValidElement(c) ? i.cloneElement(c, void 0, m) : null });
+    }
+    return /* @__PURE__ */ f(n, { ...a, ref: e, children: l });
+  });
+  return t.displayName = `${r}.Slot`, t;
+}
+var _ = /* @__PURE__ */ g("Slot");
+// @__NO_SIDE_EFFECTS__
+function R(r) {
+  const n = i.forwardRef((t, o) => {
+    const { children: e, ...l } = t;
+    if (i.isValidElement(e)) {
+      const a = x(e), s = b(l, e.props);
+      return e.type !== i.Fragment && (s.ref = o ? y(o, a) : a), i.cloneElement(e, s);
+    }
+    return i.Children.count(e) > 1 ? i.Children.only(null) : null;
+  });
+  return n.displayName = `${r}.SlotClone`, n;
+}
+var u = Symbol("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function j(r) {
+  const n = ({ children: t }) => /* @__PURE__ */ f(h, { children: t });
+  return n.displayName = `${r}.Slottable`, n.__radixId = u, n;
+}
+function S(r) {
+  return i.isValidElement(r) && typeof r.type == "function" && "__radixId" in r.type && r.type.__radixId === u;
+}
+function b(r, n) {
+  const t = { ...n };
+  for (const o in n) {
+    const e = r[o], l = n[o];
+    /^on[A-Z]/.test(o) ? e && l ? t[o] = (...a) => {
+      const s = l(...a);
+      return e(...a), s;
+    } : e && (t[o] = e) : o === "style" ? t[o] = { ...e, ...l } : o === "className" && (t[o] = [e, l].filter(Boolean).join(" "));
+  }
+  return { ...r, ...t };
+}
+function x(r) {
+  let n = Object.getOwnPropertyDescriptor(r.props, "ref")?.get, t = n && "isReactWarning" in n && n.isReactWarning;
+  return t ? r.ref : (n = Object.getOwnPropertyDescriptor(r, "ref")?.get, t = n && "isReactWarning" in n && n.isReactWarning, t ? r.props.ref : r.props.ref || r.ref);
+}
+export {
+  _ as Root,
+  _ as Slot,
+  g as createSlot,
+  j as createSlottable
+};