@knime/scripting-editor 0.0.127 → 0.0.129

package/dist/useDropdownNavigation-CdrbT-CQ-Dxb_y1Fq.js

@@ -0,0 +1,2003 @@
+import { computed as U, ref as J, shallowRef as Ot, shallowReadonly as ae, watch as be, getCurrentScope as kt, onScopeDispose as Dt, unref as At, defineComponent as Ft, readonly as Pt, onMounted as Nt, onUnmounted as Ct, Comment as It, cloneVNode as Lt } from "vue";
+var ut = ["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] *)"], ye = /* @__PURE__ */ ut.join(","), st = typeof Element > "u", te = st ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, ge = !st && Element.prototype.getRootNode ? function(e) {
+  var t;
+  return e == null || (t = e.getRootNode) === null || t === void 0 ? void 0 : t.call(e);
+} : function(e) {
+  return e == null ? void 0 : e.ownerDocument;
+}, we = function(e, t) {
+  var n;
+  t === void 0 && (t = !0);
+  var o = e == null || (n = e.getAttribute) === null || n === void 0 ? void 0 : n.call(e, "inert"), a = o === "" || o === "true", r = a || 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]") : we(e.parentNode));
+  return r;
+}, jt = function(e) {
+  var t, n = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return n === "" || n === "true";
+}, ct = function(e, t, n) {
+  if (we(e))
+    return [];
+  var o = Array.prototype.slice.apply(e.querySelectorAll(ye));
+  return t && te.call(e, ye) && o.unshift(e), o = o.filter(n), o;
+}, xe = function(e, t, n) {
+  for (var o = [], a = Array.from(e); a.length; ) {
+    var r = a.shift();
+    if (!we(r, !1))
+      if (r.tagName === "SLOT") {
+        var i = r.assignedElements(), l = i.length ? i : r.children, c = xe(l, !0, n);
+        n.flatten ? o.push.apply(o, c) : o.push({
+          scopeParent: r,
+          candidates: c
+        });
+      } else {
+        var f = te.call(r, ye);
+        f && n.filter(r) && (t || !e.includes(r)) && o.push(r);
+        var d = r.shadowRoot || // check for an undisclosed shadow
+        typeof n.getShadowRoot == "function" && n.getShadowRoot(r), v = !we(d, !1) && (!n.shadowRootFilter || n.shadowRootFilter(r));
+        if (d && v) {
+          var h = xe(d === !0 ? r.children : d.children, !0, n);
+          n.flatten ? o.push.apply(o, h) : o.push({
+            scopeParent: r,
+            candidates: h
+          });
+        } else
+          a.unshift.apply(a, r.children);
+      }
+  }
+  return o;
+}, ft = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, Q = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || jt(e)) && !ft(e) ? 0 : e.tabIndex;
+}, Bt = function(e, t) {
+  var n = Q(e);
+  return n < 0 && t && !ft(e) ? 0 : n;
+}, Gt = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, dt = function(e) {
+  return e.tagName === "INPUT";
+}, _t = function(e) {
+  return dt(e) && e.type === "hidden";
+}, Mt = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(n) {
+    return n.tagName === "SUMMARY";
+  });
+  return t;
+}, Vt = function(e, t) {
+  for (var n = 0; n < e.length; n++)
+    if (e[n].checked && e[n].form === t)
+      return e[n];
+}, Ht = function(e) {
+  if (!e.name)
+    return !0;
+  var t = e.form || ge(e), n = function(r) {
+    return t.querySelectorAll('input[type="radio"][name="' + r + '"]');
+  }, o;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    o = n(window.CSS.escape(e.name));
+  else
+    try {
+      o = n(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 a = Vt(o, e.form);
+  return !a || a === e;
+}, Kt = function(e) {
+  return dt(e) && e.type === "radio";
+}, Ut = function(e) {
+  return Kt(e) && !Ht(e);
+}, $t = function(e) {
+  var t, n = e && ge(e), o = (t = n) === null || t === void 0 ? void 0 : t.host, a = !1;
+  if (n && n !== e) {
+    var r, i, l;
+    for (a = !!((r = o) !== null && r !== void 0 && (i = r.ownerDocument) !== null && i !== void 0 && i.contains(o) || e != null && (l = e.ownerDocument) !== null && l !== void 0 && l.contains(e)); !a && o; ) {
+      var c, f, d;
+      n = ge(o), o = (c = n) === null || c === void 0 ? void 0 : c.host, a = !!((f = o) !== null && f !== void 0 && (d = f.ownerDocument) !== null && d !== void 0 && d.contains(o));
+    }
+  }
+  return a;
+}, qe = function(e) {
+  var t = e.getBoundingClientRect(), n = t.width, o = t.height;
+  return n === 0 && o === 0;
+}, Wt = function(e, t) {
+  var n = t.displayCheck, o = t.getShadowRoot;
+  if (n === "full-native" && "checkVisibility" in e) {
+    var a = 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 !a;
+  }
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var r = te.call(e, "details>summary:first-of-type"), i = r ? e.parentElement : e;
+  if (te.call(i, "details:not([open]) *"))
+    return !0;
+  if (!n || n === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  n === "full-native" || n === "legacy-full") {
+    if (typeof o == "function") {
+      for (var l = e; e; ) {
+        var c = e.parentElement, f = ge(e);
+        if (c && !c.shadowRoot && o(c) === !0)
+          return qe(e);
+        e.assignedSlot ? e = e.assignedSlot : !c && f !== e.ownerDocument ? e = f.host : e = c;
+      }
+      e = l;
+    }
+    if ($t(e))
+      return !e.getClientRects().length;
+    if (n !== "legacy-full")
+      return !0;
+  } else if (n === "non-zero-area")
+    return qe(e);
+  return !1;
+}, qt = function(e) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))
+    for (var t = e.parentElement; t; ) {
+      if (t.tagName === "FIELDSET" && t.disabled) {
+        for (var n = 0; n < t.children.length; n++) {
+          var o = t.children.item(n);
+          if (o.tagName === "LEGEND")
+            return te.call(t, "fieldset[disabled] *") ? !0 : !o.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, Se = function(e, t) {
+  return !(t.disabled || _t(t) || Wt(t, e) || // For a details element with a summary, the summary element gets the focus
+  Mt(t) || qt(t));
+}, _e = function(e, t) {
+  return !(Ut(t) || Q(t) < 0 || !Se(e, t));
+}, zt = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, pt = function(e) {
+  var t = [], n = [];
+  return e.forEach(function(o, a) {
+    var r = !!o.scopeParent, i = r ? o.scopeParent : o, l = Bt(i, r), c = r ? pt(o.candidates) : i;
+    l === 0 ? r ? t.push.apply(t, c) : t.push(i) : n.push({
+      documentOrder: a,
+      tabIndex: l,
+      item: o,
+      isScope: r,
+      content: c
+    });
+  }), n.sort(Gt).reduce(function(o, a) {
+    return a.isScope ? o.push.apply(o, a.content) : o.push(a.content), o;
+  }, []).concat(t);
+}, Yt = function(e, t) {
+  t = t || {};
+  var n;
+  return t.getShadowRoot ? n = xe([e], t.includeContainer, {
+    filter: _e.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: zt
+  }) : n = ct(e, t.includeContainer, _e.bind(null, t)), pt(n);
+}, Xt = function(e, t) {
+  t = t || {};
+  var n;
+  return t.getShadowRoot ? n = xe([e], t.includeContainer, {
+    filter: Se.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : n = ct(e, t.includeContainer, Se.bind(null, t)), n;
+}, ie = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return te.call(e, ye) === !1 ? !1 : _e(t, e);
+}, Zt = /* @__PURE__ */ ut.concat("iframe:not([inert]):not([inert] *)").join(","), je = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return te.call(e, Zt) === !1 ? !1 : Se(t, e);
+};
+function Me(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var n = 0, o = Array(t); n < t; n++) o[n] = e[n];
+  return o;
+}
+function Jt(e) {
+  if (Array.isArray(e)) return Me(e);
+}
+function ze(e, t) {
+  var n = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!n) {
+    if (Array.isArray(e) || (n = vt(e)) || t) {
+      n && (e = n);
+      var o = 0, a = function() {
+      };
+      return {
+        s: a,
+        n: function() {
+          return o >= e.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: e[o++]
+          };
+        },
+        e: function(c) {
+          throw c;
+        },
+        f: a
+      };
+    }
+    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 r, i = !0, l = !1;
+  return {
+    s: function() {
+      n = n.call(e);
+    },
+    n: function() {
+      var c = n.next();
+      return i = c.done, c;
+    },
+    e: function(c) {
+      l = !0, r = c;
+    },
+    f: function() {
+      try {
+        i || n.return == null || n.return();
+      } finally {
+        if (l) throw r;
+      }
+    }
+  };
+}
+function Qt(e, t, n) {
+  return (t = rn(t)) in e ? Object.defineProperty(e, t, {
+    value: n,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = n, e;
+}
+function en(e) {
+  if (typeof Symbol < "u" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+}
+function tn() {
+  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 Ye(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    t && (o = o.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), n.push.apply(n, o);
+  }
+  return n;
+}
+function Xe(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? Ye(Object(n), !0).forEach(function(o) {
+      Qt(e, o, n[o]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : Ye(Object(n)).forEach(function(o) {
+      Object.defineProperty(e, o, Object.getOwnPropertyDescriptor(n, o));
+    });
+  }
+  return e;
+}
+function nn(e) {
+  return Jt(e) || en(e) || vt(e) || tn();
+}
+function on(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var o = n.call(e, t);
+    if (typeof o != "object") return o;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function rn(e) {
+  var t = on(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function vt(e, t) {
+  if (e) {
+    if (typeof e == "string") return Me(e, t);
+    var n = {}.toString.call(e).slice(8, -1);
+    return n === "Object" && e.constructor && (n = e.constructor.name), n === "Map" || n === "Set" ? Array.from(e) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? Me(e, t) : void 0;
+  }
+}
+var $ = {
+  // Returns the trap from the top of the stack.
+  getActiveTrap: function(e) {
+    return (e == null ? void 0 : 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 n = $.getActiveTrap(e);
+    t !== n && $.pauseTrap(e);
+    var o = e.indexOf(t);
+    o === -1 || e.splice(o, 1), e.push(t);
+  },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
+  deactivateTrap: function(e, t) {
+    var n = e.indexOf(t);
+    n !== -1 && e.splice(n, 1), $.unpauseTrap(e);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function(e) {
+    var t = $.getActiveTrap(e);
+    t == null || t._setPausedState(!0);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function(e) {
+    var t = $.getActiveTrap(e);
+    t && !t._isManuallyPaused() && t._setPausedState(!1);
+  }
+}, an = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, ln = function(e) {
+  return (e == null ? void 0 : e.key) === "Escape" || (e == null ? void 0 : e.key) === "Esc" || (e == null ? void 0 : e.keyCode) === 27;
+}, fe = function(e) {
+  return (e == null ? void 0 : e.key) === "Tab" || (e == null ? void 0 : e.keyCode) === 9;
+}, un = function(e) {
+  return fe(e) && !e.shiftKey;
+}, sn = function(e) {
+  return fe(e) && e.shiftKey;
+}, Ze = function(e) {
+  return setTimeout(e, 0);
+}, se = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), o = 1; o < t; o++)
+    n[o - 1] = arguments[o];
+  return typeof e == "function" ? e.apply(void 0, n) : e;
+}, ve = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, cn = [], fn = function(e, t) {
+  var n = (t == null ? void 0 : t.document) || document, o = (t == null ? void 0 : t.trapStack) || cn, a = Xe({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isolateSubtrees: !1,
+    isKeyForward: un,
+    isKeyBackward: sn
+  }, 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
+  }, i, l = function(u, s, m) {
+    return u && u[s] !== void 0 ? u[s] : a[m || s];
+  }, c = function(u, s) {
+    var m = typeof (s == null ? void 0 : s.composedPath) == "function" ? s.composedPath() : void 0;
+    return r.containerGroups.findIndex(function(S) {
+      var g = S.container, x = S.tabbableNodes;
+      return g.contains(u) || (m == null ? void 0 : m.includes(g)) || x.find(function(b) {
+        return b === u;
+      });
+    });
+  }, f = function(u) {
+    var s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, m = s.hasFallback, S = m === void 0 ? !1 : m, g = s.params, x = g === void 0 ? [] : g, b = a[u];
+    if (typeof b == "function" && (b = b.apply(void 0, nn(x))), b === !0 && (b = void 0), !b) {
+      if (b === void 0 || b === !1)
+        return b;
+      throw new Error("`".concat(u, "` was specified but was not a node, or did not return a node"));
+    }
+    var E = b;
+    if (typeof b == "string") {
+      try {
+        E = n.querySelector(b);
+      } catch (k) {
+        throw new Error("`".concat(u, '` appears to be an invalid selector; error="').concat(k.message, '"'));
+      }
+      if (!E && !S)
+        throw new Error("`".concat(u, "` as selector refers to no known node"));
+    }
+    return E;
+  }, d = function() {
+    var u = f("initialFocus", {
+      hasFallback: !0
+    });
+    if (u === !1)
+      return !1;
+    if (u === void 0 || u && !je(u, a.tabbableOptions))
+      if (c(n.activeElement) >= 0)
+        u = n.activeElement;
+      else {
+        var s = r.tabbableGroups[0], m = s && s.firstTabbableNode;
+        u = m || f("fallbackFocus");
+      }
+    else u === null && (u = f("fallbackFocus"));
+    if (!u)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return u;
+  }, v = function() {
+    if (r.containerGroups = r.containers.map(function(u) {
+      var s = Yt(u, a.tabbableOptions), m = Xt(u, a.tabbableOptions), S = s.length > 0 ? s[0] : void 0, g = s.length > 0 ? s[s.length - 1] : void 0, x = m.find(function(k) {
+        return ie(k);
+      }), b = m.slice().reverse().find(function(k) {
+        return ie(k);
+      }), E = !!s.find(function(k) {
+        return Q(k) > 0;
+      });
+      return {
+        container: u,
+        tabbableNodes: s,
+        focusableNodes: m,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: E,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: S,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: g,
+        // 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: x,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: b,
+        /**
+         * 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(k) {
+          var I = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, M = s.indexOf(k);
+          return M < 0 ? I ? m.slice(m.indexOf(k) + 1).find(function(L) {
+            return ie(L);
+          }) : m.slice(0, m.indexOf(k)).reverse().find(function(L) {
+            return ie(L);
+          }) : s[M + (I ? 1 : -1)];
+        }
+      };
+    }), r.tabbableGroups = r.containerGroups.filter(function(u) {
+      return u.tabbableNodes.length > 0;
+    }), r.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 (r.containerGroups.find(function(u) {
+      return u.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.");
+  }, h = function(u) {
+    var s = u.activeElement;
+    if (s)
+      return s.shadowRoot && s.shadowRoot.activeElement !== null ? h(s.shadowRoot) : s;
+  }, p = function(u) {
+    if (u !== !1 && u !== h(document)) {
+      if (!u || !u.focus) {
+        p(d());
+        return;
+      }
+      u.focus({
+        preventScroll: !!a.preventScroll
+      }), r.mostRecentlyFocusedNode = u, an(u) && u.select();
+    }
+  }, y = function(u) {
+    var s = f("setReturnFocus", {
+      params: [u]
+    });
+    return s || (s === !1 ? !1 : u);
+  }, w = function(u) {
+    var s = u.target, m = u.event, S = u.isBackward, g = S === void 0 ? !1 : S;
+    s = s || ve(m), v();
+    var x = null;
+    if (r.tabbableGroups.length > 0) {
+      var b = c(s, m), E = b >= 0 ? r.containerGroups[b] : void 0;
+      if (b < 0)
+        g ? x = r.tabbableGroups[r.tabbableGroups.length - 1].lastTabbableNode : x = r.tabbableGroups[0].firstTabbableNode;
+      else if (g) {
+        var k = r.tabbableGroups.findIndex(function(Ie) {
+          var Le = Ie.firstTabbableNode;
+          return s === Le;
+        });
+        if (k < 0 && (E.container === s || je(s, a.tabbableOptions) && !ie(s, a.tabbableOptions) && !E.nextTabbableNode(s, !1)) && (k = b), k >= 0) {
+          var I = k === 0 ? r.tabbableGroups.length - 1 : k - 1, M = r.tabbableGroups[I];
+          x = Q(s) >= 0 ? M.lastTabbableNode : M.lastDomTabbableNode;
+        } else fe(m) || (x = E.nextTabbableNode(s, !1));
+      } else {
+        var L = r.tabbableGroups.findIndex(function(Ie) {
+          var Le = Ie.lastTabbableNode;
+          return s === Le;
+        });
+        if (L < 0 && (E.container === s || je(s, a.tabbableOptions) && !ie(s, a.tabbableOptions) && !E.nextTabbableNode(s)) && (L = b), L >= 0) {
+          var Ce = L === r.tabbableGroups.length - 1 ? 0 : L + 1, z = r.tabbableGroups[Ce];
+          x = Q(s) >= 0 ? z.firstTabbableNode : z.firstDomTabbableNode;
+        } else fe(m) || (x = E.nextTabbableNode(s));
+      }
+    } else
+      x = f("fallbackFocus");
+    return x;
+  }, T = function(u) {
+    var s = ve(u);
+    if (!(c(s, u) >= 0)) {
+      if (se(a.clickOutsideDeactivates, u)) {
+        i.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: a.returnFocusOnDeactivate
+        });
+        return;
+      }
+      se(a.allowOutsideClick, u) || u.preventDefault();
+    }
+  }, R = function(u) {
+    var s = ve(u), m = c(s, u) >= 0;
+    if (m || s instanceof Document)
+      m && (r.mostRecentlyFocusedNode = s);
+    else {
+      u.stopImmediatePropagation();
+      var S, g = !0;
+      if (r.mostRecentlyFocusedNode)
+        if (Q(r.mostRecentlyFocusedNode) > 0) {
+          var x = c(r.mostRecentlyFocusedNode), b = r.containerGroups[x].tabbableNodes;
+          if (b.length > 0) {
+            var E = b.findIndex(function(k) {
+              return k === r.mostRecentlyFocusedNode;
+            });
+            E >= 0 && (a.isKeyForward(r.recentNavEvent) ? E + 1 < b.length && (S = b[E + 1], g = !1) : E - 1 >= 0 && (S = b[E - 1], g = !1));
+          }
+        } else
+          r.containerGroups.some(function(k) {
+            return k.tabbableNodes.some(function(I) {
+              return Q(I) > 0;
+            });
+          }) || (g = !1);
+      else
+        g = !1;
+      g && (S = w({
+        // 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: a.isKeyBackward(r.recentNavEvent)
+      })), p(S || r.mostRecentlyFocusedNode || d());
+    }
+    r.recentNavEvent = void 0;
+  }, O = function(u) {
+    var s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    r.recentNavEvent = u;
+    var m = w({
+      event: u,
+      isBackward: s
+    });
+    m && (fe(u) && u.preventDefault(), p(m));
+  }, D = function(u) {
+    (a.isKeyForward(u) || a.isKeyBackward(u)) && O(u, a.isKeyBackward(u));
+  }, A = function(u) {
+    ln(u) && se(a.escapeDeactivates, u) !== !1 && (u.preventDefault(), i.deactivate());
+  }, j = function(u) {
+    var s = ve(u);
+    c(s, u) >= 0 || se(a.clickOutsideDeactivates, u) || se(a.allowOutsideClick, u) || (u.preventDefault(), u.stopImmediatePropagation());
+  }, F = function() {
+    if (r.active)
+      return $.activateTrap(o, i), r.delayInitialFocusTimer = a.delayInitialFocus ? Ze(function() {
+        p(d());
+      }) : p(d()), n.addEventListener("focusin", R, !0), n.addEventListener("mousedown", T, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("touchstart", T, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("click", j, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("keydown", D, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("keydown", A), i;
+  }, P = function(u) {
+    r.active && !r.paused && i._setSubtreeIsolation(!1), r.adjacentElements.clear(), r.alreadySilent.clear();
+    var s = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set(), S = ze(u), g;
+    try {
+      for (S.s(); !(g = S.n()).done; ) {
+        var x = g.value;
+        s.add(x);
+        for (var b = typeof ShadowRoot < "u" && x.getRootNode() instanceof ShadowRoot, E = x; E; ) {
+          s.add(E);
+          var k = E.parentElement, I = [];
+          k ? I = k.children : !k && b && (I = E.getRootNode().children, k = E.getRootNode().host, b = typeof ShadowRoot < "u" && k.getRootNode() instanceof ShadowRoot);
+          var M = ze(I), L;
+          try {
+            for (M.s(); !(L = M.n()).done; ) {
+              var Ce = L.value;
+              m.add(Ce);
+            }
+          } catch (z) {
+            M.e(z);
+          } finally {
+            M.f();
+          }
+          E = k;
+        }
+      }
+    } catch (z) {
+      S.e(z);
+    } finally {
+      S.f();
+    }
+    s.forEach(function(z) {
+      m.delete(z);
+    }), r.adjacentElements = m;
+  }, N = function() {
+    if (r.active)
+      return n.removeEventListener("focusin", R, !0), n.removeEventListener("mousedown", T, !0), n.removeEventListener("touchstart", T, !0), n.removeEventListener("click", j, !0), n.removeEventListener("keydown", D, !0), n.removeEventListener("keydown", A), i;
+  }, K = function(u) {
+    var s = u.some(function(m) {
+      var S = Array.from(m.removedNodes);
+      return S.some(function(g) {
+        return g === r.mostRecentlyFocusedNode;
+      });
+    });
+    s && p(d());
+  }, _ = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(K) : void 0, q = function() {
+    _ && (_.disconnect(), r.active && !r.paused && r.containers.map(function(u) {
+      _.observe(u, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return i = {
+    get active() {
+      return r.active;
+    },
+    get paused() {
+      return r.paused;
+    },
+    activate: function(u) {
+      if (r.active)
+        return this;
+      var s = l(u, "onActivate"), m = l(u, "onPostActivate"), S = l(u, "checkCanFocusTrap"), g = $.getActiveTrap(o), x = !1;
+      if (g && !g.paused) {
+        var b;
+        (b = g._setSubtreeIsolation) === null || b === void 0 || b.call(g, !1), x = !0;
+      }
+      try {
+        S || v(), r.active = !0, r.paused = !1, r.nodeFocusedBeforeActivation = h(n), s == null || s();
+        var E = function() {
+          S && v(), F(), q(), a.isolateSubtrees && i._setSubtreeIsolation(!0), m == null || m();
+        };
+        if (S)
+          return S(r.containers.concat()).then(E, E), this;
+        E();
+      } catch (I) {
+        if (g === $.getActiveTrap(o) && x) {
+          var k;
+          (k = g._setSubtreeIsolation) === null || k === void 0 || k.call(g, !0);
+        }
+        throw I;
+      }
+      return this;
+    },
+    deactivate: function(u) {
+      if (!r.active)
+        return this;
+      var s = Xe({
+        onDeactivate: a.onDeactivate,
+        onPostDeactivate: a.onPostDeactivate,
+        checkCanReturnFocus: a.checkCanReturnFocus
+      }, u);
+      clearTimeout(r.delayInitialFocusTimer), r.delayInitialFocusTimer = void 0, r.paused || i._setSubtreeIsolation(!1), r.alreadySilent.clear(), N(), r.active = !1, r.paused = !1, q(), $.deactivateTrap(o, i);
+      var m = l(s, "onDeactivate"), S = l(s, "onPostDeactivate"), g = l(s, "checkCanReturnFocus"), x = l(s, "returnFocus", "returnFocusOnDeactivate");
+      m == null || m();
+      var b = function() {
+        Ze(function() {
+          x && p(y(r.nodeFocusedBeforeActivation)), S == null || S();
+        });
+      };
+      return x && g ? (g(y(r.nodeFocusedBeforeActivation)).then(b, b), this) : (b(), this);
+    },
+    pause: function(u) {
+      return r.active ? (r.manuallyPaused = !0, this._setPausedState(!0, u)) : this;
+    },
+    unpause: function(u) {
+      return r.active ? (r.manuallyPaused = !1, o[o.length - 1] !== this ? this : this._setPausedState(!1, u)) : this;
+    },
+    updateContainerElements: function(u) {
+      var s = [].concat(u).filter(Boolean);
+      return r.containers = s.map(function(m) {
+        return typeof m == "string" ? n.querySelector(m) : m;
+      }), a.isolateSubtrees && P(r.containers), r.active && (v(), a.isolateSubtrees && !r.paused && i._setSubtreeIsolation(!0)), q(), this;
+    }
+  }, Object.defineProperties(i, {
+    _isManuallyPaused: {
+      value: function() {
+        return r.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(u, s) {
+        if (r.paused === u)
+          return this;
+        if (r.paused = u, u) {
+          var m = l(s, "onPause"), S = l(s, "onPostPause");
+          m == null || m(), N(), q(), i._setSubtreeIsolation(!1), S == null || S();
+        } else {
+          var g = l(s, "onUnpause"), x = l(s, "onPostUnpause");
+          g == null || g(), i._setSubtreeIsolation(!0), v(), F(), q(), x == null || x();
+        }
+        return this;
+      }
+    },
+    _setSubtreeIsolation: {
+      value: function(u) {
+        a.isolateSubtrees && r.adjacentElements.forEach(function(s) {
+          var m;
+          u ? a.isolateSubtrees === "aria-hidden" ? ((s.ariaHidden === "true" || ((m = s.getAttribute("aria-hidden")) === null || m === void 0 ? void 0 : m.toLowerCase()) === "true") && r.alreadySilent.add(s), s.setAttribute("aria-hidden", "true")) : ((s.inert || s.hasAttribute("inert")) && r.alreadySilent.add(s), s.setAttribute("inert", !0)) : r.alreadySilent.has(s) || (a.isolateSubtrees === "aria-hidden" ? s.removeAttribute("aria-hidden") : s.removeAttribute("inert"));
+        });
+      }
+    }
+  }), i.updateContainerElements(e), i;
+};
+const dn = {
+  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
+}, Jn = Ft({
+  props: Object.assign({
+    active: {
+      // TODO: could be options for activate but what about the options for deactivating?
+      type: Boolean,
+      default: !0
+    }
+  }, dn),
+  emits: [
+    "update:active",
+    "activate",
+    "postActivate",
+    "deactivate",
+    "postDeactivate"
+  ],
+  render() {
+    return this.renderImpl();
+  },
+  setup(e, { slots: t, emit: n }) {
+    let o;
+    const a = J(null), r = U(() => {
+      const l = a.value;
+      return l && (l instanceof HTMLElement ? l : l.$el);
+    });
+    function i() {
+      return o || (o = fn(r.value, {
+        escapeDeactivates: e.escapeDeactivates,
+        allowOutsideClick: e.allowOutsideClick,
+        returnFocusOnDeactivate: e.returnFocusOnDeactivate,
+        clickOutsideDeactivates: e.clickOutsideDeactivates,
+        onActivate: () => {
+          n("update:active", !0), n("activate");
+        },
+        onDeactivate: () => {
+          n("update:active", !1), n("deactivate");
+        },
+        onPostActivate: () => n("postActivate"),
+        onPostDeactivate: () => n("postDeactivate"),
+        initialFocus: e.initialFocus,
+        fallbackFocus: e.fallbackFocus,
+        tabbableOptions: e.tabbableOptions,
+        delayInitialFocus: e.delayInitialFocus
+      }));
+    }
+    return Nt(() => {
+      be(() => e.active, (l) => {
+        l && r.value ? i().activate() : o && (o.deactivate(), (!r.value || r.value.nodeType === Node.COMMENT_NODE) && (o = null));
+      }, { immediate: !0, flush: "post" });
+    }), Ct(() => {
+      o && o.deactivate(), o = null;
+    }), {
+      activate() {
+        i().activate();
+      },
+      deactivate() {
+        o && o.deactivate();
+      },
+      renderImpl() {
+        if (!t.default)
+          return null;
+        const l = t.default().filter((c) => c.type !== It);
+        return !l || !l.length || l.length > 1 ? (console.error("[focus-trap-vue]: FocusTrap requires exactly one child."), l) : Lt(l[0], { ref: a });
+      }
+    };
+  }
+}), Ee = Math.min, ee = Math.max, Te = Math.round, me = Math.floor, V = (e) => ({
+  x: e,
+  y: e
+}), pn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function Je(e, t, n) {
+  return ee(e, Ee(t, n));
+}
+function ke(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function ne(e) {
+  return e.split("-")[0];
+}
+function De(e) {
+  return e.split("-")[1];
+}
+function mt(e) {
+  return e === "x" ? "y" : "x";
+}
+function ht(e) {
+  return e === "y" ? "height" : "width";
+}
+function Y(e) {
+  const t = e[0];
+  return t === "t" || t === "b" ? "y" : "x";
+}
+function bt(e) {
+  return mt(Y(e));
+}
+function vn(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = De(e), a = bt(e), r = ht(a);
+  let i = a === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return t.reference[r] > t.floating[r] && (i = Re(i)), [i, Re(i)];
+}
+function mn(e) {
+  const t = Re(e);
+  return [Ve(e), t, Ve(t)];
+}
+function Ve(e) {
+  return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+const Qe = ["left", "right"], et = ["right", "left"], hn = ["top", "bottom"], bn = ["bottom", "top"];
+function yn(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? et : Qe : t ? Qe : et;
+    case "left":
+    case "right":
+      return t ? hn : bn;
+    default:
+      return [];
+  }
+}
+function gn(e, t, n, o) {
+  const a = De(e);
+  let r = yn(ne(e), n === "start", o);
+  return a && (r = r.map((i) => i + "-" + a), t && (r = r.concat(r.map(Ve)))), r;
+}
+function Re(e) {
+  const t = ne(e);
+  return pn[t] + e.slice(t.length);
+}
+function wn(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function xn(e) {
+  return typeof e != "number" ? wn(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Oe(e) {
+  const {
+    x: t,
+    y: n,
+    width: o,
+    height: a
+  } = e;
+  return {
+    width: o,
+    height: a,
+    top: n,
+    left: t,
+    right: t + o,
+    bottom: n + a,
+    x: t,
+    y: n
+  };
+}
+function tt(e, t, n) {
+  let {
+    reference: o,
+    floating: a
+  } = e;
+  const r = Y(t), i = bt(t), l = ht(i), c = ne(t), f = r === "y", d = o.x + o.width / 2 - a.width / 2, v = o.y + o.height / 2 - a.height / 2, h = o[l] / 2 - a[l] / 2;
+  let p;
+  switch (c) {
+    case "top":
+      p = {
+        x: d,
+        y: o.y - a.height
+      };
+      break;
+    case "bottom":
+      p = {
+        x: d,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      p = {
+        x: o.x + o.width,
+        y: v
+      };
+      break;
+    case "left":
+      p = {
+        x: o.x - a.width,
+        y: v
+      };
+      break;
+    default:
+      p = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (De(t)) {
+    case "start":
+      p[i] -= h * (n && f ? -1 : 1);
+      break;
+    case "end":
+      p[i] += h * (n && f ? -1 : 1);
+      break;
+  }
+  return p;
+}
+async function Sn(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: o,
+    y: a,
+    platform: r,
+    rects: i,
+    elements: l,
+    strategy: c
+  } = e, {
+    boundary: f = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: v = "floating",
+    altBoundary: h = !1,
+    padding: p = 0
+  } = ke(t, e), y = xn(p), w = l[h ? v === "floating" ? "reference" : "floating" : v], T = Oe(await r.getClippingRect({
+    element: (n = await (r.isElement == null ? void 0 : r.isElement(w))) == null || n ? w : w.contextElement || await (r.getDocumentElement == null ? void 0 : r.getDocumentElement(l.floating)),
+    boundary: f,
+    rootBoundary: d,
+    strategy: c
+  })), R = v === "floating" ? {
+    x: o,
+    y: a,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, O = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(l.floating)), D = await (r.isElement == null ? void 0 : r.isElement(O)) ? await (r.getScale == null ? void 0 : r.getScale(O)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, A = Oe(r.convertOffsetParentRelativeRectToViewportRelativeRect ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: R,
+    offsetParent: O,
+    strategy: c
+  }) : R);
+  return {
+    top: (T.top - A.top + y.top) / D.y,
+    bottom: (A.bottom - T.bottom + y.bottom) / D.y,
+    left: (T.left - A.left + y.left) / D.x,
+    right: (A.right - T.right + y.right) / D.x
+  };
+}
+const En = 50, Tn = async (e, t, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: a = "absolute",
+    middleware: r = [],
+    platform: i
+  } = n, l = i.detectOverflow ? i : {
+    ...i,
+    detectOverflow: Sn
+  }, c = await (i.isRTL == null ? void 0 : i.isRTL(t));
+  let f = await i.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: a
+  }), {
+    x: d,
+    y: v
+  } = tt(f, o, c), h = o, p = 0;
+  const y = {};
+  for (let w = 0; w < r.length; w++) {
+    const T = r[w];
+    if (!T)
+      continue;
+    const {
+      name: R,
+      fn: O
+    } = T, {
+      x: D,
+      y: A,
+      data: j,
+      reset: F
+    } = await O({
+      x: d,
+      y: v,
+      initialPlacement: o,
+      placement: h,
+      strategy: a,
+      middlewareData: y,
+      rects: f,
+      platform: l,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    d = D ?? d, v = A ?? v, y[R] = {
+      ...y[R],
+      ...j
+    }, F && p < En && (p++, typeof F == "object" && (F.placement && (h = F.placement), F.rects && (f = F.rects === !0 ? await i.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: a
+    }) : F.rects), {
+      x: d,
+      y: v
+    } = tt(f, h, c)), w = -1);
+  }
+  return {
+    x: d,
+    y: v,
+    placement: h,
+    strategy: a,
+    middlewareData: y
+  };
+}, Rn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: a,
+        middlewareData: r,
+        rects: i,
+        initialPlacement: l,
+        platform: c,
+        elements: f
+      } = t, {
+        mainAxis: d = !0,
+        crossAxis: v = !0,
+        fallbackPlacements: h,
+        fallbackStrategy: p = "bestFit",
+        fallbackAxisSideDirection: y = "none",
+        flipAlignment: w = !0,
+        ...T
+      } = ke(e, t);
+      if ((n = r.arrow) != null && n.alignmentOffset)
+        return {};
+      const R = ne(a), O = Y(l), D = ne(l) === l, A = await (c.isRTL == null ? void 0 : c.isRTL(f.floating)), j = h || (D || !w ? [Re(l)] : mn(l)), F = y !== "none";
+      !h && F && j.push(...gn(l, w, y, A));
+      const P = [l, ...j], N = await c.detectOverflow(t, T), K = [];
+      let _ = ((o = r.flip) == null ? void 0 : o.overflows) || [];
+      if (d && K.push(N[R]), v) {
+        const m = vn(a, i, A);
+        K.push(N[m[0]], N[m[1]]);
+      }
+      if (_ = [..._, {
+        placement: a,
+        overflows: K
+      }], !K.every((m) => m <= 0)) {
+        var q, u;
+        const m = (((q = r.flip) == null ? void 0 : q.index) || 0) + 1, S = P[m];
+        if (S && (!(v === "alignment" && O !== Y(S)) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        _.every((x) => Y(x.placement) === O ? x.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: m,
+              overflows: _
+            },
+            reset: {
+              placement: S
+            }
+          };
+        let g = (u = _.filter((x) => x.overflows[0] <= 0).sort((x, b) => x.overflows[1] - b.overflows[1])[0]) == null ? void 0 : u.placement;
+        if (!g)
+          switch (p) {
+            case "bestFit": {
+              var s;
+              const x = (s = _.filter((b) => {
+                if (F) {
+                  const E = Y(b.placement);
+                  return E === O || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  E === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((E) => E > 0).reduce((E, k) => E + k, 0)]).sort((b, E) => b[1] - E[1])[0]) == null ? void 0 : s[0];
+              x && (g = x);
+              break;
+            }
+            case "initialPlacement":
+              g = l;
+              break;
+          }
+        if (a !== g)
+          return {
+            reset: {
+              placement: g
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, On = /* @__PURE__ */ new Set(["left", "top"]);
+async function kn(e, t) {
+  const {
+    placement: n,
+    platform: o,
+    elements: a
+  } = e, r = await (o.isRTL == null ? void 0 : o.isRTL(a.floating)), i = ne(n), l = De(n), c = Y(n) === "y", f = On.has(i) ? -1 : 1, d = r && c ? -1 : 1, v = ke(t, e);
+  let {
+    mainAxis: h,
+    crossAxis: p,
+    alignmentAxis: y
+  } = typeof v == "number" ? {
+    mainAxis: v,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: v.mainAxis || 0,
+    crossAxis: v.crossAxis || 0,
+    alignmentAxis: v.alignmentAxis
+  };
+  return l && typeof y == "number" && (p = l === "end" ? y * -1 : y), c ? {
+    x: p * d,
+    y: h * f
+  } : {
+    x: h * f,
+    y: p * d
+  };
+}
+const Dn = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        x: a,
+        y: r,
+        placement: i,
+        middlewareData: l
+      } = t, c = await kn(t, e);
+      return i === ((n = l.offset) == null ? void 0 : n.placement) && (o = l.arrow) != null && o.alignmentOffset ? {} : {
+        x: a + c.x,
+        y: r + c.y,
+        data: {
+          ...c,
+          placement: i
+        }
+      };
+    }
+  };
+}, An = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: a,
+        platform: r
+      } = t, {
+        mainAxis: i = !0,
+        crossAxis: l = !1,
+        limiter: c = {
+          fn: (R) => {
+            let {
+              x: O,
+              y: D
+            } = R;
+            return {
+              x: O,
+              y: D
+            };
+          }
+        },
+        ...f
+      } = ke(e, t), d = {
+        x: n,
+        y: o
+      }, v = await r.detectOverflow(t, f), h = Y(ne(a)), p = mt(h);
+      let y = d[p], w = d[h];
+      if (i) {
+        const R = p === "y" ? "top" : "left", O = p === "y" ? "bottom" : "right", D = y + v[R], A = y - v[O];
+        y = Je(D, y, A);
+      }
+      if (l) {
+        const R = h === "y" ? "top" : "left", O = h === "y" ? "bottom" : "right", D = w + v[R], A = w - v[O];
+        w = Je(D, w, A);
+      }
+      const T = c.fn({
+        ...t,
+        [p]: y,
+        [h]: w
+      });
+      return {
+        ...T,
+        data: {
+          x: T.x - n,
+          y: T.y - o,
+          enabled: {
+            [p]: i,
+            [h]: l
+          }
+        }
+      };
+    }
+  };
+};
+function Ae() {
+  return typeof window < "u";
+}
+function re(e) {
+  return Ke(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function C(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function H(e) {
+  var t;
+  return (t = (Ke(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Ke(e) {
+  return Ae() ? e instanceof Node || e instanceof C(e).Node : !1;
+}
+function B(e) {
+  return Ae() ? e instanceof Element || e instanceof C(e).Element : !1;
+}
+function W(e) {
+  return Ae() ? e instanceof HTMLElement || e instanceof C(e).HTMLElement : !1;
+}
+function nt(e) {
+  return !Ae() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof C(e).ShadowRoot;
+}
+function pe(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: o,
+    display: a
+  } = G(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + n) && a !== "inline" && a !== "contents";
+}
+function Fn(e) {
+  return /^(table|td|th)$/.test(re(e));
+}
+function Fe(e) {
+  try {
+    if (e.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return e.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const Pn = /transform|translate|scale|rotate|perspective|filter/, Nn = /paint|layout|strict|content/, Z = (e) => !!e && e !== "none";
+let Be;
+function Ue(e) {
+  const t = B(e) ? G(e) : e;
+  return Z(t.transform) || Z(t.translate) || Z(t.scale) || Z(t.rotate) || Z(t.perspective) || !$e() && (Z(t.backdropFilter) || Z(t.filter)) || Pn.test(t.willChange || "") || Nn.test(t.contain || "");
+}
+function Cn(e) {
+  let t = X(e);
+  for (; W(t) && !ue(t); ) {
+    if (Ue(t))
+      return t;
+    if (Fe(t))
+      return null;
+    t = X(t);
+  }
+  return null;
+}
+function $e() {
+  return Be == null && (Be = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), Be;
+}
+function ue(e) {
+  return /^(html|body|#document)$/.test(re(e));
+}
+function G(e) {
+  return C(e).getComputedStyle(e);
+}
+function Pe(e) {
+  return B(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function X(e) {
+  if (re(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    nt(e) && e.host || // Fallback.
+    H(e)
+  );
+  return nt(t) ? t.host : t;
+}
+function yt(e) {
+  const t = X(e);
+  return ue(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : W(t) && pe(t) ? t : yt(t);
+}
+function de(e, t, n) {
+  var o;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const a = yt(e), r = a === ((o = e.ownerDocument) == null ? void 0 : o.body), i = C(a);
+  if (r) {
+    const l = He(i);
+    return t.concat(i, i.visualViewport || [], pe(a) ? a : [], l && n ? de(l) : []);
+  } else
+    return t.concat(a, de(a, [], n));
+}
+function He(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function gt(e) {
+  const t = G(e);
+  let n = parseFloat(t.width) || 0, o = parseFloat(t.height) || 0;
+  const a = W(e), r = a ? e.offsetWidth : n, i = a ? e.offsetHeight : o, l = Te(n) !== r || Te(o) !== i;
+  return l && (n = r, o = i), {
+    width: n,
+    height: o,
+    $: l
+  };
+}
+function We(e) {
+  return B(e) ? e : e.contextElement;
+}
+function le(e) {
+  const t = We(e);
+  if (!W(t))
+    return V(1);
+  const n = t.getBoundingClientRect(), {
+    width: o,
+    height: a,
+    $: r
+  } = gt(t);
+  let i = (r ? Te(n.width) : n.width) / o, l = (r ? Te(n.height) : n.height) / a;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: i,
+    y: l
+  };
+}
+const In = /* @__PURE__ */ V(0);
+function wt(e) {
+  const t = C(e);
+  return !$e() || !t.visualViewport ? In : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Ln(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== C(e) ? !1 : t;
+}
+function oe(e, t, n, o) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const a = e.getBoundingClientRect(), r = We(e);
+  let i = V(1);
+  t && (o ? B(o) && (i = le(o)) : i = le(e));
+  const l = Ln(r, n, o) ? wt(r) : V(0);
+  let c = (a.left + l.x) / i.x, f = (a.top + l.y) / i.y, d = a.width / i.x, v = a.height / i.y;
+  if (r) {
+    const h = C(r), p = o && B(o) ? C(o) : o;
+    let y = h, w = He(y);
+    for (; w && o && p !== y; ) {
+      const T = le(w), R = w.getBoundingClientRect(), O = G(w), D = R.left + (w.clientLeft + parseFloat(O.paddingLeft)) * T.x, A = R.top + (w.clientTop + parseFloat(O.paddingTop)) * T.y;
+      c *= T.x, f *= T.y, d *= T.x, v *= T.y, c += D, f += A, y = C(w), w = He(y);
+    }
+  }
+  return Oe({
+    width: d,
+    height: v,
+    x: c,
+    y: f
+  });
+}
+function Ne(e, t) {
+  const n = Pe(e).scrollLeft;
+  return t ? t.left + n : oe(H(e)).left + n;
+}
+function xt(e, t) {
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - Ne(e, n), a = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: a
+  };
+}
+function jn(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: o,
+    strategy: a
+  } = e;
+  const r = a === "fixed", i = H(o), l = t ? Fe(t.floating) : !1;
+  if (o === i || l && r)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = V(1);
+  const d = V(0), v = W(o);
+  if ((v || !v && !r) && ((re(o) !== "body" || pe(i)) && (c = Pe(o)), v)) {
+    const p = oe(o);
+    f = le(o), d.x = p.x + o.clientLeft, d.y = p.y + o.clientTop;
+  }
+  const h = i && !v && !r ? xt(i, c) : V(0);
+  return {
+    width: n.width * f.x,
+    height: n.height * f.y,
+    x: n.x * f.x - c.scrollLeft * f.x + d.x + h.x,
+    y: n.y * f.y - c.scrollTop * f.y + d.y + h.y
+  };
+}
+function Bn(e) {
+  return Array.from(e.getClientRects());
+}
+function Gn(e) {
+  const t = H(e), n = Pe(e), o = e.ownerDocument.body, a = ee(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), r = ee(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight);
+  let i = -n.scrollLeft + Ne(e);
+  const l = -n.scrollTop;
+  return G(o).direction === "rtl" && (i += ee(t.clientWidth, o.clientWidth) - a), {
+    width: a,
+    height: r,
+    x: i,
+    y: l
+  };
+}
+const ot = 25;
+function _n(e, t) {
+  const n = C(e), o = H(e), a = n.visualViewport;
+  let r = o.clientWidth, i = o.clientHeight, l = 0, c = 0;
+  if (a) {
+    r = a.width, i = a.height;
+    const d = $e();
+    (!d || d && t === "fixed") && (l = a.offsetLeft, c = a.offsetTop);
+  }
+  const f = Ne(o);
+  if (f <= 0) {
+    const d = o.ownerDocument, v = d.body, h = getComputedStyle(v), p = d.compatMode === "CSS1Compat" && parseFloat(h.marginLeft) + parseFloat(h.marginRight) || 0, y = Math.abs(o.clientWidth - v.clientWidth - p);
+    y <= ot && (r -= y);
+  } else f <= ot && (r += f);
+  return {
+    width: r,
+    height: i,
+    x: l,
+    y: c
+  };
+}
+function Mn(e, t) {
+  const n = oe(e, !0, t === "fixed"), o = n.top + e.clientTop, a = n.left + e.clientLeft, r = W(e) ? le(e) : V(1), i = e.clientWidth * r.x, l = e.clientHeight * r.y, c = a * r.x, f = o * r.y;
+  return {
+    width: i,
+    height: l,
+    x: c,
+    y: f
+  };
+}
+function rt(e, t, n) {
+  let o;
+  if (t === "viewport")
+    o = _n(e, n);
+  else if (t === "document")
+    o = Gn(H(e));
+  else if (B(t))
+    o = Mn(t, n);
+  else {
+    const a = wt(e);
+    o = {
+      x: t.x - a.x,
+      y: t.y - a.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Oe(o);
+}
+function St(e, t) {
+  const n = X(e);
+  return n === t || !B(n) || ue(n) ? !1 : G(n).position === "fixed" || St(n, t);
+}
+function Vn(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let o = de(e, [], !1).filter((l) => B(l) && re(l) !== "body"), a = null;
+  const r = G(e).position === "fixed";
+  let i = r ? X(e) : e;
+  for (; B(i) && !ue(i); ) {
+    const l = G(i), c = Ue(i);
+    !c && l.position === "fixed" && (a = null), (r ? !c && !a : !c && l.position === "static" && a && (a.position === "absolute" || a.position === "fixed") || pe(i) && !c && St(e, i)) ? o = o.filter((f) => f !== i) : a = l, i = X(i);
+  }
+  return t.set(e, o), o;
+}
+function Hn(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: o,
+    strategy: a
+  } = e;
+  const r = [...n === "clippingAncestors" ? Fe(t) ? [] : Vn(t, this._c) : [].concat(n), o], i = rt(t, r[0], a);
+  let l = i.top, c = i.right, f = i.bottom, d = i.left;
+  for (let v = 1; v < r.length; v++) {
+    const h = rt(t, r[v], a);
+    l = ee(h.top, l), c = Ee(h.right, c), f = Ee(h.bottom, f), d = ee(h.left, d);
+  }
+  return {
+    width: c - d,
+    height: f - l,
+    x: d,
+    y: l
+  };
+}
+function Kn(e) {
+  const {
+    width: t,
+    height: n
+  } = gt(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Un(e, t, n) {
+  const o = W(t), a = H(t), r = n === "fixed", i = oe(e, !0, r, t);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = V(0);
+  function f() {
+    c.x = Ne(a);
+  }
+  if (o || !o && !r)
+    if ((re(t) !== "body" || pe(a)) && (l = Pe(t)), o) {
+      const p = oe(t, !0, r, t);
+      c.x = p.x + t.clientLeft, c.y = p.y + t.clientTop;
+    } else a && f();
+  r && !o && a && f();
+  const d = a && !o && !r ? xt(a, l) : V(0), v = i.left + l.scrollLeft - c.x - d.x, h = i.top + l.scrollTop - c.y - d.y;
+  return {
+    x: v,
+    y: h,
+    width: i.width,
+    height: i.height
+  };
+}
+function Ge(e) {
+  return G(e).position === "static";
+}
+function at(e, t) {
+  if (!W(e) || G(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return H(e) === n && (n = n.ownerDocument.body), n;
+}
+function Et(e, t) {
+  const n = C(e);
+  if (Fe(e))
+    return n;
+  if (!W(e)) {
+    let a = X(e);
+    for (; a && !ue(a); ) {
+      if (B(a) && !Ge(a))
+        return a;
+      a = X(a);
+    }
+    return n;
+  }
+  let o = at(e, t);
+  for (; o && Fn(o) && Ge(o); )
+    o = at(o, t);
+  return o && ue(o) && Ge(o) && !Ue(o) ? n : o || Cn(e) || n;
+}
+const $n = async function(e) {
+  const t = this.getOffsetParent || Et, n = this.getDimensions, o = await n(e.floating);
+  return {
+    reference: Un(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function Wn(e) {
+  return G(e).direction === "rtl";
+}
+const qn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: jn,
+  getDocumentElement: H,
+  getClippingRect: Hn,
+  getOffsetParent: Et,
+  getElementRects: $n,
+  getClientRects: Bn,
+  getDimensions: Kn,
+  getScale: le,
+  isElement: B,
+  isRTL: Wn
+};
+function Tt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function zn(e, t) {
+  let n = null, o;
+  const a = H(e);
+  function r() {
+    var l;
+    clearTimeout(o), (l = n) == null || l.disconnect(), n = null;
+  }
+  function i(l, c) {
+    l === void 0 && (l = !1), c === void 0 && (c = 1), r();
+    const f = e.getBoundingClientRect(), {
+      left: d,
+      top: v,
+      width: h,
+      height: p
+    } = f;
+    if (l || t(), !h || !p)
+      return;
+    const y = me(v), w = me(a.clientWidth - (d + h)), T = me(a.clientHeight - (v + p)), R = me(d), O = {
+      rootMargin: -y + "px " + -w + "px " + -T + "px " + -R + "px",
+      threshold: ee(0, Ee(1, c)) || 1
+    };
+    let D = !0;
+    function A(j) {
+      const F = j[0].intersectionRatio;
+      if (F !== c) {
+        if (!D)
+          return i();
+        F ? i(!1, F) : o = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 1e3);
+      }
+      F === 1 && !Tt(f, e.getBoundingClientRect()) && i(), D = !1;
+    }
+    try {
+      n = new IntersectionObserver(A, {
+        ...O,
+        // Handle <iframe>s
+        root: a.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(A, O);
+    }
+    n.observe(e);
+  }
+  return i(!0), r;
+}
+function Qn(e, t, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: a = !0,
+    ancestorResize: r = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = o, f = We(e), d = a || r ? [...f ? de(f) : [], ...t ? de(t) : []] : [];
+  d.forEach((R) => {
+    a && R.addEventListener("scroll", n, {
+      passive: !0
+    }), r && R.addEventListener("resize", n);
+  });
+  const v = f && l ? zn(f, n) : null;
+  let h = -1, p = null;
+  i && (p = new ResizeObserver((R) => {
+    let [O] = R;
+    O && O.target === f && p && t && (p.unobserve(t), cancelAnimationFrame(h), h = requestAnimationFrame(() => {
+      var D;
+      (D = p) == null || D.observe(t);
+    })), n();
+  }), f && !c && p.observe(f), t && p.observe(t));
+  let y, w = c ? oe(e) : null;
+  c && T();
+  function T() {
+    const R = oe(e);
+    w && !Tt(w, R) && n(), w = R, y = requestAnimationFrame(T);
+  }
+  return n(), () => {
+    var R;
+    d.forEach((O) => {
+      a && O.removeEventListener("scroll", n), r && O.removeEventListener("resize", n);
+    }), v == null || v(), (R = p) == null || R.disconnect(), p = null, c && cancelAnimationFrame(y);
+  };
+}
+const eo = Dn, to = An, no = Rn, Yn = (e, t, n) => {
+  const o = /* @__PURE__ */ new Map(), a = {
+    platform: qn,
+    ...n
+  }, r = {
+    ...a.platform,
+    _c: o
+  };
+  return Tn(e, t, {
+    ...a,
+    platform: r
+  });
+};
+function Xn(e) {
+  return e != null && typeof e == "object" && "$el" in e;
+}
+function it(e) {
+  if (Xn(e)) {
+    const t = e.$el;
+    return Ke(t) && re(t) === "#comment" ? null : t;
+  }
+  return e;
+}
+function ce(e) {
+  return typeof e == "function" ? e() : At(e);
+}
+function Rt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function lt(e, t) {
+  const n = Rt(e);
+  return Math.round(t * n) / n;
+}
+function oo(e, t, n) {
+  n === void 0 && (n = {});
+  const o = n.whileElementsMounted, a = U(() => {
+    var P;
+    return (P = ce(n.open)) != null ? P : !0;
+  }), r = U(() => ce(n.middleware)), i = U(() => {
+    var P;
+    return (P = ce(n.placement)) != null ? P : "bottom";
+  }), l = U(() => {
+    var P;
+    return (P = ce(n.strategy)) != null ? P : "absolute";
+  }), c = U(() => {
+    var P;
+    return (P = ce(n.transform)) != null ? P : !0;
+  }), f = U(() => it(e.value)), d = U(() => it(t.value)), v = J(0), h = J(0), p = J(l.value), y = J(i.value), w = Ot({}), T = J(!1), R = U(() => {
+    const P = {
+      position: p.value,
+      left: "0",
+      top: "0"
+    };
+    if (!d.value)
+      return P;
+    const N = lt(d.value, v.value), K = lt(d.value, h.value);
+    return c.value ? {
+      ...P,
+      transform: "translate(" + N + "px, " + K + "px)",
+      ...Rt(d.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: p.value,
+      left: N + "px",
+      top: K + "px"
+    };
+  });
+  let O;
+  function D() {
+    if (f.value == null || d.value == null)
+      return;
+    const P = a.value;
+    Yn(f.value, d.value, {
+      middleware: r.value,
+      placement: i.value,
+      strategy: l.value
+    }).then((N) => {
+      v.value = N.x, h.value = N.y, p.value = N.strategy, y.value = N.placement, w.value = N.middlewareData, T.value = P !== !1;
+    });
+  }
+  function A() {
+    typeof O == "function" && (O(), O = void 0);
+  }
+  function j() {
+    if (A(), o === void 0) {
+      D();
+      return;
+    }
+    if (f.value != null && d.value != null) {
+      O = o(f.value, d.value, D);
+      return;
+    }
+  }
+  function F() {
+    a.value || (T.value = !1);
+  }
+  return be([r, i, l, a], D, {
+    flush: "sync"
+  }), be([f, d], j, {
+    flush: "sync"
+  }), be(a, F, {
+    flush: "sync"
+  }), kt() && Dt(A), {
+    x: ae(v),
+    y: ae(h),
+    strategy: ae(p),
+    placement: ae(y),
+    middlewareData: ae(w),
+    isPositioned: ae(T),
+    floatingStyles: R,
+    update: D
+  };
+}
+const he = (e) => {
+  e.preventDefault(), e.stopPropagation(), e.stopImmediatePropagation();
+}, ro = ({
+  getNextElement: e,
+  getFirstElement: t,
+  getLastElement: n,
+  close: o,
+  disableSpaceToClick: a,
+  keepOpenedOnTab: r
+}) => {
+  const i = J(null), l = () => {
+  };
+  let c = l;
+  const f = () => {
+    i.value = null, c = l;
+  }, d = (p) => {
+    i.value = p.index, c = p.onClick;
+  }, v = (p) => {
+    d(e(i.value, p));
+  }, h = () => {
+    f(), o();
+  };
+  return {
+    onKeydown: (p) => {
+      switch (p.code) {
+        case "ArrowDown":
+          he(p), v(1);
+          break;
+        case "ArrowUp":
+          he(p), v(-1);
+          break;
+        case "Enter":
+        case "Space": {
+          const y = p.code === "Enter", w = p.code === "Space";
+          i.value !== null && (y || w && !a) && (he(p), c());
+          break;
+        }
+        case "Home":
+          t && d(t());
+          break;
+        case "End":
+          n && d(n());
+          break;
+        case "Escape":
+          he(p), h();
+          break;
+        case "Tab":
+          r || h();
+          break;
+      }
+    },
+    currentIndex: Pt(i),
+    resetNavigation: f,
+    setElement: d
+  };
+};
+export {
+  oo as a,
+  Jn as e,
+  no as i,
+  eo as n,
+  ro as o,
+  to as r,
+  Qn as t
+};