@televet/kibble-ui 4.0.0-beta.65 → 4.0.0-beta.67

package/dist/chunks/portal-CtkZ5xTm.js

@@ -0,0 +1,3087 @@
+import { j as U } from "./jsx-runtime-C5mzlN2N.js";
+import St, { useMemo as on, useRef as M, useLayoutEffect as sn, useEffect as be, useState as Ue, memo as an, forwardRef as Ze, createElement as cn, Children as Ct, isValidElement as ln, cloneElement as un, createContext as fn, useContext as dn, useCallback as pn, useId as gn, useSyncExternalStore as hn } from "react";
+import { aV as mn, a5 as At, S as yn, aW as de, aX as $e, aY as vn, aZ as ye, aw as ct, a_ as bn, I as wn, a0 as Oe, c as Rt, ah as je, ac as xn, r as te, g as Dt, B as ve, a$ as On, j as En, b0 as Nn, a6 as Tn, D as Pn, E as Qe, b1 as Sn, ag as Cn, b2 as re, b3 as pe, V as oe, b4 as An, b5 as Be, b6 as Rn, b7 as Dn, b8 as Fn, b9 as _n, t as kn, b as Mn, f as Ln, C as In, M as lt, ba as $n } from "./index-Cb49D-ky.js";
+var Ne = { exports: {} }, D = {};
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ut;
+function Bn() {
+  if (ut) return D;
+  ut = 1;
+  var e = St;
+  function t(u) {
+    var c = "https://react.dev/errors/" + u;
+    if (1 < arguments.length) {
+      c += "?args[]=" + encodeURIComponent(arguments[1]);
+      for (var p = 2; p < arguments.length; p++)
+        c += "&args[]=" + encodeURIComponent(arguments[p]);
+    }
+    return "Minified React error #" + u + "; visit " + c + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+  }
+  function r() {
+  }
+  var n = {
+    d: {
+      f: r,
+      r: function() {
+        throw Error(t(522));
+      },
+      D: r,
+      C: r,
+      L: r,
+      m: r,
+      X: r,
+      S: r,
+      M: r
+    },
+    p: 0,
+    findDOMNode: null
+  }, o = Symbol.for("react.portal");
+  function a(u, c, p) {
+    var l = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+    return {
+      $$typeof: o,
+      key: l == null ? null : "" + l,
+      children: u,
+      containerInfo: c,
+      implementation: p
+    };
+  }
+  var s = e.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  function f(u, c) {
+    if (u === "font") return "";
+    if (typeof c == "string")
+      return c === "use-credentials" ? c : "";
+  }
+  return D.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = n, D.createPortal = function(u, c) {
+    var p = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
+    if (!c || c.nodeType !== 1 && c.nodeType !== 9 && c.nodeType !== 11)
+      throw Error(t(299));
+    return a(u, c, null, p);
+  }, D.flushSync = function(u) {
+    var c = s.T, p = n.p;
+    try {
+      if (s.T = null, n.p = 2, u) return u();
+    } finally {
+      s.T = c, n.p = p, n.d.f();
+    }
+  }, D.preconnect = function(u, c) {
+    typeof u == "string" && (c ? (c = c.crossOrigin, c = typeof c == "string" ? c === "use-credentials" ? c : "" : void 0) : c = null, n.d.C(u, c));
+  }, D.prefetchDNS = function(u) {
+    typeof u == "string" && n.d.D(u);
+  }, D.preinit = function(u, c) {
+    if (typeof u == "string" && c && typeof c.as == "string") {
+      var p = c.as, l = f(p, c.crossOrigin), i = typeof c.integrity == "string" ? c.integrity : void 0, d = typeof c.fetchPriority == "string" ? c.fetchPriority : void 0;
+      p === "style" ? n.d.S(
+        u,
+        typeof c.precedence == "string" ? c.precedence : void 0,
+        {
+          crossOrigin: l,
+          integrity: i,
+          fetchPriority: d
+        }
+      ) : p === "script" && n.d.X(u, {
+        crossOrigin: l,
+        integrity: i,
+        fetchPriority: d,
+        nonce: typeof c.nonce == "string" ? c.nonce : void 0
+      });
+    }
+  }, D.preinitModule = function(u, c) {
+    if (typeof u == "string")
+      if (typeof c == "object" && c !== null) {
+        if (c.as == null || c.as === "script") {
+          var p = f(
+            c.as,
+            c.crossOrigin
+          );
+          n.d.M(u, {
+            crossOrigin: p,
+            integrity: typeof c.integrity == "string" ? c.integrity : void 0,
+            nonce: typeof c.nonce == "string" ? c.nonce : void 0
+          });
+        }
+      } else c == null && n.d.M(u);
+  }, D.preload = function(u, c) {
+    if (typeof u == "string" && typeof c == "object" && c !== null && typeof c.as == "string") {
+      var p = c.as, l = f(p, c.crossOrigin);
+      n.d.L(u, p, {
+        crossOrigin: l,
+        integrity: typeof c.integrity == "string" ? c.integrity : void 0,
+        nonce: typeof c.nonce == "string" ? c.nonce : void 0,
+        type: typeof c.type == "string" ? c.type : void 0,
+        fetchPriority: typeof c.fetchPriority == "string" ? c.fetchPriority : void 0,
+        referrerPolicy: typeof c.referrerPolicy == "string" ? c.referrerPolicy : void 0,
+        imageSrcSet: typeof c.imageSrcSet == "string" ? c.imageSrcSet : void 0,
+        imageSizes: typeof c.imageSizes == "string" ? c.imageSizes : void 0,
+        media: typeof c.media == "string" ? c.media : void 0
+      });
+    }
+  }, D.preloadModule = function(u, c) {
+    if (typeof u == "string")
+      if (c) {
+        var p = f(c.as, c.crossOrigin);
+        n.d.m(u, {
+          as: typeof c.as == "string" && c.as !== "script" ? c.as : void 0,
+          crossOrigin: p,
+          integrity: typeof c.integrity == "string" ? c.integrity : void 0
+        });
+      } else n.d.m(u);
+  }, D.requestFormReset = function(u) {
+    n.d.r(u);
+  }, D.unstable_batchedUpdates = function(u, c) {
+    return u(c);
+  }, D.useFormState = function(u, c, p) {
+    return s.H.useFormState(u, c, p);
+  }, D.useFormStatus = function() {
+    return s.H.useHostTransitionStatus();
+  }, D.version = "19.1.0", D;
+}
+var F = {};
+/**
+ * @license React
+ * react-dom.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ft;
+function Vn() {
+  return ft || (ft = 1, process.env.NODE_ENV !== "production" && function() {
+    function e() {
+    }
+    function t(l) {
+      return "" + l;
+    }
+    function r(l, i, d) {
+      var g = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+      try {
+        t(g);
+        var h = !1;
+      } catch {
+        h = !0;
+      }
+      return h && (console.error(
+        "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+        typeof Symbol == "function" && Symbol.toStringTag && g[Symbol.toStringTag] || g.constructor.name || "Object"
+      ), t(g)), {
+        $$typeof: c,
+        key: g == null ? null : "" + g,
+        children: l,
+        containerInfo: i,
+        implementation: d
+      };
+    }
+    function n(l, i) {
+      if (l === "font") return "";
+      if (typeof i == "string")
+        return i === "use-credentials" ? i : "";
+    }
+    function o(l) {
+      return l === null ? "`null`" : l === void 0 ? "`undefined`" : l === "" ? "an empty string" : 'something with type "' + typeof l + '"';
+    }
+    function a(l) {
+      return l === null ? "`null`" : l === void 0 ? "`undefined`" : l === "" ? "an empty string" : typeof l == "string" ? JSON.stringify(l) : typeof l == "number" ? "`" + l + "`" : 'something with type "' + typeof l + '"';
+    }
+    function s() {
+      var l = p.H;
+      return l === null && console.error(
+        `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+      ), l;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var f = St, u = {
+      d: {
+        f: e,
+        r: function() {
+          throw Error(
+            "Invalid form element. requestFormReset must be passed a form that was rendered by React."
+          );
+        },
+        D: e,
+        C: e,
+        L: e,
+        m: e,
+        X: e,
+        S: e,
+        M: e
+      },
+      p: 0,
+      findDOMNode: null
+    }, c = Symbol.for("react.portal"), p = f.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+    typeof Map == "function" && Map.prototype != null && typeof Map.prototype.forEach == "function" && typeof Set == "function" && Set.prototype != null && typeof Set.prototype.clear == "function" && typeof Set.prototype.forEach == "function" || console.error(
+      "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
+    ), F.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = u, F.createPortal = function(l, i) {
+      var d = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
+      if (!i || i.nodeType !== 1 && i.nodeType !== 9 && i.nodeType !== 11)
+        throw Error("Target container is not a DOM element.");
+      return r(l, i, null, d);
+    }, F.flushSync = function(l) {
+      var i = p.T, d = u.p;
+      try {
+        if (p.T = null, u.p = 2, l)
+          return l();
+      } finally {
+        p.T = i, u.p = d, u.d.f() && console.error(
+          "flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
+        );
+      }
+    }, F.preconnect = function(l, i) {
+      typeof l == "string" && l ? i != null && typeof i != "object" ? console.error(
+        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+        a(i)
+      ) : i != null && typeof i.crossOrigin != "string" && console.error(
+        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+        o(i.crossOrigin)
+      ) : console.error(
+        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        o(l)
+      ), typeof l == "string" && (i ? (i = i.crossOrigin, i = typeof i == "string" ? i === "use-credentials" ? i : "" : void 0) : i = null, u.d.C(l, i));
+    }, F.prefetchDNS = function(l) {
+      if (typeof l != "string" || !l)
+        console.error(
+          "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          o(l)
+        );
+      else if (1 < arguments.length) {
+        var i = arguments[1];
+        typeof i == "object" && i.hasOwnProperty("crossOrigin") ? console.error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          a(i)
+        ) : console.error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          a(i)
+        );
+      }
+      typeof l == "string" && u.d.D(l);
+    }, F.preinit = function(l, i) {
+      if (typeof l == "string" && l ? i == null || typeof i != "object" ? console.error(
+        "ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
+        a(i)
+      ) : i.as !== "style" && i.as !== "script" && console.error(
+        'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
+        a(i.as)
+      ) : console.error(
+        "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        o(l)
+      ), typeof l == "string" && i && typeof i.as == "string") {
+        var d = i.as, g = n(d, i.crossOrigin), h = typeof i.integrity == "string" ? i.integrity : void 0, m = typeof i.fetchPriority == "string" ? i.fetchPriority : void 0;
+        d === "style" ? u.d.S(
+          l,
+          typeof i.precedence == "string" ? i.precedence : void 0,
+          {
+            crossOrigin: g,
+            integrity: h,
+            fetchPriority: m
+          }
+        ) : d === "script" && u.d.X(l, {
+          crossOrigin: g,
+          integrity: h,
+          fetchPriority: m,
+          nonce: typeof i.nonce == "string" ? i.nonce : void 0
+        });
+      }
+    }, F.preinitModule = function(l, i) {
+      var d = "";
+      if (typeof l == "string" && l || (d += " The `href` argument encountered was " + o(l) + "."), i !== void 0 && typeof i != "object" ? d += " The `options` argument encountered was " + o(i) + "." : i && "as" in i && i.as !== "script" && (d += " The `as` option encountered was " + a(i.as) + "."), d)
+        console.error(
+          "ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
+          d
+        );
+      else
+        switch (d = i && typeof i.as == "string" ? i.as : "script", d) {
+          case "script":
+            break;
+          default:
+            d = a(d), console.error(
+              'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
+              d,
+              l
+            );
+        }
+      typeof l == "string" && (typeof i == "object" && i !== null ? (i.as == null || i.as === "script") && (d = n(
+        i.as,
+        i.crossOrigin
+      ), u.d.M(l, {
+        crossOrigin: d,
+        integrity: typeof i.integrity == "string" ? i.integrity : void 0,
+        nonce: typeof i.nonce == "string" ? i.nonce : void 0
+      })) : i == null && u.d.M(l));
+    }, F.preload = function(l, i) {
+      var d = "";
+      if (typeof l == "string" && l || (d += " The `href` argument encountered was " + o(l) + "."), i == null || typeof i != "object" ? d += " The `options` argument encountered was " + o(i) + "." : typeof i.as == "string" && i.as || (d += " The `as` option encountered was " + o(i.as) + "."), d && console.error(
+        'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
+        d
+      ), typeof l == "string" && typeof i == "object" && i !== null && typeof i.as == "string") {
+        d = i.as;
+        var g = n(
+          d,
+          i.crossOrigin
+        );
+        u.d.L(l, d, {
+          crossOrigin: g,
+          integrity: typeof i.integrity == "string" ? i.integrity : void 0,
+          nonce: typeof i.nonce == "string" ? i.nonce : void 0,
+          type: typeof i.type == "string" ? i.type : void 0,
+          fetchPriority: typeof i.fetchPriority == "string" ? i.fetchPriority : void 0,
+          referrerPolicy: typeof i.referrerPolicy == "string" ? i.referrerPolicy : void 0,
+          imageSrcSet: typeof i.imageSrcSet == "string" ? i.imageSrcSet : void 0,
+          imageSizes: typeof i.imageSizes == "string" ? i.imageSizes : void 0,
+          media: typeof i.media == "string" ? i.media : void 0
+        });
+      }
+    }, F.preloadModule = function(l, i) {
+      var d = "";
+      typeof l == "string" && l || (d += " The `href` argument encountered was " + o(l) + "."), i !== void 0 && typeof i != "object" ? d += " The `options` argument encountered was " + o(i) + "." : i && "as" in i && typeof i.as != "string" && (d += " The `as` option encountered was " + o(i.as) + "."), d && console.error(
+        'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
+        d
+      ), typeof l == "string" && (i ? (d = n(
+        i.as,
+        i.crossOrigin
+      ), u.d.m(l, {
+        as: typeof i.as == "string" && i.as !== "script" ? i.as : void 0,
+        crossOrigin: d,
+        integrity: typeof i.integrity == "string" ? i.integrity : void 0
+      })) : u.d.m(l));
+    }, F.requestFormReset = function(l) {
+      u.d.r(l);
+    }, F.unstable_batchedUpdates = function(l, i) {
+      return l(i);
+    }, F.useFormState = function(l, i, d) {
+      return s().useFormState(l, i, d);
+    }, F.useFormStatus = function() {
+      return s().useHostTransitionStatus();
+    }, F.version = "19.1.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }()), F;
+}
+var dt;
+function Gn() {
+  if (dt) return Ne.exports;
+  dt = 1;
+  function e() {
+    if (!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > "u" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != "function")) {
+      if (process.env.NODE_ENV !== "production")
+        throw new Error("^_^");
+      try {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e);
+      } catch (t) {
+        console.error(t);
+      }
+    }
+  }
+  return process.env.NODE_ENV === "production" ? (e(), Ne.exports = Bn()) : Ne.exports = Vn(), Ne.exports;
+}
+var _e = Gn();
+function Hn(e) {
+  return new Proxy({}, {
+    get(t, r) {
+      return r === "style" ? (n) => e({ style: n }).style : e;
+    }
+  });
+}
+var Ft = () => (e) => Array.from(new Set(e)), _t = typeof globalThis.document < "u" ? sn : be;
+function Ae(e) {
+  const t = e().value ?? e().defaultValue, r = e().isEqual ?? Object.is, [n] = Ue(t), [o, a] = Ue(n), s = e().value !== void 0, f = M(o);
+  f.current = s ? e().value : o;
+  const u = M(f.current);
+  _t(() => {
+    u.current = f.current;
+  }, [o, e().value]);
+  const c = (l) => {
+    const i = u.current, d = ye(l) ? l(i) : l;
+    e().debug && console.log(`[bindable > ${e().debug}] setValue`, { next: d, prev: i }), s || a(d), r(d, i) || e().onChange?.(d, i);
+  };
+  function p() {
+    return s ? e().value : o;
+  }
+  return {
+    initial: n,
+    ref: f,
+    get: p,
+    set(l) {
+      (e().sync ? _e.flushSync : vn)(() => c(l));
+    },
+    invoke(l, i) {
+      e().onChange?.(l, i);
+    },
+    hash(l) {
+      return e().hash?.(l) ?? String(l);
+    }
+  };
+}
+Ae.cleanup = (e) => {
+  be(() => e, []);
+};
+Ae.ref = (e) => {
+  const t = M(e);
+  return {
+    get: () => t.current,
+    set: (r) => {
+      t.current = r;
+    }
+  };
+};
+function Wn(e) {
+  const t = M(e);
+  return {
+    get(r) {
+      return t.current[r];
+    },
+    set(r, n) {
+      t.current[r] = n;
+    }
+  };
+}
+var Un = (e, t) => {
+  const r = M(!1), n = M(!1);
+  be(() => {
+    if (r.current && n.current) return t();
+    n.current = !0;
+  }, [...(e ?? []).map((o) => typeof o == "function" ? o() : o)]), be(() => (r.current = !0, () => {
+    r.current = !1;
+  }), []);
+};
+function kt(e, t = {}) {
+  const r = on(() => {
+    const { id: v, ids: b, getRootNode: T } = t;
+    return mn({ id: v, ids: b, getRootNode: T });
+  }, [t]), n = (...v) => {
+    e.debug && console.log(...v);
+  }, o = e.props?.({ props: At(t), scope: r }) ?? t, a = jn(o), s = e.context?.({
+    prop: a,
+    bindable: Ae,
+    scope: r,
+    flush: pt,
+    getContext() {
+      return u;
+    },
+    getComputed() {
+      return E;
+    },
+    getRefs() {
+      return h;
+    }
+  }), f = Mt(s), u = {
+    get(v) {
+      return f.current?.[v].ref.current;
+    },
+    set(v, b) {
+      f.current?.[v].set(b);
+    },
+    initial(v) {
+      return f.current?.[v].initial;
+    },
+    hash(v) {
+      const b = f.current?.[v].get();
+      return f.current?.[v].hash(b);
+    }
+  }, c = M(/* @__PURE__ */ new Map()), p = M(null), l = M(null), i = M({ type: "" }), d = () => ({
+    ...i.current,
+    current() {
+      return i.current;
+    },
+    previous() {
+      return l.current;
+    }
+  }), g = () => ({
+    ...P,
+    matches(...v) {
+      return v.includes(P.ref.current);
+    },
+    hasTag(v) {
+      return !!e.states[P.ref.current]?.tags?.includes(v);
+    }
+  }), h = Wn(e.refs?.({ prop: a, context: u }) ?? {}), m = () => ({
+    state: g(),
+    context: u,
+    event: d(),
+    prop: a,
+    send: k,
+    action: y,
+    guard: w,
+    track: Un,
+    refs: h,
+    computed: E,
+    flush: pt,
+    scope: r,
+    choose: N
+  }), y = (v) => {
+    const b = ye(v) ? v(m()) : v;
+    if (!b) return;
+    const T = b.map((O) => {
+      const C = e.implementations?.actions?.[O];
+      return C || ct(`[zag-js] No implementation found for action "${JSON.stringify(O)}"`), C;
+    });
+    for (const O of T)
+      O?.(m());
+  }, w = (v) => ye(v) ? v(m()) : e.implementations?.guards?.[v](m()), x = (v) => {
+    const b = ye(v) ? v(m()) : v;
+    if (!b) return;
+    const T = b.map((C) => {
+      const R = e.implementations?.effects?.[C];
+      return R || ct(`[zag-js] No implementation found for effect "${JSON.stringify(C)}"`), R;
+    }), O = [];
+    for (const C of T) {
+      const R = C?.(m());
+      R && O.push(R);
+    }
+    return () => O.forEach((C) => C?.());
+  }, N = (v) => bn(v).find((b) => {
+    let T = !b.guard;
+    return wn(b.guard) ? T = !!w(b.guard) : ye(b.guard) && (T = b.guard(m())), T;
+  }), E = (v) => {
+    yn(e.computed, () => "[zag-js] No computed object found on machine");
+    const b = e.computed[v];
+    return b({
+      context: u,
+      event: d(),
+      prop: a,
+      refs: h,
+      scope: r,
+      computed: E
+    });
+  }, P = Ae(() => ({
+    defaultValue: e.initialState({ prop: a }),
+    onChange(v, b) {
+      b && (c.current.get(b)?.(), c.current.delete(b)), b && y(e.states[b]?.exit), y(p.current?.actions);
+      const T = x(e.states[v]?.effects);
+      if (T && c.current.set(v, T), b === $e) {
+        y(e.entry);
+        const O = x(e.effects);
+        O && c.current.set($e, O);
+      }
+      y(e.states[v]?.entry);
+    }
+  })), A = M(void 0), _ = M(de.NotStarted);
+  _t(() => {
+    queueMicrotask(() => {
+      const T = _.current === de.Started;
+      _.current = de.Started, n(T ? "rehydrating..." : "initializing...");
+      const O = A.current ?? P.initial;
+      P.invoke(O, T ? P.get() : $e);
+    });
+    const v = c.current, b = P.ref.current;
+    return () => {
+      n("unmounting..."), A.current = b, _.current = de.Stopped, v.forEach((T) => T?.()), c.current = /* @__PURE__ */ new Map(), p.current = null, queueMicrotask(() => {
+        y(e.exit);
+      });
+    };
+  }, []);
+  const $ = () => "ref" in P ? P.ref.current : P.get(), k = (v) => {
+    queueMicrotask(() => {
+      if (_.current !== de.Started) return;
+      l.current = i.current, i.current = v, n("send", v);
+      let b = $();
+      const T = (
+        // @ts-ignore
+        e.states[b].on?.[v.type] ?? // @ts-ignore
+        e.on?.[v.type]
+      ), O = N(T);
+      if (!O) return;
+      p.current = O;
+      const C = O.target ?? b;
+      n("transition", O);
+      const R = C !== b;
+      R ? _e.flushSync(() => P.set(C)) : O.reenter && !R ? P.invoke(b, b) : y(O.actions ?? []);
+    });
+  };
+  return e.watch?.(m()), {
+    state: g(),
+    send: k,
+    context: u,
+    prop: a,
+    scope: r,
+    refs: h,
+    computed: E,
+    event: d(),
+    getStatus: () => _.current
+  };
+}
+function Mt(e) {
+  const t = M(e);
+  return t.current = e, t;
+}
+function jn(e) {
+  const t = Mt(e);
+  return function(n) {
+    return t.current[n];
+  };
+}
+function pt(e) {
+  queueMicrotask(() => {
+    _e.flushSync(() => e());
+  });
+}
+var zn = Hn((e) => e);
+function Lt(...e) {
+  return (t) => {
+    const r = [];
+    for (const n of e)
+      if (typeof n == "function") {
+        const o = n(t);
+        typeof o == "function" && r.push(o);
+      } else n && (n.current = t);
+    if (r.length)
+      return () => {
+        for (const n of r)
+          n();
+      };
+  };
+}
+function Kn(e) {
+  let t = Object.getOwnPropertyDescriptor(e.props, "ref")?.get, r = t && "isReactWarning" in t && t.isReactWarning;
+  return r ? e.ref : (t = Object.getOwnPropertyDescriptor(e, "ref")?.get, r = t && "isReactWarning" in t && t.isReactWarning, r ? e.props.ref : e.props.ref || e.ref);
+}
+const Ve = (e) => {
+  const t = an(
+    Ze((r, n) => {
+      const { asChild: o, children: a, ...s } = r;
+      if (!o)
+        return cn(e, { ...s, ref: n }, a);
+      const f = Ct.only(a);
+      if (!ln(f))
+        return null;
+      const u = Kn(f);
+      return un(f, {
+        ...Oe(s, f.props),
+        ref: n ? Lt(n, u) : u
+      });
+    })
+  );
+  return t.displayName = e.displayName || e.name, t;
+}, qn = () => {
+  const e = /* @__PURE__ */ new Map();
+  return new Proxy(Ve, {
+    apply(t, r, n) {
+      return Ve(n[0]);
+    },
+    get(t, r) {
+      const n = r;
+      return e.has(n) || e.set(n, Ve(n)), e.get(n);
+    }
+  });
+}, It = qn();
+function Yn(e, t) {
+  return `${e} returned \`undefined\`. Seems you forgot to wrap component within ${t}`;
+}
+function ke(e = {}) {
+  const {
+    name: t,
+    strict: r = !0,
+    hookName: n = "useContext",
+    providerName: o = "Provider",
+    errorMessage: a,
+    defaultValue: s
+  } = e, f = fn(s);
+  f.displayName = t;
+  function u() {
+    const c = dn(f);
+    if (!c && r) {
+      const p = new Error(a ?? Yn(n, o));
+      throw p.name = "ContextError", Error.captureStackTrace?.(p, u), p;
+    }
+    return c;
+  }
+  return [f.Provider, u, f];
+}
+const [$t, et] = ke({
+  name: "PopoverContext",
+  hookName: "usePopoverContext",
+  providerName: "<PopoverProvider />"
+}), Xn = Ze((e, t) => {
+  const r = et(), n = Oe(r.getCloseTriggerProps(), e);
+  return /* @__PURE__ */ U.jsx(It.button, { ...n, ref: t });
+});
+Xn.displayName = "PopoverCloseTrigger";
+const [Bt, Jn] = ke({
+  name: "PresenceContext",
+  hookName: "usePresenceContext",
+  providerName: "<PresenceProvider />"
+}), Zn = Ze((e, t) => {
+  const r = et(), n = Jn(), o = Oe(r.getContentProps(), n.getPresenceProps(), e);
+  return n.unmounted ? null : /* @__PURE__ */ U.jsx(It.div, { ...o, ref: Lt(n.ref, t) });
+});
+Zn.displayName = "PopoverContent";
+const Ho = (e) => e.children(et()), Qn = () => (e, t) => t.reduce(
+  (r, n) => {
+    const [o, a] = r, s = n;
+    return a[s] !== void 0 && (o[s] = a[s]), delete a[s], [o, a];
+  },
+  [{}, { ...e }]
+), Vt = (e) => Qn()(e, [
+  "immediate",
+  "lazyMount",
+  "onExitComplete",
+  "present",
+  "skipAnimationOnMount",
+  "unmountOnExit"
+]);
+function er(e, t) {
+  const { state: r, send: n, context: o } = e, a = r.matches("mounted", "unmountSuspended");
+  return {
+    skip: !o.get("initial"),
+    present: a,
+    setNode(s) {
+      s && n({ type: "NODE.SET", node: s });
+    },
+    unmount() {
+      n({ type: "UNMOUNT" });
+    }
+  };
+}
+var tr = Rt({
+  props({ props: e }) {
+    return { ...e, present: !!e.present };
+  },
+  initialState({ prop: e }) {
+    return e("present") ? "mounted" : "unmounted";
+  },
+  refs() {
+    return {
+      node: null,
+      styles: null
+    };
+  },
+  context({ bindable: e }) {
+    return {
+      unmountAnimationName: e(() => ({ defaultValue: null })),
+      prevAnimationName: e(() => ({ defaultValue: null })),
+      present: e(() => ({ defaultValue: !1 })),
+      initial: e(() => ({
+        sync: !0,
+        defaultValue: !1
+      }))
+    };
+  },
+  exit: ["clearInitial", "cleanupNode"],
+  watch({ track: e, action: t, prop: r }) {
+    e([() => r("present")], () => {
+      t(["setInitial", "syncPresence"]);
+    });
+  },
+  on: {
+    "NODE.SET": {
+      actions: ["setNode", "setStyles"]
+    }
+  },
+  states: {
+    mounted: {
+      on: {
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        },
+        "UNMOUNT.SUSPEND": {
+          target: "unmountSuspended"
+        }
+      }
+    },
+    unmountSuspended: {
+      effects: ["trackAnimationEvents"],
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        },
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        }
+      }
+    },
+    unmounted: {
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        }
+      }
+    }
+  },
+  implementations: {
+    actions: {
+      setInitial: ({ context: e }) => {
+        e.get("initial") || queueMicrotask(() => {
+          e.set("initial", !0);
+        });
+      },
+      clearInitial: ({ context: e }) => {
+        e.set("initial", !1);
+      },
+      cleanupNode: ({ refs: e }) => {
+        e.set("node", null), e.set("styles", null);
+      },
+      invokeOnExitComplete: ({ prop: e }) => {
+        e("onExitComplete")?.();
+      },
+      setNode: ({ refs: e, event: t }) => {
+        e.set("node", t.node);
+      },
+      setStyles: ({ refs: e, event: t }) => {
+        e.set("styles", Dt(t.node));
+      },
+      syncPresence: ({ context: e, refs: t, send: r, prop: n }) => {
+        const o = n("present");
+        if (o)
+          return r({ type: "MOUNT", src: "presence.changed" });
+        const a = t.get("node");
+        if (!o && a?.ownerDocument.visibilityState === "hidden")
+          return r({ type: "UNMOUNT", src: "visibilitychange" });
+        te(() => {
+          const s = Te(t.get("styles"));
+          e.set("unmountAnimationName", s), s === "none" || s === e.get("prevAnimationName") || t.get("styles")?.display === "none" || t.get("styles")?.animationDuration === "0s" ? r({ type: "UNMOUNT", src: "presence.changed" }) : r({ type: "UNMOUNT.SUSPEND" });
+        });
+      },
+      setPrevAnimationName: ({ context: e, refs: t }) => {
+        te(() => {
+          e.set("prevAnimationName", Te(t.get("styles")));
+        });
+      },
+      clearPrevAnimationName: ({ context: e }) => {
+        e.set("prevAnimationName", null);
+      }
+    },
+    effects: {
+      trackAnimationEvents: ({ context: e, refs: t, send: r }) => {
+        const n = t.get("node");
+        if (!n) return;
+        const o = (f) => {
+          (f.composedPath?.()?.[0] ?? f.target) === n && e.set("prevAnimationName", Te(t.get("styles")));
+        }, a = (f) => {
+          const u = Te(t.get("styles"));
+          ve(f) === n && u === e.get("unmountAnimationName") && r({ type: "UNMOUNT", src: "animationend" });
+        };
+        n.addEventListener("animationstart", o), n.addEventListener("animationcancel", a), n.addEventListener("animationend", a);
+        const s = je(n, { animationFillMode: "forwards" });
+        return () => {
+          n.removeEventListener("animationstart", o), n.removeEventListener("animationcancel", a), n.removeEventListener("animationend", a), xn(() => s());
+        };
+      }
+    }
+  }
+});
+function Te(e) {
+  return e?.animationName || "none";
+}
+Ft()(["onExitComplete", "present", "immediate"]);
+function nr(e, t = {}) {
+  const { sync: r = !1 } = t, n = rr(e);
+  return pn(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    (...o) => r ? queueMicrotask(() => n.current?.(...o)) : n.current?.(...o),
+    [r, n]
+  );
+}
+function rr(e) {
+  const t = M(e);
+  return t.current = e, t;
+}
+const Gt = (e = {}) => {
+  const { lazyMount: t, unmountOnExit: r, present: n, skipAnimationOnMount: o = !1, ...a } = e, s = M(!1), f = {
+    ...a,
+    present: n,
+    onExitComplete: nr(e.onExitComplete)
+  }, u = kt(tr, f), c = er(u);
+  c.present && (s.current = !0);
+  const p = !c.present && !s.current && t || r && !c.present && s.current, l = () => ({
+    "data-state": c.skip && o ? void 0 : n ? "open" : "closed",
+    hidden: !c.present
+  });
+  return {
+    ref: c.setNode,
+    getPresenceProps: l,
+    present: c.present,
+    unmounted: p
+  };
+}, or = ["top", "right", "bottom", "left"], Q = Math.min, L = Math.max, Re = Math.round, Pe = Math.floor, z = (e) => ({
+  x: e,
+  y: e
+}), ir = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, sr = {
+  start: "end",
+  end: "start"
+};
+function ze(e, t, r) {
+  return L(e, Q(t, r));
+}
+function X(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function J(e) {
+  return e.split("-")[0];
+}
+function ue(e) {
+  return e.split("-")[1];
+}
+function tt(e) {
+  return e === "x" ? "y" : "x";
+}
+function nt(e) {
+  return e === "y" ? "height" : "width";
+}
+function j(e) {
+  return ["top", "bottom"].includes(J(e)) ? "y" : "x";
+}
+function rt(e) {
+  return tt(j(e));
+}
+function ar(e, t, r) {
+  r === void 0 && (r = !1);
+  const n = ue(e), o = rt(e), a = nt(o);
+  let s = o === "x" ? n === (r ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[a] > t.floating[a] && (s = De(s)), [s, De(s)];
+}
+function cr(e) {
+  const t = De(e);
+  return [Ke(e), t, Ke(t)];
+}
+function Ke(e) {
+  return e.replace(/start|end/g, (t) => sr[t]);
+}
+function lr(e, t, r) {
+  const n = ["left", "right"], o = ["right", "left"], a = ["top", "bottom"], s = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return r ? t ? o : n : t ? n : o;
+    case "left":
+    case "right":
+      return t ? a : s;
+    default:
+      return [];
+  }
+}
+function ur(e, t, r, n) {
+  const o = ue(e);
+  let a = lr(J(e), r === "start", n);
+  return o && (a = a.map((s) => s + "-" + o), t && (a = a.concat(a.map(Ke)))), a;
+}
+function De(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => ir[t]);
+}
+function fr(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Ht(e) {
+  return typeof e != "number" ? fr(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Fe(e) {
+  const {
+    x: t,
+    y: r,
+    width: n,
+    height: o
+  } = e;
+  return {
+    width: n,
+    height: o,
+    top: r,
+    left: t,
+    right: t + n,
+    bottom: r + o,
+    x: t,
+    y: r
+  };
+}
+function gt(e, t, r) {
+  let {
+    reference: n,
+    floating: o
+  } = e;
+  const a = j(t), s = rt(t), f = nt(s), u = J(t), c = a === "y", p = n.x + n.width / 2 - o.width / 2, l = n.y + n.height / 2 - o.height / 2, i = n[f] / 2 - o[f] / 2;
+  let d;
+  switch (u) {
+    case "top":
+      d = {
+        x: p,
+        y: n.y - o.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: p,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: l
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - o.width,
+        y: l
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (ue(t)) {
+    case "start":
+      d[s] -= i * (r && c ? -1 : 1);
+      break;
+    case "end":
+      d[s] += i * (r && c ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const dr = async (e, t, r) => {
+  const {
+    placement: n = "bottom",
+    strategy: o = "absolute",
+    middleware: a = [],
+    platform: s
+  } = r, f = a.filter(Boolean), u = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let c = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: p,
+    y: l
+  } = gt(c, n, u), i = n, d = {}, g = 0;
+  for (let h = 0; h < f.length; h++) {
+    const {
+      name: m,
+      fn: y
+    } = f[h], {
+      x: w,
+      y: x,
+      data: N,
+      reset: E
+    } = await y({
+      x: p,
+      y: l,
+      initialPlacement: n,
+      placement: i,
+      strategy: o,
+      middlewareData: d,
+      rects: c,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    p = w ?? p, l = x ?? l, d = {
+      ...d,
+      [m]: {
+        ...d[m],
+        ...N
+      }
+    }, E && g <= 50 && (g++, typeof E == "object" && (E.placement && (i = E.placement), E.rects && (c = E.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : E.rects), {
+      x: p,
+      y: l
+    } = gt(c, i, u)), h = -1);
+  }
+  return {
+    x: p,
+    y: l,
+    placement: i,
+    strategy: o,
+    middlewareData: d
+  };
+};
+async function we(e, t) {
+  var r;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: o,
+    platform: a,
+    rects: s,
+    elements: f,
+    strategy: u
+  } = e, {
+    boundary: c = "clippingAncestors",
+    rootBoundary: p = "viewport",
+    elementContext: l = "floating",
+    altBoundary: i = !1,
+    padding: d = 0
+  } = X(t, e), g = Ht(d), m = f[i ? l === "floating" ? "reference" : "floating" : l], y = Fe(await a.getClippingRect({
+    element: (r = await (a.isElement == null ? void 0 : a.isElement(m))) == null || r ? m : m.contextElement || await (a.getDocumentElement == null ? void 0 : a.getDocumentElement(f.floating)),
+    boundary: c,
+    rootBoundary: p,
+    strategy: u
+  })), w = l === "floating" ? {
+    x: n,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, x = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(f.floating)), N = await (a.isElement == null ? void 0 : a.isElement(x)) ? await (a.getScale == null ? void 0 : a.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, E = Fe(a.convertOffsetParentRelativeRectToViewportRelativeRect ? await a.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: f,
+    rect: w,
+    offsetParent: x,
+    strategy: u
+  }) : w);
+  return {
+    top: (y.top - E.top + g.top) / N.y,
+    bottom: (E.bottom - y.bottom + g.bottom) / N.y,
+    left: (y.left - E.left + g.left) / N.x,
+    right: (E.right - y.right + g.right) / N.x
+  };
+}
+const pr = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: r,
+      y: n,
+      placement: o,
+      rects: a,
+      platform: s,
+      elements: f,
+      middlewareData: u
+    } = t, {
+      element: c,
+      padding: p = 0
+    } = X(e, t) || {};
+    if (c == null)
+      return {};
+    const l = Ht(p), i = {
+      x: r,
+      y: n
+    }, d = rt(o), g = nt(d), h = await s.getDimensions(c), m = d === "y", y = m ? "top" : "left", w = m ? "bottom" : "right", x = m ? "clientHeight" : "clientWidth", N = a.reference[g] + a.reference[d] - i[d] - a.floating[g], E = i[d] - a.reference[d], P = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c));
+    let A = P ? P[x] : 0;
+    (!A || !await (s.isElement == null ? void 0 : s.isElement(P))) && (A = f.floating[x] || a.floating[g]);
+    const _ = N / 2 - E / 2, $ = A / 2 - h[g] / 2 - 1, k = Q(l[y], $), v = Q(l[w], $), b = k, T = A - h[g] - v, O = A / 2 - h[g] / 2 + _, C = ze(b, O, T), R = !u.arrow && ue(o) != null && O !== C && a.reference[g] / 2 - (O < b ? k : v) - h[g] / 2 < 0, B = R ? O < b ? O - b : O - T : 0;
+    return {
+      [d]: i[d] + B,
+      data: {
+        [d]: C,
+        centerOffset: O - C - B,
+        ...R && {
+          alignmentOffset: B
+        }
+      },
+      reset: R
+    };
+  }
+}), gr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: o,
+        middlewareData: a,
+        rects: s,
+        initialPlacement: f,
+        platform: u,
+        elements: c
+      } = t, {
+        mainAxis: p = !0,
+        crossAxis: l = !0,
+        fallbackPlacements: i,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: h = !0,
+        ...m
+      } = X(e, t);
+      if ((r = a.arrow) != null && r.alignmentOffset)
+        return {};
+      const y = J(o), w = j(f), x = J(f) === f, N = await (u.isRTL == null ? void 0 : u.isRTL(c.floating)), E = i || (x || !h ? [De(f)] : cr(f)), P = g !== "none";
+      !i && P && E.push(...ur(f, h, g, N));
+      const A = [f, ...E], _ = await we(t, m), $ = [];
+      let k = ((n = a.flip) == null ? void 0 : n.overflows) || [];
+      if (p && $.push(_[y]), l) {
+        const O = ar(o, s, N);
+        $.push(_[O[0]], _[O[1]]);
+      }
+      if (k = [...k, {
+        placement: o,
+        overflows: $
+      }], !$.every((O) => O <= 0)) {
+        var v, b;
+        const O = (((v = a.flip) == null ? void 0 : v.index) || 0) + 1, C = A[O];
+        if (C && (!(l === "alignment" ? w !== j(C) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        k.every((V) => V.overflows[0] > 0 && j(V.placement) === w)))
+          return {
+            data: {
+              index: O,
+              overflows: k
+            },
+            reset: {
+              placement: C
+            }
+          };
+        let R = (b = k.filter((B) => B.overflows[0] <= 0).sort((B, V) => B.overflows[1] - V.overflows[1])[0]) == null ? void 0 : b.placement;
+        if (!R)
+          switch (d) {
+            case "bestFit": {
+              var T;
+              const B = (T = k.filter((V) => {
+                if (P) {
+                  const Z = j(V.placement);
+                  return Z === w || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  Z === "y";
+                }
+                return !0;
+              }).map((V) => [V.placement, V.overflows.filter((Z) => Z > 0).reduce((Z, rn) => Z + rn, 0)]).sort((V, Z) => V[1] - Z[1])[0]) == null ? void 0 : T[0];
+              B && (R = B);
+              break;
+            }
+            case "initialPlacement":
+              R = f;
+              break;
+          }
+        if (o !== R)
+          return {
+            reset: {
+              placement: R
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function ht(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function mt(e) {
+  return or.some((t) => e[t] >= 0);
+}
+const hr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: r
+      } = t, {
+        strategy: n = "referenceHidden",
+        ...o
+      } = X(e, t);
+      switch (n) {
+        case "referenceHidden": {
+          const a = await we(t, {
+            ...o,
+            elementContext: "reference"
+          }), s = ht(a, r.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: mt(s)
+            }
+          };
+        }
+        case "escaped": {
+          const a = await we(t, {
+            ...o,
+            altBoundary: !0
+          }), s = ht(a, r.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: mt(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function mr(e, t) {
+  const {
+    placement: r,
+    platform: n,
+    elements: o
+  } = e, a = await (n.isRTL == null ? void 0 : n.isRTL(o.floating)), s = J(r), f = ue(r), u = j(r) === "y", c = ["left", "top"].includes(s) ? -1 : 1, p = a && u ? -1 : 1, l = X(t, e);
+  let {
+    mainAxis: i,
+    crossAxis: d,
+    alignmentAxis: g
+  } = typeof l == "number" ? {
+    mainAxis: l,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: l.mainAxis || 0,
+    crossAxis: l.crossAxis || 0,
+    alignmentAxis: l.alignmentAxis
+  };
+  return f && typeof g == "number" && (d = f === "end" ? g * -1 : g), u ? {
+    x: d * p,
+    y: i * c
+  } : {
+    x: i * c,
+    y: d * p
+  };
+}
+const yr = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        x: o,
+        y: a,
+        placement: s,
+        middlewareData: f
+      } = t, u = await mr(t, e);
+      return s === ((r = f.offset) == null ? void 0 : r.placement) && (n = f.arrow) != null && n.alignmentOffset ? {} : {
+        x: o + u.x,
+        y: a + u.y,
+        data: {
+          ...u,
+          placement: s
+        }
+      };
+    }
+  };
+}, vr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: r,
+        y: n,
+        placement: o
+      } = t, {
+        mainAxis: a = !0,
+        crossAxis: s = !1,
+        limiter: f = {
+          fn: (m) => {
+            let {
+              x: y,
+              y: w
+            } = m;
+            return {
+              x: y,
+              y: w
+            };
+          }
+        },
+        ...u
+      } = X(e, t), c = {
+        x: r,
+        y: n
+      }, p = await we(t, u), l = j(J(o)), i = tt(l);
+      let d = c[i], g = c[l];
+      if (a) {
+        const m = i === "y" ? "top" : "left", y = i === "y" ? "bottom" : "right", w = d + p[m], x = d - p[y];
+        d = ze(w, d, x);
+      }
+      if (s) {
+        const m = l === "y" ? "top" : "left", y = l === "y" ? "bottom" : "right", w = g + p[m], x = g - p[y];
+        g = ze(w, g, x);
+      }
+      const h = f.fn({
+        ...t,
+        [i]: d,
+        [l]: g
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - r,
+          y: h.y - n,
+          enabled: {
+            [i]: a,
+            [l]: s
+          }
+        }
+      };
+    }
+  };
+}, br = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: r,
+        y: n,
+        placement: o,
+        rects: a,
+        middlewareData: s
+      } = t, {
+        offset: f = 0,
+        mainAxis: u = !0,
+        crossAxis: c = !0
+      } = X(e, t), p = {
+        x: r,
+        y: n
+      }, l = j(o), i = tt(l);
+      let d = p[i], g = p[l];
+      const h = X(f, t), m = typeof h == "number" ? {
+        mainAxis: h,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...h
+      };
+      if (u) {
+        const x = i === "y" ? "height" : "width", N = a.reference[i] - a.floating[x] + m.mainAxis, E = a.reference[i] + a.reference[x] - m.mainAxis;
+        d < N ? d = N : d > E && (d = E);
+      }
+      if (c) {
+        var y, w;
+        const x = i === "y" ? "width" : "height", N = ["top", "left"].includes(J(o)), E = a.reference[l] - a.floating[x] + (N && ((y = s.offset) == null ? void 0 : y[l]) || 0) + (N ? 0 : m.crossAxis), P = a.reference[l] + a.reference[x] + (N ? 0 : ((w = s.offset) == null ? void 0 : w[l]) || 0) - (N ? m.crossAxis : 0);
+        g < E ? g = E : g > P && (g = P);
+      }
+      return {
+        [i]: d,
+        [l]: g
+      };
+    }
+  };
+}, wr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: o,
+        rects: a,
+        platform: s,
+        elements: f
+      } = t, {
+        apply: u = () => {
+        },
+        ...c
+      } = X(e, t), p = await we(t, c), l = J(o), i = ue(o), d = j(o) === "y", {
+        width: g,
+        height: h
+      } = a.floating;
+      let m, y;
+      l === "top" || l === "bottom" ? (m = l, y = i === (await (s.isRTL == null ? void 0 : s.isRTL(f.floating)) ? "start" : "end") ? "left" : "right") : (y = l, m = i === "end" ? "top" : "bottom");
+      const w = h - p.top - p.bottom, x = g - p.left - p.right, N = Q(h - p[m], w), E = Q(g - p[y], x), P = !t.middlewareData.shift;
+      let A = N, _ = E;
+      if ((r = t.middlewareData.shift) != null && r.enabled.x && (_ = x), (n = t.middlewareData.shift) != null && n.enabled.y && (A = w), P && !i) {
+        const k = L(p.left, 0), v = L(p.right, 0), b = L(p.top, 0), T = L(p.bottom, 0);
+        d ? _ = g - 2 * (k !== 0 || v !== 0 ? k + v : L(p.left, p.right)) : A = h - 2 * (b !== 0 || T !== 0 ? b + T : L(p.top, p.bottom));
+      }
+      await u({
+        ...t,
+        availableWidth: _,
+        availableHeight: A
+      });
+      const $ = await s.getDimensions(f.floating);
+      return g !== $.width || h !== $.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Me() {
+  return typeof window < "u";
+}
+function fe(e) {
+  return Wt(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function I(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function q(e) {
+  var t;
+  return (t = (Wt(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Wt(e) {
+  return Me() ? e instanceof Node || e instanceof I(e).Node : !1;
+}
+function G(e) {
+  return Me() ? e instanceof Element || e instanceof I(e).Element : !1;
+}
+function K(e) {
+  return Me() ? e instanceof HTMLElement || e instanceof I(e).HTMLElement : !1;
+}
+function yt(e) {
+  return !Me() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof I(e).ShadowRoot;
+}
+function Ee(e) {
+  const {
+    overflow: t,
+    overflowX: r,
+    overflowY: n,
+    display: o
+  } = H(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + n + r) && !["inline", "contents"].includes(o);
+}
+function xr(e) {
+  return ["table", "td", "th"].includes(fe(e));
+}
+function Le(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function ot(e) {
+  const t = it(), r = G(e) ? H(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((n) => r[n] ? r[n] !== "none" : !1) || (r.containerType ? r.containerType !== "normal" : !1) || !t && (r.backdropFilter ? r.backdropFilter !== "none" : !1) || !t && (r.filter ? r.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((n) => (r.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (r.contain || "").includes(n));
+}
+function Or(e) {
+  let t = ee(e);
+  for (; K(t) && !le(t); ) {
+    if (ot(t))
+      return t;
+    if (Le(t))
+      return null;
+    t = ee(t);
+  }
+  return null;
+}
+function it() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function le(e) {
+  return ["html", "body", "#document"].includes(fe(e));
+}
+function H(e) {
+  return I(e).getComputedStyle(e);
+}
+function Ie(e) {
+  return G(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function ee(e) {
+  if (fe(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.
+    yt(e) && e.host || // Fallback.
+    q(e)
+  );
+  return yt(t) ? t.host : t;
+}
+function Ut(e) {
+  const t = ee(e);
+  return le(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : K(t) && Ee(t) ? t : Ut(t);
+}
+function xe(e, t, r) {
+  var n;
+  t === void 0 && (t = []), r === void 0 && (r = !0);
+  const o = Ut(e), a = o === ((n = e.ownerDocument) == null ? void 0 : n.body), s = I(o);
+  if (a) {
+    const f = qe(s);
+    return t.concat(s, s.visualViewport || [], Ee(o) ? o : [], f && r ? xe(f) : []);
+  }
+  return t.concat(o, xe(o, [], r));
+}
+function qe(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function jt(e) {
+  const t = H(e);
+  let r = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const o = K(e), a = o ? e.offsetWidth : r, s = o ? e.offsetHeight : n, f = Re(r) !== a || Re(n) !== s;
+  return f && (r = a, n = s), {
+    width: r,
+    height: n,
+    $: f
+  };
+}
+function st(e) {
+  return G(e) ? e : e.contextElement;
+}
+function ce(e) {
+  const t = st(e);
+  if (!K(t))
+    return z(1);
+  const r = t.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: a
+  } = jt(t);
+  let s = (a ? Re(r.width) : r.width) / n, f = (a ? Re(r.height) : r.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!f || !Number.isFinite(f)) && (f = 1), {
+    x: s,
+    y: f
+  };
+}
+const Er = /* @__PURE__ */ z(0);
+function zt(e) {
+  const t = I(e);
+  return !it() || !t.visualViewport ? Er : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Nr(e, t, r) {
+  return t === void 0 && (t = !1), !r || t && r !== I(e) ? !1 : t;
+}
+function ne(e, t, r, n) {
+  t === void 0 && (t = !1), r === void 0 && (r = !1);
+  const o = e.getBoundingClientRect(), a = st(e);
+  let s = z(1);
+  t && (n ? G(n) && (s = ce(n)) : s = ce(e));
+  const f = Nr(a, r, n) ? zt(a) : z(0);
+  let u = (o.left + f.x) / s.x, c = (o.top + f.y) / s.y, p = o.width / s.x, l = o.height / s.y;
+  if (a) {
+    const i = I(a), d = n && G(n) ? I(n) : n;
+    let g = i, h = qe(g);
+    for (; h && n && d !== g; ) {
+      const m = ce(h), y = h.getBoundingClientRect(), w = H(h), x = y.left + (h.clientLeft + parseFloat(w.paddingLeft)) * m.x, N = y.top + (h.clientTop + parseFloat(w.paddingTop)) * m.y;
+      u *= m.x, c *= m.y, p *= m.x, l *= m.y, u += x, c += N, g = I(h), h = qe(g);
+    }
+  }
+  return Fe({
+    width: p,
+    height: l,
+    x: u,
+    y: c
+  });
+}
+function at(e, t) {
+  const r = Ie(e).scrollLeft;
+  return t ? t.left + r : ne(q(e)).left + r;
+}
+function Kt(e, t, r) {
+  r === void 0 && (r = !1);
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - (r ? 0 : (
+    // RTL <body> scrollbar.
+    at(e, n)
+  )), a = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: a
+  };
+}
+function Tr(e) {
+  let {
+    elements: t,
+    rect: r,
+    offsetParent: n,
+    strategy: o
+  } = e;
+  const a = o === "fixed", s = q(n), f = t ? Le(t.floating) : !1;
+  if (n === s || f && a)
+    return r;
+  let u = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, c = z(1);
+  const p = z(0), l = K(n);
+  if ((l || !l && !a) && ((fe(n) !== "body" || Ee(s)) && (u = Ie(n)), K(n))) {
+    const d = ne(n);
+    c = ce(n), p.x = d.x + n.clientLeft, p.y = d.y + n.clientTop;
+  }
+  const i = s && !l && !a ? Kt(s, u, !0) : z(0);
+  return {
+    width: r.width * c.x,
+    height: r.height * c.y,
+    x: r.x * c.x - u.scrollLeft * c.x + p.x + i.x,
+    y: r.y * c.y - u.scrollTop * c.y + p.y + i.y
+  };
+}
+function Pr(e) {
+  return Array.from(e.getClientRects());
+}
+function Sr(e) {
+  const t = q(e), r = Ie(e), n = e.ownerDocument.body, o = L(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), a = L(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -r.scrollLeft + at(e);
+  const f = -r.scrollTop;
+  return H(n).direction === "rtl" && (s += L(t.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: a,
+    x: s,
+    y: f
+  };
+}
+function Cr(e, t) {
+  const r = I(e), n = q(e), o = r.visualViewport;
+  let a = n.clientWidth, s = n.clientHeight, f = 0, u = 0;
+  if (o) {
+    a = o.width, s = o.height;
+    const c = it();
+    (!c || c && t === "fixed") && (f = o.offsetLeft, u = o.offsetTop);
+  }
+  return {
+    width: a,
+    height: s,
+    x: f,
+    y: u
+  };
+}
+function Ar(e, t) {
+  const r = ne(e, !0, t === "fixed"), n = r.top + e.clientTop, o = r.left + e.clientLeft, a = K(e) ? ce(e) : z(1), s = e.clientWidth * a.x, f = e.clientHeight * a.y, u = o * a.x, c = n * a.y;
+  return {
+    width: s,
+    height: f,
+    x: u,
+    y: c
+  };
+}
+function vt(e, t, r) {
+  let n;
+  if (t === "viewport")
+    n = Cr(e, r);
+  else if (t === "document")
+    n = Sr(q(e));
+  else if (G(t))
+    n = Ar(t, r);
+  else {
+    const o = zt(e);
+    n = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Fe(n);
+}
+function qt(e, t) {
+  const r = ee(e);
+  return r === t || !G(r) || le(r) ? !1 : H(r).position === "fixed" || qt(r, t);
+}
+function Rr(e, t) {
+  const r = t.get(e);
+  if (r)
+    return r;
+  let n = xe(e, [], !1).filter((f) => G(f) && fe(f) !== "body"), o = null;
+  const a = H(e).position === "fixed";
+  let s = a ? ee(e) : e;
+  for (; G(s) && !le(s); ) {
+    const f = H(s), u = ot(s);
+    !u && f.position === "fixed" && (o = null), (a ? !u && !o : !u && f.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || Ee(s) && !u && qt(e, s)) ? n = n.filter((p) => p !== s) : o = f, s = ee(s);
+  }
+  return t.set(e, n), n;
+}
+function Dr(e) {
+  let {
+    element: t,
+    boundary: r,
+    rootBoundary: n,
+    strategy: o
+  } = e;
+  const s = [...r === "clippingAncestors" ? Le(t) ? [] : Rr(t, this._c) : [].concat(r), n], f = s[0], u = s.reduce((c, p) => {
+    const l = vt(t, p, o);
+    return c.top = L(l.top, c.top), c.right = Q(l.right, c.right), c.bottom = Q(l.bottom, c.bottom), c.left = L(l.left, c.left), c;
+  }, vt(t, f, o));
+  return {
+    width: u.right - u.left,
+    height: u.bottom - u.top,
+    x: u.left,
+    y: u.top
+  };
+}
+function Fr(e) {
+  const {
+    width: t,
+    height: r
+  } = jt(e);
+  return {
+    width: t,
+    height: r
+  };
+}
+function _r(e, t, r) {
+  const n = K(t), o = q(t), a = r === "fixed", s = ne(e, !0, a, t);
+  let f = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const u = z(0);
+  if (n || !n && !a)
+    if ((fe(t) !== "body" || Ee(o)) && (f = Ie(t)), n) {
+      const i = ne(t, !0, a, t);
+      u.x = i.x + t.clientLeft, u.y = i.y + t.clientTop;
+    } else o && (u.x = at(o));
+  const c = o && !n && !a ? Kt(o, f) : z(0), p = s.left + f.scrollLeft - u.x - c.x, l = s.top + f.scrollTop - u.y - c.y;
+  return {
+    x: p,
+    y: l,
+    width: s.width,
+    height: s.height
+  };
+}
+function Ge(e) {
+  return H(e).position === "static";
+}
+function bt(e, t) {
+  if (!K(e) || H(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let r = e.offsetParent;
+  return q(e) === r && (r = r.ownerDocument.body), r;
+}
+function Yt(e, t) {
+  const r = I(e);
+  if (Le(e))
+    return r;
+  if (!K(e)) {
+    let o = ee(e);
+    for (; o && !le(o); ) {
+      if (G(o) && !Ge(o))
+        return o;
+      o = ee(o);
+    }
+    return r;
+  }
+  let n = bt(e, t);
+  for (; n && xr(n) && Ge(n); )
+    n = bt(n, t);
+  return n && le(n) && Ge(n) && !ot(n) ? r : n || Or(e) || r;
+}
+const kr = async function(e) {
+  const t = this.getOffsetParent || Yt, r = this.getDimensions, n = await r(e.floating);
+  return {
+    reference: _r(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function Mr(e) {
+  return H(e).direction === "rtl";
+}
+const Lr = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Tr,
+  getDocumentElement: q,
+  getClippingRect: Dr,
+  getOffsetParent: Yt,
+  getElementRects: kr,
+  getClientRects: Pr,
+  getDimensions: Fr,
+  getScale: ce,
+  isElement: G,
+  isRTL: Mr
+};
+function Xt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Ir(e, t) {
+  let r = null, n;
+  const o = q(e);
+  function a() {
+    var f;
+    clearTimeout(n), (f = r) == null || f.disconnect(), r = null;
+  }
+  function s(f, u) {
+    f === void 0 && (f = !1), u === void 0 && (u = 1), a();
+    const c = e.getBoundingClientRect(), {
+      left: p,
+      top: l,
+      width: i,
+      height: d
+    } = c;
+    if (f || t(), !i || !d)
+      return;
+    const g = Pe(l), h = Pe(o.clientWidth - (p + i)), m = Pe(o.clientHeight - (l + d)), y = Pe(p), x = {
+      rootMargin: -g + "px " + -h + "px " + -m + "px " + -y + "px",
+      threshold: L(0, Q(1, u)) || 1
+    };
+    let N = !0;
+    function E(P) {
+      const A = P[0].intersectionRatio;
+      if (A !== u) {
+        if (!N)
+          return s();
+        A ? s(!1, A) : n = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      A === 1 && !Xt(c, e.getBoundingClientRect()) && s(), N = !1;
+    }
+    try {
+      r = new IntersectionObserver(E, {
+        ...x,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      r = new IntersectionObserver(E, x);
+    }
+    r.observe(e);
+  }
+  return s(!0), a;
+}
+function $r(e, t, r, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: a = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: f = typeof IntersectionObserver == "function",
+    animationFrame: u = !1
+  } = n, c = st(e), p = o || a ? [...c ? xe(c) : [], ...xe(t)] : [];
+  p.forEach((y) => {
+    o && y.addEventListener("scroll", r, {
+      passive: !0
+    }), a && y.addEventListener("resize", r);
+  });
+  const l = c && f ? Ir(c, r) : null;
+  let i = -1, d = null;
+  s && (d = new ResizeObserver((y) => {
+    let [w] = y;
+    w && w.target === c && d && (d.unobserve(t), cancelAnimationFrame(i), i = requestAnimationFrame(() => {
+      var x;
+      (x = d) == null || x.observe(t);
+    })), r();
+  }), c && !u && d.observe(c), d.observe(t));
+  let g, h = u ? ne(e) : null;
+  u && m();
+  function m() {
+    const y = ne(e);
+    h && !Xt(h, y) && r(), h = y, g = requestAnimationFrame(m);
+  }
+  return r(), () => {
+    var y;
+    p.forEach((w) => {
+      o && w.removeEventListener("scroll", r), a && w.removeEventListener("resize", r);
+    }), l?.(), (y = d) == null || y.disconnect(), d = null, u && cancelAnimationFrame(g);
+  };
+}
+const Br = yr, Vr = vr, Gr = gr, Hr = wr, Wr = hr, Ur = pr, jr = br, zr = (e, t, r) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: Lr,
+    ...r
+  }, a = {
+    ...o.platform,
+    _c: n
+  };
+  return dr(e, t, {
+    ...o,
+    platform: a
+  });
+};
+function wt(e = 0, t = 0, r = 0, n = 0) {
+  if (typeof DOMRect == "function")
+    return new DOMRect(e, t, r, n);
+  const o = {
+    x: e,
+    y: t,
+    width: r,
+    height: n,
+    top: t,
+    right: e + r,
+    bottom: t + n,
+    left: e
+  };
+  return { ...o, toJSON: () => o };
+}
+function Kr(e) {
+  if (!e) return wt();
+  const { x: t, y: r, width: n, height: o } = e;
+  return wt(t, r, n, o);
+}
+function qr(e, t) {
+  return {
+    contextElement: En(e) ? e : void 0,
+    getBoundingClientRect: () => {
+      const r = e, n = t?.(r);
+      return n || !r ? Kr(n) : r.getBoundingClientRect();
+    }
+  };
+}
+var ge = (e) => ({ variable: e, reference: `var(${e})` }), Y = {
+  arrowSize: ge("--arrow-size"),
+  arrowSizeHalf: ge("--arrow-size-half"),
+  arrowBg: ge("--arrow-background"),
+  transformOrigin: ge("--transform-origin"),
+  arrowOffset: ge("--arrow-offset")
+}, Yr = (e) => ({
+  top: "bottom center",
+  "top-start": e ? `${e.x}px bottom` : "left bottom",
+  "top-end": e ? `${e.x}px bottom` : "right bottom",
+  bottom: "top center",
+  "bottom-start": e ? `${e.x}px top` : "top left",
+  "bottom-end": e ? `${e.x}px top` : "top right",
+  left: "right center",
+  "left-start": e ? `right ${e.y}px` : "right top",
+  "left-end": e ? `right ${e.y}px` : "right bottom",
+  right: "left center",
+  "right-start": e ? `left ${e.y}px` : "left top",
+  "right-end": e ? `left ${e.y}px` : "left bottom"
+}), Xr = {
+  name: "transformOrigin",
+  fn({ placement: e, elements: t, middlewareData: r }) {
+    const { arrow: n } = r, o = Yr(n)[e], { floating: a } = t;
+    return a.style.setProperty(Y.transformOrigin.variable, o), {
+      data: { transformOrigin: o }
+    };
+  }
+}, Jr = {
+  name: "rects",
+  fn({ rects: e }) {
+    return {
+      data: e
+    };
+  }
+}, Zr = (e) => {
+  if (e)
+    return {
+      name: "shiftArrow",
+      fn({ placement: t, middlewareData: r }) {
+        if (!r.arrow) return {};
+        const { x: n, y: o } = r.arrow, a = t.split("-")[0];
+        return Object.assign(e.style, {
+          left: n != null ? `${n}px` : "",
+          top: o != null ? `${o}px` : "",
+          [a]: `calc(100% + ${Y.arrowOffset.reference})`
+        }), {};
+      }
+    };
+};
+function Qr(e) {
+  const [t, r] = e.split("-");
+  return { side: t, align: r, hasAlign: r != null };
+}
+function Wo(e) {
+  return e.split("-")[0];
+}
+var eo = {
+  strategy: "absolute",
+  placement: "bottom",
+  listeners: !0,
+  gutter: 8,
+  flip: !0,
+  slide: !0,
+  overlap: !1,
+  sameWidth: !1,
+  fitViewport: !1,
+  overflowPadding: 8,
+  arrowPadding: 4
+};
+function xt(e, t) {
+  const r = e.devicePixelRatio || 1;
+  return Math.round(t * r) / r;
+}
+function Jt(e) {
+  return Tn(e.boundary);
+}
+function to(e, t) {
+  if (e)
+    return Ur({
+      element: e,
+      padding: t.arrowPadding
+    });
+}
+function no(e, t) {
+  if (!Nn(t.offset ?? t.gutter))
+    return Br(({ placement: r }) => {
+      const n = (e?.clientHeight || 0) / 2, o = t.offset?.mainAxis ?? t.gutter, a = typeof o == "number" ? o + n : o ?? n, { hasAlign: s } = Qr(r), f = s ? void 0 : t.shift, u = t.offset?.crossAxis ?? f;
+      return At({
+        crossAxis: u,
+        mainAxis: a,
+        alignmentAxis: t.shift
+      });
+    });
+}
+function ro(e) {
+  if (e.flip)
+    return Gr({
+      boundary: Jt(e),
+      padding: e.overflowPadding,
+      fallbackPlacements: e.flip === !0 ? void 0 : e.flip
+    });
+}
+function oo(e) {
+  if (!(!e.slide && !e.overlap))
+    return Vr({
+      boundary: Jt(e),
+      mainAxis: e.slide,
+      crossAxis: e.overlap,
+      padding: e.overflowPadding,
+      limiter: jr()
+    });
+}
+function io(e) {
+  return Hr({
+    padding: e.overflowPadding,
+    apply({ elements: t, rects: r, availableHeight: n, availableWidth: o }) {
+      const a = t.floating, s = Math.round(r.reference.width);
+      o = Math.floor(o), n = Math.floor(n), a.style.setProperty("--reference-width", `${s}px`), a.style.setProperty("--available-width", `${o}px`), a.style.setProperty("--available-height", `${n}px`);
+    }
+  });
+}
+function so(e) {
+  if (e.hideWhenDetached)
+    return Wr({ strategy: "referenceHidden", boundary: e.boundary?.() ?? "clippingAncestors" });
+}
+function ao(e) {
+  return e ? e === !0 ? { ancestorResize: !0, ancestorScroll: !0, elementResize: !0, layoutShift: !0 } : e : {};
+}
+function co(e, t, r = {}) {
+  const n = qr(e, r.getAnchorRect);
+  if (!t || !n) return;
+  const o = Object.assign({}, eo, r), a = t.querySelector("[data-part=arrow]"), s = [
+    no(a, o),
+    ro(o),
+    oo(o),
+    to(a, o),
+    Zr(a),
+    Xr,
+    io(o),
+    so(o),
+    Jr
+  ], { placement: f, strategy: u, onComplete: c, onPositioned: p } = o, l = async () => {
+    if (!n || !t) return;
+    const h = await zr(n, t, {
+      placement: f,
+      middleware: s,
+      strategy: u
+    });
+    c?.(h), p?.({ placed: !0 });
+    const m = Pn(t), y = xt(m, h.x), w = xt(m, h.y);
+    t.style.setProperty("--x", `${y}px`), t.style.setProperty("--y", `${w}px`), o.hideWhenDetached && (h.middlewareData.hide?.referenceHidden ? (t.style.setProperty("visibility", "hidden"), t.style.setProperty("pointer-events", "none")) : (t.style.removeProperty("visibility"), t.style.removeProperty("pointer-events")));
+    const x = t.firstElementChild;
+    if (x) {
+      const N = Dt(x);
+      t.style.setProperty("--z-index", N.zIndex);
+    }
+  }, i = async () => {
+    r.updatePosition ? (await r.updatePosition({ updatePosition: l }), p?.({ placed: !0 })) : await l();
+  }, d = ao(o.listeners), g = o.listeners ? $r(n, t, i, d) : On;
+  return i(), () => {
+    g?.(), p?.({ placed: !1 });
+  };
+}
+function Ot(e, t, r = {}) {
+  const { defer: n, ...o } = r, a = n ? te : (f) => f(), s = [];
+  return s.push(
+    a(() => {
+      const f = typeof e == "function" ? e() : e, u = typeof t == "function" ? t() : t;
+      s.push(co(f, u, o));
+    })
+  ), () => {
+    s.forEach((f) => f?.());
+  };
+}
+var lo = {
+  bottom: "rotate(45deg)",
+  left: "rotate(135deg)",
+  top: "rotate(225deg)",
+  right: "rotate(315deg)"
+};
+function uo(e = {}) {
+  const { placement: t, sameWidth: r, fitViewport: n, strategy: o = "absolute" } = e;
+  return {
+    arrow: {
+      position: "absolute",
+      width: Y.arrowSize.reference,
+      height: Y.arrowSize.reference,
+      [Y.arrowSizeHalf.variable]: `calc(${Y.arrowSize.reference} / 2)`,
+      [Y.arrowOffset.variable]: `calc(${Y.arrowSizeHalf.reference} * -1)`
+    },
+    arrowTip: {
+      // @ts-expect-error - Fix this
+      transform: t ? lo[t.split("-")[0]] : void 0,
+      background: Y.arrowBg.reference,
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      position: "absolute",
+      zIndex: "inherit"
+    },
+    floating: {
+      position: o,
+      isolation: "isolate",
+      minWidth: r ? void 0 : "max-content",
+      width: r ? "var(--reference-width)" : void 0,
+      maxWidth: n ? "var(--available-width)" : void 0,
+      maxHeight: n ? "var(--available-height)" : void 0,
+      pointerEvents: t ? void 0 : "none",
+      top: "0px",
+      left: "0px",
+      // move off-screen if placement is not defined
+      transform: t ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+      zIndex: "var(--z-index)"
+    }
+  };
+}
+var ie = /* @__PURE__ */ new WeakMap(), Se = /* @__PURE__ */ new WeakMap(), Ce = {}, He = 0, Zt = (e) => e && (e.host || Zt(e.parentNode)), fo = (e, t) => t.map((r) => {
+  if (e.contains(r)) return r;
+  const n = Zt(r);
+  return n && e.contains(n) ? n : (console.error("[zag-js > ariaHidden] target", r, "in not contained inside", e, ". Doing nothing"), null);
+}).filter((r) => !!r), po = (e) => e.localName === "next-route-announcer" || e.localName === "script" || e.hasAttribute("aria-live") ? !0 : e.matches("[data-live-announcer]"), go = (e, t) => {
+  const { parentNode: r, markerName: n, controlAttribute: o } = t, a = fo(r, Array.isArray(e) ? e : [e]);
+  Ce[n] || (Ce[n] = /* @__PURE__ */ new WeakMap());
+  const s = Ce[n], f = [], u = /* @__PURE__ */ new Set(), c = new Set(a), p = (i) => {
+    !i || u.has(i) || (u.add(i), p(i.parentNode));
+  };
+  a.forEach(p);
+  const l = (i) => {
+    !i || c.has(i) || Array.prototype.forEach.call(i.children, (d) => {
+      if (u.has(d))
+        l(d);
+      else
+        try {
+          if (po(d)) return;
+          const h = d.getAttribute(o) === "true", m = (ie.get(d) || 0) + 1, y = (s.get(d) || 0) + 1;
+          ie.set(d, m), s.set(d, y), f.push(d), m === 1 && h && Se.set(d, !0), y === 1 && d.setAttribute(n, ""), h || d.setAttribute(o, "true");
+        } catch (g) {
+          console.error("[zag-js > ariaHidden] cannot operate on ", d, g);
+        }
+    });
+  };
+  return l(r), u.clear(), He++, () => {
+    f.forEach((i) => {
+      const d = ie.get(i) - 1, g = s.get(i) - 1;
+      ie.set(i, d), s.set(i, g), d || (Se.has(i) || i.removeAttribute(o), Se.delete(i)), g || i.removeAttribute(n);
+    }), He--, He || (ie = /* @__PURE__ */ new WeakMap(), ie = /* @__PURE__ */ new WeakMap(), Se = /* @__PURE__ */ new WeakMap(), Ce = {});
+  };
+}, ho = (e) => (Array.isArray(e) ? e[0] : e).ownerDocument.body, mo = (e, t = ho(e), r = "data-aria-hidden") => {
+  if (t)
+    return go(e, {
+      parentNode: t,
+      markerName: r,
+      controlAttribute: "aria-hidden"
+    });
+}, yo = (e) => {
+  const t = requestAnimationFrame(() => e());
+  return () => cancelAnimationFrame(t);
+};
+function vo(e, t = {}) {
+  const { defer: r = !0 } = t, n = r ? yo : (a) => a(), o = [];
+  return o.push(
+    n(() => {
+      const s = (typeof e == "function" ? e() : e).filter(Boolean);
+      s.length !== 0 && o.push(mo(s));
+    })
+  ), () => {
+    o.forEach((a) => a?.());
+  };
+}
+var bo = Object.defineProperty, wo = (e, t, r) => t in e ? bo(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, S = (e, t, r) => wo(e, typeof t != "symbol" ? t + "" : t, r), Et = {
+  activateTrap(e, t) {
+    if (e.length > 0) {
+      const n = e[e.length - 1];
+      n !== t && n.pause();
+    }
+    const r = e.indexOf(t);
+    r === -1 || e.splice(r, 1), e.push(t);
+  },
+  deactivateTrap(e, t) {
+    const r = e.indexOf(t);
+    r !== -1 && e.splice(r, 1), e.length > 0 && e[e.length - 1].unpause();
+  }
+}, xo = [], Oo = class {
+  constructor(e, t) {
+    S(this, "trapStack"), S(this, "config"), S(this, "doc"), S(this, "state", {
+      containers: [],
+      containerGroups: [],
+      tabbableGroups: [],
+      nodeFocusedBeforeActivation: null,
+      mostRecentlyFocusedNode: null,
+      active: !1,
+      paused: !1,
+      delayInitialFocusTimer: void 0,
+      recentNavEvent: void 0
+    }), S(this, "listenerCleanups", []), S(this, "handleFocus", (n) => {
+      const o = ve(n), a = this.findContainerIndex(o, n) >= 0;
+      if (a || An(o))
+        a && (this.state.mostRecentlyFocusedNode = o);
+      else {
+        n.stopImmediatePropagation();
+        let s, f = !0;
+        if (this.state.mostRecentlyFocusedNode)
+          if (pe(this.state.mostRecentlyFocusedNode) > 0) {
+            const u = this.findContainerIndex(this.state.mostRecentlyFocusedNode), { tabbableNodes: c } = this.state.containerGroups[u];
+            if (c.length > 0) {
+              const p = c.findIndex((l) => l === this.state.mostRecentlyFocusedNode);
+              p >= 0 && (this.config.isKeyForward(this.state.recentNavEvent) ? p + 1 < c.length && (s = c[p + 1], f = !1) : p - 1 >= 0 && (s = c[p - 1], f = !1));
+            }
+          } else
+            this.state.containerGroups.some((u) => u.tabbableNodes.some((c) => pe(c) > 0)) || (f = !1);
+        else
+          f = !1;
+        f && (s = this.findNextNavNode({
+          // 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: this.state.mostRecentlyFocusedNode,
+          isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+        })), s ? this.tryFocus(s) : this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+      }
+      this.state.recentNavEvent = void 0;
+    }), S(this, "handlePointerDown", (n) => {
+      const o = ve(n);
+      if (!(this.findContainerIndex(o, n) >= 0)) {
+        if (me(this.config.clickOutsideDeactivates, n)) {
+          this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+          return;
+        }
+        me(this.config.allowOutsideClick, n) || n.preventDefault();
+      }
+    }), S(this, "handleClick", (n) => {
+      const o = ve(n);
+      this.findContainerIndex(o, n) >= 0 || me(this.config.clickOutsideDeactivates, n) || me(this.config.allowOutsideClick, n) || (n.preventDefault(), n.stopImmediatePropagation());
+    }), S(this, "handleTabKey", (n) => {
+      if (this.config.isKeyForward(n) || this.config.isKeyBackward(n)) {
+        this.state.recentNavEvent = n;
+        const o = this.config.isKeyBackward(n), a = this.findNextNavNode({ event: n, isBackward: o });
+        if (!a) return;
+        he(n) && n.preventDefault(), this.tryFocus(a);
+      }
+    }), S(this, "handleEscapeKey", (n) => {
+      Eo(n) && me(this.config.escapeDeactivates, n) !== !1 && (n.preventDefault(), this.deactivate());
+    }), S(this, "_mutationObserver"), S(this, "setupMutationObserver", () => {
+      const n = this.doc.defaultView || window;
+      this._mutationObserver = new n.MutationObserver((o) => {
+        o.some((s) => Array.from(s.removedNodes).some((u) => u === this.state.mostRecentlyFocusedNode)) && this.tryFocus(this.getInitialFocusNode());
+      });
+    }), S(this, "updateObservedNodes", () => {
+      this._mutationObserver?.disconnect(), this.state.active && !this.state.paused && this.state.containers.map((n) => {
+        this._mutationObserver?.observe(n, { subtree: !0, childList: !0 });
+      });
+    }), S(this, "getInitialFocusNode", () => {
+      let n = this.getNodeForOption("initialFocus", { hasFallback: !0 });
+      if (n === !1)
+        return !1;
+      if (n === void 0 || n && !Be(n))
+        if (this.findContainerIndex(this.doc.activeElement) >= 0)
+          n = this.doc.activeElement;
+        else {
+          const o = this.state.tabbableGroups[0];
+          n = o && o.firstTabbableNode || this.getNodeForOption("fallbackFocus");
+        }
+      else n === null && (n = this.getNodeForOption("fallbackFocus"));
+      if (!n)
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      return n.isConnected || (n = this.getNodeForOption("fallbackFocus")), n;
+    }), S(this, "tryFocus", (n) => {
+      if (n !== !1 && n !== Rn(this.doc)) {
+        if (!n || !n.focus) {
+          this.tryFocus(this.getInitialFocusNode());
+          return;
+        }
+        n.focus({ preventScroll: !!this.config.preventScroll }), this.state.mostRecentlyFocusedNode = n, No(n) && n.select();
+      }
+    }), S(this, "deactivate", (n) => {
+      if (!this.state.active) return this;
+      const o = {
+        onDeactivate: this.config.onDeactivate,
+        onPostDeactivate: this.config.onPostDeactivate,
+        checkCanReturnFocus: this.config.checkCanReturnFocus,
+        ...n
+      };
+      clearTimeout(this.state.delayInitialFocusTimer), this.state.delayInitialFocusTimer = void 0, this.removeListeners(), this.state.active = !1, this.state.paused = !1, this.updateObservedNodes(), Et.deactivateTrap(this.trapStack, this);
+      const a = this.getOption(o, "onDeactivate"), s = this.getOption(o, "onPostDeactivate"), f = this.getOption(o, "checkCanReturnFocus"), u = this.getOption(o, "returnFocus", "returnFocusOnDeactivate");
+      a?.();
+      const c = () => {
+        Nt(() => {
+          if (u) {
+            const p = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+            this.tryFocus(p);
+          }
+          s?.();
+        });
+      };
+      if (u && f) {
+        const p = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+        return f(p).then(c, c), this;
+      }
+      return c(), this;
+    }), S(this, "pause", (n) => {
+      if (this.state.paused || !this.state.active)
+        return this;
+      const o = this.getOption(n, "onPause"), a = this.getOption(n, "onPostPause");
+      return this.state.paused = !0, o?.(), this.removeListeners(), this.updateObservedNodes(), a?.(), this;
+    }), S(this, "unpause", (n) => {
+      if (!this.state.paused || !this.state.active)
+        return this;
+      const o = this.getOption(n, "onUnpause"), a = this.getOption(n, "onPostUnpause");
+      return this.state.paused = !1, o?.(), this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), a?.(), this;
+    }), S(this, "updateContainerElements", (n) => (this.state.containers = Array.isArray(n) ? n.filter(Boolean) : [n].filter(Boolean), this.state.active && this.updateTabbableNodes(), this.updateObservedNodes(), this)), S(this, "getReturnFocusNode", (n) => {
+      const o = this.getNodeForOption("setReturnFocus", {
+        params: [n]
+      });
+      return o || (o === !1 ? !1 : n);
+    }), S(this, "getOption", (n, o, a) => n && n[o] !== void 0 ? n[o] : (
+      // @ts-expect-error
+      this.config[a || o]
+    )), S(this, "getNodeForOption", (n, { hasFallback: o = !1, params: a = [] } = {}) => {
+      let s = this.config[n];
+      if (typeof s == "function" && (s = s(...a)), s === !0 && (s = void 0), !s) {
+        if (s === void 0 || s === !1)
+          return s;
+        throw new Error(`\`${n}\` was specified but was not a node, or did not return a node`);
+      }
+      let f = s;
+      if (typeof s == "string") {
+        try {
+          f = this.doc.querySelector(s);
+        } catch (u) {
+          throw new Error(`\`${n}\` appears to be an invalid selector; error="${u.message}"`);
+        }
+        if (!f && !o)
+          throw new Error(`\`${n}\` as selector refers to no known node`);
+      }
+      return f;
+    }), S(this, "findNextNavNode", (n) => {
+      const { event: o, isBackward: a = !1 } = n, s = n.target || ve(o);
+      this.updateTabbableNodes();
+      let f = null;
+      if (this.state.tabbableGroups.length > 0) {
+        const u = this.findContainerIndex(s, o), c = u >= 0 ? this.state.containerGroups[u] : void 0;
+        if (u < 0)
+          a ? f = this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode : f = this.state.tabbableGroups[0].firstTabbableNode;
+        else if (a) {
+          let p = this.state.tabbableGroups.findIndex(
+            ({ firstTabbableNode: l }) => s === l
+          );
+          if (p < 0 && (c?.container === s || Be(s) && !re(s) && !c?.nextTabbableNode(s, !1)) && (p = u), p >= 0) {
+            const l = p === 0 ? this.state.tabbableGroups.length - 1 : p - 1, i = this.state.tabbableGroups[l];
+            f = pe(s) >= 0 ? i.lastTabbableNode : i.lastDomTabbableNode;
+          } else he(o) || (f = c?.nextTabbableNode(s, !1));
+        } else {
+          let p = this.state.tabbableGroups.findIndex(
+            ({ lastTabbableNode: l }) => s === l
+          );
+          if (p < 0 && (c?.container === s || Be(s) && !re(s) && !c?.nextTabbableNode(s)) && (p = u), p >= 0) {
+            const l = p === this.state.tabbableGroups.length - 1 ? 0 : p + 1, i = this.state.tabbableGroups[l];
+            f = pe(s) >= 0 ? i.firstTabbableNode : i.firstDomTabbableNode;
+          } else he(o) || (f = c?.nextTabbableNode(s));
+        }
+      } else
+        f = this.getNodeForOption("fallbackFocus");
+      return f;
+    }), this.trapStack = t.trapStack || xo;
+    const r = {
+      returnFocusOnDeactivate: !0,
+      escapeDeactivates: !0,
+      delayInitialFocus: !0,
+      isKeyForward(n) {
+        return he(n) && !n.shiftKey;
+      },
+      isKeyBackward(n) {
+        return he(n) && n.shiftKey;
+      },
+      ...t
+    };
+    this.doc = r.document || Qe(Array.isArray(e) ? e[0] : e), this.config = r, this.updateContainerElements(e), this.setupMutationObserver();
+  }
+  get active() {
+    return this.state.active;
+  }
+  get paused() {
+    return this.state.paused;
+  }
+  findContainerIndex(e, t) {
+    const r = typeof t?.composedPath == "function" ? t.composedPath() : void 0;
+    return this.state.containerGroups.findIndex(
+      ({ container: n, tabbableNodes: o }) => n.contains(e) || r?.includes(n) || o.find((a) => a === e)
+    );
+  }
+  updateTabbableNodes() {
+    if (this.state.containerGroups = this.state.containers.map((e) => {
+      const t = Sn(e), r = Cn(e), n = t.length > 0 ? t[0] : void 0, o = t.length > 0 ? t[t.length - 1] : void 0, a = r.find((c) => re(c)), s = r.slice().reverse().find((c) => re(c)), f = !!t.find((c) => pe(c) > 0);
+      function u(c, p = !0) {
+        const l = t.indexOf(c);
+        return l < 0 ? p ? r.slice(r.indexOf(c) + 1).find((i) => re(i)) : r.slice(0, r.indexOf(c)).reverse().find((i) => re(i)) : t[l + (p ? 1 : -1)];
+      }
+      return {
+        container: e,
+        tabbableNodes: t,
+        focusableNodes: r,
+        posTabIndexesFound: f,
+        firstTabbableNode: n,
+        lastTabbableNode: o,
+        firstDomTabbableNode: a,
+        lastDomTabbableNode: s,
+        nextTabbableNode: u
+      };
+    }), this.state.tabbableGroups = this.state.containerGroups.filter((e) => e.tabbableNodes.length > 0), this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("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 (this.state.containerGroups.find((e) => e.posTabIndexesFound) && this.state.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."
+      );
+  }
+  addListeners() {
+    if (this.state.active)
+      return Et.activateTrap(this.trapStack, this), this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? Nt(() => {
+        this.tryFocus(this.getInitialFocusNode());
+      }) : this.tryFocus(this.getInitialFocusNode()), this.listenerCleanups.push(
+        oe(this.doc, "focusin", this.handleFocus, !0),
+        oe(this.doc, "mousedown", this.handlePointerDown, { capture: !0, passive: !1 }),
+        oe(this.doc, "touchstart", this.handlePointerDown, { capture: !0, passive: !1 }),
+        oe(this.doc, "click", this.handleClick, { capture: !0, passive: !1 }),
+        oe(this.doc, "keydown", this.handleTabKey, { capture: !0, passive: !1 }),
+        oe(this.doc, "keydown", this.handleEscapeKey)
+      ), this;
+  }
+  removeListeners() {
+    if (this.state.active)
+      return this.listenerCleanups.forEach((e) => e()), this.listenerCleanups = [], this;
+  }
+  activate(e) {
+    if (this.state.active)
+      return this;
+    const t = this.getOption(e, "onActivate"), r = this.getOption(e, "onPostActivate"), n = this.getOption(e, "checkCanFocusTrap");
+    n || this.updateTabbableNodes(), this.state.active = !0, this.state.paused = !1, this.state.nodeFocusedBeforeActivation = this.doc.activeElement || null, t?.();
+    const o = () => {
+      n && this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), r?.();
+    };
+    return n ? (n(this.state.containers.concat()).then(o, o), this) : (o(), this);
+  }
+}, he = (e) => e.key === "Tab", me = (e, ...t) => typeof e == "function" ? e(...t) : e, Eo = (e) => !e.isComposing && e.key === "Escape", Nt = (e) => setTimeout(e, 0), No = (e) => e.localName === "input" && "select" in e && typeof e.select == "function";
+function To(e, t = {}) {
+  let r;
+  const n = te(() => {
+    const o = typeof e == "function" ? e() : e;
+    if (o) {
+      r = new Oo(o, {
+        escapeDeactivates: !1,
+        allowOutsideClick: !0,
+        preventScroll: !0,
+        returnFocusOnDeactivate: !0,
+        delayInitialFocus: !1,
+        fallbackFocus: o,
+        ...t,
+        document: Qe(o)
+      });
+      try {
+        r.activate();
+      } catch {
+      }
+    }
+  });
+  return function() {
+    r?.deactivate(), n();
+  };
+}
+var We = "data-scroll-lock";
+function Po(e) {
+  const t = e.getBoundingClientRect().left;
+  return Math.round(t) + e.scrollLeft ? "paddingLeft" : "paddingRight";
+}
+function So(e) {
+  const t = e ?? document, r = t.defaultView ?? window, { documentElement: n, body: o } = t;
+  if (o.hasAttribute(We)) return;
+  o.setAttribute(We, "");
+  const s = r.innerWidth - n.clientWidth, f = () => Dn(n, "--scrollbar-width", `${s}px`), u = Po(n), c = () => je(o, {
+    overflow: "hidden",
+    [u]: `${s}px`
+  }), p = () => {
+    const { scrollX: i, scrollY: d, visualViewport: g } = r, h = g?.offsetLeft ?? 0, m = g?.offsetTop ?? 0, y = je(o, {
+      position: "fixed",
+      overflow: "hidden",
+      top: `${-(d - Math.floor(m))}px`,
+      left: `${-(i - Math.floor(h))}px`,
+      right: "0",
+      [u]: `${s}px`
+    });
+    return () => {
+      y?.(), r.scrollTo({ left: i, top: d, behavior: "instant" });
+    };
+  }, l = [f(), Fn() ? p() : c()];
+  return () => {
+    l.forEach((i) => i?.()), o.removeAttribute(We);
+  };
+}
+var Co = Mn("popover").parts(
+  "arrow",
+  "arrowTip",
+  "anchor",
+  "trigger",
+  "indicator",
+  "positioner",
+  "content",
+  "title",
+  "description",
+  "closeTrigger"
+), W = Co.build(), Qt = (e) => e.ids?.anchor ?? `popover:${e.id}:anchor`, en = (e) => e.ids?.trigger ?? `popover:${e.id}:trigger`, Ye = (e) => e.ids?.content ?? `popover:${e.id}:content`, tn = (e) => e.ids?.positioner ?? `popover:${e.id}:popper`, Ao = (e) => e.ids?.arrow ?? `popover:${e.id}:arrow`, Xe = (e) => e.ids?.title ?? `popover:${e.id}:title`, Je = (e) => e.ids?.description ?? `popover:${e.id}:desc`, Ro = (e) => e.ids?.closeTrigger ?? `popover:${e.id}:close`, Tt = (e) => e.getById(Qt(e)), se = (e) => e.getById(en(e)), ae = (e) => e.getById(Ye(e)), Pt = (e) => e.getById(tn(e)), Do = (e) => e.getById(Xe(e)), Fo = (e) => e.getById(Je(e));
+function _o(e, t) {
+  const { state: r, context: n, send: o, computed: a, prop: s, scope: f } = e, u = r.matches("open"), c = n.get("currentPlacement"), p = a("currentPortalled"), l = n.get("renderedElements"), i = uo({
+    ...s("positioning"),
+    placement: c
+  });
+  return {
+    portalled: p,
+    open: u,
+    setOpen(d) {
+      r.matches("open") !== d && o({ type: d ? "OPEN" : "CLOSE" });
+    },
+    reposition(d = {}) {
+      o({ type: "POSITIONING.SET", options: d });
+    },
+    getArrowProps() {
+      return t.element({
+        id: Ao(f),
+        ...W.arrow.attrs,
+        dir: s("dir"),
+        style: i.arrow
+      });
+    },
+    getArrowTipProps() {
+      return t.element({
+        ...W.arrowTip.attrs,
+        dir: s("dir"),
+        style: i.arrowTip
+      });
+    },
+    getAnchorProps() {
+      return t.element({
+        ...W.anchor.attrs,
+        dir: s("dir"),
+        id: Qt(f)
+      });
+    },
+    getTriggerProps() {
+      return t.button({
+        ...W.trigger.attrs,
+        dir: s("dir"),
+        type: "button",
+        "data-placement": c,
+        id: en(f),
+        "aria-haspopup": "dialog",
+        "aria-expanded": u,
+        "data-state": u ? "open" : "closed",
+        "aria-controls": Ye(f),
+        onPointerDown(d) {
+          In() && d.currentTarget.focus();
+        },
+        onClick(d) {
+          d.defaultPrevented || o({ type: "TOGGLE" });
+        },
+        onBlur(d) {
+          o({ type: "TRIGGER_BLUR", target: d.relatedTarget });
+        }
+      });
+    },
+    getIndicatorProps() {
+      return t.element({
+        ...W.indicator.attrs,
+        dir: s("dir"),
+        "data-state": u ? "open" : "closed"
+      });
+    },
+    getPositionerProps() {
+      return t.element({
+        id: tn(f),
+        ...W.positioner.attrs,
+        dir: s("dir"),
+        style: i.floating
+      });
+    },
+    getContentProps() {
+      return t.element({
+        ...W.content.attrs,
+        dir: s("dir"),
+        id: Ye(f),
+        tabIndex: -1,
+        role: "dialog",
+        hidden: !u,
+        "data-state": u ? "open" : "closed",
+        "data-expanded": Ln(u),
+        "aria-labelledby": l.title ? Xe(f) : void 0,
+        "aria-describedby": l.description ? Je(f) : void 0,
+        "data-placement": c
+      });
+    },
+    getTitleProps() {
+      return t.element({
+        ...W.title.attrs,
+        id: Xe(f),
+        dir: s("dir")
+      });
+    },
+    getDescriptionProps() {
+      return t.element({
+        ...W.description.attrs,
+        id: Je(f),
+        dir: s("dir")
+      });
+    },
+    getCloseTriggerProps() {
+      return t.button({
+        ...W.closeTrigger.attrs,
+        dir: s("dir"),
+        id: Ro(f),
+        type: "button",
+        "aria-label": "close",
+        onClick(d) {
+          d.defaultPrevented || (d.stopPropagation(), o({ type: "CLOSE" }));
+        }
+      });
+    }
+  };
+}
+var ko = Rt({
+  props({ props: e }) {
+    return {
+      closeOnInteractOutside: !0,
+      closeOnEscape: !0,
+      autoFocus: !0,
+      modal: !1,
+      portalled: !0,
+      ...e,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  initialState({ prop: e }) {
+    return e("open") || e("defaultOpen") ? "open" : "closed";
+  },
+  context({ bindable: e }) {
+    return {
+      currentPlacement: e(() => ({
+        defaultValue: void 0
+      })),
+      renderedElements: e(() => ({
+        defaultValue: { title: !0, description: !0 }
+      }))
+    };
+  },
+  computed: {
+    currentPortalled: ({ prop: e }) => !!e("modal") || !!e("portalled")
+  },
+  watch({ track: e, prop: t, action: r }) {
+    e([() => t("open")], () => {
+      r(["toggleVisibility"]);
+    });
+  },
+  entry: ["checkRenderedElements"],
+  states: {
+    closed: {
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open",
+          actions: ["setInitialFocus"]
+        },
+        TOGGLE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen", "setInitialFocus"]
+          }
+        ],
+        OPEN: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen", "setInitialFocus"]
+          }
+        ]
+      }
+    },
+    open: {
+      effects: [
+        "trapFocus",
+        "preventScroll",
+        "hideContentBelow",
+        "trackPositioning",
+        "trackDismissableElement",
+        "proxyTabFocus"
+      ],
+      on: {
+        "CONTROLLED.CLOSE": {
+          target: "closed",
+          actions: ["setFinalFocus"]
+        },
+        CLOSE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose", "setFinalFocus"]
+          }
+        ],
+        TOGGLE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "POSITIONING.SET": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isOpenControlled: ({ prop: e }) => e("open") != null
+    },
+    effects: {
+      trackPositioning({ context: e, prop: t, scope: r }) {
+        e.set("currentPlacement", t("positioning").placement);
+        const n = Tt(r) ?? se(r);
+        return Ot(n, () => Pt(r), {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(a) {
+            e.set("currentPlacement", a.placement);
+          }
+        });
+      },
+      trackDismissableElement({ send: e, prop: t, scope: r }) {
+        const n = () => ae(r);
+        let o = !0;
+        return kn(n, {
+          pointerBlocking: t("modal"),
+          exclude: se(r),
+          defer: !0,
+          onEscapeKeyDown(a) {
+            t("onEscapeKeyDown")?.(a), !t("closeOnEscape") && a.preventDefault();
+          },
+          onInteractOutside(a) {
+            t("onInteractOutside")?.(a), !a.defaultPrevented && (o = !(a.detail.focusable || a.detail.contextmenu), t("closeOnInteractOutside") || a.preventDefault());
+          },
+          onPointerDownOutside: t("onPointerDownOutside"),
+          onFocusOutside: t("onFocusOutside"),
+          persistentElements: t("persistentElements"),
+          onDismiss() {
+            e({ type: "CLOSE", src: "interact-outside", restoreFocus: o });
+          }
+        });
+      },
+      proxyTabFocus({ prop: e, scope: t }) {
+        return e("modal") || !e("portalled") ? void 0 : _n(() => ae(t), {
+          triggerElement: se(t),
+          defer: !0,
+          onFocus(n) {
+            n.focus({ preventScroll: !0 });
+          }
+        });
+      },
+      hideContentBelow({ prop: e, scope: t }) {
+        return e("modal") ? vo(() => [ae(t), se(t)], { defer: !0 }) : void 0;
+      },
+      preventScroll({ prop: e, scope: t }) {
+        if (e("modal"))
+          return So(t.getDoc());
+      },
+      trapFocus({ prop: e, scope: t }) {
+        return e("modal") ? To(() => ae(t), {
+          initialFocus: () => lt({
+            root: ae(t),
+            getInitialEl: e("initialFocusEl"),
+            enabled: e("autoFocus")
+          })
+        }) : void 0;
+      }
+    },
+    actions: {
+      reposition({ event: e, prop: t, scope: r, context: n }) {
+        const o = Tt(r) ?? se(r);
+        Ot(o, () => Pt(r), {
+          ...t("positioning"),
+          ...e.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(s) {
+            n.set("currentPlacement", s.placement);
+          }
+        });
+      },
+      checkRenderedElements({ context: e, scope: t }) {
+        te(() => {
+          Object.assign(e.get("renderedElements"), {
+            title: !!Do(t),
+            description: !!Fo(t)
+          });
+        });
+      },
+      setInitialFocus({ prop: e, scope: t }) {
+        e("modal") || te(() => {
+          lt({
+            root: ae(t),
+            getInitialEl: e("initialFocusEl"),
+            enabled: e("autoFocus")
+          })?.focus({ preventScroll: !0 });
+        });
+      },
+      setFinalFocus({ event: e, scope: t }) {
+        const r = e.restoreFocus ?? e.previousEvent?.restoreFocus;
+        r != null && !r || te(() => {
+          se(t)?.focus({ preventScroll: !0 });
+        });
+      },
+      invokeOnOpen({ prop: e }) {
+        e("onOpenChange")?.({ open: !0 });
+      },
+      invokeOnClose({ prop: e }) {
+        e("onOpenChange")?.({ open: !1 });
+      },
+      toggleVisibility({ event: e, send: t, prop: r }) {
+        t({ type: r("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: e });
+      }
+    }
+  }
+});
+Ft()([
+  "autoFocus",
+  "closeOnEscape",
+  "closeOnInteractOutside",
+  "dir",
+  "getRootNode",
+  "id",
+  "ids",
+  "initialFocusEl",
+  "modal",
+  "onEscapeKeyDown",
+  "onFocusOutside",
+  "onInteractOutside",
+  "onOpenChange",
+  "onPointerDownOutside",
+  "defaultOpen",
+  "open",
+  "persistentElements",
+  "portalled",
+  "positioning"
+]);
+const [Uo, nn] = ke({
+  name: "EnvironmentContext",
+  hookName: "useEnvironmentContext",
+  providerName: "<EnvironmentProvider />",
+  strict: !1,
+  defaultValue: {
+    getRootNode: () => document,
+    getDocument: () => document,
+    getWindow: () => window
+  }
+}), [jo, Mo] = ke({
+  name: "LocaleContext",
+  hookName: "useLocaleContext",
+  providerName: "<LocaleProvider />",
+  strict: !1,
+  defaultValue: { dir: "ltr", locale: "en-US" }
+}), Lo = (e) => {
+  const t = gn(), { getRootNode: r } = nn(), { dir: n } = Mo(), o = {
+    id: t,
+    dir: n,
+    getRootNode: r,
+    ...e
+  }, a = kt(ko, o);
+  return _o(a, zn);
+}, zo = (e) => {
+  const [t, { children: r, ...n }] = Vt(e), o = Lo(n), a = Gt(Oe({ present: o.open }, t));
+  return /* @__PURE__ */ U.jsx($t, { value: o, children: /* @__PURE__ */ U.jsx(Bt, { value: a, children: r }) });
+}, Ko = (e) => {
+  const [t, { value: r, children: n }] = Vt(e), o = Gt(Oe({ present: r.open }, t));
+  return /* @__PURE__ */ U.jsx($t, { value: r, children: /* @__PURE__ */ U.jsx(Bt, { value: o, children: n }) });
+}, qo = (e) => {
+  const { children: t, disabled: r } = e, [n, o] = Ue(e.container?.current), a = hn(
+    $o,
+    () => !1,
+    () => !0
+  ), { getRootNode: s } = nn();
+  if (be(() => {
+    o(() => e.container?.current);
+  }, [e.container]), a || r) return /* @__PURE__ */ U.jsx(U.Fragment, { children: t });
+  const f = n ?? Io(s);
+  return /* @__PURE__ */ U.jsx(U.Fragment, { children: Ct.map(t, (u) => _e.createPortal(u, f)) });
+}, Io = (e) => {
+  const t = e?.(), r = t.getRootNode();
+  return $n(r) ? r : Qe(t).body;
+}, $o = () => () => {
+};
+export {
+  Ko as A,
+  Co as B,
+  qo as P,
+  Qn as a,
+  Ft as b,
+  ke as c,
+  vo as d,
+  uo as e,
+  Wo as f,
+  Ot as g,
+  It as h,
+  Lt as i,
+  Mo as j,
+  kt as k,
+  Gt as l,
+  Jn as m,
+  zn as n,
+  Bt as o,
+  So as p,
+  nr as q,
+  _e as r,
+  Vt as s,
+  To as t,
+  nn as u,
+  et as v,
+  Ho as w,
+  Zn as x,
+  Xn as y,
+  zo as z
+};
+//# sourceMappingURL=portal-CtkZ5xTm.js.map