@knime/jsonforms 1.23.1 → 1.23.2

package/dist/DateTimeFormatPickerWithTypeControl-BXe2Elky.js

@@ -0,0 +1,2576 @@
+import { openBlock as $, createElementBlock as H, createElementVNode as z, h as Xt, defineComponent as fe, createBlock as ke, unref as q, ref as j, computed as M, onMounted as Ft, watch as le, onUnmounted as Rt, Comment as Gt, cloneVNode as Yt, shallowRef as Zt, getCurrentScope as Jt, onScopeDispose as Qt, shallowReadonly as pe, readonly as en, Fragment as Je, renderList as At, normalizeClass as Se, toDisplayString as Oe, renderSlot as Ct, createCommentVNode as Ne, resolveComponent as tn, withCtx as kt, normalizeProps as nn, guardReactiveProps as an, useCssVars as on, reactive as rn, nextTick as st, createVNode as be, useModel as ln, withDirectives as sn, vModelText as cn, normalizeStyle as un, mergeModels as dn } from "vue";
+import { _ as ge, R as fn, T as vn, u as pn } from "./SimpleButtonControl.vue_vue_type_style_index_0_scoped_c79c6b71_lang-Wvr-HAK1.js";
+const mn = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function hn(t, e) {
+  return $(), H("svg", mn, [...e[0] || (e[0] = [
+    z("path", { d: "m11.9 22.3 2.7 4.4-4.5 2.8m4.5-2.8C9 26 4.7 21.7 4.7 16c0-5.1 3.4-9.4 8.1-10.8M20 9.7l-2.6-4.4 4.5-2.8m-4.5 2.8c5.6.7 9.9 5 9.9 10.7 0 5.1-3.4 9.4-8.1 10.8" }, null, -1)
+  ])]);
+}
+const bn = { render: hn }, yn = (t, e) => ({
+  render() {
+    const n = t.render({}, []), a = Xt("title", e);
+    return a.ns = "svg", n.children.unshift(a), n;
+  }
+}), gn = /* @__PURE__ */ fe({
+  __name: "LoadingIcon",
+  setup(t) {
+    const e = yn(bn, "Loading…");
+    return (n, a) => ($(), ke(q(e)));
+  }
+}), wn = /* @__PURE__ */ ge(gn, [["__scopeId", "data-v-6b552b81"]]);
+var Ot = ["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] *)"], De = /* @__PURE__ */ Ot.join(","), Nt = typeof Element > "u", ce = Nt ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, Ie = !Nt && Element.prototype.getRootNode ? function(t) {
+  var e;
+  return t == null || (e = t.getRootNode) === null || e === void 0 ? void 0 : e.call(t);
+} : function(t) {
+  return t?.ownerDocument;
+}, Pe = function(e, n) {
+  var a;
+  n === void 0 && (n = !0);
+  var r = e == null || (a = e.getAttribute) === null || a === void 0 ? void 0 : a.call(e, "inert"), i = r === "" || r === "true", o = i || n && 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]") : Pe(e.parentNode));
+  return o;
+}, Tn = function(e) {
+  var n, a = e == null || (n = e.getAttribute) === null || n === void 0 ? void 0 : n.call(e, "contenteditable");
+  return a === "" || a === "true";
+}, Dt = function(e, n, a) {
+  if (Pe(e))
+    return [];
+  var r = Array.prototype.slice.apply(e.querySelectorAll(De));
+  return n && ce.call(e, De) && r.unshift(e), r = r.filter(a), r;
+}, Ve = function(e, n, a) {
+  for (var r = [], i = Array.from(e); i.length; ) {
+    var o = i.shift();
+    if (!Pe(o, !1))
+      if (o.tagName === "SLOT") {
+        var l = o.assignedElements(), s = l.length ? l : o.children, u = Ve(s, !0, a);
+        a.flatten ? r.push.apply(r, u) : r.push({
+          scopeParent: o,
+          candidates: u
+        });
+      } else {
+        var d = ce.call(o, De);
+        d && a.filter(o) && (n || !e.includes(o)) && r.push(o);
+        var v = o.shadowRoot || // check for an undisclosed shadow
+        typeof a.getShadowRoot == "function" && a.getShadowRoot(o), m = !Pe(v, !1) && (!a.shadowRootFilter || a.shadowRootFilter(o));
+        if (v && m) {
+          var p = Ve(v === !0 ? o.children : v.children, !0, a);
+          a.flatten ? r.push.apply(r, p) : r.push({
+            scopeParent: o,
+            candidates: p
+          });
+        } else
+          i.unshift.apply(i, o.children);
+      }
+  }
+  return r;
+}, It = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, ie = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || Tn(e)) && !It(e) ? 0 : e.tabIndex;
+}, xn = function(e, n) {
+  var a = ie(e);
+  return a < 0 && n && !It(e) ? 0 : a;
+}, Sn = function(e, n) {
+  return e.tabIndex === n.tabIndex ? e.documentOrder - n.documentOrder : e.tabIndex - n.tabIndex;
+}, Pt = function(e) {
+  return e.tagName === "INPUT";
+}, En = function(e) {
+  return Pt(e) && e.type === "hidden";
+}, Fn = function(e) {
+  var n = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(a) {
+    return a.tagName === "SUMMARY";
+  });
+  return n;
+}, Rn = function(e, n) {
+  for (var a = 0; a < e.length; a++)
+    if (e[a].checked && e[a].form === n)
+      return e[a];
+}, An = function(e) {
+  if (!e.name)
+    return !0;
+  var n = e.form || Ie(e), a = function(l) {
+    return n.querySelectorAll('input[type="radio"][name="' + l + '"]');
+  }, r;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    r = a(window.CSS.escape(e.name));
+  else
+    try {
+      r = a(e.name);
+    } catch (o) {
+      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", o.message), !1;
+    }
+  var i = Rn(r, e.form);
+  return !i || i === e;
+}, Cn = function(e) {
+  return Pt(e) && e.type === "radio";
+}, kn = function(e) {
+  return Cn(e) && !An(e);
+}, On = function(e) {
+  var n, a = e && Ie(e), r = (n = a) === null || n === void 0 ? void 0 : n.host, i = !1;
+  if (a && a !== e) {
+    var o, l, s;
+    for (i = !!((o = r) !== null && o !== void 0 && (l = o.ownerDocument) !== null && l !== void 0 && l.contains(r) || e != null && (s = e.ownerDocument) !== null && s !== void 0 && s.contains(e)); !i && r; ) {
+      var u, d, v;
+      a = Ie(r), r = (u = a) === null || u === void 0 ? void 0 : u.host, i = !!((d = r) !== null && d !== void 0 && (v = d.ownerDocument) !== null && v !== void 0 && v.contains(r));
+    }
+  }
+  return i;
+}, ct = function(e) {
+  var n = e.getBoundingClientRect(), a = n.width, r = n.height;
+  return a === 0 && r === 0;
+}, Nn = function(e, n) {
+  var a = n.displayCheck, r = n.getShadowRoot;
+  if (a === "full-native" && "checkVisibility" in e) {
+    var i = 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 !i;
+  }
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var o = ce.call(e, "details>summary:first-of-type"), l = o ? e.parentElement : e;
+  if (ce.call(l, "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 r == "function") {
+      for (var s = e; e; ) {
+        var u = e.parentElement, d = Ie(e);
+        if (u && !u.shadowRoot && r(u) === !0)
+          return ct(e);
+        e.assignedSlot ? e = e.assignedSlot : !u && d !== e.ownerDocument ? e = d.host : e = u;
+      }
+      e = s;
+    }
+    if (On(e))
+      return !e.getClientRects().length;
+    if (a !== "legacy-full")
+      return !0;
+  } else if (a === "non-zero-area")
+    return ct(e);
+  return !1;
+}, Dn = function(e) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))
+    for (var n = e.parentElement; n; ) {
+      if (n.tagName === "FIELDSET" && n.disabled) {
+        for (var a = 0; a < n.children.length; a++) {
+          var r = n.children.item(a);
+          if (r.tagName === "LEGEND")
+            return ce.call(n, "fieldset[disabled] *") ? !0 : !r.contains(e);
+        }
+        return !0;
+      }
+      n = n.parentElement;
+    }
+  return !1;
+}, Be = function(e, n) {
+  return !(n.disabled || En(n) || Nn(n, e) || // For a details element with a summary, the summary element gets the focus
+  Fn(n) || Dn(n));
+}, Qe = function(e, n) {
+  return !(kn(n) || ie(n) < 0 || !Be(e, n));
+}, In = function(e) {
+  var n = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(n) || n >= 0);
+}, Vt = function(e) {
+  var n = [], a = [];
+  return e.forEach(function(r, i) {
+    var o = !!r.scopeParent, l = o ? r.scopeParent : r, s = xn(l, o), u = o ? Vt(r.candidates) : l;
+    s === 0 ? o ? n.push.apply(n, u) : n.push(l) : a.push({
+      documentOrder: i,
+      tabIndex: s,
+      item: r,
+      isScope: o,
+      content: u
+    });
+  }), a.sort(Sn).reduce(function(r, i) {
+    return i.isScope ? r.push.apply(r, i.content) : r.push(i.content), r;
+  }, []).concat(n);
+}, Pn = function(e, n) {
+  n = n || {};
+  var a;
+  return n.getShadowRoot ? a = Ve([e], n.includeContainer, {
+    filter: Qe.bind(null, n),
+    flatten: !1,
+    getShadowRoot: n.getShadowRoot,
+    shadowRootFilter: In
+  }) : a = Dt(e, n.includeContainer, Qe.bind(null, n)), Vt(a);
+}, Vn = function(e, n) {
+  n = n || {};
+  var a;
+  return n.getShadowRoot ? a = Ve([e], n.includeContainer, {
+    filter: Be.bind(null, n),
+    flatten: !0,
+    getShadowRoot: n.getShadowRoot
+  }) : a = Dt(e, n.includeContainer, Be.bind(null, n)), a;
+}, me = function(e, n) {
+  if (n = n || {}, !e)
+    throw new Error("No node provided");
+  return ce.call(e, De) === !1 ? !1 : Qe(n, e);
+}, Bn = /* @__PURE__ */ Ot.concat("iframe:not([inert]):not([inert] *)").join(","), Ge = function(e, n) {
+  if (n = n || {}, !e)
+    throw new Error("No node provided");
+  return ce.call(e, Bn) === !1 ? !1 : Be(n, e);
+};
+function et(t, e) {
+  (e == null || e > t.length) && (e = t.length);
+  for (var n = 0, a = Array(e); n < e; n++) a[n] = t[n];
+  return a;
+}
+function Ln(t) {
+  if (Array.isArray(t)) return et(t);
+}
+function ut(t, e) {
+  var n = typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+  if (!n) {
+    if (Array.isArray(t) || (n = Bt(t)) || e) {
+      n && (t = n);
+      var a = 0, r = function() {
+      };
+      return {
+        s: r,
+        n: function() {
+          return a >= t.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: t[a++]
+          };
+        },
+        e: function(s) {
+          throw s;
+        },
+        f: r
+      };
+    }
+    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 i, o = !0, l = !1;
+  return {
+    s: function() {
+      n = n.call(t);
+    },
+    n: function() {
+      var s = n.next();
+      return o = s.done, s;
+    },
+    e: function(s) {
+      l = !0, i = s;
+    },
+    f: function() {
+      try {
+        o || n.return == null || n.return();
+      } finally {
+        if (l) throw i;
+      }
+    }
+  };
+}
+function Mn(t, e, n) {
+  return (e = Wn(e)) in t ? Object.defineProperty(t, e, {
+    value: n,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = n, t;
+}
+function _n(t) {
+  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+}
+function $n() {
+  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 dt(t, e) {
+  var n = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(t);
+    e && (a = a.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(t, r).enumerable;
+    })), n.push.apply(n, a);
+  }
+  return n;
+}
+function ft(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? dt(Object(n), !0).forEach(function(a) {
+      Mn(t, a, n[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : dt(Object(n)).forEach(function(a) {
+      Object.defineProperty(t, a, Object.getOwnPropertyDescriptor(n, a));
+    });
+  }
+  return t;
+}
+function jn(t) {
+  return Ln(t) || _n(t) || Bt(t) || $n();
+}
+function zn(t, e) {
+  if (typeof t != "object" || !t) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var a = n.call(t, e);
+    if (typeof a != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+function Wn(t) {
+  var e = zn(t, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function Bt(t, e) {
+  if (t) {
+    if (typeof t == "string") return et(t, e);
+    var n = {}.toString.call(t).slice(8, -1);
+    return n === "Object" && t.constructor && (n = t.constructor.name), n === "Map" || n === "Set" ? Array.from(t) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? et(t, e) : void 0;
+  }
+}
+var Q = {
+  // 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, n) {
+    var a = Q.getActiveTrap(e);
+    n !== a && Q.pauseTrap(e);
+    var r = e.indexOf(n);
+    r === -1 || e.splice(r, 1), e.push(n);
+  },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
+  deactivateTrap: function(e, n) {
+    var a = e.indexOf(n);
+    a !== -1 && e.splice(a, 1), Q.unpauseTrap(e);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function(e) {
+    var n = Q.getActiveTrap(e);
+    n?._setPausedState(!0);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function(e) {
+    var n = Q.getActiveTrap(e);
+    n && !n._isManuallyPaused() && n._setPausedState(!1);
+  }
+}, Hn = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, Kn = function(e) {
+  return e?.key === "Escape" || e?.key === "Esc" || e?.keyCode === 27;
+}, xe = function(e) {
+  return e?.key === "Tab" || e?.keyCode === 9;
+}, Un = function(e) {
+  return xe(e) && !e.shiftKey;
+}, qn = function(e) {
+  return xe(e) && e.shiftKey;
+}, vt = function(e) {
+  return setTimeout(e, 0);
+}, we = function(e) {
+  for (var n = arguments.length, a = new Array(n > 1 ? n - 1 : 0), r = 1; r < n; r++)
+    a[r - 1] = arguments[r];
+  return typeof e == "function" ? e.apply(void 0, a) : e;
+}, Re = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, Xn = [], Gn = function(e, n) {
+  var a = n?.document || document, r = n?.trapStack || Xn, i = ft({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isolateSubtrees: !1,
+    isKeyForward: Un,
+    isKeyBackward: qn
+  }, n), o = {
+    // 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
+  }, l, s = function(c, f, b) {
+    return c && c[f] !== void 0 ? c[f] : i[b || f];
+  }, u = function(c, f) {
+    var b = typeof f?.composedPath == "function" ? f.composedPath() : void 0;
+    return o.containerGroups.findIndex(function(x) {
+      var g = x.container, R = x.tabbableNodes;
+      return g.contains(c) || b?.includes(g) || R.find(function(F) {
+        return F === c;
+      });
+    });
+  }, d = function(c) {
+    var f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, b = f.hasFallback, x = b === void 0 ? !1 : b, g = f.params, R = g === void 0 ? [] : g, F = i[c];
+    if (typeof F == "function" && (F = F.apply(void 0, jn(R))), F === !0 && (F = void 0), !F) {
+      if (F === void 0 || F === !1)
+        return F;
+      throw new Error("`".concat(c, "` was specified but was not a node, or did not return a node"));
+    }
+    var D = F;
+    if (typeof F == "string") {
+      try {
+        D = a.querySelector(F);
+      } catch (I) {
+        throw new Error("`".concat(c, '` appears to be an invalid selector; error="').concat(I.message, '"'));
+      }
+      if (!D && !x)
+        throw new Error("`".concat(c, "` as selector refers to no known node"));
+    }
+    return D;
+  }, v = function() {
+    var c = d("initialFocus", {
+      hasFallback: !0
+    });
+    if (c === !1)
+      return !1;
+    if (c === void 0 || c && !Ge(c, i.tabbableOptions))
+      if (u(a.activeElement) >= 0)
+        c = a.activeElement;
+      else {
+        var f = o.tabbableGroups[0], b = f && f.firstTabbableNode;
+        c = b || d("fallbackFocus");
+      }
+    else c === null && (c = d("fallbackFocus"));
+    if (!c)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return c;
+  }, m = function() {
+    if (o.containerGroups = o.containers.map(function(c) {
+      var f = Pn(c, i.tabbableOptions), b = Vn(c, i.tabbableOptions), x = f.length > 0 ? f[0] : void 0, g = f.length > 0 ? f[f.length - 1] : void 0, R = b.find(function(I) {
+        return me(I);
+      }), F = b.slice().reverse().find(function(I) {
+        return me(I);
+      }), D = !!f.find(function(I) {
+        return ie(I) > 0;
+      });
+      return {
+        container: c,
+        tabbableNodes: f,
+        focusableNodes: b,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: D,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: x,
+        /** 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: R,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: F,
+        /**
+         * 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(W) {
+          var Y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, U = f.indexOf(W);
+          return U < 0 ? Y ? b.slice(b.indexOf(W) + 1).find(function(oe) {
+            return me(oe);
+          }) : b.slice(0, b.indexOf(W)).reverse().find(function(oe) {
+            return me(oe);
+          }) : f[U + (Y ? 1 : -1)];
+        }
+      };
+    }), o.tabbableGroups = o.containerGroups.filter(function(c) {
+      return c.tabbableNodes.length > 0;
+    }), o.tabbableGroups.length <= 0 && !d("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 (o.containerGroups.find(function(c) {
+      return c.posTabIndexesFound;
+    }) && o.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.");
+  }, p = function(c) {
+    var f = c.activeElement;
+    if (f)
+      return f.shadowRoot && f.shadowRoot.activeElement !== null ? p(f.shadowRoot) : f;
+  }, h = function(c) {
+    if (c !== !1 && c !== p(document)) {
+      if (!c || !c.focus) {
+        h(v());
+        return;
+      }
+      c.focus({
+        preventScroll: !!i.preventScroll
+      }), o.mostRecentlyFocusedNode = c, Hn(c) && c.select();
+    }
+  }, T = function(c) {
+    var f = d("setReturnFocus", {
+      params: [c]
+    });
+    return f || (f === !1 ? !1 : c);
+  }, A = function(c) {
+    var f = c.target, b = c.event, x = c.isBackward, g = x === void 0 ? !1 : x;
+    f = f || Re(b), m();
+    var R = null;
+    if (o.tabbableGroups.length > 0) {
+      var F = u(f, b), D = F >= 0 ? o.containerGroups[F] : void 0;
+      if (F < 0)
+        g ? R = o.tabbableGroups[o.tabbableGroups.length - 1].lastTabbableNode : R = o.tabbableGroups[0].firstTabbableNode;
+      else if (g) {
+        var I = o.tabbableGroups.findIndex(function(qe) {
+          var Xe = qe.firstTabbableNode;
+          return f === Xe;
+        });
+        if (I < 0 && (D.container === f || Ge(f, i.tabbableOptions) && !me(f, i.tabbableOptions) && !D.nextTabbableNode(f, !1)) && (I = F), I >= 0) {
+          var W = I === 0 ? o.tabbableGroups.length - 1 : I - 1, Y = o.tabbableGroups[W];
+          R = ie(f) >= 0 ? Y.lastTabbableNode : Y.lastDomTabbableNode;
+        } else xe(b) || (R = D.nextTabbableNode(f, !1));
+      } else {
+        var U = o.tabbableGroups.findIndex(function(qe) {
+          var Xe = qe.lastTabbableNode;
+          return f === Xe;
+        });
+        if (U < 0 && (D.container === f || Ge(f, i.tabbableOptions) && !me(f, i.tabbableOptions) && !D.nextTabbableNode(f)) && (U = F), U >= 0) {
+          var oe = U === o.tabbableGroups.length - 1 ? 0 : U + 1, te = o.tabbableGroups[oe];
+          R = ie(f) >= 0 ? te.firstTabbableNode : te.firstDomTabbableNode;
+        } else xe(b) || (R = D.nextTabbableNode(f));
+      }
+    } else
+      R = d("fallbackFocus");
+    return R;
+  }, S = function(c) {
+    var f = Re(c);
+    if (!(u(f, c) >= 0)) {
+      if (we(i.clickOutsideDeactivates, c)) {
+        l.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: i.returnFocusOnDeactivate
+        });
+        return;
+      }
+      we(i.allowOutsideClick, c) || c.preventDefault();
+    }
+  }, C = function(c) {
+    var f = Re(c), b = u(f, c) >= 0;
+    if (b || f instanceof Document)
+      b && (o.mostRecentlyFocusedNode = f);
+    else {
+      c.stopImmediatePropagation();
+      var x, g = !0;
+      if (o.mostRecentlyFocusedNode)
+        if (ie(o.mostRecentlyFocusedNode) > 0) {
+          var R = u(o.mostRecentlyFocusedNode), F = o.containerGroups[R].tabbableNodes;
+          if (F.length > 0) {
+            var D = F.findIndex(function(I) {
+              return I === o.mostRecentlyFocusedNode;
+            });
+            D >= 0 && (i.isKeyForward(o.recentNavEvent) ? D + 1 < F.length && (x = F[D + 1], g = !1) : D - 1 >= 0 && (x = F[D - 1], g = !1));
+          }
+        } else
+          o.containerGroups.some(function(I) {
+            return I.tabbableNodes.some(function(W) {
+              return ie(W) > 0;
+            });
+          }) || (g = !1);
+      else
+        g = !1;
+      g && (x = A({
+        // 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: o.mostRecentlyFocusedNode,
+        isBackward: i.isKeyBackward(o.recentNavEvent)
+      })), h(x || o.mostRecentlyFocusedNode || v());
+    }
+    o.recentNavEvent = void 0;
+  }, O = function(c) {
+    var f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    o.recentNavEvent = c;
+    var b = A({
+      event: c,
+      isBackward: f
+    });
+    b && (xe(c) && c.preventDefault(), h(b));
+  }, P = function(c) {
+    (i.isKeyForward(c) || i.isKeyBackward(c)) && O(c, i.isKeyBackward(c));
+  }, L = function(c) {
+    Kn(c) && we(i.escapeDeactivates, c) !== !1 && (c.preventDefault(), l.deactivate());
+  }, B = function(c) {
+    var f = Re(c);
+    u(f, c) >= 0 || we(i.clickOutsideDeactivates, c) || we(i.allowOutsideClick, c) || (c.preventDefault(), c.stopImmediatePropagation());
+  }, N = function() {
+    if (o.active)
+      return Q.activateTrap(r, l), o.delayInitialFocusTimer = i.delayInitialFocus ? vt(function() {
+        h(v());
+      }) : h(v()), a.addEventListener("focusin", C, !0), a.addEventListener("mousedown", S, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("touchstart", S, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("click", B, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", P, {
+        capture: !0,
+        passive: !1
+      }), a.addEventListener("keydown", L), l;
+  }, y = function(c) {
+    o.active && !o.paused && l._setSubtreeIsolation(!1), o.adjacentElements.clear(), o.alreadySilent.clear();
+    var f = /* @__PURE__ */ new Set(), b = /* @__PURE__ */ new Set(), x = ut(c), g;
+    try {
+      for (x.s(); !(g = x.n()).done; ) {
+        var R = g.value;
+        f.add(R);
+        for (var F = typeof ShadowRoot < "u" && R.getRootNode() instanceof ShadowRoot, D = R; D; ) {
+          f.add(D);
+          var I = D.parentElement, W = [];
+          I ? W = I.children : !I && F && (W = D.getRootNode().children, I = D.getRootNode().host, F = typeof ShadowRoot < "u" && I.getRootNode() instanceof ShadowRoot);
+          var Y = ut(W), U;
+          try {
+            for (Y.s(); !(U = Y.n()).done; ) {
+              var oe = U.value;
+              b.add(oe);
+            }
+          } catch (te) {
+            Y.e(te);
+          } finally {
+            Y.f();
+          }
+          D = I;
+        }
+      }
+    } catch (te) {
+      x.e(te);
+    } finally {
+      x.f();
+    }
+    f.forEach(function(te) {
+      b.delete(te);
+    }), o.adjacentElements = b;
+  }, w = function() {
+    if (o.active)
+      return a.removeEventListener("focusin", C, !0), a.removeEventListener("mousedown", S, !0), a.removeEventListener("touchstart", S, !0), a.removeEventListener("click", B, !0), a.removeEventListener("keydown", P, !0), a.removeEventListener("keydown", L), l;
+  }, E = function(c) {
+    var f = c.some(function(b) {
+      var x = Array.from(b.removedNodes);
+      return x.some(function(g) {
+        return g === o.mostRecentlyFocusedNode;
+      });
+    });
+    f && h(v());
+  }, V = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(E) : void 0, _ = function() {
+    V && (V.disconnect(), o.active && !o.paused && o.containers.map(function(c) {
+      V.observe(c, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return l = {
+    get active() {
+      return o.active;
+    },
+    get paused() {
+      return o.paused;
+    },
+    activate: function(c) {
+      if (o.active)
+        return this;
+      var f = s(c, "onActivate"), b = s(c, "onPostActivate"), x = s(c, "checkCanFocusTrap"), g = Q.getActiveTrap(r), R = !1;
+      if (g && !g.paused) {
+        var F;
+        (F = g._setSubtreeIsolation) === null || F === void 0 || F.call(g, !1), R = !0;
+      }
+      try {
+        x || m(), o.active = !0, o.paused = !1, o.nodeFocusedBeforeActivation = p(a), f?.();
+        var D = function() {
+          x && m(), N(), _(), i.isolateSubtrees && l._setSubtreeIsolation(!0), b?.();
+        };
+        if (x)
+          return x(o.containers.concat()).then(D, D), this;
+        D();
+      } catch (W) {
+        if (g === Q.getActiveTrap(r) && R) {
+          var I;
+          (I = g._setSubtreeIsolation) === null || I === void 0 || I.call(g, !0);
+        }
+        throw W;
+      }
+      return this;
+    },
+    deactivate: function(c) {
+      if (!o.active)
+        return this;
+      var f = ft({
+        onDeactivate: i.onDeactivate,
+        onPostDeactivate: i.onPostDeactivate,
+        checkCanReturnFocus: i.checkCanReturnFocus
+      }, c);
+      clearTimeout(o.delayInitialFocusTimer), o.delayInitialFocusTimer = void 0, o.paused || l._setSubtreeIsolation(!1), o.alreadySilent.clear(), w(), o.active = !1, o.paused = !1, _(), Q.deactivateTrap(r, l);
+      var b = s(f, "onDeactivate"), x = s(f, "onPostDeactivate"), g = s(f, "checkCanReturnFocus"), R = s(f, "returnFocus", "returnFocusOnDeactivate");
+      b?.();
+      var F = function() {
+        vt(function() {
+          R && h(T(o.nodeFocusedBeforeActivation)), x?.();
+        });
+      };
+      return R && g ? (g(T(o.nodeFocusedBeforeActivation)).then(F, F), this) : (F(), this);
+    },
+    pause: function(c) {
+      return o.active ? (o.manuallyPaused = !0, this._setPausedState(!0, c)) : this;
+    },
+    unpause: function(c) {
+      return o.active ? (o.manuallyPaused = !1, r[r.length - 1] !== this ? this : this._setPausedState(!1, c)) : this;
+    },
+    updateContainerElements: function(c) {
+      var f = [].concat(c).filter(Boolean);
+      return o.containers = f.map(function(b) {
+        return typeof b == "string" ? a.querySelector(b) : b;
+      }), i.isolateSubtrees && y(o.containers), o.active && (m(), i.isolateSubtrees && !o.paused && l._setSubtreeIsolation(!0)), _(), this;
+    }
+  }, Object.defineProperties(l, {
+    _isManuallyPaused: {
+      value: function() {
+        return o.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(c, f) {
+        if (o.paused === c)
+          return this;
+        if (o.paused = c, c) {
+          var b = s(f, "onPause"), x = s(f, "onPostPause");
+          b?.(), w(), _(), l._setSubtreeIsolation(!1), x?.();
+        } else {
+          var g = s(f, "onUnpause"), R = s(f, "onPostUnpause");
+          g?.(), l._setSubtreeIsolation(!0), m(), N(), _(), R?.();
+        }
+        return this;
+      }
+    },
+    _setSubtreeIsolation: {
+      value: function(c) {
+        i.isolateSubtrees && o.adjacentElements.forEach(function(f) {
+          var b;
+          c ? i.isolateSubtrees === "aria-hidden" ? ((f.ariaHidden === "true" || ((b = f.getAttribute("aria-hidden")) === null || b === void 0 ? void 0 : b.toLowerCase()) === "true") && o.alreadySilent.add(f), f.setAttribute("aria-hidden", "true")) : ((f.inert || f.hasAttribute("inert")) && o.alreadySilent.add(f), f.setAttribute("inert", !0)) : o.alreadySilent.has(f) || (i.isolateSubtrees === "aria-hidden" ? f.removeAttribute("aria-hidden") : f.removeAttribute("inert"));
+        });
+      }
+    }
+  }), l.updateContainerElements(e), l;
+};
+const Yn = {
+  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
+}, Zn = fe({
+  props: Object.assign({
+    active: {
+      // TODO: could be options for activate but what about the options for deactivating?
+      type: Boolean,
+      default: !0
+    }
+  }, Yn),
+  emits: [
+    "update:active",
+    "activate",
+    "postActivate",
+    "deactivate",
+    "postDeactivate"
+  ],
+  render() {
+    return this.renderImpl();
+  },
+  setup(t, { slots: e, emit: n }) {
+    let a;
+    const r = j(null), i = M(() => {
+      const l = r.value;
+      return l && (l instanceof HTMLElement ? l : l.$el);
+    });
+    function o() {
+      return a || (a = Gn(i.value, {
+        escapeDeactivates: t.escapeDeactivates,
+        allowOutsideClick: t.allowOutsideClick,
+        returnFocusOnDeactivate: t.returnFocusOnDeactivate,
+        clickOutsideDeactivates: t.clickOutsideDeactivates,
+        onActivate: () => {
+          n("update:active", !0), n("activate");
+        },
+        onDeactivate: () => {
+          n("update:active", !1), n("deactivate");
+        },
+        onPostActivate: () => n("postActivate"),
+        onPostDeactivate: () => n("postDeactivate"),
+        initialFocus: t.initialFocus,
+        fallbackFocus: t.fallbackFocus,
+        tabbableOptions: t.tabbableOptions,
+        delayInitialFocus: t.delayInitialFocus
+      }));
+    }
+    return Ft(() => {
+      le(() => t.active, (l) => {
+        l && i.value ? o().activate() : a && (a.deactivate(), (!i.value || i.value.nodeType === Node.COMMENT_NODE) && (a = null));
+      }, { immediate: !0, flush: "post" });
+    }), Rt(() => {
+      a && a.deactivate(), a = null;
+    }), {
+      activate() {
+        o().activate();
+      },
+      deactivate() {
+        a && a.deactivate();
+      },
+      renderImpl() {
+        if (!e.default)
+          return null;
+        const l = e.default().filter((u) => u.type !== Gt);
+        return !l || !l.length || l.length > 1 ? (console.error("[focus-trap-vue]: FocusTrap requires exactly one child."), l) : Yt(l[0], { ref: r });
+      }
+    };
+  }
+}), Le = Math.min, se = Math.max, Me = Math.round, Ae = Math.floor, Z = (t) => ({
+  x: t,
+  y: t
+}), Jn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function pt(t, e, n) {
+  return se(t, Le(e, n));
+}
+function je(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function ue(t) {
+  return t.split("-")[0];
+}
+function ze(t) {
+  return t.split("-")[1];
+}
+function Lt(t) {
+  return t === "x" ? "y" : "x";
+}
+function Mt(t) {
+  return t === "y" ? "height" : "width";
+}
+function ne(t) {
+  const e = t[0];
+  return e === "t" || e === "b" ? "y" : "x";
+}
+function _t(t) {
+  return Lt(ne(t));
+}
+function Qn(t, e, n) {
+  n === void 0 && (n = !1);
+  const a = ze(t), r = _t(t), i = Mt(r);
+  let o = r === "x" ? a === (n ? "end" : "start") ? "right" : "left" : a === "start" ? "bottom" : "top";
+  return e.reference[i] > e.floating[i] && (o = _e(o)), [o, _e(o)];
+}
+function ea(t) {
+  const e = _e(t);
+  return [tt(t), e, tt(e)];
+}
+function tt(t) {
+  return t.includes("start") ? t.replace("start", "end") : t.replace("end", "start");
+}
+const mt = ["left", "right"], ht = ["right", "left"], ta = ["top", "bottom"], na = ["bottom", "top"];
+function aa(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? ht : mt : e ? mt : ht;
+    case "left":
+    case "right":
+      return e ? ta : na;
+    default:
+      return [];
+  }
+}
+function oa(t, e, n, a) {
+  const r = ze(t);
+  let i = aa(ue(t), n === "start", a);
+  return r && (i = i.map((o) => o + "-" + r), e && (i = i.concat(i.map(tt)))), i;
+}
+function _e(t) {
+  const e = ue(t);
+  return Jn[e] + t.slice(e.length);
+}
+function ra(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function ia(t) {
+  return typeof t != "number" ? ra(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function $e(t) {
+  const {
+    x: e,
+    y: n,
+    width: a,
+    height: r
+  } = t;
+  return {
+    width: a,
+    height: r,
+    top: n,
+    left: e,
+    right: e + a,
+    bottom: n + r,
+    x: e,
+    y: n
+  };
+}
+function bt(t, e, n) {
+  let {
+    reference: a,
+    floating: r
+  } = t;
+  const i = ne(e), o = _t(e), l = Mt(o), s = ue(e), u = i === "y", d = a.x + a.width / 2 - r.width / 2, v = a.y + a.height / 2 - r.height / 2, m = a[l] / 2 - r[l] / 2;
+  let p;
+  switch (s) {
+    case "top":
+      p = {
+        x: d,
+        y: a.y - r.height
+      };
+      break;
+    case "bottom":
+      p = {
+        x: d,
+        y: a.y + a.height
+      };
+      break;
+    case "right":
+      p = {
+        x: a.x + a.width,
+        y: v
+      };
+      break;
+    case "left":
+      p = {
+        x: a.x - r.width,
+        y: v
+      };
+      break;
+    default:
+      p = {
+        x: a.x,
+        y: a.y
+      };
+  }
+  switch (ze(e)) {
+    case "start":
+      p[o] -= m * (n && u ? -1 : 1);
+      break;
+    case "end":
+      p[o] += m * (n && u ? -1 : 1);
+      break;
+  }
+  return p;
+}
+async function la(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: a,
+    y: r,
+    platform: i,
+    rects: o,
+    elements: l,
+    strategy: s
+  } = t, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: v = "floating",
+    altBoundary: m = !1,
+    padding: p = 0
+  } = je(e, t), h = ia(p), A = l[m ? v === "floating" ? "reference" : "floating" : v], S = $e(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(A))) == null || n ? A : A.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(l.floating)),
+    boundary: u,
+    rootBoundary: d,
+    strategy: s
+  })), C = v === "floating" ? {
+    x: a,
+    y: r,
+    width: o.floating.width,
+    height: o.floating.height
+  } : o.reference, O = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(l.floating)), P = await (i.isElement == null ? void 0 : i.isElement(O)) ? await (i.getScale == null ? void 0 : i.getScale(O)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, L = $e(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: C,
+    offsetParent: O,
+    strategy: s
+  }) : C);
+  return {
+    top: (S.top - L.top + h.top) / P.y,
+    bottom: (L.bottom - S.bottom + h.bottom) / P.y,
+    left: (S.left - L.left + h.left) / P.x,
+    right: (L.right - S.right + h.right) / P.x
+  };
+}
+const sa = 50, ca = async (t, e, n) => {
+  const {
+    placement: a = "bottom",
+    strategy: r = "absolute",
+    middleware: i = [],
+    platform: o
+  } = n, l = o.detectOverflow ? o : {
+    ...o,
+    detectOverflow: la
+  }, s = await (o.isRTL == null ? void 0 : o.isRTL(e));
+  let u = await o.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: r
+  }), {
+    x: d,
+    y: v
+  } = bt(u, a, s), m = a, p = 0;
+  const h = {};
+  for (let T = 0; T < i.length; T++) {
+    const A = i[T];
+    if (!A)
+      continue;
+    const {
+      name: S,
+      fn: C
+    } = A, {
+      x: O,
+      y: P,
+      data: L,
+      reset: B
+    } = await C({
+      x: d,
+      y: v,
+      initialPlacement: a,
+      placement: m,
+      strategy: r,
+      middlewareData: h,
+      rects: u,
+      platform: l,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    d = O ?? d, v = P ?? v, h[S] = {
+      ...h[S],
+      ...L
+    }, B && p < sa && (p++, typeof B == "object" && (B.placement && (m = B.placement), B.rects && (u = B.rects === !0 ? await o.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: r
+    }) : B.rects), {
+      x: d,
+      y: v
+    } = bt(u, m, s)), T = -1);
+  }
+  return {
+    x: d,
+    y: v,
+    placement: m,
+    strategy: r,
+    middlewareData: h
+  };
+}, ua = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, a;
+      const {
+        placement: r,
+        middlewareData: i,
+        rects: o,
+        initialPlacement: l,
+        platform: s,
+        elements: u
+      } = e, {
+        mainAxis: d = !0,
+        crossAxis: v = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: p = "bestFit",
+        fallbackAxisSideDirection: h = "none",
+        flipAlignment: T = !0,
+        ...A
+      } = je(t, e);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const S = ue(r), C = ne(l), O = ue(l) === l, P = await (s.isRTL == null ? void 0 : s.isRTL(u.floating)), L = m || (O || !T ? [_e(l)] : ea(l)), B = h !== "none";
+      !m && B && L.push(...oa(l, T, h, P));
+      const N = [l, ...L], y = await s.detectOverflow(e, A), w = [];
+      let E = ((a = i.flip) == null ? void 0 : a.overflows) || [];
+      if (d && w.push(y[S]), v) {
+        const c = Qn(r, o, P);
+        w.push(y[c[0]], y[c[1]]);
+      }
+      if (E = [...E, {
+        placement: r,
+        overflows: w
+      }], !w.every((c) => c <= 0)) {
+        var V, _;
+        const c = (((V = i.flip) == null ? void 0 : V.index) || 0) + 1, f = N[c];
+        if (f && (!(v === "alignment" ? C !== ne(f) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        E.every((g) => ne(g.placement) === C ? g.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: c,
+              overflows: E
+            },
+            reset: {
+              placement: f
+            }
+          };
+        let b = (_ = E.filter((x) => x.overflows[0] <= 0).sort((x, g) => x.overflows[1] - g.overflows[1])[0]) == null ? void 0 : _.placement;
+        if (!b)
+          switch (p) {
+            case "bestFit": {
+              var k;
+              const x = (k = E.filter((g) => {
+                if (B) {
+                  const R = ne(g.placement);
+                  return R === C || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  R === "y";
+                }
+                return !0;
+              }).map((g) => [g.placement, g.overflows.filter((R) => R > 0).reduce((R, F) => R + F, 0)]).sort((g, R) => g[1] - R[1])[0]) == null ? void 0 : k[0];
+              x && (b = x);
+              break;
+            }
+            case "initialPlacement":
+              b = l;
+              break;
+          }
+        if (r !== b)
+          return {
+            reset: {
+              placement: b
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, da = /* @__PURE__ */ new Set(["left", "top"]);
+async function fa(t, e) {
+  const {
+    placement: n,
+    platform: a,
+    elements: r
+  } = t, i = await (a.isRTL == null ? void 0 : a.isRTL(r.floating)), o = ue(n), l = ze(n), s = ne(n) === "y", u = da.has(o) ? -1 : 1, d = i && s ? -1 : 1, v = je(e, t);
+  let {
+    mainAxis: m,
+    crossAxis: p,
+    alignmentAxis: h
+  } = typeof v == "number" ? {
+    mainAxis: v,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: v.mainAxis || 0,
+    crossAxis: v.crossAxis || 0,
+    alignmentAxis: v.alignmentAxis
+  };
+  return l && typeof h == "number" && (p = l === "end" ? h * -1 : h), s ? {
+    x: p * d,
+    y: m * u
+  } : {
+    x: m * u,
+    y: p * d
+  };
+}
+const va = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, a;
+      const {
+        x: r,
+        y: i,
+        placement: o,
+        middlewareData: l
+      } = e, s = await fa(e, t);
+      return o === ((n = l.offset) == null ? void 0 : n.placement) && (a = l.arrow) != null && a.alignmentOffset ? {} : {
+        x: r + s.x,
+        y: i + s.y,
+        data: {
+          ...s,
+          placement: o
+        }
+      };
+    }
+  };
+}, pa = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: a,
+        placement: r,
+        platform: i
+      } = e, {
+        mainAxis: o = !0,
+        crossAxis: l = !1,
+        limiter: s = {
+          fn: (S) => {
+            let {
+              x: C,
+              y: O
+            } = S;
+            return {
+              x: C,
+              y: O
+            };
+          }
+        },
+        ...u
+      } = je(t, e), d = {
+        x: n,
+        y: a
+      }, v = await i.detectOverflow(e, u), m = ne(ue(r)), p = Lt(m);
+      let h = d[p], T = d[m];
+      if (o) {
+        const S = p === "y" ? "top" : "left", C = p === "y" ? "bottom" : "right", O = h + v[S], P = h - v[C];
+        h = pt(O, h, P);
+      }
+      if (l) {
+        const S = m === "y" ? "top" : "left", C = m === "y" ? "bottom" : "right", O = T + v[S], P = T - v[C];
+        T = pt(O, T, P);
+      }
+      const A = s.fn({
+        ...e,
+        [p]: h,
+        [m]: T
+      });
+      return {
+        ...A,
+        data: {
+          x: A.x - n,
+          y: A.y - a,
+          enabled: {
+            [p]: o,
+            [m]: l
+          }
+        }
+      };
+    }
+  };
+};
+function We() {
+  return typeof window < "u";
+}
+function ve(t) {
+  return ot(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function K(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function J(t) {
+  var e;
+  return (e = (ot(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function ot(t) {
+  return We() ? t instanceof Node || t instanceof K(t).Node : !1;
+}
+function X(t) {
+  return We() ? t instanceof Element || t instanceof K(t).Element : !1;
+}
+function ee(t) {
+  return We() ? t instanceof HTMLElement || t instanceof K(t).HTMLElement : !1;
+}
+function yt(t) {
+  return !We() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof K(t).ShadowRoot;
+}
+function Fe(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: a,
+    display: r
+  } = G(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + a + n) && r !== "inline" && r !== "contents";
+}
+function ma(t) {
+  return /^(table|td|th)$/.test(ve(t));
+}
+function He(t) {
+  try {
+    if (t.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const ha = /transform|translate|scale|rotate|perspective|filter/, ba = /paint|layout|strict|content/, re = (t) => !!t && t !== "none";
+let Ye;
+function rt(t) {
+  const e = X(t) ? G(t) : t;
+  return re(e.transform) || re(e.translate) || re(e.scale) || re(e.rotate) || re(e.perspective) || !it() && (re(e.backdropFilter) || re(e.filter)) || ha.test(e.willChange || "") || ba.test(e.contain || "");
+}
+function ya(t) {
+  let e = ae(t);
+  for (; ee(e) && !ye(e); ) {
+    if (rt(e))
+      return e;
+    if (He(e))
+      return null;
+    e = ae(e);
+  }
+  return null;
+}
+function it() {
+  return Ye == null && (Ye = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), Ye;
+}
+function ye(t) {
+  return /^(html|body|#document)$/.test(ve(t));
+}
+function G(t) {
+  return K(t).getComputedStyle(t);
+}
+function Ke(t) {
+  return X(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function ae(t) {
+  if (ve(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    yt(t) && t.host || // Fallback.
+    J(t)
+  );
+  return yt(e) ? e.host : e;
+}
+function $t(t) {
+  const e = ae(t);
+  return ye(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : ee(e) && Fe(e) ? e : $t(e);
+}
+function Ee(t, e, n) {
+  var a;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const r = $t(t), i = r === ((a = t.ownerDocument) == null ? void 0 : a.body), o = K(r);
+  if (i) {
+    const l = nt(o);
+    return e.concat(o, o.visualViewport || [], Fe(r) ? r : [], l && n ? Ee(l) : []);
+  } else
+    return e.concat(r, Ee(r, [], n));
+}
+function nt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function jt(t) {
+  const e = G(t);
+  let n = parseFloat(e.width) || 0, a = parseFloat(e.height) || 0;
+  const r = ee(t), i = r ? t.offsetWidth : n, o = r ? t.offsetHeight : a, l = Me(n) !== i || Me(a) !== o;
+  return l && (n = i, a = o), {
+    width: n,
+    height: a,
+    $: l
+  };
+}
+function lt(t) {
+  return X(t) ? t : t.contextElement;
+}
+function he(t) {
+  const e = lt(t);
+  if (!ee(e))
+    return Z(1);
+  const n = e.getBoundingClientRect(), {
+    width: a,
+    height: r,
+    $: i
+  } = jt(e);
+  let o = (i ? Me(n.width) : n.width) / a, l = (i ? Me(n.height) : n.height) / r;
+  return (!o || !Number.isFinite(o)) && (o = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: o,
+    y: l
+  };
+}
+const ga = /* @__PURE__ */ Z(0);
+function zt(t) {
+  const e = K(t);
+  return !it() || !e.visualViewport ? ga : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function wa(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== K(t) ? !1 : e;
+}
+function de(t, e, n, a) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const r = t.getBoundingClientRect(), i = lt(t);
+  let o = Z(1);
+  e && (a ? X(a) && (o = he(a)) : o = he(t));
+  const l = wa(i, n, a) ? zt(i) : Z(0);
+  let s = (r.left + l.x) / o.x, u = (r.top + l.y) / o.y, d = r.width / o.x, v = r.height / o.y;
+  if (i) {
+    const m = K(i), p = a && X(a) ? K(a) : a;
+    let h = m, T = nt(h);
+    for (; T && a && p !== h; ) {
+      const A = he(T), S = T.getBoundingClientRect(), C = G(T), O = S.left + (T.clientLeft + parseFloat(C.paddingLeft)) * A.x, P = S.top + (T.clientTop + parseFloat(C.paddingTop)) * A.y;
+      s *= A.x, u *= A.y, d *= A.x, v *= A.y, s += O, u += P, h = K(T), T = nt(h);
+    }
+  }
+  return $e({
+    width: d,
+    height: v,
+    x: s,
+    y: u
+  });
+}
+function Ue(t, e) {
+  const n = Ke(t).scrollLeft;
+  return e ? e.left + n : de(J(t)).left + n;
+}
+function Wt(t, e) {
+  const n = t.getBoundingClientRect(), a = n.left + e.scrollLeft - Ue(t, n), r = n.top + e.scrollTop;
+  return {
+    x: a,
+    y: r
+  };
+}
+function Ta(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: a,
+    strategy: r
+  } = t;
+  const i = r === "fixed", o = J(a), l = e ? He(e.floating) : !1;
+  if (a === o || l && i)
+    return n;
+  let s = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = Z(1);
+  const d = Z(0), v = ee(a);
+  if ((v || !v && !i) && ((ve(a) !== "body" || Fe(o)) && (s = Ke(a)), v)) {
+    const p = de(a);
+    u = he(a), d.x = p.x + a.clientLeft, d.y = p.y + a.clientTop;
+  }
+  const m = o && !v && !i ? Wt(o, s) : Z(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - s.scrollLeft * u.x + d.x + m.x,
+    y: n.y * u.y - s.scrollTop * u.y + d.y + m.y
+  };
+}
+function xa(t) {
+  return Array.from(t.getClientRects());
+}
+function Sa(t) {
+  const e = J(t), n = Ke(t), a = t.ownerDocument.body, r = se(e.scrollWidth, e.clientWidth, a.scrollWidth, a.clientWidth), i = se(e.scrollHeight, e.clientHeight, a.scrollHeight, a.clientHeight);
+  let o = -n.scrollLeft + Ue(t);
+  const l = -n.scrollTop;
+  return G(a).direction === "rtl" && (o += se(e.clientWidth, a.clientWidth) - r), {
+    width: r,
+    height: i,
+    x: o,
+    y: l
+  };
+}
+const gt = 25;
+function Ea(t, e) {
+  const n = K(t), a = J(t), r = n.visualViewport;
+  let i = a.clientWidth, o = a.clientHeight, l = 0, s = 0;
+  if (r) {
+    i = r.width, o = r.height;
+    const d = it();
+    (!d || d && e === "fixed") && (l = r.offsetLeft, s = r.offsetTop);
+  }
+  const u = Ue(a);
+  if (u <= 0) {
+    const d = a.ownerDocument, v = d.body, m = getComputedStyle(v), p = d.compatMode === "CSS1Compat" && parseFloat(m.marginLeft) + parseFloat(m.marginRight) || 0, h = Math.abs(a.clientWidth - v.clientWidth - p);
+    h <= gt && (i -= h);
+  } else u <= gt && (i += u);
+  return {
+    width: i,
+    height: o,
+    x: l,
+    y: s
+  };
+}
+function Fa(t, e) {
+  const n = de(t, !0, e === "fixed"), a = n.top + t.clientTop, r = n.left + t.clientLeft, i = ee(t) ? he(t) : Z(1), o = t.clientWidth * i.x, l = t.clientHeight * i.y, s = r * i.x, u = a * i.y;
+  return {
+    width: o,
+    height: l,
+    x: s,
+    y: u
+  };
+}
+function wt(t, e, n) {
+  let a;
+  if (e === "viewport")
+    a = Ea(t, n);
+  else if (e === "document")
+    a = Sa(J(t));
+  else if (X(e))
+    a = Fa(e, n);
+  else {
+    const r = zt(t);
+    a = {
+      x: e.x - r.x,
+      y: e.y - r.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return $e(a);
+}
+function Ht(t, e) {
+  const n = ae(t);
+  return n === e || !X(n) || ye(n) ? !1 : G(n).position === "fixed" || Ht(n, e);
+}
+function Ra(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let a = Ee(t, [], !1).filter((l) => X(l) && ve(l) !== "body"), r = null;
+  const i = G(t).position === "fixed";
+  let o = i ? ae(t) : t;
+  for (; X(o) && !ye(o); ) {
+    const l = G(o), s = rt(o);
+    !s && l.position === "fixed" && (r = null), (i ? !s && !r : !s && l.position === "static" && !!r && (r.position === "absolute" || r.position === "fixed") || Fe(o) && !s && Ht(t, o)) ? a = a.filter((d) => d !== o) : r = l, o = ae(o);
+  }
+  return e.set(t, a), a;
+}
+function Aa(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: a,
+    strategy: r
+  } = t;
+  const o = [...n === "clippingAncestors" ? He(e) ? [] : Ra(e, this._c) : [].concat(n), a], l = wt(e, o[0], r);
+  let s = l.top, u = l.right, d = l.bottom, v = l.left;
+  for (let m = 1; m < o.length; m++) {
+    const p = wt(e, o[m], r);
+    s = se(p.top, s), u = Le(p.right, u), d = Le(p.bottom, d), v = se(p.left, v);
+  }
+  return {
+    width: u - v,
+    height: d - s,
+    x: v,
+    y: s
+  };
+}
+function Ca(t) {
+  const {
+    width: e,
+    height: n
+  } = jt(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function ka(t, e, n) {
+  const a = ee(e), r = J(e), i = n === "fixed", o = de(t, !0, i, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const s = Z(0);
+  function u() {
+    s.x = Ue(r);
+  }
+  if (a || !a && !i)
+    if ((ve(e) !== "body" || Fe(r)) && (l = Ke(e)), a) {
+      const p = de(e, !0, i, e);
+      s.x = p.x + e.clientLeft, s.y = p.y + e.clientTop;
+    } else r && u();
+  i && !a && r && u();
+  const d = r && !a && !i ? Wt(r, l) : Z(0), v = o.left + l.scrollLeft - s.x - d.x, m = o.top + l.scrollTop - s.y - d.y;
+  return {
+    x: v,
+    y: m,
+    width: o.width,
+    height: o.height
+  };
+}
+function Ze(t) {
+  return G(t).position === "static";
+}
+function Tt(t, e) {
+  if (!ee(t) || G(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return J(t) === n && (n = n.ownerDocument.body), n;
+}
+function Kt(t, e) {
+  const n = K(t);
+  if (He(t))
+    return n;
+  if (!ee(t)) {
+    let r = ae(t);
+    for (; r && !ye(r); ) {
+      if (X(r) && !Ze(r))
+        return r;
+      r = ae(r);
+    }
+    return n;
+  }
+  let a = Tt(t, e);
+  for (; a && ma(a) && Ze(a); )
+    a = Tt(a, e);
+  return a && ye(a) && Ze(a) && !rt(a) ? n : a || ya(t) || n;
+}
+const Oa = async function(t) {
+  const e = this.getOffsetParent || Kt, n = this.getDimensions, a = await n(t.floating);
+  return {
+    reference: ka(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: a.width,
+      height: a.height
+    }
+  };
+};
+function Na(t) {
+  return G(t).direction === "rtl";
+}
+const Da = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ta,
+  getDocumentElement: J,
+  getClippingRect: Aa,
+  getOffsetParent: Kt,
+  getElementRects: Oa,
+  getClientRects: xa,
+  getDimensions: Ca,
+  getScale: he,
+  isElement: X,
+  isRTL: Na
+};
+function Ut(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function Ia(t, e) {
+  let n = null, a;
+  const r = J(t);
+  function i() {
+    var l;
+    clearTimeout(a), (l = n) == null || l.disconnect(), n = null;
+  }
+  function o(l, s) {
+    l === void 0 && (l = !1), s === void 0 && (s = 1), i();
+    const u = t.getBoundingClientRect(), {
+      left: d,
+      top: v,
+      width: m,
+      height: p
+    } = u;
+    if (l || e(), !m || !p)
+      return;
+    const h = Ae(v), T = Ae(r.clientWidth - (d + m)), A = Ae(r.clientHeight - (v + p)), S = Ae(d), O = {
+      rootMargin: -h + "px " + -T + "px " + -A + "px " + -S + "px",
+      threshold: se(0, Le(1, s)) || 1
+    };
+    let P = !0;
+    function L(B) {
+      const N = B[0].intersectionRatio;
+      if (N !== s) {
+        if (!P)
+          return o();
+        N ? o(!1, N) : a = setTimeout(() => {
+          o(!1, 1e-7);
+        }, 1e3);
+      }
+      N === 1 && !Ut(u, t.getBoundingClientRect()) && o(), P = !1;
+    }
+    try {
+      n = new IntersectionObserver(L, {
+        ...O,
+        // Handle <iframe>s
+        root: r.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(L, O);
+    }
+    n.observe(t);
+  }
+  return o(!0), i;
+}
+function Pa(t, e, n, a) {
+  a === void 0 && (a = {});
+  const {
+    ancestorScroll: r = !0,
+    ancestorResize: i = !0,
+    elementResize: o = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: s = !1
+  } = a, u = lt(t), d = r || i ? [...u ? Ee(u) : [], ...e ? Ee(e) : []] : [];
+  d.forEach((S) => {
+    r && S.addEventListener("scroll", n, {
+      passive: !0
+    }), i && S.addEventListener("resize", n);
+  });
+  const v = u && l ? Ia(u, n) : null;
+  let m = -1, p = null;
+  o && (p = new ResizeObserver((S) => {
+    let [C] = S;
+    C && C.target === u && p && e && (p.unobserve(e), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var O;
+      (O = p) == null || O.observe(e);
+    })), n();
+  }), u && !s && p.observe(u), e && p.observe(e));
+  let h, T = s ? de(t) : null;
+  s && A();
+  function A() {
+    const S = de(t);
+    T && !Ut(T, S) && n(), T = S, h = requestAnimationFrame(A);
+  }
+  return n(), () => {
+    var S;
+    d.forEach((C) => {
+      r && C.removeEventListener("scroll", n), i && C.removeEventListener("resize", n);
+    }), v?.(), (S = p) == null || S.disconnect(), p = null, s && cancelAnimationFrame(h);
+  };
+}
+const Va = va, Ba = pa, La = ua, Ma = (t, e, n) => {
+  const a = /* @__PURE__ */ new Map(), r = {
+    platform: Da,
+    ...n
+  }, i = {
+    ...r.platform,
+    _c: a
+  };
+  return ca(t, e, {
+    ...r,
+    platform: i
+  });
+};
+function _a(t) {
+  return t != null && typeof t == "object" && "$el" in t;
+}
+function xt(t) {
+  if (_a(t)) {
+    const e = t.$el;
+    return ot(e) && ve(e) === "#comment" ? null : e;
+  }
+  return t;
+}
+function Te(t) {
+  return typeof t == "function" ? t() : q(t);
+}
+function qt(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function St(t, e) {
+  const n = qt(t);
+  return Math.round(e * n) / n;
+}
+function $a(t, e, n) {
+  n === void 0 && (n = {});
+  const a = n.whileElementsMounted, r = M(() => {
+    var N;
+    return (N = Te(n.open)) != null ? N : !0;
+  }), i = M(() => Te(n.middleware)), o = M(() => {
+    var N;
+    return (N = Te(n.placement)) != null ? N : "bottom";
+  }), l = M(() => {
+    var N;
+    return (N = Te(n.strategy)) != null ? N : "absolute";
+  }), s = M(() => {
+    var N;
+    return (N = Te(n.transform)) != null ? N : !0;
+  }), u = M(() => xt(t.value)), d = M(() => xt(e.value)), v = j(0), m = j(0), p = j(l.value), h = j(o.value), T = Zt({}), A = j(!1), S = M(() => {
+    const N = {
+      position: p.value,
+      left: "0",
+      top: "0"
+    };
+    if (!d.value)
+      return N;
+    const y = St(d.value, v.value), w = St(d.value, m.value);
+    return s.value ? {
+      ...N,
+      transform: "translate(" + y + "px, " + w + "px)",
+      ...qt(d.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: p.value,
+      left: y + "px",
+      top: w + "px"
+    };
+  });
+  let C;
+  function O() {
+    if (u.value == null || d.value == null)
+      return;
+    const N = r.value;
+    Ma(u.value, d.value, {
+      middleware: i.value,
+      placement: o.value,
+      strategy: l.value
+    }).then((y) => {
+      v.value = y.x, m.value = y.y, p.value = y.strategy, h.value = y.placement, T.value = y.middlewareData, A.value = N !== !1;
+    });
+  }
+  function P() {
+    typeof C == "function" && (C(), C = void 0);
+  }
+  function L() {
+    if (P(), a === void 0) {
+      O();
+      return;
+    }
+    if (u.value != null && d.value != null) {
+      C = a(u.value, d.value, O);
+      return;
+    }
+  }
+  function B() {
+    r.value || (A.value = !1);
+  }
+  return le([i, o, l, r], O, {
+    flush: "sync"
+  }), le([u, d], L, {
+    flush: "sync"
+  }), le(r, B, {
+    flush: "sync"
+  }), Jt() && Qt(P), {
+    x: pe(v),
+    y: pe(m),
+    strategy: pe(p),
+    placement: pe(h),
+    middlewareData: pe(T),
+    isPositioned: pe(A),
+    floatingStyles: S,
+    update: O
+  };
+}
+const Ce = (t) => {
+  t.preventDefault(), t.stopPropagation(), t.stopImmediatePropagation();
+}, ja = ({
+  getNextElement: t,
+  getFirstElement: e,
+  getLastElement: n,
+  close: a,
+  disableSpaceToClick: r,
+  keepOpenedOnTab: i
+}) => {
+  const o = j(null), l = () => {
+  };
+  let s = l;
+  const u = () => {
+    o.value = null, s = l;
+  }, d = (h) => {
+    o.value = h.index, s = h.onClick;
+  }, v = (h) => {
+    d(t(o.value, h));
+  }, m = () => {
+    u(), a();
+  };
+  return {
+    onKeydown: (h) => {
+      switch (h.code) {
+        case "ArrowDown":
+          Ce(h), v(1);
+          break;
+        case "ArrowUp":
+          Ce(h), v(-1);
+          break;
+        case "Enter":
+        case "Space": {
+          const T = h.code === "Enter", A = h.code === "Space";
+          o.value !== null && (T || A && !r) && (Ce(h), s());
+          break;
+        }
+        case "Home":
+          e && d(e());
+          break;
+        case "End":
+          n && d(n());
+          break;
+        case "Escape":
+          Ce(h), m();
+          break;
+      }
+    },
+    currentIndex: en(o),
+    resetNavigation: u,
+    setElement: d
+  };
+}, za = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function Wa(t, e) {
+  return $(), H("svg", za, [...e[0] || (e[0] = [
+    z("path", {
+      fill: "#000",
+      d: "M2 3.842v-.5a.5.5 0 0 0-.5.5zm22.611 0h.5a.5.5 0 0 0-.5-.5zm-.5 7.48a.5.5 0 1 0 1 0zM2 21.43h-.5a.5.5 0 0 0 .5.5zm10.298.5a.5.5 0 1 0 0-1zm5.283 8.222h-.5a.5.5 0 0 0 .765.424zm3.278-2.046.265.424a.5.5 0 0 0 .235-.424zm0-5.87-.366-.34a.5.5 0 0 0-.134.34zM27.613 15l.366.341a.5.5 0 0 0-.366-.841zm-10.032 7.235h.5a.5.5 0 0 0-.128-.334zM11.063 15v-.5a.5.5 0 0 0-.372.835zm-.69-9.483V2h-1v3.517zM16.155 2v3.517h1V2zM2 4.342h22.611v-1H2zm22.111-.5v7.48h1v-7.48zM2.5 21.43V3.842h-1V21.43zM2 8.362h22.611v-1H2zM12.298 20.93h-6.81v1h6.81zm-6.81 0H2v1h3.488zm12.358 9.646 3.278-2.046-.53-.849-3.278 2.047zm3.513-2.47v-5.87h-1v5.87zm-.135-5.528 6.755-7.236-.731-.682-6.755 7.235zm-4.143-.342v7.916h1v-7.916zm.872-.334-6.519-7.236-.743.67 6.519 7.235zm-6.89-6.401h16.55v-1h-16.55z"
+    }, null, -1)
+  ])]);
+}
+const Ha = { render: Wa }, Ka = fe({
+  name: "BaseRadioButtons",
+  props: {
+    id: {
+      type: String,
+      default: null
+    },
+    modelValue: {
+      type: String,
+      default: null
+    },
+    name: {
+      type: String,
+      default() {
+        return `RadioButtons-${fn()}`;
+      }
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    possibleValues: {
+      type: Array,
+      default: () => [],
+      validator(t) {
+        return Array.isArray(t) ? t.every(
+          (e) => e.hasOwnProperty("id") && e.hasOwnProperty("text")
+        ) : !1;
+      }
+    }
+  },
+  emits: ["update:modelValue"],
+  methods: {
+    onInput(t) {
+      const e = t.target.value;
+      this.$emit("update:modelValue", e);
+    }
+  }
+}), Ua = ["id"], qa = ["checked", "value", "name", "disabled"], Xa = ["title"];
+function Ga(t, e, n, a, r, i) {
+  return $(), H("div", {
+    id: t.id,
+    role: "radiogroup"
+  }, [
+    ($(!0), H(Je, null, At(t.possibleValues, (o) => ($(), H("label", {
+      key: `radio-${o.id}`,
+      class: Se({ disabled: t.disabled || o.disabled })
+    }, [
+      z("input", {
+        ref_for: !0,
+        ref: "input",
+        checked: t.modelValue === o.id,
+        value: o.id,
+        name: t.name,
+        disabled: t.disabled || o.disabled,
+        type: "radio",
+        onChange: e[0] || (e[0] = (...l) => t.onInput && t.onInput(...l))
+      }, null, 40, qa),
+      z("span", {
+        title: o.text
+      }, Oe(o.text), 9, Xa),
+      Ct(t.$slots, "default", { item: o }, void 0, !0),
+      o.subtext ? ($(), H(Je, { key: 0 }, [
+        e[1] || (e[1] = z("br", null, null, -1)),
+        z("span", null, Oe(o.subtext), 1)
+      ], 64)) : Ne("", !0)
+    ], 2))), 128))
+  ], 8, Ua);
+}
+const Ya = /* @__PURE__ */ ge(Ka, [["render", Ga], ["__scopeId", "data-v-2bbebb4b"]]), Za = fe({
+  name: "ValueSwitch",
+  components: {
+    BaseRadioButtons: Ya
+  },
+  props: {
+    id: {
+      type: String,
+      default: null
+    },
+    modelValue: {
+      type: String,
+      default: null
+    },
+    name: {
+      type: String,
+      default: null
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    possibleValues: {
+      type: Array,
+      default: () => []
+    },
+    compact: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"]
+});
+function Ja(t, e, n, a, r, i) {
+  const o = tn("BaseRadioButtons");
+  return $(), ke(o, {
+    id: t.id,
+    ref: "radioButton",
+    "possible-values": t.possibleValues,
+    "model-value": t.modelValue,
+    name: t.name,
+    disabled: t.disabled,
+    class: Se(["value-switch", {
+      disabled: t.disabled,
+      compact: t.compact,
+      normal: !t.compact
+    }]),
+    "onUpdate:modelValue": e[0] || (e[0] = (l) => t.$emit("update:modelValue", l))
+  }, {
+    default: kt((l) => [
+      Ct(t.$slots, "default", nn(an(l)), void 0, !0)
+    ]),
+    _: 3
+  }, 8, ["id", "possible-values", "model-value", "name", "disabled", "class"]);
+}
+const at = /* @__PURE__ */ ge(Za, [["render", Ja], ["__scopeId", "data-v-83231815"]]), Qa = { class: "popover" }, eo = { class: "formats-container-border-host" }, to = {
+  key: 0,
+  class: "no-formats-available"
+}, no = {
+  key: 1,
+  class: "no-formats-available"
+}, ao = ["onClick"], oo = { class: "format-pattern" }, ro = { class: "format-preview" }, Et = 1, io = /* @__PURE__ */ fe({
+  __name: "DateTimeFormatPickerPopover",
+  props: {
+    allFormats: {},
+    selectedType: {},
+    initialSelectedPattern: {},
+    showTypeSwitch: { type: Boolean }
+  },
+  emits: ["commit", "cancel"],
+  setup(t, { emit: e }) {
+    on((y) => ({
+      v3b9e5e3a: Et
+    }));
+    const n = e, a = t, r = M(() => [
+      {
+        id: "RECENT",
+        text: "Recent"
+      },
+      {
+        id: "STANDARD",
+        text: "ISO"
+      },
+      {
+        id: "EUROPEAN",
+        text: "European"
+      },
+      {
+        id: "AMERICAN",
+        text: "United States"
+      }
+    ]), i = M(() => [
+      {
+        id: "DATE",
+        text: "Date"
+      },
+      {
+        id: "DATE_TIME",
+        text: "Date & time"
+      },
+      {
+        id: "TIME",
+        text: "Time"
+      },
+      {
+        id: "ZONED_DATE_TIME",
+        text: "Zoned date & time"
+      }
+    ]), o = j(null), l = j(null), s = j("RECENT"), u = j(a.selectedType);
+    le(
+      () => a.selectedType,
+      (y) => {
+        l.value = y;
+      }
+    );
+    const d = M(
+      () => a.allFormats?.filter(
+        (y) => y.category === s.value && y.temporalType === u.value
+      ) ?? null
+    ), v = j(null), m = rn({}), p = (y) => `${y.format}-${y.category}-${y.temporalType}`, h = (y) => (w) => {
+      m[p(y)] = w;
+    }, T = (y) => ({
+      format: y.format,
+      temporalType: y.temporalType
+    }), {
+      currentIndex: A,
+      onKeydown: S,
+      resetNavigation: C,
+      setElement: O
+    } = ja({
+      keepOpenedOnTab: !0,
+      getFirstElement: () => ({
+        index: 0,
+        onClick: () => n(
+          "commit",
+          T(d.value[0])
+        )
+      }),
+      getLastElement: () => {
+        const y = d.value.length - 1;
+        return {
+          index: y,
+          onClick: () => n(
+            "commit",
+            T(d.value[y])
+          )
+        };
+      },
+      getNextElement: (y, w) => {
+        if (y = y === null || y === -1 ? null : y, w === 1) {
+          const V = ((y ?? -1) + 1) % d.value.length;
+          return {
+            index: V,
+            onClick: () => n(
+              "commit",
+              T(d.value[V])
+            )
+          };
+        } else {
+          const V = ((y ?? 0) - 1 + d.value.length) % d.value.length;
+          return {
+            index: V,
+            onClick: () => n(
+              "commit",
+              T(d.value[V])
+            )
+          };
+        }
+      },
+      close: () => {
+        n("cancel");
+      }
+    }), P = (y) => {
+      const w = y.parentElement;
+      if (w && w.scrollHeight > w.clientHeight) {
+        const E = w.offsetTop + Et, V = w.clientHeight + w.scrollTop, _ = y.offsetTop + y.offsetHeight - E;
+        _ > V ? w.scrollTop = _ - w.clientHeight : y.offsetTop - w.scrollTop < E && (w.scrollTop = y.offsetTop - E);
+      }
+    }, L = (y) => {
+      const w = m[`${y}-${s.value}-${u.value}`];
+      w && P(w);
+    }, B = async (y, w, E) => {
+      u.value = w ?? u.value, s.value = E ?? s.value, await st(), l.value = y, L(y);
+      const V = d.value.findIndex(
+        (_) => _.format === y
+      );
+      O({
+        index: V,
+        onClick: () => n(
+          "commit",
+          T(d.value[V])
+        )
+      });
+    };
+    le(A, (y) => {
+      if (y === null)
+        return;
+      const w = d.value?.[y]?.format;
+      w && L(w);
+    }), le([u, s], () => {
+      u.value === o.value?.temporalType && s.value === o.value?.category ? B(
+        o.value.format,
+        o.value.temporalType,
+        o.value.category
+      ) : (l.value = null, C());
+    });
+    const N = j(!1);
+    return Ft(async () => {
+      if (!a.allFormats)
+        return;
+      const y = [
+        "RECENT",
+        "STANDARD",
+        "EUROPEAN",
+        "AMERICAN"
+      ], w = a.allFormats.filter((E) => a.initialSelectedPattern === E.format).filter(
+        (E) => (
+          // if the type switch is hidden, filter to only formats with the same type
+          a.selectedType === E.temporalType || a.showTypeSwitch
+        )
+      ).sort((E, V) => {
+        const _ = y.indexOf(E.category), k = y.indexOf(V.category);
+        return _ - k;
+      });
+      if (w.length > 0) {
+        const E = w[0].format, V = w[0].temporalType, _ = w[0].category;
+        await B(E, V, _);
+        const k = d.value.findIndex(
+          (c) => c.format === E
+        );
+        o.value = {
+          format: E,
+          index: k,
+          category: _,
+          temporalType: V
+        };
+      }
+      st(() => N.value = !0);
+    }), Rt(() => N.value = !1), (y, w) => ($(), ke(q(Zn), {
+      active: N.value,
+      "onUpdate:active": w[3] || (w[3] = (E) => N.value = E),
+      "initial-focus": () => v.value ?? !1
+    }, {
+      default: kt(() => [
+        z("div", Qa, [
+          t.showTypeSwitch ? ($(), ke(at, {
+            key: 0,
+            id: "selectedFormatType",
+            ref: "typeSwitchRef",
+            modelValue: u.value,
+            "onUpdate:modelValue": w[0] || (w[0] = (E) => u.value = E),
+            compact: "",
+            "possible-values": i.value,
+            class: "filter-switch"
+          }, null, 8, ["modelValue", "possible-values"])) : Ne("", !0),
+          be(at, {
+            id: "selectedFormatStandard",
+            ref: "standardSwitchRef",
+            modelValue: s.value,
+            "onUpdate:modelValue": w[1] || (w[1] = (E) => s.value = E),
+            compact: "",
+            "possible-values": r.value,
+            class: "filter-switch"
+          }, null, 8, ["modelValue", "possible-values"]),
+          z("div", eo, [
+            z("div", {
+              id: "dateFormats",
+              ref_key: "formatContainerRef",
+              ref: v,
+              class: "formats-container",
+              tabindex: "0",
+              role: "menu",
+              onKeydown: w[2] || (w[2] = //@ts-ignore
+              (...E) => q(S) && q(S)(...E))
+            }, [
+              d.value === null ? ($(), H("div", to, [
+                be(wn, { class: "loading-spinner" })
+              ])) : d.value.length === 0 ? ($(), H("div", no, " No formats available ")) : ($(!0), H(Je, { key: 2 }, At(d.value, (E, V) => ($(), H("div", {
+                key: p(E),
+                ref_for: !0,
+                ref: h(E),
+                class: Se([{
+                  highlighted: V === q(A),
+                  applied: V === o.value?.index && E.category === o.value.category && E.temporalType === o.value.temporalType
+                }, "single-format"]),
+                role: "menuitem",
+                onClick: () => n("commit", T(E))
+              }, [
+                z("span", oo, Oe(E.format), 1),
+                z("span", ro, Oe(E.example), 1)
+              ], 10, ao))), 128))
+            ], 544)
+          ])
+        ])
+      ]),
+      _: 1
+    }, 8, ["active", "initial-focus"]));
+  }
+}), lo = /* @__PURE__ */ ge(io, [["__scopeId", "data-v-8bb40d8b"]]), so = { class: "input-fields" }, co = ["disabled"], uo = {
+  key: 0,
+  class: "invalid-marker"
+}, fo = ["disabled"], vo = {}, po = /* @__PURE__ */ fe({
+  ...vo,
+  __name: "DateTimeFormatInput",
+  props: /* @__PURE__ */ dn({
+    disabled: { type: Boolean, default: !1 },
+    compact: { type: Boolean, default: !1 },
+    isValid: { type: Boolean, default: !0 },
+    allDefaultFormats: {},
+    allowedTypes: { default: () => [
+      "DATE",
+      "TIME",
+      "DATE_TIME",
+      "ZONED_DATE_TIME"
+    ] },
+    showTypeSwitchInPopover: { type: Boolean, default: !0 }
+  }, {
+    modelValue: {
+      default: {
+        format: "yyyy-MM-dd",
+        temporalType: "DATE"
+      }
+    },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(t) {
+    const e = t, n = ln(t, "modelValue"), a = M({
+      get: () => n.value.format,
+      set: (v) => {
+        n.value = {
+          ...n.value,
+          format: v
+        };
+      }
+    }), r = "Format like 'yyyy-MM-dd'", i = M(() => e.isValid), o = j(null), l = j(null), s = j(!1), u = (v) => {
+      n.value = v, s.value = !1;
+    };
+    vn(l, () => s.value = !1, {
+      ignore: [o]
+    });
+    const { floatingStyles: d } = $a(
+      o,
+      l,
+      {
+        middleware: [
+          Va({
+            mainAxis: 2,
+            crossAxis: 0
+          }),
+          Ba(),
+          La({
+            mainAxis: !0,
+            crossAxis: !1
+          })
+        ],
+        placement: "top-end",
+        whileElementsMounted: Pa
+      }
+    );
+    return (v, m) => ($(), H("div", null, [
+      z("div", {
+        class: Se(["wrapper", { disabled: t.disabled, compact: t.compact }])
+      }, [
+        z("span", so, [
+          sn(z("input", {
+            "onUpdate:modelValue": m[0] || (m[0] = (p) => a.value = p),
+            type: "text",
+            disabled: t.disabled,
+            placeholder: r,
+            spellcheck: "false",
+            onFocus: m[1] || (m[1] = (p) => s.value = !1)
+          }, null, 40, co), [
+            [cn, a.value]
+          ]),
+          i.value ? Ne("", !0) : ($(), H("span", uo)),
+          z("button", {
+            ref_key: "togglePopoverButtonRef",
+            ref: o,
+            class: Se(["trigger-popover-button", { active: s.value }]),
+            disabled: t.disabled,
+            onClick: m[2] || (m[2] = (p) => s.value = !s.value)
+          }, [
+            be(q(Ha))
+          ], 10, fo)
+        ])
+      ], 2),
+      s.value ? ($(), H("div", {
+        key: 0,
+        ref_key: "floatingPopoverRef",
+        ref: l,
+        class: "popover",
+        style: un(q(d))
+      }, [
+        be(lo, {
+          "all-formats": t.allDefaultFormats,
+          "initial-selected-pattern": n.value.format,
+          "selected-type": n.value.temporalType,
+          "show-type-switch": t.showTypeSwitchInPopover,
+          onCommit: u,
+          onCancel: m[3] || (m[3] = (p) => s.value = !1)
+        }, null, 8, ["all-formats", "initial-selected-pattern", "selected-type", "show-type-switch"])
+      ], 4)) : Ne("", !0)
+    ]));
+  }
+}), mo = /* @__PURE__ */ ge(po, [["__scopeId", "data-v-1577d5ce"]]), ho = ["id"], bo = /* @__PURE__ */ fe({
+  __name: "DateTimeFormatPickerWithTypeControl",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    error: { type: Boolean },
+    subText: {},
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(t) {
+    const e = t, n = M(
+      () => e.control.uischema
+    ), a = M(() => n.value.options), r = M(() => a.value?.allowedFormats), i = pn(n, "dateTimeFormats"), o = [
+      {
+        id: "DATE",
+        text: "Date"
+      },
+      {
+        id: "DATE_TIME",
+        text: "Date & time"
+      },
+      {
+        id: "TIME",
+        text: "Time"
+      },
+      {
+        id: "ZONED_DATE_TIME",
+        text: "Zoned date & time"
+      }
+    ], l = M({
+      get: () => e.control.data,
+      set: (u) => {
+        e.changeValue(u);
+      }
+    }), s = M({
+      get: () => l.value.temporalType,
+      set: (u) => {
+        l.value = {
+          ...l.value,
+          temporalType: u
+        };
+      }
+    });
+    return (u, d) => ($(), H("div", {
+      id: t.labelForId,
+      class: "control-container"
+    }, [
+      be(q(at), {
+        modelValue: s.value,
+        "onUpdate:modelValue": d[0] || (d[0] = (v) => s.value = v),
+        compact: "",
+        "possible-values": o,
+        disabled: t.disabled
+      }, null, 8, ["modelValue", "disabled"]),
+      be(q(mo), {
+        modelValue: l.value,
+        "onUpdate:modelValue": d[1] || (d[1] = (v) => l.value = v),
+        compact: "",
+        disabled: t.disabled,
+        "show-type-switch-in-popover": !1,
+        "allowed-formats": r.value,
+        "all-default-formats": q(i),
+        "is-valid": !0
+      }, null, 8, ["modelValue", "disabled", "allowed-formats", "all-default-formats"])
+    ], 8, ho));
+  }
+}), wo = /* @__PURE__ */ ge(bo, [["__scopeId", "data-v-f6f7c887"]]);
+export {
+  wo as default
+};