@synopackageland/ui 0.25.21 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/Popover/PopoverRoot.js

@@ -0,0 +1,56 @@
+import { createContext as d } from "../shared/createContext.js";
+import { PopperRoot_default as i } from "../Popper/PopperRoot.js";
+import { defineComponent as c, toRefs as v, ref as r, openBlock as m, createBlock as _, unref as n, withCtx as g, renderSlot as R } from "vue";
+import { useVModel as C } from "../../../@vueuse/core/dist/index.js";
+const [k, P] = /* @__PURE__ */ d("PopoverRoot");
+var h = /* @__PURE__ */ c({
+  __name: "PopoverRoot",
+  props: {
+    defaultOpen: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    open: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    modal: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    }
+  },
+  emits: ["update:open"],
+  setup(a, { emit: l }) {
+    const o = a, p = l, { modal: u } = v(o), e = C(o, "open", p, {
+      defaultValue: o.defaultOpen,
+      passive: o.open === void 0
+    }), s = r(), f = r(!1);
+    return P({
+      contentId: "",
+      triggerId: "",
+      modal: u,
+      open: e,
+      onOpenChange: (t) => {
+        e.value = t;
+      },
+      onOpenToggle: () => {
+        e.value = !e.value;
+      },
+      triggerElement: s,
+      hasCustomAnchor: f
+    }), (t, x) => (m(), _(n(i), null, {
+      default: g(() => [R(t.$slots, "default", {
+        open: n(e),
+        close: () => e.value = !1
+      })]),
+      _: 3
+    }));
+  }
+}), I = h;
+export {
+  I as PopoverRoot_default,
+  k as injectPopoverRootContext
+};

package/dist/modules/vendor/reka-ui/dist/Popover/PopoverTrigger.js

@@ -0,0 +1,55 @@
+import { useForwardExpose as u } from "../shared/useForwardExpose.js";
+import { useId as r } from "../shared/useId.js";
+import { Primitive as a } from "../Primitive/Primitive.js";
+import { PopperAnchor_default as s } from "../Popper/PopperAnchor.js";
+import { injectPopoverRootContext as c } from "./PopoverRoot.js";
+import { defineComponent as v, onMounted as m, openBlock as f, createBlock as g, resolveDynamicComponent as h, unref as e, withCtx as n, createVNode as _, renderSlot as C } from "vue";
+var x = /* @__PURE__ */ v({
+  __name: "PopoverTrigger",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "button"
+    }
+  },
+  setup(t) {
+    const i = t, o = c(), { forwardRef: d, currentElement: l } = u();
+    return o.triggerId ||= r(void 0, "reka-popover-trigger"), o.contentId ||= r(void 0, "reka-popover-content"), m(() => {
+      o.triggerElement.value = l.value;
+    }), (p, k) => (f(), g(h(e(o).hasCustomAnchor.value ? e(a) : e(s)), { "as-child": "" }, {
+      default: n(() => [_(e(a), {
+        id: e(o).triggerId,
+        ref: e(d),
+        type: t.as === "button" ? "button" : void 0,
+        "aria-haspopup": "dialog",
+        "aria-expanded": e(o).open.value,
+        "aria-controls": e(o).open.value ? e(o).contentId : void 0,
+        "data-state": e(o).open.value ? "open" : "closed",
+        as: t.as,
+        "as-child": i.asChild,
+        onClick: e(o).onOpenToggle
+      }, {
+        default: n(() => [C(p.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "id",
+        "type",
+        "aria-expanded",
+        "aria-controls",
+        "data-state",
+        "as",
+        "as-child",
+        "onClick"
+      ])]),
+      _: 3
+    }));
+  }
+}), w = x;
+export {
+  w as PopoverTrigger_default
+};

package/dist/modules/vendor/reka-ui/dist/Popper/PopperAnchor.js

@@ -0,0 +1,37 @@
+import { useForwardExpose as p } from "../shared/useForwardExpose.js";
+import { Primitive as s } from "../Primitive/Primitive.js";
+import { injectPopperRootContext as c } from "./PopperRoot.js";
+import { defineComponent as f, watchPostEffect as u, openBlock as i, createBlock as d, unref as r, withCtx as h, renderSlot as m } from "vue";
+var _ = /* @__PURE__ */ f({
+  __name: "PopperAnchor",
+  props: {
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(e) {
+    const t = e, { forwardRef: o, currentElement: n } = p(), a = c();
+    return u(() => {
+      a.onAnchorChange(t.reference ?? n.value);
+    }), (l, C) => (i(), d(r(s), {
+      ref: r(o),
+      as: e.as,
+      "as-child": e.asChild
+    }, {
+      default: h(() => [m(l.$slots, "default")]),
+      _: 3
+    }, 8, ["as", "as-child"]));
+  }
+}), y = _;
+export {
+  y as PopperAnchor_default
+};

package/dist/modules/vendor/reka-ui/dist/Popper/PopperArrow.js

@@ -0,0 +1,84 @@
+import { useForwardExpose as i } from "../shared/useForwardExpose.js";
+import { Arrow_default as n } from "../component/Arrow.js";
+import { injectPopperContentContext as s } from "./PopperContent.js";
+import { defineComponent as u, computed as p, openBlock as f, createElementBlock as h, normalizeStyle as m, unref as t, createVNode as c, mergeProps as v, withCtx as w, renderSlot as g } from "vue";
+const y = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+};
+var b = /* @__PURE__ */ u({
+  inheritAttrs: !1,
+  __name: "PopperArrow",
+  props: {
+    width: {
+      type: Number,
+      required: !1
+    },
+    height: {
+      type: Number,
+      required: !1
+    },
+    rounded: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "svg"
+    }
+  },
+  setup(r) {
+    const { forwardRef: a } = i(), e = s(), l = p(() => y[e.placedSide.value]);
+    return (o, C) => (f(), h("span", {
+      ref: (d) => {
+        t(e).onArrowChange(d ?? void 0);
+      },
+      style: m({
+        position: "absolute",
+        left: t(e).arrowX?.value ? `${t(e).arrowX?.value}px` : void 0,
+        top: t(e).arrowY?.value ? `${t(e).arrowY?.value}px` : void 0,
+        [l.value]: 0,
+        transformOrigin: {
+          top: "",
+          right: "0 0",
+          bottom: "center 0",
+          left: "100% 0"
+        }[t(e).placedSide.value],
+        transform: {
+          top: "translateY(100%)",
+          right: "translateY(50%) rotate(90deg) translateX(-50%)",
+          bottom: "rotate(180deg)",
+          left: "translateY(50%) rotate(-90deg) translateX(50%)"
+        }[t(e).placedSide.value],
+        visibility: t(e).shouldHideArrow.value ? "hidden" : void 0
+      })
+    }, [c(n, v(o.$attrs, {
+      ref: t(a),
+      style: { display: "block" },
+      as: r.as,
+      "as-child": r.asChild,
+      rounded: r.rounded,
+      width: r.width,
+      height: r.height
+    }), {
+      default: w(() => [g(o.$slots, "default")]),
+      _: 3
+    }, 16, [
+      "as",
+      "as-child",
+      "rounded",
+      "width",
+      "height"
+    ])], 4));
+  }
+}), _ = b;
+export {
+  _ as PopperArrow_default
+};

package/dist/modules/vendor/reka-ui/dist/Popper/PopperContent.js

@@ -0,0 +1,272 @@
+import { injectModalScope as Z } from "../../../../lib/localModal.js";
+import { createContext as G } from "../shared/createContext.js";
+import { useDirection as J } from "../shared/useDirection.js";
+import { useForwardExpose as K } from "../shared/useForwardExpose.js";
+import { useSize as Q } from "../shared/useSize.js";
+import { Primitive as x } from "../Primitive/Primitive.js";
+import { injectPopperRootContext as T } from "./PopperRoot.js";
+import { isNotNull as ee, transformOrigin as te, getSideAndAlignFromPlacement as A } from "./utils.js";
+import { defineComponent as ie, computed as r, ref as m, watchPostEffect as re, watchEffect as oe, openBlock as y, createElementBlock as ae, normalizeStyle as ne, unref as t, withMemo as le, createBlock as B, mergeProps as O, withCtx as b, renderSlot as k, mergeDefaults as se } from "vue";
+import { arrow as de, useFloating as pe } from "../../../@floating-ui/vue/dist/floating-ui.vue.js";
+import { offset as ue, flip as z, shift as fe, limitShift as ce, size as me, hide as ye, autoUpdate as he } from "../../../@floating-ui/dom/dist/floating-ui.dom.js";
+const ge = ["dir"], ve = {
+  side: "bottom",
+  sideOffset: 0,
+  sideFlip: !0,
+  align: "center",
+  alignOffset: 0,
+  alignFlip: !0,
+  arrowPadding: 0,
+  hideShiftedArrow: !0,
+  avoidCollisions: !0,
+  collisionBoundary: () => [],
+  collisionPadding: 0,
+  sticky: "partial",
+  hideWhenDetached: !1,
+  positionStrategy: "fixed",
+  updatePositionStrategy: "optimized",
+  prioritizePosition: !1
+}, [$e, we] = /* @__PURE__ */ G("PopperContent");
+var Pe = /* @__PURE__ */ ie({
+  inheritAttrs: !1,
+  __name: "PopperContent",
+  props: /* @__PURE__ */ se({
+    memoDependencies: {
+      type: Array,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  }, { ...ve }),
+  emits: ["placed"],
+  setup(_, { emit: $ }) {
+    const e = _, D = Z(), F = $, E = T(), { forwardRef: h, currentElement: g } = K(), u = J(r(() => e.dir)), v = m(), l = m(), { width: W, height: w } = Q(l), j = r(() => e.side + (e.align !== "center" ? `-${e.align}` : "")), H = r(() => typeof e.collisionPadding == "number" ? e.collisionPadding : {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...e.collisionPadding
+    }), P = r(() => Array.isArray(e.collisionBoundary) ? e.collisionBoundary : [e.collisionBoundary]), a = r(() => ({
+      padding: H.value,
+      boundary: P.value.filter(ee),
+      altBoundary: P.value.length > 0
+    })), S = r(() => ({
+      mainAxis: e.sideFlip,
+      crossAxis: e.alignFlip
+    })), N = r(() => [
+      ue({
+        mainAxis: e.sideOffset + w.value,
+        alignmentAxis: e.alignOffset
+      }),
+      e.prioritizePosition && e.avoidCollisions && z({
+        ...a.value,
+        ...S.value
+      }),
+      e.avoidCollisions && fe({
+        mainAxis: !0,
+        crossAxis: !!e.prioritizePosition,
+        limiter: e.sticky === "partial" ? ce() : void 0,
+        ...a.value
+      }),
+      !e.prioritizePosition && e.avoidCollisions && z({
+        ...a.value,
+        ...S.value
+      }),
+      me({
+        ...a.value,
+        apply: ({ elements: i, rects: d, availableWidth: L, availableHeight: V }) => {
+          const { width: X, height: Y } = d.reference, p = i.floating.style;
+          p.setProperty("--reka-popper-available-width", `${L}px`), p.setProperty("--reka-popper-available-height", `${V}px`), p.setProperty("--reka-popper-anchor-width", `${X}px`), p.setProperty("--reka-popper-anchor-height", `${Y}px`);
+        }
+      }),
+      l.value && de({
+        element: l.value,
+        padding: e.arrowPadding
+      }),
+      te({
+        arrowWidth: W.value,
+        arrowHeight: w.value,
+        dir: u.value
+      }),
+      e.hideWhenDetached && ye({
+        strategy: "referenceHidden",
+        ...a.value
+      })
+    ]), M = r(() => e.reference ?? E.anchor.value), { floatingStyles: C, placement: q, isPositioned: n, middlewareData: o } = pe(M, v, {
+      strategy: e.positionStrategy,
+      placement: j,
+      whileElementsMounted: (...i) => he(...i, {
+        layoutShift: !e.disableUpdateOnLayoutShift,
+        animationFrame: e.updatePositionStrategy === "always"
+      }),
+      middleware: N
+    }), s = r(() => A(q.value)[0]), f = r(() => A(q.value)[1]);
+    re(() => {
+      n.value && F("placed");
+    });
+    const R = r(() => {
+      const i = o.value.arrow?.centerOffset !== 0;
+      return e.hideShiftedArrow && i;
+    }), c = m("");
+    oe(() => {
+      g.value && (c.value = window.getComputedStyle(g.value).zIndex);
+    });
+    const I = r(() => o.value.arrow?.x ?? 0), U = r(() => o.value.arrow?.y ?? 0);
+    return we({
+      placedSide: s,
+      onArrowChange: (i) => l.value = i,
+      arrowX: I,
+      arrowY: U,
+      shouldHideArrow: R
+    }), (i, d) => (y(), ae("div", {
+      ref_key: "floatingRef",
+      ref: v,
+      "data-reka-popper-content-wrapper": "",
+      dir: t(u),
+      style: ne({
+        ...t(C),
+        transform: t(n) ? t(C).transform : "translate(0, -200%)",
+        minWidth: "max-content",
+        zIndex: D ? "var(--ui-local-layer-z, " + (c.value || "auto") + ")" : c.value,
+        "--reka-popper-transform-origin": [t(o).transformOrigin?.x, t(o).transformOrigin?.y].join(" "),
+        ...t(o).hide?.referenceHidden && {
+          visibility: "hidden",
+          pointerEvents: "none"
+        }
+      })
+    }, [e.memoDependencies ? le([
+      e.asChild,
+      e.as,
+      s.value,
+      f.value,
+      t(n),
+      ...Object.values(i.$attrs),
+      ...e.memoDependencies
+    ], () => (y(), B(t(x), O({
+      key: 0,
+      ref: t(h)
+    }, i.$attrs, {
+      "as-child": e.asChild,
+      as: e.as,
+      "data-side": s.value,
+      "data-align": f.value,
+      style: { animation: t(n) ? void 0 : "none" }
+    }), {
+      default: b(() => [k(i.$slots, "default")]),
+      _: 3
+    }, 16, [
+      "as-child",
+      "as",
+      "data-side",
+      "data-align",
+      "style"
+    ])), d, 0) : (y(), B(t(x), O({
+      key: 1,
+      ref: t(h)
+    }, i.$attrs, {
+      "as-child": e.asChild,
+      as: e.as,
+      "data-side": s.value,
+      "data-align": f.value,
+      dir: t(u),
+      style: { animation: t(n) ? void 0 : "none" }
+    }), {
+      default: b(() => [k(i.$slots, "default")]),
+      _: 3
+    }, 16, [
+      "as-child",
+      "as",
+      "data-side",
+      "data-align",
+      "dir",
+      "style"
+    ]))], 12, ge));
+  }
+}), De = Pe;
+export {
+  ve as PopperContentPropsDefaultValue,
+  De as PopperContent_default,
+  $e as injectPopperContentContext
+};

package/dist/modules/vendor/reka-ui/dist/Popper/PopperRoot.js

@@ -0,0 +1,18 @@
+import { createContext as t } from "../shared/createContext.js";
+import { defineComponent as r, ref as p, renderSlot as n } from "vue";
+const [i, _] = /* @__PURE__ */ t("PopperRoot");
+var a = /* @__PURE__ */ r({
+  inheritAttrs: !1,
+  __name: "PopperRoot",
+  setup(u) {
+    const o = p();
+    return _({
+      anchor: o,
+      onAnchorChange: (e) => o.value = e
+    }), (e, s) => n(e.$slots, "default");
+  }
+}), l = a;
+export {
+  l as PopperRoot_default,
+  i as injectPopperRootContext
+};

package/dist/modules/vendor/reka-ui/dist/Popper/utils.js

@@ -0,0 +1,34 @@
+function h(r) {
+  return r !== null;
+}
+function m(r) {
+  return {
+    name: "transformOrigin",
+    options: r,
+    fn(a) {
+      const { placement: c, rects: s, middlewareData: l } = a, t = l.arrow?.centerOffset !== 0, p = t ? 0 : r.arrowWidth, e = t ? 0 : r.arrowHeight, [i, d] = A(c), w = {
+        start: r.dir === "rtl" ? "100%" : "0%",
+        center: "50%",
+        end: r.dir === "rtl" ? "0%" : "100%"
+      }[d], f = {
+        start: "0%",
+        center: "50%",
+        end: "100%"
+      }[d], g = (l.arrow?.x ?? 0) + p / 2, x = (l.arrow?.y ?? 0) + e / 2;
+      let n = "", o = "";
+      return i === "bottom" ? (n = t ? w : `${g}px`, o = `${-e}px`) : i === "top" ? (n = t ? w : `${g}px`, o = `${s.floating.height + e}px`) : i === "right" ? (n = `${-e}px`, o = t ? f : `${x}px`) : i === "left" && (n = `${s.floating.width + e}px`, o = t ? f : `${x}px`), { data: {
+        x: n,
+        y: o
+      } };
+    }
+  };
+}
+function A(r) {
+  const [a, c = "center"] = r.split("-");
+  return [a, c];
+}
+export {
+  A as getSideAndAlignFromPlacement,
+  h as isNotNull,
+  m as transformOrigin
+};

package/dist/modules/vendor/reka-ui/dist/Presence/Presence.js

@@ -0,0 +1,41 @@
+import { renderSlotFragments as u } from "../shared/renderSlotFragments.js";
+import { usePresence as f } from "./usePresence.js";
+import { defineComponent as d, toRefs as m, ref as h, getCurrentInstance as v, h as y } from "vue";
+import { unrefElement as w } from "../../../@vueuse/core/dist/index.js";
+var x = /* @__PURE__ */ d({
+  name: "Presence",
+  props: {
+    present: {
+      type: Boolean,
+      required: !0
+    },
+    forceMount: { type: Boolean }
+  },
+  slots: {},
+  setup(l, { slots: a, expose: c }) {
+    const { present: i, forceMount: p } = m(l), r = h(), { isPresent: t } = f(i, r);
+    c({ present: t });
+    let n = a.default({ present: t.value });
+    n = u(n || []);
+    const s = v();
+    if (n && n?.length > 1) {
+      const o = s?.parent?.type.name ? `<${s.parent.type.name} />` : "component";
+      throw new Error([
+        `Detected an invalid children for \`${o}\` for  \`Presence\` component.`,
+        "",
+        "Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",
+        "You can apply a few solutions:",
+        ["Provide a single child element so that `presence` directive attach correctly.", "Ensure the first child is an actual element instead of a raw text node or comment node."].map((e) => `  - ${e}`).join(`
+`)
+      ].join(`
+`));
+    }
+    return () => p.value || i.value || t.value ? y(a.default({ present: t.value })[0], { ref: (o) => {
+      const e = w(o);
+      return typeof e?.hasAttribute > "u" || (e?.hasAttribute("data-reka-popper-content-wrapper") ? r.value = e.firstElementChild : r.value = e), e;
+    } }) : null;
+  }
+});
+export {
+  x as Presence_default
+};

package/dist/modules/vendor/reka-ui/dist/Presence/usePresence.js

@@ -0,0 +1,73 @@
+import { useStateMachine as h } from "../shared/useStateMachine.js";
+import { ref as A, watch as T, nextTick as S, onUnmounted as y, computed as L } from "vue";
+import { defaultWindow as g } from "../../../@vueuse/core/dist/index.js";
+import { isClient as C } from "../../../@vueuse/shared/dist/index.js";
+function R(u, e) {
+  const E = A({}), c = A("none"), p = A(u), O = u.value ? "mounted" : "unmounted";
+  let r;
+  const o = e.value?.ownerDocument.defaultView ?? g, M = (t) => o?.requestAnimationFrame ? o.requestAnimationFrame(() => o.setTimeout(t)) : t(), { state: m, dispatch: a } = h(O, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: { MOUNT: "mounted" }
+  }), i = (t) => {
+    if (C) {
+      const n = new CustomEvent(t, {
+        bubbles: !1,
+        cancelable: !1
+      });
+      e.value?.dispatchEvent(n);
+    }
+  };
+  T(u, async (t, n) => {
+    const d = n !== t;
+    if (await S(), d) {
+      const N = c.value;
+      if (t) {
+        a("MOUNT"), i("enter"), M(() => {
+          m.value === "mounted" && e.value && v(e.value) === "none" && i("after-enter");
+        });
+        return;
+      }
+      const l = v(e.value);
+      l === "none" || l === "undefined" || E.value?.display === "none" ? (a("UNMOUNT"), i("leave"), i("after-leave")) : n && N !== l ? (a("ANIMATION_OUT"), i("leave")) : (a("UNMOUNT"), i("after-leave"));
+    }
+  }, { immediate: !0 });
+  const s = (t) => {
+    if (t.target !== e.value) return;
+    const n = v(e.value), d = n.includes(CSS.escape(t.animationName)), N = m.value === "mounted" ? "enter" : "leave";
+    if (d && (i(`after-${N}`), a("ANIMATION_END"), !p.value)) {
+      const l = e.value.style.animationFillMode;
+      e.value.style.animationFillMode = "forwards", r = o?.setTimeout(() => {
+        e.value?.style.animationFillMode === "forwards" && (e.value.style.animationFillMode = l);
+      });
+    }
+    n === "none" && a("ANIMATION_END");
+  }, f = (t) => {
+    t.target === e.value && (c.value = v(e.value));
+  }, I = T(e, (t, n) => {
+    t ? (E.value = getComputedStyle(t), t.addEventListener("animationstart", f), t.addEventListener("animationcancel", s), t.addEventListener("animationend", s)) : (a("ANIMATION_END"), r !== void 0 && o?.clearTimeout(r), n?.removeEventListener("animationstart", f), n?.removeEventListener("animationcancel", s), n?.removeEventListener("animationend", s));
+  }, { immediate: !0 }), U = T(m, () => {
+    if (m.value !== "mounted") {
+      c.value = "none";
+      return;
+    }
+    M(() => {
+      m.value === "mounted" && (c.value = v(e.value));
+    });
+  });
+  return y(() => {
+    I(), U(), e.value && (e.value.removeEventListener("animationstart", f), e.value.removeEventListener("animationcancel", s), e.value.removeEventListener("animationend", s)), r !== void 0 && o?.clearTimeout(r);
+  }), { isPresent: L(() => ["mounted", "unmountSuspended"].includes(m.value)) };
+}
+function v(u) {
+  return u && getComputedStyle(u).animationName || "none";
+}
+export {
+  R as usePresence
+};