@orchidui/dashboard 1.8.1-93 → 1.8.1-96

package/dist/DialogOverlay-Cj3UTjZ8.js

@@ -0,0 +1,309 @@
+import { defineComponent as v, ref as C, toRefs as M, renderSlot as y, unref as t, createBlock as m, openBlock as g, mergeProps as D, withCtx as f, onMounted as A, createVNode as I, createCommentVNode as T } from "vue";
+import { u as O } from "./useForwardExpose-DZT6mL_U.js";
+import { P as F } from "./Primitive-B3twiLO1.js";
+import { g as k } from "./utils-DxQ_ywGa.js";
+import { u as $ } from "./useId-reAg216X.js";
+import { g as _ } from "./getActiveElement-B-HWdUIb.js";
+import { _ as R } from "./FocusScope--pJ6bboI.js";
+import { _ as N } from "./DismissableLayer-C7IJliOb.js";
+import { b as w } from "./useForwardPropsEmits-0XKBv1pB.js";
+import { u as S, a as K } from "./useBodyScrollLock-CazCRZjZ.js";
+import { P } from "./Presence-CxfTrw6l.js";
+import { u as L } from "./index-BwPb_idr.js";
+import { c as V } from "./createContext-CZEfaSVa.js";
+const [E, U] = V("DialogRoot"), re = /* @__PURE__ */ v({
+  inheritAttrs: !1,
+  __name: "DialogRoot",
+  props: {
+    open: { type: Boolean, default: void 0 },
+    defaultOpen: { type: Boolean, default: !1 },
+    modal: { type: Boolean, default: !0 }
+  },
+  emits: ["update:open"],
+  setup(d, { emit: l }) {
+    const a = d, e = L(a, "open", l, {
+      defaultValue: a.defaultOpen,
+      passive: a.open === void 0
+    }), u = C(), p = C(), { modal: i } = M(a);
+    return U({
+      open: e,
+      modal: i,
+      openModal: () => {
+        e.value = !0;
+      },
+      onOpenChange: (n) => {
+        e.value = n;
+      },
+      onOpenToggle: () => {
+        e.value = !e.value;
+      },
+      contentId: "",
+      titleId: "",
+      descriptionId: "",
+      triggerElement: u,
+      contentElement: p
+    }), (n, o) => y(n.$slots, "default", {
+      open: t(e),
+      close: () => e.value = !1
+    });
+  }
+}), le = /* @__PURE__ */ v({
+  __name: "DialogClose",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "button" }
+  },
+  setup(d) {
+    const l = d;
+    O();
+    const a = E();
+    return (s, e) => (g(), m(t(F), D(l, {
+      type: s.as === "button" ? "button" : void 0,
+      onClick: e[0] || (e[0] = (u) => t(a).onOpenChange(!1))
+    }), {
+      default: f(() => [
+        y(s.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["type"]));
+  }
+}), W = "DialogTitle", G = "DialogContent";
+function H({
+  titleName: d = W,
+  contentName: l = G,
+  componentLink: a = "dialog.html#title",
+  titleId: s,
+  descriptionId: e,
+  contentElement: u
+}) {
+  const p = `Warning: \`${l}\` requires a \`${d}\` for the component to be accessible for screen reader users.
+
+If you want to hide the \`${d}\`, you can wrap it with our VisuallyHidden component.
+
+For more information, see https://www.reka-ui.com/docs/components/${a}`, i = `Warning: Missing \`Description\` or \`aria-describedby="undefined"\` for ${l}.`;
+  A(() => {
+    var r;
+    document.getElementById(s) || console.warn(p);
+    const o = (r = u.value) == null ? void 0 : r.getAttribute("aria-describedby");
+    e && o && (document.getElementById(e) || console.warn(i));
+  });
+}
+const h = /* @__PURE__ */ v({
+  __name: "DialogContentImpl",
+  props: {
+    forceMount: { type: Boolean },
+    trapFocus: { type: Boolean },
+    disableOutsidePointerEvents: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "openAutoFocus", "closeAutoFocus"],
+  setup(d, { emit: l }) {
+    const a = d, s = l, e = E(), { forwardRef: u, currentElement: p } = O();
+    return e.titleId || (e.titleId = $(void 0, "reka-dialog-title")), e.descriptionId || (e.descriptionId = $(void 0, "reka-dialog-description")), A(() => {
+      e.contentElement = p, _() !== document.body && (e.triggerElement.value = _());
+    }), process.env.NODE_ENV !== "production" && H({
+      titleName: "DialogTitle",
+      contentName: "DialogContent",
+      componentLink: "dialog.html#title",
+      titleId: e.titleId,
+      descriptionId: e.descriptionId,
+      contentElement: p
+    }), (i, n) => (g(), m(t(R), {
+      "as-child": "",
+      loop: "",
+      trapped: a.trapFocus,
+      onMountAutoFocus: n[5] || (n[5] = (o) => s("openAutoFocus", o)),
+      onUnmountAutoFocus: n[6] || (n[6] = (o) => s("closeAutoFocus", o))
+    }, {
+      default: f(() => [
+        I(t(N), D({
+          id: t(e).contentId,
+          ref: t(u),
+          as: i.as,
+          "as-child": i.asChild,
+          "disable-outside-pointer-events": i.disableOutsidePointerEvents,
+          role: "dialog",
+          "aria-describedby": t(e).descriptionId,
+          "aria-labelledby": t(e).titleId,
+          "data-state": t(k)(t(e).open.value)
+        }, i.$attrs, {
+          onDismiss: n[0] || (n[0] = (o) => t(e).onOpenChange(!1)),
+          onEscapeKeyDown: n[1] || (n[1] = (o) => s("escapeKeyDown", o)),
+          onFocusOutside: n[2] || (n[2] = (o) => s("focusOutside", o)),
+          onInteractOutside: n[3] || (n[3] = (o) => s("interactOutside", o)),
+          onPointerDownOutside: n[4] || (n[4] = (o) => s("pointerDownOutside", o))
+        }), {
+          default: f(() => [
+            y(i.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["id", "as", "as-child", "disable-outside-pointer-events", "aria-describedby", "aria-labelledby", "data-state"])
+      ]),
+      _: 3
+    }, 8, ["trapped"]));
+  }
+}), j = /* @__PURE__ */ v({
+  __name: "DialogContentModal",
+  props: {
+    forceMount: { type: Boolean },
+    trapFocus: { type: Boolean },
+    disableOutsidePointerEvents: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "openAutoFocus", "closeAutoFocus"],
+  setup(d, { emit: l }) {
+    const a = d, s = l, e = E(), u = w(s), { forwardRef: p, currentElement: i } = O();
+    return S(i), (n, o) => (g(), m(h, D({ ...a, ...t(u) }, {
+      ref: t(p),
+      "trap-focus": t(e).open.value,
+      "disable-outside-pointer-events": !0,
+      onCloseAutoFocus: o[0] || (o[0] = (r) => {
+        var c;
+        r.defaultPrevented || (r.preventDefault(), (c = t(e).triggerElement.value) == null || c.focus());
+      }),
+      onPointerDownOutside: o[1] || (o[1] = (r) => {
+        const c = r.detail.originalEvent, B = c.button === 0 && c.ctrlKey === !0;
+        (c.button === 2 || B) && r.preventDefault();
+      }),
+      onFocusOutside: o[2] || (o[2] = (r) => {
+        r.preventDefault();
+      })
+    }), {
+      default: f(() => [
+        y(n.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["trap-focus"]));
+  }
+}), q = /* @__PURE__ */ v({
+  __name: "DialogContentNonModal",
+  props: {
+    forceMount: { type: Boolean },
+    trapFocus: { type: Boolean },
+    disableOutsidePointerEvents: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "openAutoFocus", "closeAutoFocus"],
+  setup(d, { emit: l }) {
+    const a = d, e = w(l);
+    O();
+    const u = E(), p = C(!1), i = C(!1);
+    return (n, o) => (g(), m(h, D({ ...a, ...t(e) }, {
+      "trap-focus": !1,
+      "disable-outside-pointer-events": !1,
+      onCloseAutoFocus: o[0] || (o[0] = (r) => {
+        var c;
+        r.defaultPrevented || (p.value || (c = t(u).triggerElement.value) == null || c.focus(), r.preventDefault()), p.value = !1, i.value = !1;
+      }),
+      onInteractOutside: o[1] || (o[1] = (r) => {
+        var b;
+        r.defaultPrevented || (p.value = !0, r.detail.originalEvent.type === "pointerdown" && (i.value = !0));
+        const c = r.target;
+        ((b = t(u).triggerElement.value) == null ? void 0 : b.contains(c)) && r.preventDefault(), r.detail.originalEvent.type === "focusin" && i.value && r.preventDefault();
+      })
+    }), {
+      default: f(() => [
+        y(n.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), ue = /* @__PURE__ */ v({
+  __name: "DialogContent",
+  props: {
+    forceMount: { type: Boolean },
+    trapFocus: { type: Boolean },
+    disableOutsidePointerEvents: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "openAutoFocus", "closeAutoFocus"],
+  setup(d, { emit: l }) {
+    const a = d, s = l, e = E(), u = w(s), { forwardRef: p } = O();
+    return (i, n) => (g(), m(t(P), {
+      present: i.forceMount || t(e).open.value
+    }, {
+      default: f(() => [
+        t(e).modal.value ? (g(), m(j, D({
+          key: 0,
+          ref: t(p)
+        }, { ...a, ...t(u), ...i.$attrs }), {
+          default: f(() => [
+            y(i.$slots, "default")
+          ]),
+          _: 3
+        }, 16)) : (g(), m(q, D({
+          key: 1,
+          ref: t(p)
+        }, { ...a, ...t(u), ...i.$attrs }), {
+          default: f(() => [
+            y(i.$slots, "default")
+          ]),
+          _: 3
+        }, 16))
+      ]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), z = /* @__PURE__ */ v({
+  __name: "DialogOverlayImpl",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(d) {
+    const l = E();
+    return K(!0), O(), (a, s) => (g(), m(t(F), {
+      as: a.as,
+      "as-child": a.asChild,
+      "data-state": t(l).open.value ? "open" : "closed",
+      style: { "pointer-events": "auto" }
+    }, {
+      default: f(() => [
+        y(a.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["as", "as-child", "data-state"]));
+  }
+}), de = /* @__PURE__ */ v({
+  __name: "DialogOverlay",
+  props: {
+    forceMount: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(d) {
+    const l = E(), { forwardRef: a } = O();
+    return (s, e) => {
+      var u;
+      return (u = t(l)) != null && u.modal.value ? (g(), m(t(P), {
+        key: 0,
+        present: s.forceMount || t(l).open.value
+      }, {
+        default: f(() => [
+          I(z, D(s.$attrs, {
+            ref: t(a),
+            as: s.as,
+            "as-child": s.asChild
+          }), {
+            default: f(() => [
+              y(s.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["as", "as-child"])
+        ]),
+        _: 3
+      }, 8, ["present"])) : T("", !0);
+    };
+  }
+});
+export {
+  re as _,
+  de as a,
+  ue as b,
+  le as c,
+  E as i
+};

package/dist/DialogPortal-zAvO8zt4.js

@@ -0,0 +1,23 @@
+import { defineComponent as r, createBlock as a, openBlock as n, unref as p, normalizeProps as s, guardReactiveProps as l, withCtx as c, renderSlot as f } from "vue";
+import { _ as i } from "./Teleport-DnUewq5H.js";
+const u = /* @__PURE__ */ r({
+  __name: "DialogPortal",
+  props: {
+    to: {},
+    disabled: { type: Boolean },
+    defer: { type: Boolean },
+    forceMount: { type: Boolean }
+  },
+  setup(e) {
+    const o = e;
+    return (t, _) => (n(), a(p(i), s(l(o)), {
+      default: c(() => [
+        f(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+});
+export {
+  u as _
+};

package/dist/DialogTrigger-BIF1A4hk.js

@@ -0,0 +1,72 @@
+import { defineComponent as s, createBlock as i, openBlock as l, unref as o, mergeProps as p, withCtx as d, renderSlot as u, onMounted as g } from "vue";
+import { u as c } from "./useForwardExpose-DZT6mL_U.js";
+import { P as f } from "./Primitive-B3twiLO1.js";
+import { i as m } from "./DialogOverlay-Cj3UTjZ8.js";
+import { u as h } from "./useId-reAg216X.js";
+const D = /* @__PURE__ */ s({
+  __name: "DialogDescription",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "p" }
+  },
+  setup(t) {
+    const a = t;
+    c();
+    const e = m();
+    return (n, r) => (l(), i(o(f), p(a, {
+      id: o(e).descriptionId
+    }), {
+      default: d(() => [
+        u(n.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["id"]));
+  }
+}), I = /* @__PURE__ */ s({
+  __name: "DialogTitle",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "h2" }
+  },
+  setup(t) {
+    const a = t, e = m();
+    return c(), (n, r) => (l(), i(o(f), p(a, {
+      id: o(e).titleId
+    }), {
+      default: d(() => [
+        u(n.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["id"]));
+  }
+}), $ = /* @__PURE__ */ s({
+  __name: "DialogTrigger",
+  props: {
+    asChild: { type: Boolean },
+    as: { default: "button" }
+  },
+  setup(t) {
+    const a = t, e = m(), { forwardRef: n, currentElement: r } = c();
+    return e.contentId || (e.contentId = h(void 0, "reka-dialog-content")), g(() => {
+      e.triggerElement.value = r.value;
+    }), (_, v) => (l(), i(o(f), p(a, {
+      ref: o(n),
+      type: _.as === "button" ? "button" : void 0,
+      "aria-haspopup": "dialog",
+      "aria-expanded": o(e).open.value || !1,
+      "aria-controls": o(e).open.value ? o(e).contentId : void 0,
+      "data-state": o(e).open.value ? "open" : "closed",
+      onClick: o(e).onOpenToggle
+    }), {
+      default: d(() => [
+        u(_.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["type", "aria-expanded", "aria-controls", "data-state", "onClick"]));
+  }
+});
+export {
+  D as _,
+  I as a,
+  $ as b
+};

package/dist/DismissableLayer-C7IJliOb.js

@@ -0,0 +1,151 @@
+import { ref as P, watchEffect as h, toValue as O, nextTick as L, defineComponent as B, reactive as T, computed as D, createBlock as F, openBlock as S, unref as E, normalizeStyle as x, withCtx as W, renderSlot as k } from "vue";
+import { i as b, o as I } from "./index-BwPb_idr.js";
+import { h as C } from "./handleAndDispatchCustomEvent-Byh08EHr.js";
+import { u as _ } from "./useForwardExpose-DZT6mL_U.js";
+import { P as A } from "./Primitive-B3twiLO1.js";
+const z = "dismissableLayer.pointerDownOutside", R = "dismissableLayer.focusOutside";
+function g(r, s) {
+  const n = s.closest(
+    "[data-dismissable-layer]"
+  ), t = r.dataset.dismissableLayer === "" ? r : r.querySelector(
+    "[data-dismissable-layer]"
+  ), o = Array.from(
+    r.ownerDocument.querySelectorAll("[data-dismissable-layer]")
+  );
+  return !!(n && (t === n || o.indexOf(t) < o.indexOf(n)));
+}
+function K(r, s, n = !0) {
+  var c;
+  const t = ((c = s == null ? void 0 : s.value) == null ? void 0 : c.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), o = P(!1), i = P(() => {
+  });
+  return h((a) => {
+    if (!b || !O(n))
+      return;
+    const u = async (v) => {
+      const w = v.target;
+      if (!(!(s != null && s.value) || !w)) {
+        if (g(s.value, w)) {
+          o.value = !1;
+          return;
+        }
+        if (v.target && !o.value) {
+          let p = function() {
+            C(
+              z,
+              r,
+              m
+            );
+          };
+          const m = { originalEvent: v };
+          v.pointerType === "touch" ? (t.removeEventListener("click", i.value), i.value = p, t.addEventListener("click", i.value, {
+            once: !0
+          })) : p();
+        } else
+          t.removeEventListener("click", i.value);
+        o.value = !1;
+      }
+    }, f = window.setTimeout(() => {
+      t.addEventListener("pointerdown", u);
+    }, 0);
+    a(() => {
+      window.clearTimeout(f), t.removeEventListener("pointerdown", u), t.removeEventListener("click", i.value);
+    });
+  }), {
+    onPointerDownCapture: () => {
+      O(n) && (o.value = !0);
+    }
+  };
+}
+function U(r, s, n = !0) {
+  var i;
+  const t = ((i = s == null ? void 0 : s.value) == null ? void 0 : i.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), o = P(!1);
+  return h((c) => {
+    if (!b || !O(n))
+      return;
+    const a = async (u) => {
+      if (!(s != null && s.value))
+        return;
+      await L(), await L();
+      const f = u.target;
+      !s.value || !f || g(s.value, f) || u.target && !o.value && C(
+        R,
+        r,
+        { originalEvent: u }
+      );
+    };
+    t.addEventListener("focusin", a), c(() => t.removeEventListener("focusin", a));
+  }), {
+    onFocusCapture: () => {
+      O(n) && (o.value = !0);
+    },
+    onBlurCapture: () => {
+      O(n) && (o.value = !1);
+    }
+  };
+}
+const d = T({
+  layersRoot: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), $ = /* @__PURE__ */ B({
+  __name: "DismissableLayer",
+  props: {
+    disableOutsidePointerEvents: { type: Boolean, default: !1 },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "dismiss"],
+  setup(r, { emit: s }) {
+    const n = r, t = s, { forwardRef: o, currentElement: i } = _(), c = D(
+      () => {
+        var e;
+        return ((e = i.value) == null ? void 0 : e.ownerDocument) ?? globalThis.document;
+      }
+    ), a = D(() => d.layersRoot), u = D(() => i.value ? Array.from(a.value).indexOf(i.value) : -1), f = D(() => d.layersWithOutsidePointerEventsDisabled.size > 0), v = D(() => {
+      const e = Array.from(a.value), [y] = [...d.layersWithOutsidePointerEventsDisabled].slice(-1), l = e.indexOf(y);
+      return u.value >= l;
+    }), w = K(async (e) => {
+      const y = [...d.branches].some(
+        (l) => l == null ? void 0 : l.contains(e.target)
+      );
+      !v.value || y || (t("pointerDownOutside", e), t("interactOutside", e), await L(), e.defaultPrevented || t("dismiss"));
+    }, i), p = U((e) => {
+      [...d.branches].some(
+        (l) => l == null ? void 0 : l.contains(e.target)
+      ) || (t("focusOutside", e), t("interactOutside", e), e.defaultPrevented || t("dismiss"));
+    }, i);
+    I("Escape", (e) => {
+      u.value === a.value.size - 1 && (t("escapeKeyDown", e), e.defaultPrevented || t("dismiss"));
+    });
+    let m;
+    return h((e) => {
+      i.value && (n.disableOutsidePointerEvents && (d.layersWithOutsidePointerEventsDisabled.size === 0 && (m = c.value.body.style.pointerEvents, c.value.body.style.pointerEvents = "none"), d.layersWithOutsidePointerEventsDisabled.add(i.value)), a.value.add(i.value), e(() => {
+        n.disableOutsidePointerEvents && d.layersWithOutsidePointerEventsDisabled.size === 1 && (c.value.body.style.pointerEvents = m);
+      }));
+    }), h((e) => {
+      e(() => {
+        i.value && (a.value.delete(i.value), d.layersWithOutsidePointerEventsDisabled.delete(i.value));
+      });
+    }), (e, y) => (S(), F(E(A), {
+      ref: E(o),
+      "as-child": e.asChild,
+      as: e.as,
+      "data-dismissable-layer": "",
+      style: x({
+        pointerEvents: f.value ? v.value ? "auto" : "none" : void 0
+      }),
+      onFocusCapture: E(p).onFocusCapture,
+      onBlurCapture: E(p).onBlurCapture,
+      onPointerdownCapture: E(w).onPointerDownCapture
+    }, {
+      default: W(() => [
+        k(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["as-child", "as", "style", "onFocusCapture", "onBlurCapture", "onPointerdownCapture"]));
+  }
+});
+export {
+  $ as _,
+  d as c
+};

package/dist/FocusScope--pJ6bboI.js

@@ -0,0 +1,121 @@
+import { ref as g, defineComponent as L, reactive as A, watchEffect as y, nextTick as _, createBlock as S, openBlock as w, unref as K, withCtx as N, renderSlot as x } from "vue";
+import { d as U, i as B } from "./index-BwPb_idr.js";
+import { A as v, f as P, g as D, a as i, b as E, E as T, c as I } from "./utils-DKNaYMZh.js";
+import { u as M } from "./useForwardExpose-DZT6mL_U.js";
+import { g as h } from "./getActiveElement-B-HWdUIb.js";
+import { P as R } from "./Primitive-B3twiLO1.js";
+const G = U(() => g([]));
+function H() {
+  const n = G();
+  return {
+    add(o) {
+      const s = n.value[0];
+      o !== s && (s == null || s.pause()), n.value = O(n.value, o), n.value.unshift(o);
+    },
+    remove(o) {
+      var s;
+      n.value = O(n.value, o), (s = n.value[0]) == null || s.resume();
+    }
+  };
+}
+function O(n, o) {
+  const s = [...n], l = s.indexOf(o);
+  return l !== -1 && s.splice(l, 1), s;
+}
+function V(n) {
+  return n.filter((o) => o.tagName !== "A");
+}
+const W = /* @__PURE__ */ L({
+  __name: "FocusScope",
+  props: {
+    loop: { type: Boolean, default: !1 },
+    trapped: { type: Boolean, default: !1 },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["mountAutoFocus", "unmountAutoFocus"],
+  setup(n, { emit: o }) {
+    const s = n, l = o, { currentRef: k, currentElement: b } = M(), p = g(null), F = H(), m = A({
+      paused: !1,
+      pause() {
+        this.paused = !0;
+      },
+      resume() {
+        this.paused = !1;
+      }
+    });
+    y((t) => {
+      if (!B)
+        return;
+      const e = b.value;
+      if (!s.trapped)
+        return;
+      function a(c) {
+        if (m.paused || !e)
+          return;
+        const f = c.target;
+        e.contains(f) ? p.value = f : i(p.value, { select: !0 });
+      }
+      function d(c) {
+        if (m.paused || !e)
+          return;
+        const f = c.relatedTarget;
+        f !== null && (e.contains(f) || i(p.value, { select: !0 }));
+      }
+      function u(c) {
+        e.contains(p.value) || i(e);
+      }
+      document.addEventListener("focusin", a), document.addEventListener("focusout", d);
+      const r = new MutationObserver(u);
+      e && r.observe(e, { childList: !0, subtree: !0 }), t(() => {
+        document.removeEventListener("focusin", a), document.removeEventListener("focusout", d), r.disconnect();
+      });
+    }), y(async (t) => {
+      const e = b.value;
+      if (await _(), !e)
+        return;
+      F.add(m);
+      const a = h();
+      if (!e.contains(a)) {
+        const u = new CustomEvent(v, T);
+        e.addEventListener(v, (r) => l("mountAutoFocus", r)), e.dispatchEvent(u), u.defaultPrevented || (P(V(D(e)), {
+          select: !0
+        }), h() === a && i(e));
+      }
+      t(() => {
+        e.removeEventListener(v, (c) => l("mountAutoFocus", c));
+        const u = new CustomEvent(E, T), r = (c) => {
+          l("unmountAutoFocus", c);
+        };
+        e.addEventListener(E, r), e.dispatchEvent(u), setTimeout(() => {
+          u.defaultPrevented || i(a ?? document.body, { select: !0 }), e.removeEventListener(E, r), F.remove(m);
+        }, 0);
+      });
+    });
+    function C(t) {
+      if (!s.loop && !s.trapped || m.paused)
+        return;
+      const e = t.key === "Tab" && !t.altKey && !t.ctrlKey && !t.metaKey, a = h();
+      if (e && a) {
+        const d = t.currentTarget, [u, r] = I(d);
+        u && r ? !t.shiftKey && a === r ? (t.preventDefault(), s.loop && i(u, { select: !0 })) : t.shiftKey && a === u && (t.preventDefault(), s.loop && i(r, { select: !0 })) : a === d && t.preventDefault();
+      }
+    }
+    return (t, e) => (w(), S(K(R), {
+      ref_key: "currentRef",
+      ref: k,
+      tabindex: "-1",
+      "as-child": t.asChild,
+      as: t.as,
+      onKeydown: C
+    }, {
+      default: N(() => [
+        x(t.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["as-child", "as"]));
+  }
+});
+export {
+  W as _
+};