@serendie/ui 3.2.0 → 3.2.1-dev.202604251106

package/dist/node_modules/@zag-js/dom-query/dist/tabbable.js

@@ -0,0 +1,110 @@
+import { isHTMLElement as h, isElementVisible as T, isInputElement as v, isEditableElement as w } from "./node.js";
+var y = (t) => h(t) && t.tagName === "IFRAME", N = /^(audio|video|details)$/;
+function A(t) {
+  const s = t.getAttribute("tabindex");
+  return s ? parseInt(s, 10) : NaN;
+}
+var S = (t) => !Number.isNaN(A(t)), R = (t) => A(t) < 0;
+function D(t) {
+  return v(t) && t.type === "radio";
+}
+function B(t) {
+  if (!D(t) || !t.name || t.checked) return !0;
+  const s = `input[type="radio"][name="${CSS.escape(t.name)}"]`, o = t.form ?? t.ownerDocument, e = Array.from(o.querySelectorAll(s)).filter(
+    (i) => i.form === t.form && d(i)
+  ), r = e.find((i) => i.checked);
+  return r ? r === t : e[0] === t;
+}
+function F(t, s) {
+  if (!s) return null;
+  if (s === !0)
+    return t.shadowRoot || null;
+  const o = s(t);
+  return (o === !0 ? t.shadowRoot : o) || null;
+}
+function x(t, s, o) {
+  const e = [...t], r = [...t], i = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
+  t.forEach((a, b) => n.set(a, b));
+  let u = 0;
+  for (; u < r.length; ) {
+    const a = r[u++];
+    if (!a || i.has(a)) continue;
+    i.add(a);
+    const b = F(a, s);
+    if (b) {
+      const l = Array.from(b.querySelectorAll(m)).filter(o), E = n.get(a);
+      if (E !== void 0) {
+        const f = E + 1;
+        e.splice(f, 0, ...l), l.forEach((c, p) => {
+          n.set(c, f + p);
+        });
+        for (let c = f + l.length; c < e.length; c++)
+          n.set(e[c], c);
+      } else {
+        const f = e.length;
+        e.push(...l), l.forEach((c, p) => {
+          n.set(c, f + p);
+        });
+      }
+      r.push(...l);
+    }
+  }
+  return e;
+}
+var m = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type", M = (t, s = {}) => {
+  if (!t) return [];
+  const { includeContainer: o = !1, getShadowRoot: e } = s, r = Array.from(t.querySelectorAll(m));
+  (o == !0 || o == "if-empty" && r.length === 0) && h(t) && d(t) && r.unshift(t);
+  const n = [];
+  for (const u of r)
+    if (d(u)) {
+      if (y(u) && u.contentDocument) {
+        const a = u.contentDocument.body;
+        n.push(...M(a, { getShadowRoot: e }));
+        continue;
+      }
+      n.push(u);
+    }
+  return e ? x(n, e, d) : n;
+};
+function d(t) {
+  return !h(t) || t.closest("[inert]") ? !1 : t.matches(m) && T(t);
+}
+function I(t, s = {}) {
+  if (!t) return [];
+  const { includeContainer: o, getShadowRoot: e } = s, r = Array.from(t.querySelectorAll(m));
+  o && g(t) && r.unshift(t);
+  const i = [];
+  for (const n of r)
+    if (g(n)) {
+      if (y(n) && n.contentDocument) {
+        const u = n.contentDocument.body;
+        i.push(...I(u, { getShadowRoot: e }));
+        continue;
+      }
+      i.push(n);
+    }
+  if (e) {
+    const n = x(i, e, g);
+    return !n.length && o ? r : n;
+  }
+  return !i.length && o ? r : i;
+}
+function g(t) {
+  return h(t) && t.tabIndex > 0 ? !0 : !d(t) || R(t) ? !1 : B(t);
+}
+function L(t, s = {}) {
+  const o = I(t, s), e = o[0] || null, r = o[o.length - 1] || null;
+  return [e, r];
+}
+function k(t) {
+  return t.tabIndex < 0 && (N.test(t.localName) || w(t)) && !S(t) ? 0 : t.tabIndex;
+}
+export {
+  M as getFocusables,
+  k as getTabIndex,
+  L as getTabbableEdges,
+  I as getTabbables,
+  d as isFocusable,
+  g as isTabbable
+};

package/dist/node_modules/@zag-js/dom-query/dist/text-selection.js

@@ -0,0 +1,36 @@
+import { isIos as d } from "./platform.js";
+import { raf as a, nextTick as f } from "./raf.js";
+var n = "default", u = "", i = /* @__PURE__ */ new WeakMap();
+function m(r = {}) {
+  const { target: e, doc: t } = r, c = t ?? document, o = c.documentElement;
+  return d() ? (n === "default" && (u = o.style.webkitUserSelect, o.style.webkitUserSelect = "none"), n = "disabled") : e && (i.set(e, e.style.userSelect), e.style.userSelect = "none"), () => S({ target: e, doc: c });
+}
+function S(r = {}) {
+  const { target: e, doc: t } = r, o = (t ?? document).documentElement;
+  if (d()) {
+    if (n !== "disabled") return;
+    n = "restoring", setTimeout(() => {
+      f(() => {
+        n === "restoring" && (o.style.webkitUserSelect === "none" && (o.style.webkitUserSelect = u || ""), u = "", n = "default");
+      });
+    }, 300);
+  } else if (e && i.has(e)) {
+    const l = i.get(e);
+    e.style.userSelect === "none" && (e.style.userSelect = l ?? ""), e.getAttribute("style") === "" && e.removeAttribute("style"), i.delete(e);
+  }
+}
+function b(r = {}) {
+  const { defer: e, target: t, ...c } = r, o = e ? a : (s) => s(), l = [];
+  return l.push(
+    o(() => {
+      const s = typeof t == "function" ? t() : t;
+      l.push(m({ ...c, target: s }));
+    })
+  ), () => {
+    l.forEach((s) => s == null ? void 0 : s());
+  };
+}
+export {
+  b as disableTextSelection,
+  S as restoreTextSelection
+};

package/dist/node_modules/@zag-js/dom-query/dist/typeahead.js

@@ -0,0 +1,25 @@
+import { getByText as l } from "./searchable.js";
+function f(t, o) {
+  const { state: i, activeId: s, key: c, timeout: y = 350, itemToId: m } = o, e = i.keysSoFar + c, u = e.length > 1 && Array.from(e).every((a) => a === e[0]) ? e[0] : e;
+  let d = t.slice();
+  const p = l(d, u, s, m);
+  function r() {
+    clearTimeout(i.timer), i.timer = -1;
+  }
+  function n(a) {
+    i.keysSoFar = a, r(), a !== "" && (i.timer = +setTimeout(() => {
+      n(""), r();
+    }, y));
+  }
+  return n(e), p;
+}
+var k = /* @__PURE__ */ Object.assign(f, {
+  defaultOptions: { keysSoFar: "", timer: -1 },
+  isValidEvent: T
+});
+function T(t) {
+  return t.key.length === 1 && !t.ctrlKey && !t.metaKey;
+}
+export {
+  k as getByTypeahead
+};

package/dist/node_modules/@zag-js/dom-query/dist/visually-hidden.js

@@ -0,0 +1,15 @@
+var e = {
+  border: "0",
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: "0",
+  position: "absolute",
+  width: "1px",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+};
+export {
+  e as visuallyHiddenStyle
+};

package/dist/node_modules/@zag-js/dom-query/dist/wait-for.js

@@ -0,0 +1,42 @@
+import { getWindow as u, getDocument as b } from "./node.js";
+function w(n, i, s) {
+  const { signal: o } = i;
+  return [new Promise((a, e) => {
+    const t = setTimeout(() => {
+      e(new Error(`Timeout of ${s}ms exceeded`));
+    }, s);
+    o.addEventListener("abort", () => {
+      clearTimeout(t), e(new DOMException("Promise aborted", "AbortError"));
+    }), n.then((r) => {
+      o.aborted || (clearTimeout(t), a(r));
+    }).catch((r) => {
+      o.aborted || (clearTimeout(t), e(r));
+    });
+  }), () => i.abort()];
+}
+function f(n, i) {
+  const { timeout: s, rootNode: o } = i, c = u(o), m = b(o), a = new c.AbortController();
+  return w(
+    new Promise((e) => {
+      const t = n();
+      if (t) {
+        e(t);
+        return;
+      }
+      const r = new c.MutationObserver(() => {
+        const d = n();
+        d && d.isConnected && (r.disconnect(), e(d));
+      });
+      r.observe(m.body, {
+        childList: !0,
+        subtree: !0
+      });
+    }),
+    a,
+    s
+  );
+}
+export {
+  f as waitForElement,
+  w as waitForPromise
+};

package/dist/node_modules/@zag-js/focus-trap/dist/chunk-QZ7TP4HQ.js

@@ -0,0 +1,4 @@
+var a = Object.defineProperty, i = (e, r, t) => r in e ? a(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t, l = (e, r, t) => i(e, typeof r != "symbol" ? r + "" : r, t);
+export {
+  l as __publicField
+};

package/dist/node_modules/@zag-js/focus-trap/dist/focus-trap.js

@@ -0,0 +1,335 @@
+import { __publicField as l } from "./chunk-QZ7TP4HQ.js";
+import { getDocument as E, getActiveElement as m, isDocument as O } from "../../dom-query/dist/node.js";
+import { getControlledElements as I, isControlledElement as k, hasControllerElements as D, isControlledByExpandedController as R } from "../../dom-query/dist/controller.js";
+import { getTabbables as G, getFocusables as P, getTabIndex as g, isTabbable as v, isFocusable as y } from "../../dom-query/dist/tabbable.js";
+import { addDomEvent as p, getEventTarget as F } from "../../dom-query/dist/event.js";
+var w = {
+  activateTrap(e, o) {
+    if (e.length > 0) {
+      const t = e[e.length - 1];
+      t !== o && t.pause();
+    }
+    const c = e.indexOf(o);
+    c === -1 || e.splice(c, 1), e.push(o);
+  },
+  deactivateTrap(e, o) {
+    const c = e.indexOf(o);
+    c !== -1 && e.splice(c, 1), e.length > 0 && e[e.length - 1].unpause();
+  }
+}, B = [], q = class {
+  constructor(e, o) {
+    l(this, "trapStack"), l(this, "config"), l(this, "doc"), l(this, "state", {
+      containers: [],
+      containerGroups: [],
+      tabbableGroups: [],
+      nodeFocusedBeforeActivation: null,
+      mostRecentlyFocusedNode: null,
+      active: !1,
+      paused: !1,
+      delayInitialFocusTimer: void 0,
+      recentNavEvent: void 0
+    }), l(this, "portalContainers", /* @__PURE__ */ new Set()), l(this, "listenerCleanups", []), l(this, "handleFocus", (t) => {
+      const s = F(t), r = this.findContainerIndex(s, t) >= 0;
+      if (r || O(s))
+        r && (this.state.mostRecentlyFocusedNode = s);
+      else {
+        t.stopImmediatePropagation();
+        let a, n = !0;
+        if (this.state.mostRecentlyFocusedNode)
+          if (g(this.state.mostRecentlyFocusedNode) > 0) {
+            const h = this.findContainerIndex(this.state.mostRecentlyFocusedNode), { tabbableNodes: i } = this.state.containerGroups[h];
+            if (i.length > 0) {
+              const d = i.findIndex((u) => u === this.state.mostRecentlyFocusedNode);
+              d >= 0 && (this.config.isKeyForward(this.state.recentNavEvent) ? d + 1 < i.length && (a = i[d + 1], n = !1) : d - 1 >= 0 && (a = i[d - 1], n = !1));
+            }
+          } else
+            this.state.containerGroups.some((h) => h.tabbableNodes.some((i) => g(i) > 0)) || (n = !1);
+        else
+          n = !1;
+        n && (a = this.findNextNavNode({
+          // move FROM the MRU node, not event-related node (which will be the node that is
+          //  outside the trap causing the focus escape we're trying to fix)
+          target: this.state.mostRecentlyFocusedNode,
+          isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+        })), a ? this.tryFocus(a) : this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+      }
+      this.state.recentNavEvent = void 0;
+    }), l(this, "handlePointerDown", (t) => {
+      const s = F(t);
+      if (!(this.findContainerIndex(s, t) >= 0)) {
+        if (N(this.config.clickOutsideDeactivates, t)) {
+          this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+          return;
+        }
+        N(this.config.allowOutsideClick, t) || t.preventDefault();
+      }
+    }), l(this, "handleClick", (t) => {
+      const s = F(t);
+      this.findContainerIndex(s, t) >= 0 || N(this.config.clickOutsideDeactivates, t) || N(this.config.allowOutsideClick, t) || (t.preventDefault(), t.stopImmediatePropagation());
+    }), l(this, "handleTabKey", (t) => {
+      if (this.config.isKeyForward(t) || this.config.isKeyBackward(t)) {
+        this.state.recentNavEvent = t;
+        const s = this.config.isKeyBackward(t), r = this.findNextNavNode({ event: t, isBackward: s });
+        if (!r) return;
+        T(t) && t.preventDefault(), this.tryFocus(r);
+      }
+    }), l(this, "handleEscapeKey", (t) => {
+      L(t) && N(this.config.escapeDeactivates, t) !== !1 && (t.preventDefault(), this.deactivate());
+    }), l(this, "_mutationObserver"), l(this, "setupMutationObserver", () => {
+      const t = this.doc.defaultView || window;
+      this._mutationObserver = new t.MutationObserver((s) => {
+        s.some((n) => Array.from(n.removedNodes).some((i) => i === this.state.mostRecentlyFocusedNode)) && this.tryFocus(this.getInitialFocusNode()), s.some((n) => n.type === "attributes" && (n.attributeName === "aria-controls" || n.attributeName === "aria-expanded") ? !0 : n.type === "childList" && n.addedNodes.length > 0 ? Array.from(n.addedNodes).some((h) => {
+          if (h.nodeType !== Node.ELEMENT_NODE) return !1;
+          const i = h;
+          return D(i) ? !0 : i.id && !this.state.containers.some((d) => d.contains(i)) ? R(i) : !1;
+        }) : !1) && this.state.active && !this.state.paused && (this.updateTabbableNodes(), this.updatePortalContainers());
+      });
+    }), l(this, "updateObservedNodes", () => {
+      var t;
+      (t = this._mutationObserver) == null || t.disconnect(), this.state.active && !this.state.paused && (this.state.containers.map((s) => {
+        var r;
+        (r = this._mutationObserver) == null || r.observe(s, {
+          subtree: !0,
+          childList: !0,
+          attributes: !0,
+          attributeFilter: ["aria-controls", "aria-expanded"]
+        });
+      }), this.portalContainers.forEach((s) => {
+        this.observePortalContainer(s);
+      }));
+    }), l(this, "getInitialFocusNode", () => {
+      let t = this.getNodeForOption("initialFocus", { hasFallback: !0 });
+      if (t === !1)
+        return !1;
+      if (t === void 0 || t && !y(t)) {
+        const s = m(this.doc);
+        if (s && this.findContainerIndex(s) >= 0)
+          t = s;
+        else {
+          const r = this.state.tabbableGroups[0];
+          t = r && r.firstTabbableNode || this.getNodeForOption("fallbackFocus");
+        }
+      } else t === null && (t = this.getNodeForOption("fallbackFocus"));
+      if (!t)
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      if (t.isConnected || (t = this.getNodeForOption("fallbackFocus")), !t || !t.isConnected)
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      return t;
+    }), l(this, "tryFocus", (t) => {
+      if (t !== !1 && t !== m(this.doc)) {
+        if (!t || !t.focus) {
+          this.tryFocus(this.getInitialFocusNode());
+          return;
+        }
+        t.focus({ preventScroll: !!this.config.preventScroll }), this.state.mostRecentlyFocusedNode = t, _(t) && t.select();
+      }
+    }), l(this, "deactivate", (t) => {
+      if (!this.state.active) return this;
+      const s = {
+        onDeactivate: this.config.onDeactivate,
+        onPostDeactivate: this.config.onPostDeactivate,
+        checkCanReturnFocus: this.config.checkCanReturnFocus,
+        ...t
+      };
+      clearTimeout(this.state.delayInitialFocusTimer), this.state.delayInitialFocusTimer = void 0, this.removeListeners(), this.state.active = !1, this.state.paused = !1, this.updateObservedNodes(), w.deactivateTrap(this.trapStack, this), this.portalContainers.clear();
+      const r = this.getOption(s, "onDeactivate"), a = this.getOption(s, "onPostDeactivate"), n = this.getOption(s, "checkCanReturnFocus"), h = this.getOption(s, "returnFocus", "returnFocusOnDeactivate");
+      r == null || r();
+      const i = () => {
+        x(() => {
+          if (h) {
+            const d = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+            this.tryFocus(d);
+          }
+          a == null || a();
+        });
+      };
+      if (h && n) {
+        const d = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+        return n(d).then(i, i), this;
+      }
+      return i(), this;
+    }), l(this, "pause", (t) => {
+      if (this.state.paused || !this.state.active)
+        return this;
+      const s = this.getOption(t, "onPause"), r = this.getOption(t, "onPostPause");
+      return this.state.paused = !0, s == null || s(), this.removeListeners(), this.updateObservedNodes(), r == null || r(), this;
+    }), l(this, "unpause", (t) => {
+      if (!this.state.paused || !this.state.active)
+        return this;
+      const s = this.getOption(t, "onUnpause"), r = this.getOption(t, "onPostUnpause");
+      return this.state.paused = !1, s == null || s(), this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), r == null || r(), this;
+    }), l(this, "updateContainerElements", (t) => (this.state.containers = Array.isArray(t) ? t.filter(Boolean) : [t].filter(Boolean), this.state.active && this.updateTabbableNodes(), this.updateObservedNodes(), this)), l(this, "getReturnFocusNode", (t) => {
+      const s = this.getNodeForOption("setReturnFocus", {
+        params: [t]
+      });
+      return s || (s === !1 ? !1 : t);
+    }), l(this, "getOption", (t, s, r) => t && t[s] !== void 0 ? t[s] : (
+      // @ts-expect-error
+      this.config[r || s]
+    )), l(this, "getNodeForOption", (t, { hasFallback: s = !1, params: r = [] } = {}) => {
+      let a = this.config[t];
+      if (typeof a == "function" && (a = a(...r)), a === !0 && (a = void 0), !a) {
+        if (a === void 0 || a === !1)
+          return a;
+        throw new Error(`\`${t}\` was specified but was not a node, or did not return a node`);
+      }
+      let n = a;
+      if (typeof a == "string") {
+        try {
+          n = this.doc.querySelector(a);
+        } catch (h) {
+          throw new Error(`\`${t}\` appears to be an invalid selector; error="${h.message}"`);
+        }
+        if (!n && !s)
+          throw new Error(`\`${t}\` as selector refers to no known node`);
+      }
+      return n;
+    }), l(this, "findNextNavNode", (t) => {
+      const { event: s, isBackward: r = !1 } = t, a = t.target || F(s);
+      this.updateTabbableNodes();
+      let n = null;
+      if (this.state.tabbableGroups.length > 0) {
+        const h = this.findContainerIndex(a, s), i = h >= 0 ? this.state.containerGroups[h] : void 0;
+        if (h < 0)
+          r ? n = this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode : n = this.state.tabbableGroups[0].firstTabbableNode;
+        else if (r) {
+          let d = this.state.tabbableGroups.findIndex(
+            ({ firstTabbableNode: u }) => a === u
+          );
+          if (d < 0 && ((i == null ? void 0 : i.container) === a || y(a) && !v(a) && !(i != null && i.nextTabbableNode(a, !1))) && (d = h), d >= 0) {
+            const u = d === 0 ? this.state.tabbableGroups.length - 1 : d - 1, f = this.state.tabbableGroups[u];
+            n = g(a) >= 0 ? f.lastTabbableNode : f.lastDomTabbableNode;
+          } else T(s) || (n = i == null ? void 0 : i.nextTabbableNode(a, !1));
+        } else {
+          let d = this.state.tabbableGroups.findIndex(
+            ({ lastTabbableNode: u }) => a === u
+          );
+          if (d < 0 && ((i == null ? void 0 : i.container) === a || y(a) && !v(a) && !(i != null && i.nextTabbableNode(a))) && (d = h), d >= 0) {
+            const u = d === this.state.tabbableGroups.length - 1 ? 0 : d + 1, f = this.state.tabbableGroups[u];
+            n = g(a) >= 0 ? f.firstTabbableNode : f.firstDomTabbableNode;
+          } else T(s) || (n = i == null ? void 0 : i.nextTabbableNode(a));
+        }
+      } else
+        n = this.getNodeForOption("fallbackFocus");
+      return n;
+    }), this.trapStack = o.trapStack || B;
+    const c = {
+      returnFocusOnDeactivate: !0,
+      escapeDeactivates: !0,
+      delayInitialFocus: !0,
+      followControlledElements: !0,
+      isKeyForward: K,
+      isKeyBackward: A,
+      ...o
+    };
+    this.doc = c.document || E(Array.isArray(e) ? e[0] : e), this.config = c, this.updateContainerElements(e), this.setupMutationObserver();
+  }
+  addPortalContainer(e) {
+    const o = e.parentElement;
+    o && !this.portalContainers.has(o) && (this.portalContainers.add(o), this.state.active && !this.state.paused && this.observePortalContainer(o));
+  }
+  observePortalContainer(e) {
+    var o;
+    (o = this._mutationObserver) == null || o.observe(e, {
+      subtree: !0,
+      childList: !0,
+      attributes: !0,
+      attributeFilter: ["aria-controls", "aria-expanded"]
+    });
+  }
+  updatePortalContainers() {
+    this.config.followControlledElements && this.state.containers.forEach((e) => {
+      I(e).forEach((c) => {
+        this.addPortalContainer(c);
+      });
+    });
+  }
+  get active() {
+    return this.state.active;
+  }
+  get paused() {
+    return this.state.paused;
+  }
+  findContainerIndex(e, o) {
+    const c = typeof (o == null ? void 0 : o.composedPath) == "function" ? o.composedPath() : void 0;
+    return this.state.containerGroups.findIndex(
+      ({ container: t, tabbableNodes: s }) => t.contains(e) || (c == null ? void 0 : c.includes(t)) || s.find((r) => r === e) || this.isControlledElement(t, e)
+    );
+  }
+  isControlledElement(e, o) {
+    return this.config.followControlledElements ? k(e, o) : !1;
+  }
+  updateTabbableNodes() {
+    if (this.state.containerGroups = this.state.containers.map((e) => {
+      const o = G(e, { getShadowRoot: this.config.getShadowRoot }), c = P(e, { getShadowRoot: this.config.getShadowRoot }), t = o[0], s = o[o.length - 1], r = t, a = s;
+      let n = !1;
+      for (let i = 0; i < o.length; i++)
+        if (g(o[i]) > 0) {
+          n = !0;
+          break;
+        }
+      function h(i, d = !0) {
+        const u = o.indexOf(i);
+        if (u >= 0)
+          return o[u + (d ? 1 : -1)];
+        const f = c.indexOf(i);
+        if (!(f < 0)) {
+          if (d) {
+            for (let b = f + 1; b < c.length; b++)
+              if (v(c[b])) return c[b];
+          } else
+            for (let b = f - 1; b >= 0; b--)
+              if (v(c[b])) return c[b];
+        }
+      }
+      return {
+        container: e,
+        tabbableNodes: o,
+        focusableNodes: c,
+        posTabIndexesFound: n,
+        firstTabbableNode: t,
+        lastTabbableNode: s,
+        firstDomTabbableNode: r,
+        lastDomTabbableNode: a,
+        nextTabbableNode: h
+      };
+    }), this.state.tabbableGroups = this.state.containerGroups.filter((e) => e.tabbableNodes.length > 0), this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("fallbackFocus"))
+      throw new Error(
+        "Your focus-trap must have at least one container with at least one tabbable node in it at all times"
+      );
+    if (this.state.containerGroups.find((e) => e.posTabIndexesFound) && this.state.containerGroups.length > 1)
+      throw new Error(
+        "At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps."
+      );
+  }
+  addListeners() {
+    if (this.state.active)
+      return w.activateTrap(this.trapStack, this), this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? x(() => {
+        this.tryFocus(this.getInitialFocusNode());
+      }) : this.tryFocus(this.getInitialFocusNode()), this.listenerCleanups.push(
+        p(this.doc, "focusin", this.handleFocus, !0),
+        p(this.doc, "mousedown", this.handlePointerDown, { capture: !0, passive: !1 }),
+        p(this.doc, "touchstart", this.handlePointerDown, { capture: !0, passive: !1 }),
+        p(this.doc, "click", this.handleClick, { capture: !0, passive: !1 }),
+        p(this.doc, "keydown", this.handleTabKey, { capture: !0, passive: !1 }),
+        p(this.doc, "keydown", this.handleEscapeKey)
+      ), this;
+  }
+  removeListeners() {
+    if (this.state.active)
+      return this.listenerCleanups.forEach((e) => e()), this.listenerCleanups = [], this;
+  }
+  activate(e) {
+    if (this.state.active)
+      return this;
+    const o = this.getOption(e, "onActivate"), c = this.getOption(e, "onPostActivate"), t = this.getOption(e, "checkCanFocusTrap");
+    t || this.updateTabbableNodes(), this.state.active = !0, this.state.paused = !1, this.state.nodeFocusedBeforeActivation = m(this.doc), o == null || o();
+    const s = () => {
+      t && this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), c == null || c();
+    };
+    return t ? (t(this.state.containers.concat()).then(s, s), this) : (s(), this);
+  }
+}, C = (e) => (e == null ? void 0 : e.type) === "keydown", T = (e) => C(e) && (e == null ? void 0 : e.key) === "Tab", K = (e) => C(e) && e.key === "Tab" && !(e != null && e.shiftKey), A = (e) => C(e) && e.key === "Tab" && (e == null ? void 0 : e.shiftKey), N = (e, ...o) => typeof e == "function" ? e(...o) : e, L = (e) => !e.isComposing && e.key === "Escape", x = (e) => setTimeout(e, 0), _ = (e) => e.localName === "input" && "select" in e && typeof e.select == "function";
+export {
+  q as FocusTrap
+};