@knime/jsonforms 1.19.5 → 1.20.0

package/dist/useDropdownNavigation-EOwf_fL0.js

@@ -0,0 +1,946 @@
+import { defineComponent as Te, ref as se, computed as Se, onMounted as Fe, watch as Ne, onUnmounted as Ee, Comment as ke, cloneVNode as Ae, readonly as Ie } from "vue";
+var de = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[href]:not([inert]):not([inert] *)", "button:not([inert]):not([inert] *)", "[tabindex]:not(slot):not([inert]):not([inert] *)", "audio[controls]:not([inert]):not([inert] *)", "video[controls]:not([inert]):not([inert] *)", '[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)', "details>summary:first-of-type:not([inert]):not([inert] *)", "details:not([inert]):not([inert] *)"], V = /* @__PURE__ */ de.join(","), fe = typeof Element > "u", R = fe ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, q = !fe && Element.prototype.getRootNode ? function(n) {
+  var e;
+  return n == null || (e = n.getRootNode) === null || e === void 0 ? void 0 : e.call(n);
+} : function(n) {
+  return n?.ownerDocument;
+}, H = function(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", r = c || t && e && // closest does not exist on shadow roots, so we fall back to a manual
+  // lookup upward, in case it is not defined.
+  (typeof e.closest == "function" ? e.closest("[inert]") : H(e.parentNode));
+  return r;
+}, De = function(e) {
+  var t, a = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return a === "" || a === "true";
+}, ve = function(e, t, a) {
+  if (H(e))
+    return [];
+  var u = Array.prototype.slice.apply(e.querySelectorAll(V));
+  return t && R.call(e, V) && u.unshift(e), u = u.filter(a), u;
+}, U = function(e, t, a) {
+  for (var u = [], c = Array.from(e); c.length; ) {
+    var r = c.shift();
+    if (!H(r, !1))
+      if (r.tagName === "SLOT") {
+        var s = r.assignedElements(), b = s.length ? s : r.children, m = U(b, !0, a);
+        a.flatten ? u.push.apply(u, m) : u.push({
+          scopeParent: r,
+          candidates: m
+        });
+      } else {
+        var T = R.call(r, V);
+        T && a.filter(r) && (t || !e.includes(r)) && u.push(r);
+        var S = r.shadowRoot || // check for an undisclosed shadow
+        typeof a.getShadowRoot == "function" && a.getShadowRoot(r), E = !H(S, !1) && (!a.shadowRootFilter || a.shadowRootFilter(r));
+        if (S && E) {
+          var D = U(S === !0 ? r.children : S.children, !0, a);
+          a.flatten ? u.push.apply(u, D) : u.push({
+            scopeParent: r,
+            candidates: D
+          });
+        } else
+          c.unshift.apply(c, r.children);
+      }
+  }
+  return u;
+}, be = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, C = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || De(e)) && !be(e) ? 0 : e.tabIndex;
+}, Oe = function(e, t) {
+  var a = C(e);
+  return a < 0 && t && !be(e) ? 0 : a;
+}, Ce = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, pe = function(e) {
+  return e.tagName === "INPUT";
+}, Re = function(e) {
+  return pe(e) && e.type === "hidden";
+}, Pe = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(a) {
+    return a.tagName === "SUMMARY";
+  });
+  return t;
+}, xe = function(e, t) {
+  for (var a = 0; a < e.length; a++)
+    if (e[a].checked && e[a].form === t)
+      return e[a];
+}, je = 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 (r) {
+      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", r.message), !1;
+    }
+  var c = xe(u, e.form);
+  return !c || c === e;
+}, Be = function(e) {
+  return pe(e) && e.type === "radio";
+}, Le = function(e) {
+  return Be(e) && !je(e);
+}, Ke = 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 r, s, b;
+    for (c = !!((r = u) !== null && r !== void 0 && (s = r.ownerDocument) !== null && s !== void 0 && s.contains(u) || e != null && (b = e.ownerDocument) !== null && b !== void 0 && b.contains(e)); !c && u; ) {
+      var m, T, S;
+      a = q(u), u = (m = a) === null || m === void 0 ? void 0 : m.host, c = !!((T = u) !== null && T !== void 0 && (S = T.ownerDocument) !== null && S !== void 0 && S.contains(u));
+    }
+  }
+  return c;
+}, ie = function(e) {
+  var t = e.getBoundingClientRect(), a = t.width, u = t.height;
+  return a === 0 && u === 0;
+}, Me = function(e, t) {
+  var a = t.displayCheck, u = t.getShadowRoot;
+  if (a === "full-native" && "checkVisibility" in e) {
+    var c = e.checkVisibility({
+      // Checking opacity might be desirable for some use cases, but natively,
+      // opacity zero elements _are_ focusable and tabbable.
+      checkOpacity: !1,
+      opacityProperty: !1,
+      contentVisibilityAuto: !0,
+      visibilityProperty: !0,
+      // This is an alias for `visibilityProperty`. Contemporary browsers
+      // support both. However, this alias has wider browser support (Chrome
+      // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+      // we include it anyway.
+      checkVisibilityCSS: !0
+    });
+    return !c;
+  }
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var r = R.call(e, "details>summary:first-of-type"), s = r ? e.parentElement : e;
+  if (R.call(s, "details:not([open]) *"))
+    return !0;
+  if (!a || a === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  a === "full-native" || a === "legacy-full") {
+    if (typeof u == "function") {
+      for (var b = e; e; ) {
+        var m = e.parentElement, T = q(e);
+        if (m && !m.shadowRoot && u(m) === !0)
+          return ie(e);
+        e.assignedSlot ? e = e.assignedSlot : !m && T !== e.ownerDocument ? e = T.host : e = m;
+      }
+      e = b;
+    }
+    if (Ke(e))
+      return !e.getClientRects().length;
+    if (a !== "legacy-full")
+      return !0;
+  } else if (a === "non-zero-area")
+    return ie(e);
+  return !1;
+}, _e = 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 R.call(t, "fieldset[disabled] *") ? !0 : !u.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, W = function(e, t) {
+  return !(t.disabled || Re(t) || Me(t, e) || // For a details element with a summary, the summary element gets the focus
+  Pe(t) || _e(t));
+}, J = function(e, t) {
+  return !(Le(t) || C(t) < 0 || !W(e, t));
+}, Ge = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, he = function(e) {
+  var t = [], a = [];
+  return e.forEach(function(u, c) {
+    var r = !!u.scopeParent, s = r ? u.scopeParent : u, b = Oe(s, r), m = r ? he(u.candidates) : s;
+    b === 0 ? r ? t.push.apply(t, m) : t.push(s) : a.push({
+      documentOrder: c,
+      tabIndex: b,
+      item: u,
+      isScope: r,
+      content: m
+    });
+  }), a.sort(Ce).reduce(function(u, c) {
+    return c.isScope ? u.push.apply(u, c.content) : u.push(c.content), u;
+  }, []).concat(t);
+}, Ve = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = U([e], t.includeContainer, {
+    filter: J.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: Ge
+  }) : a = ve(e, t.includeContainer, J.bind(null, t)), he(a);
+}, qe = function(e, t) {
+  t = t || {};
+  var a;
+  return t.getShadowRoot ? a = U([e], t.includeContainer, {
+    filter: W.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : a = ve(e, t.includeContainer, W.bind(null, t)), a;
+}, P = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return R.call(e, V) === !1 ? !1 : J(t, e);
+}, He = /* @__PURE__ */ de.concat("iframe:not([inert]):not([inert] *)").join(","), X = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return R.call(e, He) === !1 ? !1 : W(t, e);
+};
+function Q(n, e) {
+  (e == null || e > n.length) && (e = n.length);
+  for (var t = 0, a = Array(e); t < e; t++) a[t] = n[t];
+  return a;
+}
+function Ue(n) {
+  if (Array.isArray(n)) return Q(n);
+}
+function oe(n, e) {
+  var t = typeof Symbol < "u" && n[Symbol.iterator] || n["@@iterator"];
+  if (!t) {
+    if (Array.isArray(n) || (t = ye(n)) || e) {
+      t && (n = t);
+      var a = 0, u = function() {
+      };
+      return {
+        s: u,
+        n: function() {
+          return a >= n.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: n[a++]
+          };
+        },
+        e: function(b) {
+          throw b;
+        },
+        f: u
+      };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var c, r = !0, s = !1;
+  return {
+    s: function() {
+      t = t.call(n);
+    },
+    n: function() {
+      var b = t.next();
+      return r = b.done, b;
+    },
+    e: function(b) {
+      s = !0, c = b;
+    },
+    f: function() {
+      try {
+        r || t.return == null || t.return();
+      } finally {
+        if (s) throw c;
+      }
+    }
+  };
+}
+function We(n, e, t) {
+  return (e = Xe(e)) in n ? Object.defineProperty(n, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : n[e] = t, n;
+}
+function Ye(n) {
+  if (typeof Symbol < "u" && n[Symbol.iterator] != null || n["@@iterator"] != null) return Array.from(n);
+}
+function Ze() {
+  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 ue(n, e) {
+  var t = Object.keys(n);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(n);
+    e && (a = a.filter(function(u) {
+      return Object.getOwnPropertyDescriptor(n, u).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function ce(n) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? ue(Object(t), !0).forEach(function(a) {
+      We(n, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(n, Object.getOwnPropertyDescriptors(t)) : ue(Object(t)).forEach(function(a) {
+      Object.defineProperty(n, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return n;
+}
+function $e(n) {
+  return Ue(n) || Ye(n) || ye(n) || Ze();
+}
+function ze(n, e) {
+  if (typeof n != "object" || !n) return n;
+  var t = n[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var a = t.call(n, e);
+    if (typeof a != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(n);
+}
+function Xe(n) {
+  var e = ze(n, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function ye(n, e) {
+  if (n) {
+    if (typeof n == "string") return Q(n, e);
+    var t = {}.toString.call(n).slice(8, -1);
+    return t === "Object" && n.constructor && (t = n.constructor.name), t === "Map" || t === "Set" ? Array.from(n) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? Q(n, e) : void 0;
+  }
+}
+var A = {
+  // Returns the trap from the top of the stack.
+  getActiveTrap: function(e) {
+    return e?.length > 0 ? e[e.length - 1] : null;
+  },
+  // Pauses the currently active trap, then adds a new trap to the stack.
+  activateTrap: function(e, t) {
+    var a = A.getActiveTrap(e);
+    t !== a && A.pauseTrap(e);
+    var u = e.indexOf(t);
+    u === -1 || e.splice(u, 1), e.push(t);
+  },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
+  deactivateTrap: function(e, t) {
+    var a = e.indexOf(t);
+    a !== -1 && e.splice(a, 1), A.unpauseTrap(e);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function(e) {
+    var t = A.getActiveTrap(e);
+    t?._setPausedState(!0);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function(e) {
+    var t = A.getActiveTrap(e);
+    t && !t._isManuallyPaused() && t._setPausedState(!1);
+  }
+}, Je = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, Qe = function(e) {
+  return e?.key === "Escape" || e?.key === "Esc" || e?.keyCode === 27;
+}, L = function(e) {
+  return e?.key === "Tab" || e?.keyCode === 9;
+}, et = function(e) {
+  return L(e) && !e.shiftKey;
+}, tt = function(e) {
+  return L(e) && e.shiftKey;
+}, le = function(e) {
+  return setTimeout(e, 0);
+}, B = 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;
+}, _ = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, at = [], rt = function(e, t) {
+  var a = t?.document || document, u = t?.trapStack || at, c = ce({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isolateSubtrees: !1,
+    isKeyForward: et,
+    isKeyBackward: tt
+  }, t), r = {
+    // 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: [],
+    // references to nodes that are siblings to the ancestors of this trap's containers.
+    /** @type {Set<HTMLElement>} */
+    adjacentElements: /* @__PURE__ */ new Set(),
+    // references to nodes that were inert or aria-hidden before the trap was activated.
+    /** @type {Set<HTMLElement>} */
+    alreadySilent: /* @__PURE__ */ new Set(),
+    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, b = function(i, o, l) {
+    return i && i[o] !== void 0 ? i[o] : c[l || o];
+  }, m = function(i, o) {
+    var l = typeof o?.composedPath == "function" ? o.composedPath() : void 0;
+    return r.containerGroups.findIndex(function(v) {
+      var f = v.container, p = v.tabbableNodes;
+      return f.contains(i) || l?.includes(f) || p.find(function(d) {
+        return d === i;
+      });
+    });
+  }, T = function(i) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, l = o.hasFallback, v = l === void 0 ? !1 : l, f = o.params, p = f === void 0 ? [] : f, d = c[i];
+    if (typeof d == "function" && (d = d.apply(void 0, $e(p))), 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 h = d;
+    if (typeof d == "string") {
+      try {
+        h = a.querySelector(d);
+      } catch (y) {
+        throw new Error("`".concat(i, '` appears to be an invalid selector; error="').concat(y.message, '"'));
+      }
+      if (!h && !v)
+        throw new Error("`".concat(i, "` as selector refers to no known node"));
+    }
+    return h;
+  }, S = function() {
+    var i = T("initialFocus", {
+      hasFallback: !0
+    });
+    if (i === !1)
+      return !1;
+    if (i === void 0 || i && !X(i, c.tabbableOptions))
+      if (m(a.activeElement) >= 0)
+        i = a.activeElement;
+      else {
+        var o = r.tabbableGroups[0], l = o && o.firstTabbableNode;
+        i = l || T("fallbackFocus");
+      }
+    else i === null && (i = T("fallbackFocus"));
+    if (!i)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return i;
+  }, E = function() {
+    if (r.containerGroups = r.containers.map(function(i) {
+      var o = Ve(i, c.tabbableOptions), l = qe(i, c.tabbableOptions), v = o.length > 0 ? o[0] : void 0, f = o.length > 0 ? o[o.length - 1] : void 0, p = l.find(function(y) {
+        return P(y);
+      }), d = l.slice().reverse().find(function(y) {
+        return P(y);
+      }), h = !!o.find(function(y) {
+        return C(y) > 0;
+      });
+      return {
+        container: i,
+        tabbableNodes: o,
+        focusableNodes: l,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: h,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: v,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: f,
+        // 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: p,
+        /** 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(F) {
+          var k = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, N = o.indexOf(F);
+          return N < 0 ? k ? l.slice(l.indexOf(F) + 1).find(function(O) {
+            return P(O);
+          }) : l.slice(0, l.indexOf(F)).reverse().find(function(O) {
+            return P(O);
+          }) : o[N + (k ? 1 : -1)];
+        }
+      };
+    }), r.tabbableGroups = r.containerGroups.filter(function(i) {
+      return i.tabbableNodes.length > 0;
+    }), r.tabbableGroups.length <= 0 && !T("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 (r.containerGroups.find(function(i) {
+      return i.posTabIndexesFound;
+    }) && r.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.");
+  }, D = function(i) {
+    var o = i.activeElement;
+    if (o)
+      return o.shadowRoot && o.shadowRoot.activeElement !== null ? D(o.shadowRoot) : o;
+  }, w = function(i) {
+    if (i !== !1 && i !== D(document)) {
+      if (!i || !i.focus) {
+        w(S());
+        return;
+      }
+      i.focus({
+        preventScroll: !!c.preventScroll
+      }), r.mostRecentlyFocusedNode = i, Je(i) && i.select();
+    }
+  }, K = function(i) {
+    var o = T("setReturnFocus", {
+      params: [i]
+    });
+    return o || (o === !1 ? !1 : i);
+  }, M = function(i) {
+    var o = i.target, l = i.event, v = i.isBackward, f = v === void 0 ? !1 : v;
+    o = o || _(l), E();
+    var p = null;
+    if (r.tabbableGroups.length > 0) {
+      var d = m(o, l), h = d >= 0 ? r.containerGroups[d] : void 0;
+      if (d < 0)
+        f ? p = r.tabbableGroups[r.tabbableGroups.length - 1].lastTabbableNode : p = r.tabbableGroups[0].firstTabbableNode;
+      else if (f) {
+        var y = r.tabbableGroups.findIndex(function($) {
+          var z = $.firstTabbableNode;
+          return o === z;
+        });
+        if (y < 0 && (h.container === o || X(o, c.tabbableOptions) && !P(o, c.tabbableOptions) && !h.nextTabbableNode(o, !1)) && (y = d), y >= 0) {
+          var F = y === 0 ? r.tabbableGroups.length - 1 : y - 1, k = r.tabbableGroups[F];
+          p = C(o) >= 0 ? k.lastTabbableNode : k.lastDomTabbableNode;
+        } else L(l) || (p = h.nextTabbableNode(o, !1));
+      } else {
+        var N = r.tabbableGroups.findIndex(function($) {
+          var z = $.lastTabbableNode;
+          return o === z;
+        });
+        if (N < 0 && (h.container === o || X(o, c.tabbableOptions) && !P(o, c.tabbableOptions) && !h.nextTabbableNode(o)) && (N = d), N >= 0) {
+          var O = N === r.tabbableGroups.length - 1 ? 0 : N + 1, I = r.tabbableGroups[O];
+          p = C(o) >= 0 ? I.firstTabbableNode : I.firstDomTabbableNode;
+        } else L(l) || (p = h.nextTabbableNode(o));
+      }
+    } else
+      p = T("fallbackFocus");
+    return p;
+  }, x = function(i) {
+    var o = _(i);
+    if (!(m(o, i) >= 0)) {
+      if (B(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;
+      }
+      B(c.allowOutsideClick, i) || i.preventDefault();
+    }
+  }, Y = function(i) {
+    var o = _(i), l = m(o, i) >= 0;
+    if (l || o instanceof Document)
+      l && (r.mostRecentlyFocusedNode = o);
+    else {
+      i.stopImmediatePropagation();
+      var v, f = !0;
+      if (r.mostRecentlyFocusedNode)
+        if (C(r.mostRecentlyFocusedNode) > 0) {
+          var p = m(r.mostRecentlyFocusedNode), d = r.containerGroups[p].tabbableNodes;
+          if (d.length > 0) {
+            var h = d.findIndex(function(y) {
+              return y === r.mostRecentlyFocusedNode;
+            });
+            h >= 0 && (c.isKeyForward(r.recentNavEvent) ? h + 1 < d.length && (v = d[h + 1], f = !1) : h - 1 >= 0 && (v = d[h - 1], f = !1));
+          }
+        } else
+          r.containerGroups.some(function(y) {
+            return y.tabbableNodes.some(function(F) {
+              return C(F) > 0;
+            });
+          }) || (f = !1);
+      else
+        f = !1;
+      f && (v = M({
+        // 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: r.mostRecentlyFocusedNode,
+        isBackward: c.isKeyBackward(r.recentNavEvent)
+      })), w(v || r.mostRecentlyFocusedNode || S());
+    }
+    r.recentNavEvent = void 0;
+  }, me = function(i) {
+    var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    r.recentNavEvent = i;
+    var l = M({
+      event: i,
+      isBackward: o
+    });
+    l && (L(i) && i.preventDefault(), w(l));
+  }, ee = function(i) {
+    (c.isKeyForward(i) || c.isKeyBackward(i)) && me(i, c.isKeyBackward(i));
+  }, te = function(i) {
+    Qe(i) && B(c.escapeDeactivates, i) !== !1 && (i.preventDefault(), s.deactivate());
+  }, ae = function(i) {
+    var o = _(i);
+    m(o, i) >= 0 || B(c.clickOutsideDeactivates, i) || B(c.allowOutsideClick, i) || (i.preventDefault(), i.stopImmediatePropagation());
+  }, re = function() {
+    if (r.active)
+      return A.activateTrap(u, s), r.delayInitialFocusTimer = c.delayInitialFocus ? le(function() {
+        w(S());
+      }) : w(S()), a.addEventListener("focusin", Y, !0), a.addEventListener("mousedown", x, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("touchstart", x, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("click", ae, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", ee, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", te), s;
+  }, ge = function(i) {
+    r.active && !r.paused && s._setSubtreeIsolation(!1), r.adjacentElements.clear(), r.alreadySilent.clear();
+    var o = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), v = oe(i), f;
+    try {
+      for (v.s(); !(f = v.n()).done; ) {
+        var p = f.value;
+        o.add(p);
+        for (var d = typeof ShadowRoot < "u" && p.getRootNode() instanceof ShadowRoot, h = p; h; ) {
+          o.add(h);
+          var y = h.parentElement, F = [];
+          y ? F = y.children : !y && d && (F = h.getRootNode().children, y = h.getRootNode().host, d = typeof ShadowRoot < "u" && y.getRootNode() instanceof ShadowRoot);
+          var k = oe(F), N;
+          try {
+            for (k.s(); !(N = k.n()).done; ) {
+              var O = N.value;
+              l.add(O);
+            }
+          } catch (I) {
+            k.e(I);
+          } finally {
+            k.f();
+          }
+          h = y;
+        }
+      }
+    } catch (I) {
+      v.e(I);
+    } finally {
+      v.f();
+    }
+    o.forEach(function(I) {
+      l.delete(I);
+    }), r.adjacentElements = l;
+  }, ne = function() {
+    if (r.active)
+      return a.removeEventListener("focusin", Y, !0), a.removeEventListener("mousedown", x, !0), a.removeEventListener("touchstart", x, !0), a.removeEventListener("click", ae, !0), a.removeEventListener("keydown", ee, !0), a.removeEventListener("keydown", te), s;
+  }, we = function(i) {
+    var o = i.some(function(l) {
+      var v = Array.from(l.removedNodes);
+      return v.some(function(f) {
+        return f === r.mostRecentlyFocusedNode;
+      });
+    });
+    o && w(S());
+  }, Z = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(we) : void 0, j = function() {
+    Z && (Z.disconnect(), r.active && !r.paused && r.containers.map(function(i) {
+      Z.observe(i, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return s = {
+    get active() {
+      return r.active;
+    },
+    get paused() {
+      return r.paused;
+    },
+    activate: function(i) {
+      if (r.active)
+        return this;
+      var o = b(i, "onActivate"), l = b(i, "onPostActivate"), v = b(i, "checkCanFocusTrap"), f = A.getActiveTrap(u), p = !1;
+      if (f && !f.paused) {
+        var d;
+        (d = f._setSubtreeIsolation) === null || d === void 0 || d.call(f, !1), p = !0;
+      }
+      try {
+        v || E(), r.active = !0, r.paused = !1, r.nodeFocusedBeforeActivation = D(a), o?.();
+        var h = function() {
+          v && E(), re(), j(), c.isolateSubtrees && s._setSubtreeIsolation(!0), l?.();
+        };
+        if (v)
+          return v(r.containers.concat()).then(h, h), this;
+        h();
+      } catch (F) {
+        if (f === A.getActiveTrap(u) && p) {
+          var y;
+          (y = f._setSubtreeIsolation) === null || y === void 0 || y.call(f, !0);
+        }
+        throw F;
+      }
+      return this;
+    },
+    deactivate: function(i) {
+      if (!r.active)
+        return this;
+      var o = ce({
+        onDeactivate: c.onDeactivate,
+        onPostDeactivate: c.onPostDeactivate,
+        checkCanReturnFocus: c.checkCanReturnFocus
+      }, i);
+      clearTimeout(r.delayInitialFocusTimer), r.delayInitialFocusTimer = void 0, r.paused || s._setSubtreeIsolation(!1), r.alreadySilent.clear(), ne(), r.active = !1, r.paused = !1, j(), A.deactivateTrap(u, s);
+      var l = b(o, "onDeactivate"), v = b(o, "onPostDeactivate"), f = b(o, "checkCanReturnFocus"), p = b(o, "returnFocus", "returnFocusOnDeactivate");
+      l?.();
+      var d = function() {
+        le(function() {
+          p && w(K(r.nodeFocusedBeforeActivation)), v?.();
+        });
+      };
+      return p && f ? (f(K(r.nodeFocusedBeforeActivation)).then(d, d), this) : (d(), this);
+    },
+    pause: function(i) {
+      return r.active ? (r.manuallyPaused = !0, this._setPausedState(!0, i)) : this;
+    },
+    unpause: function(i) {
+      return r.active ? (r.manuallyPaused = !1, u[u.length - 1] !== this ? this : this._setPausedState(!1, i)) : this;
+    },
+    updateContainerElements: function(i) {
+      var o = [].concat(i).filter(Boolean);
+      return r.containers = o.map(function(l) {
+        return typeof l == "string" ? a.querySelector(l) : l;
+      }), c.isolateSubtrees && ge(r.containers), r.active && (E(), c.isolateSubtrees && !r.paused && s._setSubtreeIsolation(!0)), j(), this;
+    }
+  }, Object.defineProperties(s, {
+    _isManuallyPaused: {
+      value: function() {
+        return r.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(i, o) {
+        if (r.paused === i)
+          return this;
+        if (r.paused = i, i) {
+          var l = b(o, "onPause"), v = b(o, "onPostPause");
+          l?.(), ne(), j(), s._setSubtreeIsolation(!1), v?.();
+        } else {
+          var f = b(o, "onUnpause"), p = b(o, "onPostUnpause");
+          f?.(), s._setSubtreeIsolation(!0), E(), re(), j(), p?.();
+        }
+        return this;
+      }
+    },
+    _setSubtreeIsolation: {
+      value: function(i) {
+        c.isolateSubtrees && r.adjacentElements.forEach(function(o) {
+          var l;
+          i ? c.isolateSubtrees === "aria-hidden" ? ((o.ariaHidden === "true" || ((l = o.getAttribute("aria-hidden")) === null || l === void 0 ? void 0 : l.toLowerCase()) === "true") && r.alreadySilent.add(o), o.setAttribute("aria-hidden", "true")) : ((o.inert || o.hasAttribute("inert")) && r.alreadySilent.add(o), o.setAttribute("inert", !0)) : r.alreadySilent.has(o) || (c.isolateSubtrees === "aria-hidden" ? o.removeAttribute("aria-hidden") : o.removeAttribute("inert"));
+        });
+      }
+    }
+  }), s.updateContainerElements(e), s;
+};
+const nt = {
+  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
+}, ot = Te({
+  props: Object.assign({
+    active: {
+      // TODO: could be options for activate but what about the options for deactivating?
+      type: Boolean,
+      default: !0
+    }
+  }, nt),
+  emits: [
+    "update:active",
+    "activate",
+    "postActivate",
+    "deactivate",
+    "postDeactivate"
+  ],
+  render() {
+    return this.renderImpl();
+  },
+  setup(n, { slots: e, emit: t }) {
+    let a;
+    const u = se(null), c = Se(() => {
+      const s = u.value;
+      return s && (s instanceof HTMLElement ? s : s.$el);
+    });
+    function r() {
+      return a || (a = rt(c.value, {
+        escapeDeactivates: n.escapeDeactivates,
+        allowOutsideClick: n.allowOutsideClick,
+        returnFocusOnDeactivate: n.returnFocusOnDeactivate,
+        clickOutsideDeactivates: n.clickOutsideDeactivates,
+        onActivate: () => {
+          t("update:active", !0), t("activate");
+        },
+        onDeactivate: () => {
+          t("update:active", !1), t("deactivate");
+        },
+        onPostActivate: () => t("postActivate"),
+        onPostDeactivate: () => t("postDeactivate"),
+        initialFocus: n.initialFocus,
+        fallbackFocus: n.fallbackFocus,
+        tabbableOptions: n.tabbableOptions,
+        delayInitialFocus: n.delayInitialFocus
+      }));
+    }
+    return Fe(() => {
+      Ne(() => n.active, (s) => {
+        s && c.value ? r().activate() : a && (a.deactivate(), (!c.value || c.value.nodeType === Node.COMMENT_NODE) && (a = null));
+      }, { immediate: !0, flush: "post" });
+    }), Ee(() => {
+      a && a.deactivate(), a = null;
+    }), {
+      activate() {
+        r().activate();
+      },
+      deactivate() {
+        a && a.deactivate();
+      },
+      renderImpl() {
+        if (!e.default)
+          return null;
+        const s = e.default().filter((m) => m.type !== ke);
+        return !s || !s.length || s.length > 1 ? (console.error("[focus-trap-vue]: FocusTrap requires exactly one child."), s) : Ae(s[0], { ref: u });
+      }
+    };
+  }
+}), G = (n) => {
+  n.preventDefault(), n.stopPropagation(), n.stopImmediatePropagation();
+}, ut = ({
+  getNextElement: n,
+  getFirstElement: e,
+  getLastElement: t,
+  close: a,
+  disableSpaceToClick: u,
+  keepOpenedOnTab: c
+}) => {
+  const r = se(null), s = () => {
+  };
+  let b = s;
+  const m = () => {
+    r.value = null, b = s;
+  }, T = (w) => {
+    r.value = w.index, b = w.onClick;
+  }, S = (w) => {
+    T(n(r.value, w));
+  }, E = () => {
+    m(), a();
+  };
+  return {
+    onKeydown: (w) => {
+      switch (w.code) {
+        case "ArrowDown":
+          G(w), S(1);
+          break;
+        case "ArrowUp":
+          G(w), S(-1);
+          break;
+        case "Enter":
+        case "Space": {
+          const K = w.code === "Enter", M = w.code === "Space";
+          r.value !== null && (K || M && !u) && (G(w), b());
+          break;
+        }
+        case "Home":
+          e && T(e());
+          break;
+        case "End":
+          t && T(t());
+          break;
+        case "Escape":
+          G(w), E();
+          break;
+        case "Tab":
+          c || E();
+          break;
+      }
+    },
+    currentIndex: Ie(r),
+    resetNavigation: m,
+    setElement: T
+  };
+};
+export {
+  ot as F,
+  ut as u
+};