bitboss-ui 2.0.110 → 2.0.111

package/dist/index294.js

@@ -1,438 +1,433 @@
-import { evaluate as F, getSide as M, getSideAxis as j, getOppositePlacement as Q, getExpandedPlacements as U, getOppositeAxisPlacements as Z, getAlignmentSides as ee, clamp as Y, getPaddingObject as G, rectToClientRect as _, getAlignmentAxis as J, getAlignment as X, sides as te, getOppositeAxis as ne, getAxisLength as K, min as z } from "./index295.js";
-function I(t, e, f) {
-  let {
-    reference: s,
-    floating: a
-  } = t;
-  const n = j(e), o = J(e), c = K(o), u = M(e), g = n === "y", d = s.x + s.width / 2 - a.width / 2, r = s.y + s.height / 2 - a.height / 2, m = s[c] / 2 - a[c] / 2;
-  let i;
-  switch (u) {
-    case "top":
-      i = {
-        x: d,
-        y: s.y - a.height
-      };
-      break;
-    case "bottom":
-      i = {
-        x: d,
-        y: s.y + s.height
-      };
-      break;
-    case "right":
-      i = {
-        x: s.x + s.width,
-        y: r
-      };
-      break;
-    case "left":
-      i = {
-        x: s.x - a.width,
-        y: r
-      };
-      break;
-    default:
-      i = {
-        x: s.x,
-        y: s.y
-      };
-  }
-  switch (X(e)) {
-    case "start":
-      i[o] -= m * (f && g ? -1 : 1);
-      break;
-    case "end":
-      i[o] += m * (f && g ? -1 : 1);
-      break;
+import { isFocusable as G, tabbable as te, focusable as ae, isTabbable as T, getTabIndex as K } from "./index301.js";
+/*!
+* focus-trap 7.5.4
+* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+*/
+function z(u, a) {
+  var o = Object.keys(u);
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(u);
+    a && (i = i.filter(function(m) {
+      return Object.getOwnPropertyDescriptor(u, m).enumerable;
+    })), o.push.apply(o, i);
   }
-  return i;
+  return o;
 }
-const oe = async (t, e, f) => {
-  const {
-    placement: s = "bottom",
-    strategy: a = "absolute",
-    middleware: n = [],
-    platform: o
-  } = f, c = n.filter(Boolean), u = await (o.isRTL == null ? void 0 : o.isRTL(e));
-  let g = await o.getElementRects({
-    reference: t,
-    floating: e,
-    strategy: a
-  }), {
-    x: d,
-    y: r
-  } = I(g, s, u), m = s, i = {}, l = 0;
-  for (let w = 0; w < c.length; w++) {
-    const {
-      name: x,
-      fn: h
-    } = c[w], {
-      x: y,
-      y: v,
-      data: b,
-      reset: p
-    } = await h({
-      x: d,
-      y: r,
-      initialPlacement: s,
-      placement: m,
-      strategy: a,
-      middlewareData: i,
-      rects: g,
-      platform: o,
-      elements: {
-        reference: t,
-        floating: e
-      }
+function J(u) {
+  for (var a = 1; a < arguments.length; a++) {
+    var o = arguments[a] != null ? arguments[a] : {};
+    a % 2 ? z(Object(o), !0).forEach(function(i) {
+      ne(u, i, o[i]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(u, Object.getOwnPropertyDescriptors(o)) : z(Object(o)).forEach(function(i) {
+      Object.defineProperty(u, i, Object.getOwnPropertyDescriptor(o, i));
     });
-    d = y ?? d, r = v ?? r, i = {
-      ...i,
-      [x]: {
-        ...i[x],
-        ...b
-      }
-    }, p && l <= 50 && (l++, typeof p == "object" && (p.placement && (m = p.placement), p.rects && (g = p.rects === !0 ? await o.getElementRects({
-      reference: t,
-      floating: e,
-      strategy: a
-    }) : p.rects), {
-      x: d,
-      y: r
-    } = I(g, m, u)), w = -1);
   }
-  return {
-    x: d,
-    y: r,
-    placement: m,
-    strategy: a,
-    middlewareData: i
-  };
-};
-async function $(t, e) {
-  var f;
-  e === void 0 && (e = {});
-  const {
-    x: s,
-    y: a,
-    platform: n,
-    rects: o,
-    elements: c,
-    strategy: u
-  } = t, {
-    boundary: g = "clippingAncestors",
-    rootBoundary: d = "viewport",
-    elementContext: r = "floating",
-    altBoundary: m = !1,
-    padding: i = 0
-  } = F(e, t), l = G(i), x = c[m ? r === "floating" ? "reference" : "floating" : r], h = _(await n.getClippingRect({
-    element: (f = await (n.isElement == null ? void 0 : n.isElement(x))) == null || f ? x : x.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(c.floating)),
-    boundary: g,
-    rootBoundary: d,
-    strategy: u
-  })), y = r === "floating" ? {
-    x: s,
-    y: a,
-    width: o.floating.width,
-    height: o.floating.height
-  } : o.reference, v = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(c.floating)), b = await (n.isElement == null ? void 0 : n.isElement(v)) ? await (n.getScale == null ? void 0 : n.getScale(v)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, p = _(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: c,
-    rect: y,
-    offsetParent: v,
-    strategy: u
-  }) : y);
-  return {
-    top: (h.top - p.top + l.top) / b.y,
-    bottom: (p.bottom - h.bottom + l.bottom) / b.y,
-    left: (h.left - p.left + l.left) / b.x,
-    right: (p.right - h.right + l.right) / b.x
-  };
+  return u;
 }
-const ae = (t) => ({
-  name: "arrow",
-  options: t,
-  async fn(e) {
-    const {
-      x: f,
-      y: s,
-      placement: a,
-      rects: n,
-      platform: o,
-      elements: c,
-      middlewareData: u
-    } = e, {
-      element: g,
-      padding: d = 0
-    } = F(t, e) || {};
-    if (g == null)
-      return {};
-    const r = G(d), m = {
-      x: f,
-      y: s
-    }, i = J(a), l = K(i), w = await o.getDimensions(g), x = i === "y", h = x ? "top" : "left", y = x ? "bottom" : "right", v = x ? "clientHeight" : "clientWidth", b = n.reference[l] + n.reference[i] - m[i] - n.floating[l], p = m[i] - n.reference[i], T = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(g));
-    let S = T ? T[v] : 0;
-    (!S || !await (o.isElement == null ? void 0 : o.isElement(T))) && (S = c.floating[v] || n.floating[l]);
-    const V = b / 2 - p / 2, D = S / 2 - w[l] / 2 - 1, R = z(r[h], D), B = z(r[y], D), E = R, H = S - w[l] - B, A = S / 2 - w[l] / 2 + V, L = Y(E, A, H), O = !u.arrow && X(a) != null && A !== L && n.reference[l] / 2 - (A < E ? R : B) - w[l] / 2 < 0, P = O ? A < E ? A - E : A - H : 0;
-    return {
-      [i]: m[i] + P,
-      data: {
-        [i]: L,
-        centerOffset: A - L - P,
-        ...O && {
-          alignmentOffset: P
-        }
-      },
-      reset: O
-    };
+function ne(u, a, o) {
+  return a = ie(a), a in u ? Object.defineProperty(u, a, {
+    value: o,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : u[a] = o, u;
+}
+function re(u, a) {
+  if (typeof u != "object" || u === null) return u;
+  var o = u[Symbol.toPrimitive];
+  if (o !== void 0) {
+    var i = o.call(u, a || "default");
+    if (typeof i != "object") return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-}), ce = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "flip",
-    options: t,
-    async fn(e) {
-      var f, s;
-      const {
-        placement: a,
-        middlewareData: n,
-        rects: o,
-        initialPlacement: c,
-        platform: u,
-        elements: g
-      } = e, {
-        mainAxis: d = !0,
-        crossAxis: r = !0,
-        fallbackPlacements: m,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: l = "none",
-        flipAlignment: w = !0,
-        ...x
-      } = F(t, e);
-      if ((f = n.arrow) != null && f.alignmentOffset)
-        return {};
-      const h = M(a), y = j(c), v = M(c) === c, b = await (u.isRTL == null ? void 0 : u.isRTL(g.floating)), p = m || (v || !w ? [Q(c)] : U(c)), T = l !== "none";
-      !m && T && p.push(...Z(c, w, l, b));
-      const S = [c, ...p], V = await $(e, x), D = [];
-      let R = ((s = n.flip) == null ? void 0 : s.overflows) || [];
-      if (d && D.push(V[h]), r) {
-        const A = ee(a, o, b);
-        D.push(V[A[0]], V[A[1]]);
-      }
-      if (R = [...R, {
-        placement: a,
-        overflows: D
-      }], !D.every((A) => A <= 0)) {
-        var B, E;
-        const A = (((B = n.flip) == null ? void 0 : B.index) || 0) + 1, L = S[A];
-        if (L)
-          return {
-            data: {
-              index: A,
-              overflows: R
-            },
-            reset: {
-              placement: L
-            }
-          };
-        let O = (E = R.filter((P) => P.overflows[0] <= 0).sort((P, k) => P.overflows[1] - k.overflows[1])[0]) == null ? void 0 : E.placement;
-        if (!O)
-          switch (i) {
-            case "bestFit": {
-              var H;
-              const P = (H = R.filter((k) => {
-                if (T) {
-                  const C = j(k.placement);
-                  return C === y || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  C === "y";
-                }
-                return !0;
-              }).map((k) => [k.placement, k.overflows.filter((C) => C > 0).reduce((C, N) => C + N, 0)]).sort((k, C) => k[1] - C[1])[0]) == null ? void 0 : H[0];
-              P && (O = P);
-              break;
-            }
-            case "initialPlacement":
-              O = c;
-              break;
-          }
-        if (a !== O)
-          return {
-            reset: {
-              placement: O
-            }
-          };
-      }
-      return {};
-    }
-  };
-};
-function W(t, e) {
-  return {
-    top: t.top - e.height,
-    right: t.right - e.width,
-    bottom: t.bottom - e.height,
-    left: t.left - e.width
-  };
+  return (a === "string" ? String : Number)(u);
 }
-function q(t) {
-  return te.some((e) => t[e] >= 0);
+function ie(u) {
+  var a = re(u, "string");
+  return typeof a == "symbol" ? a : String(a);
 }
-const le = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "hide",
-    options: t,
-    async fn(e) {
-      const {
-        rects: f
-      } = e, {
-        strategy: s = "referenceHidden",
-        ...a
-      } = F(t, e);
-      switch (s) {
-        case "referenceHidden": {
-          const n = await $(e, {
-            ...a,
-            elementContext: "reference"
-          }), o = W(n, f.reference);
-          return {
-            data: {
-              referenceHiddenOffsets: o,
-              referenceHidden: q(o)
-            }
-          };
-        }
-        case "escaped": {
-          const n = await $(e, {
-            ...a,
-            altBoundary: !0
-          }), o = W(n, f.floating);
-          return {
-            data: {
-              escapedOffsets: o,
-              escaped: q(o)
-            }
-          };
-        }
-        default:
-          return {};
-      }
+var Q = {
+  activateTrap: function(a, o) {
+    if (a.length > 0) {
+      var i = a[a.length - 1];
+      i !== o && i.pause();
     }
-  };
-};
-async function ie(t, e) {
-  const {
-    placement: f,
-    platform: s,
-    elements: a
-  } = t, n = await (s.isRTL == null ? void 0 : s.isRTL(a.floating)), o = M(f), c = X(f), u = j(f) === "y", g = ["left", "top"].includes(o) ? -1 : 1, d = n && u ? -1 : 1, r = F(e, t);
-  let {
-    mainAxis: m,
-    crossAxis: i,
-    alignmentAxis: l
-  } = typeof r == "number" ? {
-    mainAxis: r,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...r
-  };
-  return c && typeof l == "number" && (i = c === "end" ? l * -1 : l), u ? {
-    x: i * d,
-    y: m * g
-  } : {
-    x: m * g,
-    y: i * d
-  };
-}
-const re = function(t) {
-  return t === void 0 && (t = 0), {
-    name: "offset",
-    options: t,
-    async fn(e) {
-      var f, s;
-      const {
-        x: a,
-        y: n,
-        placement: o,
-        middlewareData: c
-      } = e, u = await ie(e, t);
-      return o === ((f = c.offset) == null ? void 0 : f.placement) && (s = c.arrow) != null && s.alignmentOffset ? {} : {
-        x: a + u.x,
-        y: n + u.y,
-        data: {
-          ...u,
-          placement: o
-        }
-      };
+    var m = a.indexOf(o);
+    m === -1 || a.splice(m, 1), a.push(o);
+  },
+  deactivateTrap: function(a, o) {
+    var i = a.indexOf(o);
+    i !== -1 && a.splice(i, 1), a.length > 0 && a[a.length - 1].unpause();
+  }
+}, oe = function(a) {
+  return a.tagName && a.tagName.toLowerCase() === "input" && typeof a.select == "function";
+}, ue = function(a) {
+  return (a == null ? void 0 : a.key) === "Escape" || (a == null ? void 0 : a.key) === "Esc" || (a == null ? void 0 : a.keyCode) === 27;
+}, L = function(a) {
+  return (a == null ? void 0 : a.key) === "Tab" || (a == null ? void 0 : a.keyCode) === 9;
+}, se = function(a) {
+  return L(a) && !a.shiftKey;
+}, ce = function(a) {
+  return L(a) && a.shiftKey;
+}, W = function(a) {
+  return setTimeout(a, 0);
+}, X = function(a, o) {
+  var i = -1;
+  return a.every(function(m, s) {
+    return o(m) ? (i = s, !1) : !0;
+  }), i;
+}, B = function(a) {
+  for (var o = arguments.length, i = new Array(o > 1 ? o - 1 : 0), m = 1; m < o; m++)
+    i[m - 1] = arguments[m];
+  return typeof a == "function" ? a.apply(void 0, i) : a;
+}, C = function(a) {
+  return a.target.shadowRoot && typeof a.composedPath == "function" ? a.composedPath()[0] : a.target;
+}, le = [], de = function(a, o) {
+  var i = (o == null ? void 0 : o.document) || document, m = (o == null ? void 0 : o.trapStack) || le, s = J({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isKeyForward: se,
+    isKeyBackward: ce
+  }, o), n = {
+    // containers given to createFocusTrap()
+    // @type {Array<HTMLElement>}
+    containers: [],
+    // list of objects identifying tabbable nodes in `containers` in the trap
+    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap
+    //  is active, but the trap should never get to a state where there isn't at least one group
+    //  with at least one tabbable node in it (that would lead to an error condition that would
+    //  result in an error being thrown)
+    // @type {Array<{
+    //   container: HTMLElement,
+    //   tabbableNodes: Array<HTMLElement>, // empty if none
+    //   focusableNodes: Array<HTMLElement>, // empty if none
+    //   posTabIndexesFound: boolean,
+    //   firstTabbableNode: HTMLElement|undefined,
+    //   lastTabbableNode: HTMLElement|undefined,
+    //   firstDomTabbableNode: HTMLElement|undefined,
+    //   lastDomTabbableNode: HTMLElement|undefined,
+    //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined
+    // }>}
+    containerGroups: [],
+    // same order/length as `containers` list
+    // references to objects in `containerGroups`, but only those that actually have
+    //  tabbable nodes in them
+    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__
+    //  the same length
+    tabbableGroups: [],
+    nodeFocusedBeforeActivation: null,
+    mostRecentlyFocusedNode: null,
+    active: !1,
+    paused: !1,
+    // timer ID for when delayInitialFocus is true and initial focus in this trap
+    //  has been delayed during activation
+    delayInitialFocusTimer: void 0,
+    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any
+    recentNavEvent: void 0
+  }, g, h = function(t, e, r) {
+    return t && t[e] !== void 0 ? t[e] : s[r || e];
+  }, F = function(t, e) {
+    var r = typeof (e == null ? void 0 : e.composedPath) == "function" ? e.composedPath() : void 0;
+    return n.containerGroups.findIndex(function(c) {
+      var l = c.container, d = c.tabbableNodes;
+      return l.contains(t) || // fall back to explicit tabbable search which will take into consideration any
+      //  web components if the `tabbableOptions.getShadowRoot` option was used for
+      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't
+      //  look inside web components even if open)
+      (r == null ? void 0 : r.includes(l)) || d.find(function(v) {
+        return v === t;
+      });
+    });
+  }, E = function(t) {
+    var e = s[t];
+    if (typeof e == "function") {
+      for (var r = arguments.length, c = new Array(r > 1 ? r - 1 : 0), l = 1; l < r; l++)
+        c[l - 1] = arguments[l];
+      e = e.apply(void 0, c);
     }
-  };
-}, fe = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "shift",
-    options: t,
-    async fn(e) {
-      const {
-        x: f,
-        y: s,
-        placement: a
-      } = e, {
-        mainAxis: n = !0,
-        crossAxis: o = !1,
-        limiter: c = {
-          fn: (x) => {
-            let {
-              x: h,
-              y
-            } = x;
-            return {
-              x: h,
-              y
-            };
-          }
-        },
-        ...u
-      } = F(t, e), g = {
-        x: f,
-        y: s
-      }, d = await $(e, u), r = j(M(a)), m = ne(r);
-      let i = g[m], l = g[r];
-      if (n) {
-        const x = m === "y" ? "top" : "left", h = m === "y" ? "bottom" : "right", y = i + d[x], v = i - d[h];
-        i = Y(y, i, v);
-      }
-      if (o) {
-        const x = r === "y" ? "top" : "left", h = r === "y" ? "bottom" : "right", y = l + d[x], v = l - d[h];
-        l = Y(y, l, v);
+    if (e === !0 && (e = void 0), !e) {
+      if (e === void 0 || e === !1)
+        return e;
+      throw new Error("`".concat(t, "` was specified but was not a node, or did not return a node"));
+    }
+    var d = e;
+    if (typeof e == "string" && (d = i.querySelector(e), !d))
+      throw new Error("`".concat(t, "` as selector refers to no known node"));
+    return d;
+  }, P = function() {
+    var t = E("initialFocus");
+    if (t === !1)
+      return !1;
+    if (t === void 0 || !G(t, s.tabbableOptions))
+      if (F(i.activeElement) >= 0)
+        t = i.activeElement;
+      else {
+        var e = n.tabbableGroups[0], r = e && e.firstTabbableNode;
+        t = r || E("fallbackFocus");
       }
-      const w = c.fn({
-        ...e,
-        [m]: i,
-        [r]: l
+    if (!t)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return t;
+  }, D = function() {
+    if (n.containerGroups = n.containers.map(function(t) {
+      var e = te(t, s.tabbableOptions), r = ae(t, s.tabbableOptions), c = e.length > 0 ? e[0] : void 0, l = e.length > 0 ? e[e.length - 1] : void 0, d = r.find(function(b) {
+        return T(b);
+      }), v = r.slice().reverse().find(function(b) {
+        return T(b);
+      }), p = !!e.find(function(b) {
+        return K(b) > 0;
       });
       return {
-        ...w,
-        data: {
-          x: w.x - f,
-          y: w.y - s
+        container: t,
+        tabbableNodes: e,
+        focusableNodes: r,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: p,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: c,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: l,
+        // NOTE: DOM order is NOT NECESSARILY "document position" order, but figuring that out
+        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
+        //  because that API doesn't work with Shadow DOM as well as it should (@see
+        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,
+        //  to address an edge case related to positive tabindex support, this seems like a much easier,
+        //  "close enough most of the time" alternative for positive tabindexes which should generally
+        //  be avoided anyway...
+        /** First tabbable node in container, __DOM__ order; `undefined` if none. */
+        firstDomTabbableNode: d,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: v,
+        /**
+         * Finds the __tabbable__ node that follows the given node in the specified direction,
+         *  in this container, if any.
+         * @param {HTMLElement} node
+         * @param {boolean} [forward] True if going in forward tab order; false if going
+         *  in reverse.
+         * @returns {HTMLElement|undefined} The next tabbable node, if any.
+         */
+        nextTabbableNode: function(N) {
+          var O = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, y = e.indexOf(N);
+          return y < 0 ? O ? r.slice(r.indexOf(N) + 1).find(function(R) {
+            return T(R);
+          }) : r.slice(0, r.indexOf(N)).reverse().find(function(R) {
+            return T(R);
+          }) : e[y + (O ? 1 : -1)];
         }
       };
+    }), n.tabbableGroups = n.containerGroups.filter(function(t) {
+      return t.tabbableNodes.length > 0;
+    }), n.tabbableGroups.length <= 0 && !E("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 (n.containerGroups.find(function(t) {
+      return t.posTabIndexesFound;
+    }) && n.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.");
+  }, Z = function f(t) {
+    var e = t.activeElement;
+    if (e)
+      return e.shadowRoot && e.shadowRoot.activeElement !== null ? f(e.shadowRoot) : e;
+  }, w = function f(t) {
+    if (t !== !1 && t !== Z(document)) {
+      if (!t || !t.focus) {
+        f(P());
+        return;
+      }
+      t.focus({
+        preventScroll: !!s.preventScroll
+      }), n.mostRecentlyFocusedNode = t, oe(t) && t.select();
     }
+  }, S = function(t) {
+    var e = E("setReturnFocus", t);
+    return e || (e === !1 ? !1 : t);
+  }, U = function(t) {
+    var e = t.target, r = t.event, c = t.isBackward, l = c === void 0 ? !1 : c;
+    e = e || C(r), D();
+    var d = null;
+    if (n.tabbableGroups.length > 0) {
+      var v = F(e, r), p = v >= 0 ? n.containerGroups[v] : void 0;
+      if (v < 0)
+        l ? d = n.tabbableGroups[n.tabbableGroups.length - 1].lastTabbableNode : d = n.tabbableGroups[0].firstTabbableNode;
+      else if (l) {
+        var b = X(n.tabbableGroups, function(I) {
+          var x = I.firstTabbableNode;
+          return e === x;
+        });
+        if (b < 0 && (p.container === e || G(e, s.tabbableOptions) && !T(e, s.tabbableOptions) && !p.nextTabbableNode(e, !1)) && (b = v), b >= 0) {
+          var N = b === 0 ? n.tabbableGroups.length - 1 : b - 1, O = n.tabbableGroups[N];
+          d = K(e) >= 0 ? O.lastTabbableNode : O.lastDomTabbableNode;
+        } else L(r) || (d = p.nextTabbableNode(e, !1));
+      } else {
+        var y = X(n.tabbableGroups, function(I) {
+          var x = I.lastTabbableNode;
+          return e === x;
+        });
+        if (y < 0 && (p.container === e || G(e, s.tabbableOptions) && !T(e, s.tabbableOptions) && !p.nextTabbableNode(e)) && (y = v), y >= 0) {
+          var R = y === n.tabbableGroups.length - 1 ? 0 : y + 1, $ = n.tabbableGroups[R];
+          d = K(e) >= 0 ? $.firstTabbableNode : $.firstDomTabbableNode;
+        } else L(r) || (d = p.nextTabbableNode(e));
+      }
+    } else
+      d = E("fallbackFocus");
+    return d;
+  }, A = function(t) {
+    var e = C(t);
+    if (!(F(e, t) >= 0)) {
+      if (B(s.clickOutsideDeactivates, t)) {
+        g.deactivate({
+          // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,
+          //  which will result in the outside click setting focus to the node
+          //  that was clicked (and if not focusable, to "nothing"); by setting
+          //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused
+          //  on activation (or the configured `setReturnFocus` node), whether the
+          //  outside click was on a focusable node or not
+          returnFocus: s.returnFocusOnDeactivate
+        });
+        return;
+      }
+      B(s.allowOutsideClick, t) || t.preventDefault();
+    }
+  }, q = function(t) {
+    var e = C(t), r = F(e, t) >= 0;
+    if (r || e instanceof Document)
+      r && (n.mostRecentlyFocusedNode = e);
+    else {
+      t.stopImmediatePropagation();
+      var c, l = !0;
+      if (n.mostRecentlyFocusedNode)
+        if (K(n.mostRecentlyFocusedNode) > 0) {
+          var d = F(n.mostRecentlyFocusedNode), v = n.containerGroups[d].tabbableNodes;
+          if (v.length > 0) {
+            var p = v.findIndex(function(b) {
+              return b === n.mostRecentlyFocusedNode;
+            });
+            p >= 0 && (s.isKeyForward(n.recentNavEvent) ? p + 1 < v.length && (c = v[p + 1], l = !1) : p - 1 >= 0 && (c = v[p - 1], l = !1));
+          }
+        } else
+          n.containerGroups.some(function(b) {
+            return b.tabbableNodes.some(function(N) {
+              return K(N) > 0;
+            });
+          }) || (l = !1);
+      else
+        l = !1;
+      l && (c = U({
+        // 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: n.mostRecentlyFocusedNode,
+        isBackward: s.isKeyBackward(n.recentNavEvent)
+      })), w(c || n.mostRecentlyFocusedNode || P());
+    }
+    n.recentNavEvent = void 0;
+  }, _ = function(t) {
+    var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    n.recentNavEvent = t;
+    var r = U({
+      event: t,
+      isBackward: e
+    });
+    r && (L(t) && t.preventDefault(), w(r));
+  }, H = function(t) {
+    if (ue(t) && B(s.escapeDeactivates, t) !== !1) {
+      t.preventDefault(), g.deactivate();
+      return;
+    }
+    (s.isKeyForward(t) || s.isKeyBackward(t)) && _(t, s.isKeyBackward(t));
+  }, M = function(t) {
+    var e = C(t);
+    F(e, t) >= 0 || B(s.clickOutsideDeactivates, t) || B(s.allowOutsideClick, t) || (t.preventDefault(), t.stopImmediatePropagation());
+  }, Y = function() {
+    if (n.active)
+      return Q.activateTrap(m, g), n.delayInitialFocusTimer = s.delayInitialFocus ? W(function() {
+        w(P());
+      }) : w(P()), i.addEventListener("focusin", q, !0), i.addEventListener("mousedown", A, {
+        capture: !0,
+        passive: !1
+      }), i.addEventListener("touchstart", A, {
+        capture: !0,
+        passive: !1
+      }), i.addEventListener("click", M, {
+        capture: !0,
+        passive: !1
+      }), i.addEventListener("keydown", H, {
+        capture: !0,
+        passive: !1
+      }), g;
+  }, V = function() {
+    if (n.active)
+      return i.removeEventListener("focusin", q, !0), i.removeEventListener("mousedown", A, !0), i.removeEventListener("touchstart", A, !0), i.removeEventListener("click", M, !0), i.removeEventListener("keydown", H, !0), g;
+  }, ee = function(t) {
+    var e = t.some(function(r) {
+      var c = Array.from(r.removedNodes);
+      return c.some(function(l) {
+        return l === n.mostRecentlyFocusedNode;
+      });
+    });
+    e && w(P());
+  }, j = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(ee) : void 0, k = function() {
+    j && (j.disconnect(), n.active && !n.paused && n.containers.map(function(t) {
+      j.observe(t, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
   };
+  return g = {
+    get active() {
+      return n.active;
+    },
+    get paused() {
+      return n.paused;
+    },
+    activate: function(t) {
+      if (n.active)
+        return this;
+      var e = h(t, "onActivate"), r = h(t, "onPostActivate"), c = h(t, "checkCanFocusTrap");
+      c || D(), n.active = !0, n.paused = !1, n.nodeFocusedBeforeActivation = i.activeElement, e == null || e();
+      var l = function() {
+        c && D(), Y(), k(), r == null || r();
+      };
+      return c ? (c(n.containers.concat()).then(l, l), this) : (l(), this);
+    },
+    deactivate: function(t) {
+      if (!n.active)
+        return this;
+      var e = J({
+        onDeactivate: s.onDeactivate,
+        onPostDeactivate: s.onPostDeactivate,
+        checkCanReturnFocus: s.checkCanReturnFocus
+      }, t);
+      clearTimeout(n.delayInitialFocusTimer), n.delayInitialFocusTimer = void 0, V(), n.active = !1, n.paused = !1, k(), Q.deactivateTrap(m, g);
+      var r = h(e, "onDeactivate"), c = h(e, "onPostDeactivate"), l = h(e, "checkCanReturnFocus"), d = h(e, "returnFocus", "returnFocusOnDeactivate");
+      r == null || r();
+      var v = function() {
+        W(function() {
+          d && w(S(n.nodeFocusedBeforeActivation)), c == null || c();
+        });
+      };
+      return d && l ? (l(S(n.nodeFocusedBeforeActivation)).then(v, v), this) : (v(), this);
+    },
+    pause: function(t) {
+      if (n.paused || !n.active)
+        return this;
+      var e = h(t, "onPause"), r = h(t, "onPostPause");
+      return n.paused = !0, e == null || e(), V(), k(), r == null || r(), this;
+    },
+    unpause: function(t) {
+      if (!n.paused || !n.active)
+        return this;
+      var e = h(t, "onUnpause"), r = h(t, "onPostUnpause");
+      return n.paused = !1, e == null || e(), D(), Y(), k(), r == null || r(), this;
+    },
+    updateContainerElements: function(t) {
+      var e = [].concat(t).filter(Boolean);
+      return n.containers = e.map(function(r) {
+        return typeof r == "string" ? i.querySelector(r) : r;
+      }), n.active && D(), k(), this;
+    }
+  }, g.updateContainerElements(a), g;
 };
 export {
-  ae as arrow,
-  oe as computePosition,
-  $ as detectOverflow,
-  ce as flip,
-  le as hide,
-  re as offset,
-  _ as rectToClientRect,
-  fe as shift
+  de as createFocusTrap
 };