@knime/jsonforms 1.8.5 → 1.8.7

package/dist/useDropdownNavigation-BfCXUheD.js

@@ -0,0 +1,817 @@
+import { defineComponent as ye, ref as ce, computed as me, onMounted as ge, watch as we, onUnmounted as Fe, Comment as Te, cloneVNode as Ne, readonly as Ee } from "vue";
+/*!
+* tabbable 6.2.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var le = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"], G = /* @__PURE__ */ le.join(","), se = typeof Element > "u", O = se ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, q = !se && Element.prototype.getRootNode ? function(r) {
+  var e;
+  return r == null || (e = r.getRootNode) === null || e === void 0 ? void 0 : e.call(r);
+} : function(r) {
+  return r?.ownerDocument;
+}, V = function r(e, t) {
+  var a;
+  t === void 0 && (t = !0);
+  var u = e == null || (a = e.getAttribute) === null || a === void 0 ? void 0 : a.call(e, "inert"), c = u === "" || u === "true", n = c || t && e && r(e.parentNode);
+  return n;
+}, ke = function(e) {
+  var t, a = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return a === "" || a === "true";
+}, de = function(e, t, a) {
+  if (V(e))
+    return [];
+  var u = Array.prototype.slice.apply(e.querySelectorAll(G));
+  return t && O.call(e, G) && u.unshift(e), u = u.filter(a), u;
+}, fe = function r(e, t, a) {
+  for (var u = [], c = Array.from(e); c.length; ) {
+    var n = c.shift();
+    if (!V(n, !1))
+      if (n.tagName === "SLOT") {
+        var s = n.assignedElements(), f = s.length ? s : n.children, p = r(f, !0, a);
+        a.flatten ? u.push.apply(u, p) : u.push({
+          scopeParent: n,
+          candidates: p
+        });
+      } else {
+        var F = O.call(n, G);
+        F && a.filter(n) && (t || !e.includes(n)) && u.push(n);
+        var T = n.shadowRoot || // check for an undisclosed shadow
+        typeof a.getShadowRoot == "function" && a.getShadowRoot(n), N = !V(T, !1) && (!a.shadowRootFilter || a.shadowRootFilter(n));
+        if (T && N) {
+          var k = r(T === !0 ? n.children : T.children, !0, a);
+          a.flatten ? u.push.apply(u, k) : u.push({
+            scopeParent: n,
+            candidates: k
+          });
+        } else
+          c.unshift.apply(c, n.children);
+      }
+  }
+  return u;
+}, ve = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, D = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || ke(e)) && !ve(e) ? 0 : e.tabIndex;
+}, Se = function(e, t) {
+  var a = D(e);
+  return a < 0 && t && !ve(e) ? 0 : a;
+}, De = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, be = function(e) {
+  return e.tagName === "INPUT";
+}, Oe = function(e) {
+  return be(e) && e.type === "hidden";
+}, Ie = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(a) {
+    return a.tagName === "SUMMARY";
+  });
+  return t;
+}, Ce = function(e, t) {
+  for (var a = 0; a < e.length; a++)
+    if (e[a].checked && e[a].form === t)
+      return e[a];
+}, Ae = function(e) {
+  if (!e.name)
+    return !0;
+  var t = e.form || q(e), a = function(s) {
+    return t.querySelectorAll('input[type="radio"][name="' + s + '"]');
+  }, u;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    u = a(window.CSS.escape(e.name));
+  else
+    try {
+      u = a(e.name);
+    } catch (n) {
+      return console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", n.message), !1;
+    }
+  var c = Ce(u, e.form);
+  return !c || c === e;
+}, Re = function(e) {
+  return be(e) && e.type === "radio";
+}, Pe = function(e) {
+  return Re(e) && !Ae(e);
+}, xe = function(e) {
+  var t, a = e && q(e), u = (t = a) === null || t === void 0 ? void 0 : t.host, c = !1;
+  if (a && a !== e) {
+    var n, s, f;
+    for (c = !!((n = u) !== null && n !== void 0 && (s = n.ownerDocument) !== null && s !== void 0 && s.contains(u) || e != null && (f = e.ownerDocument) !== null && f !== void 0 && f.contains(e)); !c && u; ) {
+      var p, F, T;
+      a = q(u), u = (p = a) === null || p === void 0 ? void 0 : p.host, c = !!((F = u) !== null && F !== void 0 && (T = F.ownerDocument) !== null && T !== void 0 && T.contains(u));
+    }
+  }
+  return c;
+}, re = function(e) {
+  var t = e.getBoundingClientRect(), a = t.width, u = t.height;
+  return a === 0 && u === 0;
+}, Be = function(e, t) {
+  var a = t.displayCheck, u = t.getShadowRoot;
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var c = O.call(e, "details>summary:first-of-type"), n = c ? e.parentElement : e;
+  if (O.call(n, "details:not([open]) *"))
+    return !0;
+  if (!a || a === "full" || a === "legacy-full") {
+    if (typeof u == "function") {
+      for (var s = e; e; ) {
+        var f = e.parentElement, p = q(e);
+        if (f && !f.shadowRoot && u(f) === !0)
+          return re(e);
+        e.assignedSlot ? e = e.assignedSlot : !f && p !== e.ownerDocument ? e = p.host : e = f;
+      }
+      e = s;
+    }
+    if (xe(e))
+      return !e.getClientRects().length;
+    if (a !== "legacy-full")
+      return !0;
+  } else if (a === "non-zero-area")
+    return re(e);
+  return !1;
+}, Le = function(e) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))
+    for (var t = e.parentElement; t; ) {
+      if (t.tagName === "FIELDSET" && t.disabled) {
+        for (var a = 0; a < t.children.length; a++) {
+          var u = t.children.item(a);
+          if (u.tagName === "LEGEND")
+            return O.call(t, "fieldset[disabled] *") ? !0 : !u.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, _ = function(e, t) {
+  return !(t.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
+  //  because we're limited in the type of selectors we can use in JSDom (see related
+  //  note related to `candidateSelectors`)
+  V(t) || Oe(t) || Be(t, e) || // For a details element with a summary, the summary element gets the focus
+  Ie(t) || Le(t));
+}, Z = function(e, t) {
+  return !(Pe(t) || D(t) < 0 || !_(e, t));
+}, je = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, Ke = function r(e) {
+  var t = [], a = [];
+  return e.forEach(function(u, c) {
+    var n = !!u.scopeParent, s = n ? u.scopeParent : u, f = Se(s, n), p = n ? r(u.candidates) : s;
+    f === 0 ? n ? t.push.apply(t, p) : t.push(s) : a.push({
+      documentOrder: c,
+      tabIndex: f,
+      item: u,
+      isScope: n,
+      content: p
+    });
+  }), a.sort(De).reduce(function(u, c) {
+    return c.isScope ? u.push.apply(u, c.content) : u.push(c.content), u;
+  }, []).concat(t);
+}, Me = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = fe([e], t.includeContainer, {
+    filter: Z.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: je
+  }) : a = de(e, t.includeContainer, Z.bind(null, t)), Ke(a);
+}, Ge = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = fe([e], t.includeContainer, {
+    filter: _.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : a = de(e, t.includeContainer, _.bind(null, t)), a;
+}, I = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return O.call(e, G) === !1 ? !1 : Z(t, e);
+}, qe = /* @__PURE__ */ le.concat("iframe").join(","), Y = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return O.call(e, qe) === !1 ? !1 : _(t, e);
+};
+/*!
+* focus-trap 7.6.5
+* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+*/
+function z(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var t = 0, a = Array(e); t < e; t++) a[t] = r[t];
+  return a;
+}
+function Ve(r) {
+  if (Array.isArray(r)) return z(r);
+}
+function _e(r, e, t) {
+  return (e = Ye(e)) in r ? Object.defineProperty(r, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[e] = t, r;
+}
+function Ue(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function $e() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function ne(r, e) {
+  var t = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(r);
+    e && (a = a.filter(function(u) {
+      return Object.getOwnPropertyDescriptor(r, u).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function ie(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? ne(Object(t), !0).forEach(function(a) {
+      _e(r, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(t)) : ne(Object(t)).forEach(function(a) {
+      Object.defineProperty(r, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return r;
+}
+function He(r) {
+  return Ve(r) || Ue(r) || Ze(r) || $e();
+}
+function We(r, e) {
+  if (typeof r != "object" || !r) return r;
+  var t = r[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var a = t.call(r, e);
+    if (typeof a != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+function Ye(r) {
+  var e = We(r, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function Ze(r, e) {
+  if (r) {
+    if (typeof r == "string") return z(r, e);
+    var t = {}.toString.call(r).slice(8, -1);
+    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? z(r, e) : void 0;
+  }
+}
+var oe = {
+  activateTrap: function(e, t) {
+    if (e.length > 0) {
+      var a = e[e.length - 1];
+      a !== t && a._setPausedState(!0);
+    }
+    var u = e.indexOf(t);
+    u === -1 || e.splice(u, 1), e.push(t);
+  },
+  deactivateTrap: function(e, t) {
+    var a = e.indexOf(t);
+    a !== -1 && e.splice(a, 1), e.length > 0 && !e[e.length - 1]._isManuallyPaused() && e[e.length - 1]._setPausedState(!1);
+  }
+}, ze = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, Xe = function(e) {
+  return e?.key === "Escape" || e?.key === "Esc" || e?.keyCode === 27;
+}, B = function(e) {
+  return e?.key === "Tab" || e?.keyCode === 9;
+}, Je = function(e) {
+  return B(e) && !e.shiftKey;
+}, Qe = function(e) {
+  return B(e) && e.shiftKey;
+}, ue = function(e) {
+  return setTimeout(e, 0);
+}, x = function(e) {
+  for (var t = arguments.length, a = new Array(t > 1 ? t - 1 : 0), u = 1; u < t; u++)
+    a[u - 1] = arguments[u];
+  return typeof e == "function" ? e.apply(void 0, a) : e;
+}, K = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, et = [], tt = function(e, t) {
+  var a = t?.document || document, u = t?.trapStack || et, c = ie({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isKeyForward: Je,
+    isKeyBackward: Qe
+  }, t), 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,
+    manuallyPaused: !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
+  }, s, f = function(i, o, l) {
+    return i && i[o] !== void 0 ? i[o] : c[l || o];
+  }, p = function(i, o) {
+    var l = typeof o?.composedPath == "function" ? o.composedPath() : void 0;
+    return n.containerGroups.findIndex(function(v) {
+      var b = v.container, y = v.tabbableNodes;
+      return b.contains(i) || l?.includes(b) || y.find(function(d) {
+        return d === i;
+      });
+    });
+  }, F = function(i) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, l = o.hasFallback, v = l === void 0 ? !1 : l, b = o.params, y = b === void 0 ? [] : b, d = c[i];
+    if (typeof d == "function" && (d = d.apply(void 0, He(y))), d === !0 && (d = void 0), !d) {
+      if (d === void 0 || d === !1)
+        return d;
+      throw new Error("`".concat(i, "` was specified but was not a node, or did not return a node"));
+    }
+    var g = d;
+    if (typeof d == "string") {
+      try {
+        g = a.querySelector(d);
+      } catch (w) {
+        throw new Error("`".concat(i, '` appears to be an invalid selector; error="').concat(w.message, '"'));
+      }
+      if (!g && !v)
+        throw new Error("`".concat(i, "` as selector refers to no known node"));
+    }
+    return g;
+  }, T = function() {
+    var i = F("initialFocus", {
+      hasFallback: !0
+    });
+    if (i === !1)
+      return !1;
+    if (i === void 0 || i && !Y(i, c.tabbableOptions))
+      if (p(a.activeElement) >= 0)
+        i = a.activeElement;
+      else {
+        var o = n.tabbableGroups[0], l = o && o.firstTabbableNode;
+        i = l || F("fallbackFocus");
+      }
+    else i === null && (i = F("fallbackFocus"));
+    if (!i)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return i;
+  }, N = function() {
+    if (n.containerGroups = n.containers.map(function(i) {
+      var o = Me(i, c.tabbableOptions), l = Ge(i, c.tabbableOptions), v = o.length > 0 ? o[0] : void 0, b = o.length > 0 ? o[o.length - 1] : void 0, y = l.find(function(w) {
+        return I(w);
+      }), d = l.slice().reverse().find(function(w) {
+        return I(w);
+      }), g = !!o.find(function(w) {
+        return D(w) > 0;
+      });
+      return {
+        container: i,
+        tabbableNodes: o,
+        focusableNodes: l,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: g,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: v,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: b,
+        // 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: y,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: d,
+        /**
+         * 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(S) {
+          var R = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, E = o.indexOf(S);
+          return E < 0 ? R ? l.slice(l.indexOf(S) + 1).find(function(P) {
+            return I(P);
+          }) : l.slice(0, l.indexOf(S)).reverse().find(function(P) {
+            return I(P);
+          }) : o[E + (R ? 1 : -1)];
+        }
+      };
+    }), n.tabbableGroups = n.containerGroups.filter(function(i) {
+      return i.tabbableNodes.length > 0;
+    }), n.tabbableGroups.length <= 0 && !F("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(i) {
+      return i.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.");
+  }, k = function(i) {
+    var o = i.activeElement;
+    if (o)
+      return o.shadowRoot && o.shadowRoot.activeElement !== null ? k(o.shadowRoot) : o;
+  }, m = function(i) {
+    if (i !== !1 && i !== k(document)) {
+      if (!i || !i.focus) {
+        m(T());
+        return;
+      }
+      i.focus({
+        preventScroll: !!c.preventScroll
+      }), n.mostRecentlyFocusedNode = i, ze(i) && i.select();
+    }
+  }, L = function(i) {
+    var o = F("setReturnFocus", {
+      params: [i]
+    });
+    return o || (o === !1 ? !1 : i);
+  }, j = function(i) {
+    var o = i.target, l = i.event, v = i.isBackward, b = v === void 0 ? !1 : v;
+    o = o || K(l), N();
+    var y = null;
+    if (n.tabbableGroups.length > 0) {
+      var d = p(o, l), g = d >= 0 ? n.containerGroups[d] : void 0;
+      if (d < 0)
+        b ? y = n.tabbableGroups[n.tabbableGroups.length - 1].lastTabbableNode : y = n.tabbableGroups[0].firstTabbableNode;
+      else if (b) {
+        var w = n.tabbableGroups.findIndex(function(H) {
+          var W = H.firstTabbableNode;
+          return o === W;
+        });
+        if (w < 0 && (g.container === o || Y(o, c.tabbableOptions) && !I(o, c.tabbableOptions) && !g.nextTabbableNode(o, !1)) && (w = d), w >= 0) {
+          var S = w === 0 ? n.tabbableGroups.length - 1 : w - 1, R = n.tabbableGroups[S];
+          y = D(o) >= 0 ? R.lastTabbableNode : R.lastDomTabbableNode;
+        } else B(l) || (y = g.nextTabbableNode(o, !1));
+      } else {
+        var E = n.tabbableGroups.findIndex(function(H) {
+          var W = H.lastTabbableNode;
+          return o === W;
+        });
+        if (E < 0 && (g.container === o || Y(o, c.tabbableOptions) && !I(o, c.tabbableOptions) && !g.nextTabbableNode(o)) && (E = d), E >= 0) {
+          var P = E === n.tabbableGroups.length - 1 ? 0 : E + 1, ae = n.tabbableGroups[P];
+          y = D(o) >= 0 ? ae.firstTabbableNode : ae.firstDomTabbableNode;
+        } else B(l) || (y = g.nextTabbableNode(o));
+      }
+    } else
+      y = F("fallbackFocus");
+    return y;
+  }, C = function(i) {
+    var o = K(i);
+    if (!(p(o, i) >= 0)) {
+      if (x(c.clickOutsideDeactivates, i)) {
+        s.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: c.returnFocusOnDeactivate
+        });
+        return;
+      }
+      x(c.allowOutsideClick, i) || i.preventDefault();
+    }
+  }, U = function(i) {
+    var o = K(i), l = p(o, i) >= 0;
+    if (l || o instanceof Document)
+      l && (n.mostRecentlyFocusedNode = o);
+    else {
+      i.stopImmediatePropagation();
+      var v, b = !0;
+      if (n.mostRecentlyFocusedNode)
+        if (D(n.mostRecentlyFocusedNode) > 0) {
+          var y = p(n.mostRecentlyFocusedNode), d = n.containerGroups[y].tabbableNodes;
+          if (d.length > 0) {
+            var g = d.findIndex(function(w) {
+              return w === n.mostRecentlyFocusedNode;
+            });
+            g >= 0 && (c.isKeyForward(n.recentNavEvent) ? g + 1 < d.length && (v = d[g + 1], b = !1) : g - 1 >= 0 && (v = d[g - 1], b = !1));
+          }
+        } else
+          n.containerGroups.some(function(w) {
+            return w.tabbableNodes.some(function(S) {
+              return D(S) > 0;
+            });
+          }) || (b = !1);
+      else
+        b = !1;
+      b && (v = j({
+        // 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: c.isKeyBackward(n.recentNavEvent)
+      })), m(v || n.mostRecentlyFocusedNode || T());
+    }
+    n.recentNavEvent = void 0;
+  }, he = function(i) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    n.recentNavEvent = i;
+    var l = j({
+      event: i,
+      isBackward: o
+    });
+    l && (B(i) && i.preventDefault(), m(l));
+  }, X = function(i) {
+    (c.isKeyForward(i) || c.isKeyBackward(i)) && he(i, c.isKeyBackward(i));
+  }, J = function(i) {
+    Xe(i) && x(c.escapeDeactivates, i) !== !1 && (i.preventDefault(), s.deactivate());
+  }, Q = function(i) {
+    var o = K(i);
+    p(o, i) >= 0 || x(c.clickOutsideDeactivates, i) || x(c.allowOutsideClick, i) || (i.preventDefault(), i.stopImmediatePropagation());
+  }, ee = function() {
+    if (n.active)
+      return oe.activateTrap(u, s), n.delayInitialFocusTimer = c.delayInitialFocus ? ue(function() {
+        m(T());
+      }) : m(T()), a.addEventListener("focusin", U, !0), a.addEventListener("mousedown", C, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("touchstart", C, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("click", Q, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", X, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", J), s;
+  }, te = function() {
+    if (n.active)
+      return a.removeEventListener("focusin", U, !0), a.removeEventListener("mousedown", C, !0), a.removeEventListener("touchstart", C, !0), a.removeEventListener("click", Q, !0), a.removeEventListener("keydown", X, !0), a.removeEventListener("keydown", J), s;
+  }, pe = function(i) {
+    var o = i.some(function(l) {
+      var v = Array.from(l.removedNodes);
+      return v.some(function(b) {
+        return b === n.mostRecentlyFocusedNode;
+      });
+    });
+    o && m(T());
+  }, $ = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(pe) : void 0, A = function() {
+    $ && ($.disconnect(), n.active && !n.paused && n.containers.map(function(i) {
+      $.observe(i, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return s = {
+    get active() {
+      return n.active;
+    },
+    get paused() {
+      return n.paused;
+    },
+    activate: function(i) {
+      if (n.active)
+        return this;
+      var o = f(i, "onActivate"), l = f(i, "onPostActivate"), v = f(i, "checkCanFocusTrap");
+      v || N(), n.active = !0, n.paused = !1, n.nodeFocusedBeforeActivation = k(a), o?.();
+      var b = function() {
+        v && N(), ee(), A(), l?.();
+      };
+      return v ? (v(n.containers.concat()).then(b, b), this) : (b(), this);
+    },
+    deactivate: function(i) {
+      if (!n.active)
+        return this;
+      var o = ie({
+        onDeactivate: c.onDeactivate,
+        onPostDeactivate: c.onPostDeactivate,
+        checkCanReturnFocus: c.checkCanReturnFocus
+      }, i);
+      clearTimeout(n.delayInitialFocusTimer), n.delayInitialFocusTimer = void 0, te(), n.active = !1, n.paused = !1, A(), oe.deactivateTrap(u, s);
+      var l = f(o, "onDeactivate"), v = f(o, "onPostDeactivate"), b = f(o, "checkCanReturnFocus"), y = f(o, "returnFocus", "returnFocusOnDeactivate");
+      l?.();
+      var d = function() {
+        ue(function() {
+          y && m(L(n.nodeFocusedBeforeActivation)), v?.();
+        });
+      };
+      return y && b ? (b(L(n.nodeFocusedBeforeActivation)).then(d, d), this) : (d(), this);
+    },
+    pause: function(i) {
+      return n.active ? (n.manuallyPaused = !0, this._setPausedState(!0, i)) : this;
+    },
+    unpause: function(i) {
+      return n.active ? (n.manuallyPaused = !1, u[u.length - 1] !== this ? this : this._setPausedState(!1, i)) : this;
+    },
+    updateContainerElements: function(i) {
+      var o = [].concat(i).filter(Boolean);
+      return n.containers = o.map(function(l) {
+        return typeof l == "string" ? a.querySelector(l) : l;
+      }), n.active && N(), A(), this;
+    }
+  }, Object.defineProperties(s, {
+    _isManuallyPaused: {
+      value: function() {
+        return n.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(i, o) {
+        if (n.paused === i)
+          return this;
+        if (n.paused = i, i) {
+          var l = f(o, "onPause"), v = f(o, "onPostPause");
+          l?.(), te(), A(), v?.();
+        } else {
+          var b = f(o, "onUnpause"), y = f(o, "onPostUnpause");
+          b?.(), N(), ee(), A(), y?.();
+        }
+        return this;
+      }
+    }
+  }), s.updateContainerElements(e), s;
+};
+/*!
+  * focus-trap-vue v4.0.1
+  * (c) 2023 Eduardo San Martin Morote
+  * @license MIT
+  */
+const at = {
+  escapeDeactivates: {
+    type: Boolean,
+    default: !0
+  },
+  returnFocusOnDeactivate: {
+    type: Boolean,
+    default: !0
+  },
+  allowOutsideClick: {
+    type: [Boolean, Function],
+    default: !0
+  },
+  clickOutsideDeactivates: [Boolean, Function],
+  initialFocus: [String, Function, Boolean],
+  fallbackFocus: [String, Function],
+  checkCanFocusTrap: Function,
+  checkCanReturnFocus: Function,
+  delayInitialFocus: {
+    type: Boolean,
+    default: !0
+  },
+  document: Object,
+  preventScroll: Boolean,
+  setReturnFocus: [Object, String, Boolean, Function],
+  tabbableOptions: Object
+}, nt = ye({
+  props: Object.assign({
+    active: {
+      // TODO: could be options for activate but what about the options for deactivating?
+      type: Boolean,
+      default: !0
+    }
+  }, at),
+  emits: [
+    "update:active",
+    "activate",
+    "postActivate",
+    "deactivate",
+    "postDeactivate"
+  ],
+  render() {
+    return this.renderImpl();
+  },
+  setup(r, { slots: e, emit: t }) {
+    let a;
+    const u = ce(null), c = me(() => {
+      const s = u.value;
+      return s && (s instanceof HTMLElement ? s : s.$el);
+    });
+    function n() {
+      return a || (a = tt(c.value, {
+        escapeDeactivates: r.escapeDeactivates,
+        allowOutsideClick: r.allowOutsideClick,
+        returnFocusOnDeactivate: r.returnFocusOnDeactivate,
+        clickOutsideDeactivates: r.clickOutsideDeactivates,
+        onActivate: () => {
+          t("update:active", !0), t("activate");
+        },
+        onDeactivate: () => {
+          t("update:active", !1), t("deactivate");
+        },
+        onPostActivate: () => t("postActivate"),
+        onPostDeactivate: () => t("postDeactivate"),
+        initialFocus: r.initialFocus,
+        fallbackFocus: r.fallbackFocus,
+        tabbableOptions: r.tabbableOptions,
+        delayInitialFocus: r.delayInitialFocus
+      }));
+    }
+    return ge(() => {
+      we(() => r.active, (s) => {
+        s && c.value ? n().activate() : a && (a.deactivate(), (!c.value || c.value.nodeType === Node.COMMENT_NODE) && (a = null));
+      }, { immediate: !0, flush: "post" });
+    }), Fe(() => {
+      a && a.deactivate(), a = null;
+    }), {
+      activate() {
+        n().activate();
+      },
+      deactivate() {
+        a && a.deactivate();
+      },
+      renderImpl() {
+        if (!e.default)
+          return null;
+        const s = e.default().filter((p) => p.type !== Te);
+        return !s || !s.length || s.length > 1 ? (console.error("[focus-trap-vue]: FocusTrap requires exactly one child."), s) : Ne(s[0], { ref: u });
+      }
+    };
+  }
+}), M = (r) => {
+  r.preventDefault(), r.stopPropagation(), r.stopImmediatePropagation();
+}, it = ({
+  getNextElement: r,
+  getFirstElement: e,
+  getLastElement: t,
+  close: a,
+  disableSpaceToClick: u,
+  keepOpenedOnTab: c
+}) => {
+  const n = ce(null), s = () => {
+  };
+  let f = s;
+  const p = () => {
+    n.value = null, f = s;
+  }, F = (m) => {
+    n.value = m.index, f = m.onClick;
+  }, T = (m) => {
+    F(r(n.value, m));
+  }, N = () => {
+    p(), a();
+  };
+  return {
+    onKeydown: (m) => {
+      switch (m.code) {
+        case "ArrowDown":
+          M(m), T(1);
+          break;
+        case "ArrowUp":
+          M(m), T(-1);
+          break;
+        case "Enter":
+        case "Space": {
+          const L = m.code === "Enter", j = m.code === "Space";
+          n.value !== null && (L || j && !u) && (M(m), f());
+          break;
+        }
+        case "Home":
+          e && F(e());
+          break;
+        case "End":
+          t && F(t());
+          break;
+        case "Escape":
+          M(m), N();
+          break;
+        case "Tab":
+          c || N();
+          break;
+      }
+    },
+    currentIndex: Ee(n),
+    resetNavigation: p,
+    setElement: F
+  };
+};
+export {
+  nt as F,
+  it as u
+};