@televet/kibble-ui 4.0.0-beta.6 → 4.0.0-beta.60

package/dist/chunks/portal-D2KZrSzZ.js

@@ -0,0 +1,2301 @@
+import { b2 as mt, a6 as Je, T as pt, b3 as re, b4 as Oe, b5 as yt, b6 as ie, aF as He, b7 as ht, K as vt, a1 as xt, c as wt, al as bt, an as Ot, r as Re, e as Qe, E as St, b8 as Et, l as Rt, b9 as At, a7 as Tt, F as _t, ba as Pt, G as Nt } from "./index-C323eOJV.js";
+import Ze, { useMemo as Ct, useRef as L, useLayoutEffect as Dt, useEffect as se, useState as Ae, memo as Mt, forwardRef as Lt, createElement as kt, Children as et, isValidElement as $t, cloneElement as Vt, createContext as Ht, useContext as zt, useCallback as Ut, useSyncExternalStore as Ft } from "react";
+import { j as ue } from "./jsx-runtime-C5mzlN2N.js";
+var fe = { exports: {} }, N = {};
+/**
+ * @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 ze;
+function It() {
+  if (ze) return N;
+  ze = 1;
+  var e = Ze;
+  function t(u) {
+    var s = "https://react.dev/errors/" + u;
+    if (1 < arguments.length) {
+      s += "?args[]=" + encodeURIComponent(arguments[1]);
+      for (var g = 2; g < arguments.length; g++)
+        s += "&args[]=" + encodeURIComponent(arguments[g]);
+    }
+    return "Minified React error #" + u + "; visit " + s + " 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 c(u, s, g) {
+    var a = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+    return {
+      $$typeof: o,
+      key: a == null ? null : "" + a,
+      children: u,
+      containerInfo: s,
+      implementation: g
+    };
+  }
+  var l = e.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  function f(u, s) {
+    if (u === "font") return "";
+    if (typeof s == "string")
+      return s === "use-credentials" ? s : "";
+  }
+  return N.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = n, N.createPortal = function(u, s) {
+    var g = 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
+    if (!s || s.nodeType !== 1 && s.nodeType !== 9 && s.nodeType !== 11)
+      throw Error(t(299));
+    return c(u, s, null, g);
+  }, N.flushSync = function(u) {
+    var s = l.T, g = n.p;
+    try {
+      if (l.T = null, n.p = 2, u) return u();
+    } finally {
+      l.T = s, n.p = g, n.d.f();
+    }
+  }, N.preconnect = function(u, s) {
+    typeof u == "string" && (s ? (s = s.crossOrigin, s = typeof s == "string" ? s === "use-credentials" ? s : "" : void 0) : s = null, n.d.C(u, s));
+  }, N.prefetchDNS = function(u) {
+    typeof u == "string" && n.d.D(u);
+  }, N.preinit = function(u, s) {
+    if (typeof u == "string" && s && typeof s.as == "string") {
+      var g = s.as, a = f(g, s.crossOrigin), i = typeof s.integrity == "string" ? s.integrity : void 0, d = typeof s.fetchPriority == "string" ? s.fetchPriority : void 0;
+      g === "style" ? n.d.S(
+        u,
+        typeof s.precedence == "string" ? s.precedence : void 0,
+        {
+          crossOrigin: a,
+          integrity: i,
+          fetchPriority: d
+        }
+      ) : g === "script" && n.d.X(u, {
+        crossOrigin: a,
+        integrity: i,
+        fetchPriority: d,
+        nonce: typeof s.nonce == "string" ? s.nonce : void 0
+      });
+    }
+  }, N.preinitModule = function(u, s) {
+    if (typeof u == "string")
+      if (typeof s == "object" && s !== null) {
+        if (s.as == null || s.as === "script") {
+          var g = f(
+            s.as,
+            s.crossOrigin
+          );
+          n.d.M(u, {
+            crossOrigin: g,
+            integrity: typeof s.integrity == "string" ? s.integrity : void 0,
+            nonce: typeof s.nonce == "string" ? s.nonce : void 0
+          });
+        }
+      } else s == null && n.d.M(u);
+  }, N.preload = function(u, s) {
+    if (typeof u == "string" && typeof s == "object" && s !== null && typeof s.as == "string") {
+      var g = s.as, a = f(g, s.crossOrigin);
+      n.d.L(u, g, {
+        crossOrigin: a,
+        integrity: typeof s.integrity == "string" ? s.integrity : void 0,
+        nonce: typeof s.nonce == "string" ? s.nonce : void 0,
+        type: typeof s.type == "string" ? s.type : void 0,
+        fetchPriority: typeof s.fetchPriority == "string" ? s.fetchPriority : void 0,
+        referrerPolicy: typeof s.referrerPolicy == "string" ? s.referrerPolicy : void 0,
+        imageSrcSet: typeof s.imageSrcSet == "string" ? s.imageSrcSet : void 0,
+        imageSizes: typeof s.imageSizes == "string" ? s.imageSizes : void 0,
+        media: typeof s.media == "string" ? s.media : void 0
+      });
+    }
+  }, N.preloadModule = function(u, s) {
+    if (typeof u == "string")
+      if (s) {
+        var g = f(s.as, s.crossOrigin);
+        n.d.m(u, {
+          as: typeof s.as == "string" && s.as !== "script" ? s.as : void 0,
+          crossOrigin: g,
+          integrity: typeof s.integrity == "string" ? s.integrity : void 0
+        });
+      } else n.d.m(u);
+  }, N.requestFormReset = function(u) {
+    n.d.r(u);
+  }, N.unstable_batchedUpdates = function(u, s) {
+    return u(s);
+  }, N.useFormState = function(u, s, g) {
+    return l.H.useFormState(u, s, g);
+  }, N.useFormStatus = function() {
+    return l.H.useHostTransitionStatus();
+  }, N.version = "19.1.0", N;
+}
+var C = {};
+/**
+ * @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 Ue;
+function Wt() {
+  return Ue || (Ue = 1, process.env.NODE_ENV !== "production" && function() {
+    function e() {
+    }
+    function t(a) {
+      return "" + a;
+    }
+    function r(a, i, d) {
+      var m = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
+      try {
+        t(m);
+        var p = !1;
+      } catch {
+        p = !0;
+      }
+      return p && (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 && m[Symbol.toStringTag] || m.constructor.name || "Object"
+      ), t(m)), {
+        $$typeof: s,
+        key: m == null ? null : "" + m,
+        children: a,
+        containerInfo: i,
+        implementation: d
+      };
+    }
+    function n(a, i) {
+      if (a === "font") return "";
+      if (typeof i == "string")
+        return i === "use-credentials" ? i : "";
+    }
+    function o(a) {
+      return a === null ? "`null`" : a === void 0 ? "`undefined`" : a === "" ? "an empty string" : 'something with type "' + typeof a + '"';
+    }
+    function c(a) {
+      return a === null ? "`null`" : a === void 0 ? "`undefined`" : a === "" ? "an empty string" : typeof a == "string" ? JSON.stringify(a) : typeof a == "number" ? "`" + a + "`" : 'something with type "' + typeof a + '"';
+    }
+    function l() {
+      var a = g.H;
+      return a === 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.`
+      ), a;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var f = Ze, 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
+    }, s = Symbol.for("react.portal"), g = 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"
+    ), C.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = u, C.createPortal = function(a, 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(a, i, null, d);
+    }, C.flushSync = function(a) {
+      var i = g.T, d = u.p;
+      try {
+        if (g.T = null, u.p = 2, a)
+          return a();
+      } finally {
+        g.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."
+        );
+      }
+    }, C.preconnect = function(a, i) {
+      typeof a == "string" && a ? 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.",
+        c(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(a)
+      ), typeof a == "string" && (i ? (i = i.crossOrigin, i = typeof i == "string" ? i === "use-credentials" ? i : "" : void 0) : i = null, u.d.C(a, i));
+    }, C.prefetchDNS = function(a) {
+      if (typeof a != "string" || !a)
+        console.error(
+          "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          o(a)
+        );
+      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`.",
+          c(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`.",
+          c(i)
+        );
+      }
+      typeof a == "string" && u.d.D(a);
+    }, C.preinit = function(a, i) {
+      if (typeof a == "string" && a ? 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.",
+        c(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".',
+        c(i.as)
+      ) : console.error(
+        "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        o(a)
+      ), typeof a == "string" && i && typeof i.as == "string") {
+        var d = i.as, m = n(d, i.crossOrigin), p = typeof i.integrity == "string" ? i.integrity : void 0, y = typeof i.fetchPriority == "string" ? i.fetchPriority : void 0;
+        d === "style" ? u.d.S(
+          a,
+          typeof i.precedence == "string" ? i.precedence : void 0,
+          {
+            crossOrigin: m,
+            integrity: p,
+            fetchPriority: y
+          }
+        ) : d === "script" && u.d.X(a, {
+          crossOrigin: m,
+          integrity: p,
+          fetchPriority: y,
+          nonce: typeof i.nonce == "string" ? i.nonce : void 0
+        });
+      }
+    }, C.preinitModule = function(a, i) {
+      var d = "";
+      if (typeof a == "string" && a || (d += " The `href` argument encountered was " + o(a) + "."), 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 " + c(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 = c(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,
+              a
+            );
+        }
+      typeof a == "string" && (typeof i == "object" && i !== null ? (i.as == null || i.as === "script") && (d = n(
+        i.as,
+        i.crossOrigin
+      ), u.d.M(a, {
+        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(a));
+    }, C.preload = function(a, i) {
+      var d = "";
+      if (typeof a == "string" && a || (d += " The `href` argument encountered was " + o(a) + "."), 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 a == "string" && typeof i == "object" && i !== null && typeof i.as == "string") {
+        d = i.as;
+        var m = n(
+          d,
+          i.crossOrigin
+        );
+        u.d.L(a, d, {
+          crossOrigin: m,
+          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
+        });
+      }
+    }, C.preloadModule = function(a, i) {
+      var d = "";
+      typeof a == "string" && a || (d += " The `href` argument encountered was " + o(a) + "."), 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 a == "string" && (i ? (d = n(
+        i.as,
+        i.crossOrigin
+      ), u.d.m(a, {
+        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(a));
+    }, C.requestFormReset = function(a) {
+      u.d.r(a);
+    }, C.unstable_batchedUpdates = function(a, i) {
+      return a(i);
+    }, C.useFormState = function(a, i, d) {
+      return l().useFormState(a, i, d);
+    }, C.useFormStatus = function() {
+      return l().useHostTransitionStatus();
+    }, C.version = "19.1.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }()), C;
+}
+var Fe;
+function jt() {
+  if (Fe) return fe.exports;
+  Fe = 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(), fe.exports = It()) : fe.exports = Wt(), fe.exports;
+}
+var ve = jt();
+function Bt(e) {
+  return new Proxy({}, {
+    get(t, r) {
+      return r === "style" ? (n) => e({ style: n }).style : e;
+    }
+  });
+}
+var qt = () => (e) => Array.from(new Set(e)), tt = typeof globalThis.document < "u" ? Dt : se;
+function me(e) {
+  const t = e().value ?? e().defaultValue, r = e().isEqual ?? Object.is, [n] = Ae(t), [o, c] = Ae(n), l = e().value !== void 0, f = L(o);
+  f.current = l ? e().value : o;
+  const u = L(f.current);
+  tt(() => {
+    u.current = f.current;
+  }, [o, e().value]);
+  const s = (a) => {
+    const i = u.current, d = ie(a) ? a(i) : a;
+    e().debug && console.log(`[bindable > ${e().debug}] setValue`, { next: d, prev: i }), l || c(d), r(d, i) || e().onChange?.(d, i);
+  };
+  function g() {
+    return l ? e().value : o;
+  }
+  return {
+    initial: n,
+    ref: f,
+    get: g,
+    set(a) {
+      (e().sync ? ve.flushSync : yt)(() => s(a));
+    },
+    invoke(a, i) {
+      e().onChange?.(a, i);
+    },
+    hash(a) {
+      return e().hash?.(a) ?? String(a);
+    }
+  };
+}
+me.cleanup = (e) => {
+  se(() => e, []);
+};
+me.ref = (e) => {
+  const t = L(e);
+  return {
+    get: () => t.current,
+    set: (r) => {
+      t.current = r;
+    }
+  };
+};
+function Yt(e) {
+  const t = L(e);
+  return {
+    get(r) {
+      return t.current[r];
+    },
+    set(r, n) {
+      t.current[r] = n;
+    }
+  };
+}
+var Gt = (e, t) => {
+  const r = L(!1), n = L(!1);
+  se(() => {
+    if (r.current && n.current) return t();
+    n.current = !0;
+  }, [...(e ?? []).map((o) => typeof o == "function" ? o() : o)]), se(() => (r.current = !0, () => {
+    r.current = !1;
+  }), []);
+};
+function Kt(e, t = {}) {
+  const r = Ct(() => {
+    const { id: h, ids: x, getRootNode: R } = t;
+    return mt({ id: h, ids: x, getRootNode: R });
+  }, [t]), n = (...h) => {
+    e.debug && console.log(...h);
+  }, o = e.props?.({ props: Je(t), scope: r }) ?? t, c = Xt(o), l = e.context?.({
+    prop: c,
+    bindable: me,
+    scope: r,
+    flush: Ie,
+    getContext() {
+      return u;
+    },
+    getComputed() {
+      return S;
+    },
+    getRefs() {
+      return p;
+    }
+  }), f = nt(l), u = {
+    get(h) {
+      return f.current?.[h].ref.current;
+    },
+    set(h, x) {
+      f.current?.[h].set(x);
+    },
+    initial(h) {
+      return f.current?.[h].initial;
+    },
+    hash(h) {
+      const x = f.current?.[h].get();
+      return f.current?.[h].hash(x);
+    }
+  }, s = L(/* @__PURE__ */ new Map()), g = L(null), a = L(null), i = L({ type: "" }), d = () => ({
+    ...i.current,
+    current() {
+      return i.current;
+    },
+    previous() {
+      return a.current;
+    }
+  }), m = () => ({
+    ...A,
+    matches(...h) {
+      return h.includes(A.ref.current);
+    },
+    hasTag(h) {
+      return !!e.states[A.ref.current]?.tags?.includes(h);
+    }
+  }), p = Yt(e.refs?.({ prop: c, context: u }) ?? {}), y = () => ({
+    state: m(),
+    context: u,
+    event: d(),
+    prop: c,
+    send: M,
+    action: v,
+    guard: w,
+    track: Gt,
+    refs: p,
+    computed: S,
+    flush: Ie,
+    scope: r,
+    choose: E
+  }), v = (h) => {
+    const x = ie(h) ? h(y()) : h;
+    if (!x) return;
+    const R = x.map((O) => {
+      const T = e.implementations?.actions?.[O];
+      return T || He(`[zag-js] No implementation found for action "${JSON.stringify(O)}"`), T;
+    });
+    for (const O of R)
+      O?.(y());
+  }, w = (h) => ie(h) ? h(y()) : e.implementations?.guards?.[h](y()), b = (h) => {
+    const x = ie(h) ? h(y()) : h;
+    if (!x) return;
+    const R = x.map((T) => {
+      const P = e.implementations?.effects?.[T];
+      return P || He(`[zag-js] No implementation found for effect "${JSON.stringify(T)}"`), P;
+    }), O = [];
+    for (const T of R) {
+      const P = T?.(y());
+      P && O.push(P);
+    }
+    return () => O.forEach((T) => T?.());
+  }, E = (h) => ht(h).find((x) => {
+    let R = !x.guard;
+    return vt(x.guard) ? R = !!w(x.guard) : ie(x.guard) && (R = x.guard(y())), R;
+  }), S = (h) => {
+    pt(e.computed, () => "[zag-js] No computed object found on machine");
+    const x = e.computed[h];
+    return x({
+      context: u,
+      event: d(),
+      prop: c,
+      refs: p,
+      scope: r,
+      computed: S
+    });
+  }, A = me(() => ({
+    defaultValue: e.initialState({ prop: c }),
+    onChange(h, x) {
+      x && (s.current.get(x)?.(), s.current.delete(x)), x && v(e.states[x]?.exit), v(g.current?.actions);
+      const R = b(e.states[h]?.effects);
+      if (R && s.current.set(h, R), x === Oe) {
+        v(e.entry);
+        const O = b(e.effects);
+        O && s.current.set(Oe, O);
+      }
+      v(e.states[h]?.entry);
+    }
+  })), _ = L(void 0), D = L(re.NotStarted);
+  tt(() => {
+    queueMicrotask(() => {
+      const R = D.current === re.Started;
+      D.current = re.Started, n(R ? "rehydrating..." : "initializing...");
+      const O = _.current ?? A.initial;
+      A.invoke(O, R ? A.get() : Oe);
+    });
+    const h = s.current, x = A.ref.current;
+    return () => {
+      n("unmounting..."), _.current = x, D.current = re.Stopped, h.forEach((R) => R?.()), s.current = /* @__PURE__ */ new Map(), g.current = null, queueMicrotask(() => {
+        v(e.exit);
+      });
+    };
+  }, []);
+  const V = () => "ref" in A ? A.ref.current : A.get(), M = (h) => {
+    queueMicrotask(() => {
+      if (D.current !== re.Started) return;
+      a.current = i.current, i.current = h, n("send", h);
+      let x = V();
+      const R = (
+        // @ts-ignore
+        e.states[x].on?.[h.type] ?? // @ts-ignore
+        e.on?.[h.type]
+      ), O = E(R);
+      if (!O) return;
+      g.current = O;
+      const T = O.target ?? x;
+      n("transition", O);
+      const P = T !== x;
+      P ? ve.flushSync(() => A.set(T)) : O.reenter && !P ? A.invoke(x, x) : v(O.actions ?? []);
+    });
+  };
+  return e.watch?.(y()), {
+    state: m(),
+    send: M,
+    context: u,
+    prop: c,
+    scope: r,
+    refs: p,
+    computed: S,
+    event: d(),
+    getStatus: () => D.current
+  };
+}
+function nt(e) {
+  const t = L(e);
+  return t.current = e, t;
+}
+function Xt(e) {
+  const t = nt(e);
+  return function(n) {
+    return t.current[n];
+  };
+}
+function Ie(e) {
+  queueMicrotask(() => {
+    ve.flushSync(() => e());
+  });
+}
+var xr = Bt((e) => e);
+function Jt(...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 Qt(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 Se = (e) => {
+  const t = Mt(
+    Lt((r, n) => {
+      const { asChild: o, children: c, ...l } = r;
+      if (!o)
+        return kt(e, { ...l, ref: n }, c);
+      const f = et.only(c);
+      if (!$t(f))
+        return null;
+      const u = Qt(f);
+      return Vt(f, {
+        ...xt(l, f.props),
+        ref: n ? Jt(n, u) : u
+      });
+    })
+  );
+  return t.displayName = e.displayName || e.name, t;
+}, Zt = () => {
+  const e = /* @__PURE__ */ new Map();
+  return new Proxy(Se, {
+    apply(t, r, n) {
+      return Se(n[0]);
+    },
+    get(t, r) {
+      const n = r;
+      return e.has(n) || e.set(n, Se(n)), e.get(n);
+    }
+  });
+}, wr = Zt();
+function en(e, t) {
+  return `${e} returned \`undefined\`. Seems you forgot to wrap component within ${t}`;
+}
+function Ne(e = {}) {
+  const {
+    name: t,
+    strict: r = !0,
+    hookName: n = "useContext",
+    providerName: o = "Provider",
+    errorMessage: c,
+    defaultValue: l
+  } = e, f = Ht(l);
+  f.displayName = t;
+  function u() {
+    const s = zt(f);
+    if (!s && r) {
+      const g = new Error(c ?? en(n, o));
+      throw g.name = "ContextError", Error.captureStackTrace?.(g, u), g;
+    }
+    return s;
+  }
+  return [f.Provider, u, f];
+}
+const [br, Or] = Ne({
+  name: "PresenceContext",
+  hookName: "usePresenceContext",
+  providerName: "<PresenceProvider />"
+}), tn = () => (e, t) => t.reduce(
+  (r, n) => {
+    const [o, c] = r, l = n;
+    return c[l] !== void 0 && (o[l] = c[l]), delete c[l], [o, c];
+  },
+  [{}, { ...e }]
+), Sr = (e) => tn()(e, [
+  "immediate",
+  "lazyMount",
+  "onExitComplete",
+  "present",
+  "skipAnimationOnMount",
+  "unmountOnExit"
+]);
+function nn(e, t) {
+  const { state: r, send: n, context: o } = e, c = r.matches("mounted", "unmountSuspended");
+  return {
+    skip: !o.get("initial"),
+    present: c,
+    setNode(l) {
+      l && n({ type: "NODE.SET", node: l });
+    },
+    unmount() {
+      n({ type: "UNMOUNT" });
+    }
+  };
+}
+var rn = wt({
+  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", Qe(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 c = t.get("node");
+        if (!o && c?.ownerDocument.visibilityState === "hidden")
+          return r({ type: "UNMOUNT", src: "visibilitychange" });
+        Re(() => {
+          const l = de(t.get("styles"));
+          e.set("unmountAnimationName", l), l === "none" || l === 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 }) => {
+        Re(() => {
+          e.set("prevAnimationName", de(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", de(t.get("styles")));
+        }, c = (f) => {
+          const u = de(t.get("styles"));
+          St(f) === n && u === e.get("unmountAnimationName") && r({ type: "UNMOUNT", src: "animationend" });
+        };
+        n.addEventListener("animationstart", o), n.addEventListener("animationcancel", c), n.addEventListener("animationend", c);
+        const l = bt(n, { animationFillMode: "forwards" });
+        return () => {
+          n.removeEventListener("animationstart", o), n.removeEventListener("animationcancel", c), n.removeEventListener("animationend", c), Ot(() => l());
+        };
+      }
+    }
+  }
+});
+function de(e) {
+  return e?.animationName || "none";
+}
+qt()(["onExitComplete", "present", "immediate"]);
+function on(e, t = {}) {
+  const { sync: r = !1 } = t, n = sn(e);
+  return Ut(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    (...o) => r ? queueMicrotask(() => n.current?.(...o)) : n.current?.(...o),
+    [r, n]
+  );
+}
+function sn(e) {
+  const t = L(e);
+  return t.current = e, t;
+}
+const Er = (e = {}) => {
+  const { lazyMount: t, unmountOnExit: r, present: n, skipAnimationOnMount: o = !1, ...c } = e, l = L(!1), f = {
+    ...c,
+    present: n,
+    onExitComplete: on(e.onExitComplete)
+  }, u = Kt(rn, f), s = nn(u);
+  s.present && (l.current = !0);
+  const g = !s.present && !l.current && t || r && !s.present && l.current, a = () => ({
+    "data-state": s.skip && o ? void 0 : n ? "open" : "closed",
+    hidden: !s.present
+  });
+  return {
+    ref: s.setNode,
+    getPresenceProps: a,
+    present: s.present,
+    unmounted: g
+  };
+}, cn = ["top", "right", "bottom", "left"], X = Math.min, k = Math.max, pe = Math.round, ge = Math.floor, W = (e) => ({
+  x: e,
+  y: e
+}), an = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, ln = {
+  start: "end",
+  end: "start"
+};
+function Te(e, t, r) {
+  return k(e, X(t, r));
+}
+function Y(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function G(e) {
+  return e.split("-")[0];
+}
+function te(e) {
+  return e.split("-")[1];
+}
+function Ce(e) {
+  return e === "x" ? "y" : "x";
+}
+function De(e) {
+  return e === "y" ? "height" : "width";
+}
+function I(e) {
+  return ["top", "bottom"].includes(G(e)) ? "y" : "x";
+}
+function Me(e) {
+  return Ce(I(e));
+}
+function un(e, t, r) {
+  r === void 0 && (r = !1);
+  const n = te(e), o = Me(e), c = De(o);
+  let l = o === "x" ? n === (r ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[c] > t.floating[c] && (l = ye(l)), [l, ye(l)];
+}
+function fn(e) {
+  const t = ye(e);
+  return [_e(e), t, _e(t)];
+}
+function _e(e) {
+  return e.replace(/start|end/g, (t) => ln[t]);
+}
+function dn(e, t, r) {
+  const n = ["left", "right"], o = ["right", "left"], c = ["top", "bottom"], l = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return r ? t ? o : n : t ? n : o;
+    case "left":
+    case "right":
+      return t ? c : l;
+    default:
+      return [];
+  }
+}
+function gn(e, t, r, n) {
+  const o = te(e);
+  let c = dn(G(e), r === "start", n);
+  return o && (c = c.map((l) => l + "-" + o), t && (c = c.concat(c.map(_e)))), c;
+}
+function ye(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => an[t]);
+}
+function mn(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function rt(e) {
+  return typeof e != "number" ? mn(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function he(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 We(e, t, r) {
+  let {
+    reference: n,
+    floating: o
+  } = e;
+  const c = I(t), l = Me(t), f = De(l), u = G(t), s = c === "y", g = n.x + n.width / 2 - o.width / 2, a = n.y + n.height / 2 - o.height / 2, i = n[f] / 2 - o[f] / 2;
+  let d;
+  switch (u) {
+    case "top":
+      d = {
+        x: g,
+        y: n.y - o.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: g,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: a
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - o.width,
+        y: a
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (te(t)) {
+    case "start":
+      d[l] -= i * (r && s ? -1 : 1);
+      break;
+    case "end":
+      d[l] += i * (r && s ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const pn = async (e, t, r) => {
+  const {
+    placement: n = "bottom",
+    strategy: o = "absolute",
+    middleware: c = [],
+    platform: l
+  } = r, f = c.filter(Boolean), u = await (l.isRTL == null ? void 0 : l.isRTL(t));
+  let s = await l.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: g,
+    y: a
+  } = We(s, n, u), i = n, d = {}, m = 0;
+  for (let p = 0; p < f.length; p++) {
+    const {
+      name: y,
+      fn: v
+    } = f[p], {
+      x: w,
+      y: b,
+      data: E,
+      reset: S
+    } = await v({
+      x: g,
+      y: a,
+      initialPlacement: n,
+      placement: i,
+      strategy: o,
+      middlewareData: d,
+      rects: s,
+      platform: l,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    g = w ?? g, a = b ?? a, d = {
+      ...d,
+      [y]: {
+        ...d[y],
+        ...E
+      }
+    }, S && m <= 50 && (m++, typeof S == "object" && (S.placement && (i = S.placement), S.rects && (s = S.rects === !0 ? await l.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : S.rects), {
+      x: g,
+      y: a
+    } = We(s, i, u)), p = -1);
+  }
+  return {
+    x: g,
+    y: a,
+    placement: i,
+    strategy: o,
+    middlewareData: d
+  };
+};
+async function ce(e, t) {
+  var r;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: o,
+    platform: c,
+    rects: l,
+    elements: f,
+    strategy: u
+  } = e, {
+    boundary: s = "clippingAncestors",
+    rootBoundary: g = "viewport",
+    elementContext: a = "floating",
+    altBoundary: i = !1,
+    padding: d = 0
+  } = Y(t, e), m = rt(d), y = f[i ? a === "floating" ? "reference" : "floating" : a], v = he(await c.getClippingRect({
+    element: (r = await (c.isElement == null ? void 0 : c.isElement(y))) == null || r ? y : y.contextElement || await (c.getDocumentElement == null ? void 0 : c.getDocumentElement(f.floating)),
+    boundary: s,
+    rootBoundary: g,
+    strategy: u
+  })), w = a === "floating" ? {
+    x: n,
+    y: o,
+    width: l.floating.width,
+    height: l.floating.height
+  } : l.reference, b = await (c.getOffsetParent == null ? void 0 : c.getOffsetParent(f.floating)), E = await (c.isElement == null ? void 0 : c.isElement(b)) ? await (c.getScale == null ? void 0 : c.getScale(b)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, S = he(c.convertOffsetParentRelativeRectToViewportRelativeRect ? await c.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: f,
+    rect: w,
+    offsetParent: b,
+    strategy: u
+  }) : w);
+  return {
+    top: (v.top - S.top + m.top) / E.y,
+    bottom: (S.bottom - v.bottom + m.bottom) / E.y,
+    left: (v.left - S.left + m.left) / E.x,
+    right: (S.right - v.right + m.right) / E.x
+  };
+}
+const yn = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: r,
+      y: n,
+      placement: o,
+      rects: c,
+      platform: l,
+      elements: f,
+      middlewareData: u
+    } = t, {
+      element: s,
+      padding: g = 0
+    } = Y(e, t) || {};
+    if (s == null)
+      return {};
+    const a = rt(g), i = {
+      x: r,
+      y: n
+    }, d = Me(o), m = De(d), p = await l.getDimensions(s), y = d === "y", v = y ? "top" : "left", w = y ? "bottom" : "right", b = y ? "clientHeight" : "clientWidth", E = c.reference[m] + c.reference[d] - i[d] - c.floating[m], S = i[d] - c.reference[d], A = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(s));
+    let _ = A ? A[b] : 0;
+    (!_ || !await (l.isElement == null ? void 0 : l.isElement(A))) && (_ = f.floating[b] || c.floating[m]);
+    const D = E / 2 - S / 2, V = _ / 2 - p[m] / 2 - 1, M = X(a[v], V), h = X(a[w], V), x = M, R = _ - p[m] - h, O = _ / 2 - p[m] / 2 + D, T = Te(x, O, R), P = !u.arrow && te(o) != null && O !== T && c.reference[m] / 2 - (O < x ? M : h) - p[m] / 2 < 0, H = P ? O < x ? O - x : O - R : 0;
+    return {
+      [d]: i[d] + H,
+      data: {
+        [d]: T,
+        centerOffset: O - T - H,
+        ...P && {
+          alignmentOffset: H
+        }
+      },
+      reset: P
+    };
+  }
+}), hn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: o,
+        middlewareData: c,
+        rects: l,
+        initialPlacement: f,
+        platform: u,
+        elements: s
+      } = t, {
+        mainAxis: g = !0,
+        crossAxis: a = !0,
+        fallbackPlacements: i,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: p = !0,
+        ...y
+      } = Y(e, t);
+      if ((r = c.arrow) != null && r.alignmentOffset)
+        return {};
+      const v = G(o), w = I(f), b = G(f) === f, E = await (u.isRTL == null ? void 0 : u.isRTL(s.floating)), S = i || (b || !p ? [ye(f)] : fn(f)), A = m !== "none";
+      !i && A && S.push(...gn(f, p, m, E));
+      const _ = [f, ...S], D = await ce(t, y), V = [];
+      let M = ((n = c.flip) == null ? void 0 : n.overflows) || [];
+      if (g && V.push(D[v]), a) {
+        const O = un(o, l, E);
+        V.push(D[O[0]], D[O[1]]);
+      }
+      if (M = [...M, {
+        placement: o,
+        overflows: V
+      }], !V.every((O) => O <= 0)) {
+        var h, x;
+        const O = (((h = c.flip) == null ? void 0 : h.index) || 0) + 1, T = _[O];
+        if (T && (!(a === "alignment" ? w !== I(T) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        M.every((z) => z.overflows[0] > 0 && I(z.placement) === w)))
+          return {
+            data: {
+              index: O,
+              overflows: M
+            },
+            reset: {
+              placement: T
+            }
+          };
+        let P = (x = M.filter((H) => H.overflows[0] <= 0).sort((H, z) => H.overflows[1] - z.overflows[1])[0]) == null ? void 0 : x.placement;
+        if (!P)
+          switch (d) {
+            case "bestFit": {
+              var R;
+              const H = (R = M.filter((z) => {
+                if (A) {
+                  const K = I(z.placement);
+                  return K === w || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  K === "y";
+                }
+                return !0;
+              }).map((z) => [z.placement, z.overflows.filter((K) => K > 0).reduce((K, gt) => K + gt, 0)]).sort((z, K) => z[1] - K[1])[0]) == null ? void 0 : R[0];
+              H && (P = H);
+              break;
+            }
+            case "initialPlacement":
+              P = f;
+              break;
+          }
+        if (o !== P)
+          return {
+            reset: {
+              placement: P
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function je(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function Be(e) {
+  return cn.some((t) => e[t] >= 0);
+}
+const vn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: r
+      } = t, {
+        strategy: n = "referenceHidden",
+        ...o
+      } = Y(e, t);
+      switch (n) {
+        case "referenceHidden": {
+          const c = await ce(t, {
+            ...o,
+            elementContext: "reference"
+          }), l = je(c, r.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: l,
+              referenceHidden: Be(l)
+            }
+          };
+        }
+        case "escaped": {
+          const c = await ce(t, {
+            ...o,
+            altBoundary: !0
+          }), l = je(c, r.floating);
+          return {
+            data: {
+              escapedOffsets: l,
+              escaped: Be(l)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function xn(e, t) {
+  const {
+    placement: r,
+    platform: n,
+    elements: o
+  } = e, c = await (n.isRTL == null ? void 0 : n.isRTL(o.floating)), l = G(r), f = te(r), u = I(r) === "y", s = ["left", "top"].includes(l) ? -1 : 1, g = c && u ? -1 : 1, a = Y(t, e);
+  let {
+    mainAxis: i,
+    crossAxis: d,
+    alignmentAxis: m
+  } = typeof a == "number" ? {
+    mainAxis: a,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: a.mainAxis || 0,
+    crossAxis: a.crossAxis || 0,
+    alignmentAxis: a.alignmentAxis
+  };
+  return f && typeof m == "number" && (d = f === "end" ? m * -1 : m), u ? {
+    x: d * g,
+    y: i * s
+  } : {
+    x: i * s,
+    y: d * g
+  };
+}
+const wn = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        x: o,
+        y: c,
+        placement: l,
+        middlewareData: f
+      } = t, u = await xn(t, e);
+      return l === ((r = f.offset) == null ? void 0 : r.placement) && (n = f.arrow) != null && n.alignmentOffset ? {} : {
+        x: o + u.x,
+        y: c + u.y,
+        data: {
+          ...u,
+          placement: l
+        }
+      };
+    }
+  };
+}, bn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: r,
+        y: n,
+        placement: o
+      } = t, {
+        mainAxis: c = !0,
+        crossAxis: l = !1,
+        limiter: f = {
+          fn: (y) => {
+            let {
+              x: v,
+              y: w
+            } = y;
+            return {
+              x: v,
+              y: w
+            };
+          }
+        },
+        ...u
+      } = Y(e, t), s = {
+        x: r,
+        y: n
+      }, g = await ce(t, u), a = I(G(o)), i = Ce(a);
+      let d = s[i], m = s[a];
+      if (c) {
+        const y = i === "y" ? "top" : "left", v = i === "y" ? "bottom" : "right", w = d + g[y], b = d - g[v];
+        d = Te(w, d, b);
+      }
+      if (l) {
+        const y = a === "y" ? "top" : "left", v = a === "y" ? "bottom" : "right", w = m + g[y], b = m - g[v];
+        m = Te(w, m, b);
+      }
+      const p = f.fn({
+        ...t,
+        [i]: d,
+        [a]: m
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - r,
+          y: p.y - n,
+          enabled: {
+            [i]: c,
+            [a]: l
+          }
+        }
+      };
+    }
+  };
+}, On = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: r,
+        y: n,
+        placement: o,
+        rects: c,
+        middlewareData: l
+      } = t, {
+        offset: f = 0,
+        mainAxis: u = !0,
+        crossAxis: s = !0
+      } = Y(e, t), g = {
+        x: r,
+        y: n
+      }, a = I(o), i = Ce(a);
+      let d = g[i], m = g[a];
+      const p = Y(f, t), y = typeof p == "number" ? {
+        mainAxis: p,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...p
+      };
+      if (u) {
+        const b = i === "y" ? "height" : "width", E = c.reference[i] - c.floating[b] + y.mainAxis, S = c.reference[i] + c.reference[b] - y.mainAxis;
+        d < E ? d = E : d > S && (d = S);
+      }
+      if (s) {
+        var v, w;
+        const b = i === "y" ? "width" : "height", E = ["top", "left"].includes(G(o)), S = c.reference[a] - c.floating[b] + (E && ((v = l.offset) == null ? void 0 : v[a]) || 0) + (E ? 0 : y.crossAxis), A = c.reference[a] + c.reference[b] + (E ? 0 : ((w = l.offset) == null ? void 0 : w[a]) || 0) - (E ? y.crossAxis : 0);
+        m < S ? m = S : m > A && (m = A);
+      }
+      return {
+        [i]: d,
+        [a]: m
+      };
+    }
+  };
+}, Sn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: o,
+        rects: c,
+        platform: l,
+        elements: f
+      } = t, {
+        apply: u = () => {
+        },
+        ...s
+      } = Y(e, t), g = await ce(t, s), a = G(o), i = te(o), d = I(o) === "y", {
+        width: m,
+        height: p
+      } = c.floating;
+      let y, v;
+      a === "top" || a === "bottom" ? (y = a, v = i === (await (l.isRTL == null ? void 0 : l.isRTL(f.floating)) ? "start" : "end") ? "left" : "right") : (v = a, y = i === "end" ? "top" : "bottom");
+      const w = p - g.top - g.bottom, b = m - g.left - g.right, E = X(p - g[y], w), S = X(m - g[v], b), A = !t.middlewareData.shift;
+      let _ = E, D = S;
+      if ((r = t.middlewareData.shift) != null && r.enabled.x && (D = b), (n = t.middlewareData.shift) != null && n.enabled.y && (_ = w), A && !i) {
+        const M = k(g.left, 0), h = k(g.right, 0), x = k(g.top, 0), R = k(g.bottom, 0);
+        d ? D = m - 2 * (M !== 0 || h !== 0 ? M + h : k(g.left, g.right)) : _ = p - 2 * (x !== 0 || R !== 0 ? x + R : k(g.top, g.bottom));
+      }
+      await u({
+        ...t,
+        availableWidth: D,
+        availableHeight: _
+      });
+      const V = await l.getDimensions(f.floating);
+      return m !== V.width || p !== V.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function xe() {
+  return typeof window < "u";
+}
+function ne(e) {
+  return ot(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function $(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function B(e) {
+  var t;
+  return (t = (ot(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function ot(e) {
+  return xe() ? e instanceof Node || e instanceof $(e).Node : !1;
+}
+function U(e) {
+  return xe() ? e instanceof Element || e instanceof $(e).Element : !1;
+}
+function j(e) {
+  return xe() ? e instanceof HTMLElement || e instanceof $(e).HTMLElement : !1;
+}
+function qe(e) {
+  return !xe() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof $(e).ShadowRoot;
+}
+function le(e) {
+  const {
+    overflow: t,
+    overflowX: r,
+    overflowY: n,
+    display: o
+  } = F(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + n + r) && !["inline", "contents"].includes(o);
+}
+function En(e) {
+  return ["table", "td", "th"].includes(ne(e));
+}
+function we(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Le(e) {
+  const t = ke(), r = U(e) ? F(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 Rn(e) {
+  let t = J(e);
+  for (; j(t) && !ee(t); ) {
+    if (Le(t))
+      return t;
+    if (we(t))
+      return null;
+    t = J(t);
+  }
+  return null;
+}
+function ke() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ee(e) {
+  return ["html", "body", "#document"].includes(ne(e));
+}
+function F(e) {
+  return $(e).getComputedStyle(e);
+}
+function be(e) {
+  return U(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function J(e) {
+  if (ne(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.
+    qe(e) && e.host || // Fallback.
+    B(e)
+  );
+  return qe(t) ? t.host : t;
+}
+function it(e) {
+  const t = J(e);
+  return ee(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : j(t) && le(t) ? t : it(t);
+}
+function ae(e, t, r) {
+  var n;
+  t === void 0 && (t = []), r === void 0 && (r = !0);
+  const o = it(e), c = o === ((n = e.ownerDocument) == null ? void 0 : n.body), l = $(o);
+  if (c) {
+    const f = Pe(l);
+    return t.concat(l, l.visualViewport || [], le(o) ? o : [], f && r ? ae(f) : []);
+  }
+  return t.concat(o, ae(o, [], r));
+}
+function Pe(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function st(e) {
+  const t = F(e);
+  let r = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const o = j(e), c = o ? e.offsetWidth : r, l = o ? e.offsetHeight : n, f = pe(r) !== c || pe(n) !== l;
+  return f && (r = c, n = l), {
+    width: r,
+    height: n,
+    $: f
+  };
+}
+function $e(e) {
+  return U(e) ? e : e.contextElement;
+}
+function Z(e) {
+  const t = $e(e);
+  if (!j(t))
+    return W(1);
+  const r = t.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: c
+  } = st(t);
+  let l = (c ? pe(r.width) : r.width) / n, f = (c ? pe(r.height) : r.height) / o;
+  return (!l || !Number.isFinite(l)) && (l = 1), (!f || !Number.isFinite(f)) && (f = 1), {
+    x: l,
+    y: f
+  };
+}
+const An = /* @__PURE__ */ W(0);
+function ct(e) {
+  const t = $(e);
+  return !ke() || !t.visualViewport ? An : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Tn(e, t, r) {
+  return t === void 0 && (t = !1), !r || t && r !== $(e) ? !1 : t;
+}
+function Q(e, t, r, n) {
+  t === void 0 && (t = !1), r === void 0 && (r = !1);
+  const o = e.getBoundingClientRect(), c = $e(e);
+  let l = W(1);
+  t && (n ? U(n) && (l = Z(n)) : l = Z(e));
+  const f = Tn(c, r, n) ? ct(c) : W(0);
+  let u = (o.left + f.x) / l.x, s = (o.top + f.y) / l.y, g = o.width / l.x, a = o.height / l.y;
+  if (c) {
+    const i = $(c), d = n && U(n) ? $(n) : n;
+    let m = i, p = Pe(m);
+    for (; p && n && d !== m; ) {
+      const y = Z(p), v = p.getBoundingClientRect(), w = F(p), b = v.left + (p.clientLeft + parseFloat(w.paddingLeft)) * y.x, E = v.top + (p.clientTop + parseFloat(w.paddingTop)) * y.y;
+      u *= y.x, s *= y.y, g *= y.x, a *= y.y, u += b, s += E, m = $(p), p = Pe(m);
+    }
+  }
+  return he({
+    width: g,
+    height: a,
+    x: u,
+    y: s
+  });
+}
+function Ve(e, t) {
+  const r = be(e).scrollLeft;
+  return t ? t.left + r : Q(B(e)).left + r;
+}
+function at(e, t, r) {
+  r === void 0 && (r = !1);
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - (r ? 0 : (
+    // RTL <body> scrollbar.
+    Ve(e, n)
+  )), c = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: c
+  };
+}
+function _n(e) {
+  let {
+    elements: t,
+    rect: r,
+    offsetParent: n,
+    strategy: o
+  } = e;
+  const c = o === "fixed", l = B(n), f = t ? we(t.floating) : !1;
+  if (n === l || f && c)
+    return r;
+  let u = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, s = W(1);
+  const g = W(0), a = j(n);
+  if ((a || !a && !c) && ((ne(n) !== "body" || le(l)) && (u = be(n)), j(n))) {
+    const d = Q(n);
+    s = Z(n), g.x = d.x + n.clientLeft, g.y = d.y + n.clientTop;
+  }
+  const i = l && !a && !c ? at(l, u, !0) : W(0);
+  return {
+    width: r.width * s.x,
+    height: r.height * s.y,
+    x: r.x * s.x - u.scrollLeft * s.x + g.x + i.x,
+    y: r.y * s.y - u.scrollTop * s.y + g.y + i.y
+  };
+}
+function Pn(e) {
+  return Array.from(e.getClientRects());
+}
+function Nn(e) {
+  const t = B(e), r = be(e), n = e.ownerDocument.body, o = k(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), c = k(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let l = -r.scrollLeft + Ve(e);
+  const f = -r.scrollTop;
+  return F(n).direction === "rtl" && (l += k(t.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: c,
+    x: l,
+    y: f
+  };
+}
+function Cn(e, t) {
+  const r = $(e), n = B(e), o = r.visualViewport;
+  let c = n.clientWidth, l = n.clientHeight, f = 0, u = 0;
+  if (o) {
+    c = o.width, l = o.height;
+    const s = ke();
+    (!s || s && t === "fixed") && (f = o.offsetLeft, u = o.offsetTop);
+  }
+  return {
+    width: c,
+    height: l,
+    x: f,
+    y: u
+  };
+}
+function Dn(e, t) {
+  const r = Q(e, !0, t === "fixed"), n = r.top + e.clientTop, o = r.left + e.clientLeft, c = j(e) ? Z(e) : W(1), l = e.clientWidth * c.x, f = e.clientHeight * c.y, u = o * c.x, s = n * c.y;
+  return {
+    width: l,
+    height: f,
+    x: u,
+    y: s
+  };
+}
+function Ye(e, t, r) {
+  let n;
+  if (t === "viewport")
+    n = Cn(e, r);
+  else if (t === "document")
+    n = Nn(B(e));
+  else if (U(t))
+    n = Dn(t, r);
+  else {
+    const o = ct(e);
+    n = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return he(n);
+}
+function lt(e, t) {
+  const r = J(e);
+  return r === t || !U(r) || ee(r) ? !1 : F(r).position === "fixed" || lt(r, t);
+}
+function Mn(e, t) {
+  const r = t.get(e);
+  if (r)
+    return r;
+  let n = ae(e, [], !1).filter((f) => U(f) && ne(f) !== "body"), o = null;
+  const c = F(e).position === "fixed";
+  let l = c ? J(e) : e;
+  for (; U(l) && !ee(l); ) {
+    const f = F(l), u = Le(l);
+    !u && f.position === "fixed" && (o = null), (c ? !u && !o : !u && f.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || le(l) && !u && lt(e, l)) ? n = n.filter((g) => g !== l) : o = f, l = J(l);
+  }
+  return t.set(e, n), n;
+}
+function Ln(e) {
+  let {
+    element: t,
+    boundary: r,
+    rootBoundary: n,
+    strategy: o
+  } = e;
+  const l = [...r === "clippingAncestors" ? we(t) ? [] : Mn(t, this._c) : [].concat(r), n], f = l[0], u = l.reduce((s, g) => {
+    const a = Ye(t, g, o);
+    return s.top = k(a.top, s.top), s.right = X(a.right, s.right), s.bottom = X(a.bottom, s.bottom), s.left = k(a.left, s.left), s;
+  }, Ye(t, f, o));
+  return {
+    width: u.right - u.left,
+    height: u.bottom - u.top,
+    x: u.left,
+    y: u.top
+  };
+}
+function kn(e) {
+  const {
+    width: t,
+    height: r
+  } = st(e);
+  return {
+    width: t,
+    height: r
+  };
+}
+function $n(e, t, r) {
+  const n = j(t), o = B(t), c = r === "fixed", l = Q(e, !0, c, t);
+  let f = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const u = W(0);
+  if (n || !n && !c)
+    if ((ne(t) !== "body" || le(o)) && (f = be(t)), n) {
+      const i = Q(t, !0, c, t);
+      u.x = i.x + t.clientLeft, u.y = i.y + t.clientTop;
+    } else o && (u.x = Ve(o));
+  const s = o && !n && !c ? at(o, f) : W(0), g = l.left + f.scrollLeft - u.x - s.x, a = l.top + f.scrollTop - u.y - s.y;
+  return {
+    x: g,
+    y: a,
+    width: l.width,
+    height: l.height
+  };
+}
+function Ee(e) {
+  return F(e).position === "static";
+}
+function Ge(e, t) {
+  if (!j(e) || F(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let r = e.offsetParent;
+  return B(e) === r && (r = r.ownerDocument.body), r;
+}
+function ut(e, t) {
+  const r = $(e);
+  if (we(e))
+    return r;
+  if (!j(e)) {
+    let o = J(e);
+    for (; o && !ee(o); ) {
+      if (U(o) && !Ee(o))
+        return o;
+      o = J(o);
+    }
+    return r;
+  }
+  let n = Ge(e, t);
+  for (; n && En(n) && Ee(n); )
+    n = Ge(n, t);
+  return n && ee(n) && Ee(n) && !Le(n) ? r : n || Rn(e) || r;
+}
+const Vn = async function(e) {
+  const t = this.getOffsetParent || ut, r = this.getDimensions, n = await r(e.floating);
+  return {
+    reference: $n(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function Hn(e) {
+  return F(e).direction === "rtl";
+}
+const zn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: _n,
+  getDocumentElement: B,
+  getClippingRect: Ln,
+  getOffsetParent: ut,
+  getElementRects: Vn,
+  getClientRects: Pn,
+  getDimensions: kn,
+  getScale: Z,
+  isElement: U,
+  isRTL: Hn
+};
+function ft(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Un(e, t) {
+  let r = null, n;
+  const o = B(e);
+  function c() {
+    var f;
+    clearTimeout(n), (f = r) == null || f.disconnect(), r = null;
+  }
+  function l(f, u) {
+    f === void 0 && (f = !1), u === void 0 && (u = 1), c();
+    const s = e.getBoundingClientRect(), {
+      left: g,
+      top: a,
+      width: i,
+      height: d
+    } = s;
+    if (f || t(), !i || !d)
+      return;
+    const m = ge(a), p = ge(o.clientWidth - (g + i)), y = ge(o.clientHeight - (a + d)), v = ge(g), b = {
+      rootMargin: -m + "px " + -p + "px " + -y + "px " + -v + "px",
+      threshold: k(0, X(1, u)) || 1
+    };
+    let E = !0;
+    function S(A) {
+      const _ = A[0].intersectionRatio;
+      if (_ !== u) {
+        if (!E)
+          return l();
+        _ ? l(!1, _) : n = setTimeout(() => {
+          l(!1, 1e-7);
+        }, 1e3);
+      }
+      _ === 1 && !ft(s, e.getBoundingClientRect()) && l(), E = !1;
+    }
+    try {
+      r = new IntersectionObserver(S, {
+        ...b,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      r = new IntersectionObserver(S, b);
+    }
+    r.observe(e);
+  }
+  return l(!0), c;
+}
+function Fn(e, t, r, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: c = !0,
+    elementResize: l = typeof ResizeObserver == "function",
+    layoutShift: f = typeof IntersectionObserver == "function",
+    animationFrame: u = !1
+  } = n, s = $e(e), g = o || c ? [...s ? ae(s) : [], ...ae(t)] : [];
+  g.forEach((v) => {
+    o && v.addEventListener("scroll", r, {
+      passive: !0
+    }), c && v.addEventListener("resize", r);
+  });
+  const a = s && f ? Un(s, r) : null;
+  let i = -1, d = null;
+  l && (d = new ResizeObserver((v) => {
+    let [w] = v;
+    w && w.target === s && d && (d.unobserve(t), cancelAnimationFrame(i), i = requestAnimationFrame(() => {
+      var b;
+      (b = d) == null || b.observe(t);
+    })), r();
+  }), s && !u && d.observe(s), d.observe(t));
+  let m, p = u ? Q(e) : null;
+  u && y();
+  function y() {
+    const v = Q(e);
+    p && !ft(p, v) && r(), p = v, m = requestAnimationFrame(y);
+  }
+  return r(), () => {
+    var v;
+    g.forEach((w) => {
+      o && w.removeEventListener("scroll", r), c && w.removeEventListener("resize", r);
+    }), a?.(), (v = d) == null || v.disconnect(), d = null, u && cancelAnimationFrame(m);
+  };
+}
+const In = wn, Wn = bn, jn = hn, Bn = Sn, qn = vn, Yn = yn, Gn = On, Kn = (e, t, r) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: zn,
+    ...r
+  }, c = {
+    ...o.platform,
+    _c: n
+  };
+  return pn(e, t, {
+    ...o,
+    platform: c
+  });
+};
+function Ke(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 Xn(e) {
+  if (!e) return Ke();
+  const { x: t, y: r, width: n, height: o } = e;
+  return Ke(t, r, n, o);
+}
+function Jn(e, t) {
+  return {
+    contextElement: Rt(e) ? e : void 0,
+    getBoundingClientRect: () => {
+      const r = e, n = t?.(r);
+      return n || !r ? Xn(n) : r.getBoundingClientRect();
+    }
+  };
+}
+var oe = (e) => ({ variable: e, reference: `var(${e})` }), q = {
+  arrowSize: oe("--arrow-size"),
+  arrowSizeHalf: oe("--arrow-size-half"),
+  arrowBg: oe("--arrow-background"),
+  transformOrigin: oe("--transform-origin"),
+  arrowOffset: oe("--arrow-offset")
+}, Qn = (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"
+}), Zn = {
+  name: "transformOrigin",
+  fn({ placement: e, elements: t, middlewareData: r }) {
+    const { arrow: n } = r, o = Qn(n)[e], { floating: c } = t;
+    return c.style.setProperty(q.transformOrigin.variable, o), {
+      data: { transformOrigin: o }
+    };
+  }
+}, er = {
+  name: "rects",
+  fn({ rects: e }) {
+    return {
+      data: e
+    };
+  }
+}, tr = (e) => {
+  if (e)
+    return {
+      name: "shiftArrow",
+      fn({ placement: t, middlewareData: r }) {
+        if (!r.arrow) return {};
+        const { x: n, y: o } = r.arrow, c = t.split("-")[0];
+        return Object.assign(e.style, {
+          left: n != null ? `${n}px` : "",
+          top: o != null ? `${o}px` : "",
+          [c]: `calc(100% + ${q.arrowOffset.reference})`
+        }), {};
+      }
+    };
+};
+function nr(e) {
+  const [t, r] = e.split("-");
+  return { side: t, align: r, hasAlign: r != null };
+}
+function Rr(e) {
+  return e.split("-")[0];
+}
+var rr = {
+  strategy: "absolute",
+  placement: "bottom",
+  listeners: !0,
+  gutter: 8,
+  flip: !0,
+  slide: !0,
+  overlap: !1,
+  sameWidth: !1,
+  fitViewport: !1,
+  overflowPadding: 8,
+  arrowPadding: 4
+};
+function Xe(e, t) {
+  const r = e.devicePixelRatio || 1;
+  return Math.round(t * r) / r;
+}
+function dt(e) {
+  return Tt(e.boundary);
+}
+function or(e, t) {
+  if (e)
+    return Yn({
+      element: e,
+      padding: t.arrowPadding
+    });
+}
+function ir(e, t) {
+  if (!At(t.offset ?? t.gutter))
+    return In(({ placement: r }) => {
+      const n = (e?.clientHeight || 0) / 2, o = t.offset?.mainAxis ?? t.gutter, c = typeof o == "number" ? o + n : o ?? n, { hasAlign: l } = nr(r), f = l ? void 0 : t.shift, u = t.offset?.crossAxis ?? f;
+      return Je({
+        crossAxis: u,
+        mainAxis: c,
+        alignmentAxis: t.shift
+      });
+    });
+}
+function sr(e) {
+  if (e.flip)
+    return jn({
+      boundary: dt(e),
+      padding: e.overflowPadding,
+      fallbackPlacements: e.flip === !0 ? void 0 : e.flip
+    });
+}
+function cr(e) {
+  if (!(!e.slide && !e.overlap))
+    return Wn({
+      boundary: dt(e),
+      mainAxis: e.slide,
+      crossAxis: e.overlap,
+      padding: e.overflowPadding,
+      limiter: Gn()
+    });
+}
+function ar(e) {
+  return Bn({
+    padding: e.overflowPadding,
+    apply({ elements: t, rects: r, availableHeight: n, availableWidth: o }) {
+      const c = t.floating, l = Math.round(r.reference.width);
+      o = Math.floor(o), n = Math.floor(n), c.style.setProperty("--reference-width", `${l}px`), c.style.setProperty("--available-width", `${o}px`), c.style.setProperty("--available-height", `${n}px`);
+    }
+  });
+}
+function lr(e) {
+  if (e.hideWhenDetached)
+    return qn({ strategy: "referenceHidden", boundary: e.boundary?.() ?? "clippingAncestors" });
+}
+function ur(e) {
+  return e ? e === !0 ? { ancestorResize: !0, ancestorScroll: !0, elementResize: !0, layoutShift: !0 } : e : {};
+}
+function fr(e, t, r = {}) {
+  const n = Jn(e, r.getAnchorRect);
+  if (!t || !n) return;
+  const o = Object.assign({}, rr, r), c = t.querySelector("[data-part=arrow]"), l = [
+    ir(c, o),
+    sr(o),
+    cr(o),
+    or(c, o),
+    tr(c),
+    Zn,
+    ar(o),
+    lr(o),
+    er
+  ], { placement: f, strategy: u, onComplete: s, onPositioned: g } = o, a = async () => {
+    if (!n || !t) return;
+    const p = await Kn(n, t, {
+      placement: f,
+      middleware: l,
+      strategy: u
+    });
+    s?.(p), g?.({ placed: !0 });
+    const y = _t(t), v = Xe(y, p.x), w = Xe(y, p.y);
+    t.style.setProperty("--x", `${v}px`), t.style.setProperty("--y", `${w}px`), o.hideWhenDetached && (p.middlewareData.hide?.referenceHidden ? (t.style.setProperty("visibility", "hidden"), t.style.setProperty("pointer-events", "none")) : (t.style.removeProperty("visibility"), t.style.removeProperty("pointer-events")));
+    const b = t.firstElementChild;
+    if (b) {
+      const E = Qe(b);
+      t.style.setProperty("--z-index", E.zIndex);
+    }
+  }, i = async () => {
+    r.updatePosition ? (await r.updatePosition({ updatePosition: a }), g?.({ placed: !0 })) : await a();
+  }, d = ur(o.listeners), m = o.listeners ? Fn(n, t, i, d) : Et;
+  return i(), () => {
+    m?.(), g?.({ placed: !1 });
+  };
+}
+function Ar(e, t, r = {}) {
+  const { defer: n, ...o } = r, c = n ? Re : (f) => f(), l = [];
+  return l.push(
+    c(() => {
+      const f = typeof e == "function" ? e() : e, u = typeof t == "function" ? t() : t;
+      l.push(fr(f, u, o));
+    })
+  ), () => {
+    l.forEach((f) => f?.());
+  };
+}
+var dr = {
+  bottom: "rotate(45deg)",
+  left: "rotate(135deg)",
+  top: "rotate(225deg)",
+  right: "rotate(315deg)"
+};
+function Tr(e = {}) {
+  const { placement: t, sameWidth: r, fitViewport: n, strategy: o = "absolute" } = e;
+  return {
+    arrow: {
+      position: "absolute",
+      width: q.arrowSize.reference,
+      height: q.arrowSize.reference,
+      [q.arrowSizeHalf.variable]: `calc(${q.arrowSize.reference} / 2)`,
+      [q.arrowOffset.variable]: `calc(${q.arrowSizeHalf.reference} * -1)`
+    },
+    arrowTip: {
+      // @ts-expect-error - Fix this
+      transform: t ? dr[t.split("-")[0]] : void 0,
+      background: q.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)"
+    }
+  };
+}
+const [_r, gr] = Ne({
+  name: "EnvironmentContext",
+  hookName: "useEnvironmentContext",
+  providerName: "<EnvironmentProvider />",
+  strict: !1,
+  defaultValue: {
+    getRootNode: () => document,
+    getDocument: () => document,
+    getWindow: () => window
+  }
+}), [Pr, Nr] = Ne({
+  name: "LocaleContext",
+  hookName: "useLocaleContext",
+  providerName: "<LocaleProvider />",
+  strict: !1,
+  defaultValue: { dir: "ltr", locale: "en-US" }
+}), Cr = (e) => {
+  const { children: t, disabled: r } = e, [n, o] = Ae(e.container?.current), c = Ft(
+    pr,
+    () => !1,
+    () => !0
+  ), { getRootNode: l } = gr();
+  if (se(() => {
+    o(() => e.container?.current);
+  }, [e.container]), c || r) return /* @__PURE__ */ ue.jsx(ue.Fragment, { children: t });
+  const f = n ?? mr(l);
+  return /* @__PURE__ */ ue.jsx(ue.Fragment, { children: et.map(t, (u) => ve.createPortal(u, f)) });
+}, mr = (e) => {
+  const t = e?.(), r = t.getRootNode();
+  return Pt(r) ? r : Nt(t).body;
+}, pr = () => () => {
+};
+export {
+  Cr as P,
+  tn as a,
+  qt as b,
+  Ne as c,
+  Tr as d,
+  Rr as e,
+  wr as f,
+  Ar as g,
+  Jt as h,
+  gr as i,
+  Nr as j,
+  Kt as k,
+  Er as l,
+  br as m,
+  xr as n,
+  on as o,
+  ve as r,
+  Sr as s,
+  Or as u
+};
+//# sourceMappingURL=portal-D2KZrSzZ.js.map