@g4rcez/components 3.0.2 → 4.0.1

package/dist/notifications-cUdVPs-B.js

@@ -0,0 +1,2786 @@
+import { jsx as T, jsxs as B } from "react/jsx-runtime";
+import { c as wn } from "./index-DJSMaZR4.js";
+import { c as Sn } from "./CheckCircle.es-C6QWLfk_.js";
+import * as c from "react";
+import Ne, { createElement as ut, useState as xn, useEffect as Tn, createContext as On, useContext as Cn, useCallback as ct, useRef as Nn } from "react";
+import { p as Rn } from "./IconBase.es-DJ1oCtpo.js";
+import { e as ae } from "./Info.es-CrZKs4q4.js";
+import { r as lt } from "./Warning.es-D_eI6tLe.js";
+import { e as Dn } from "./X.es-BJ1O93El.js";
+import { c as ft } from "./dom-Dl8XH0CK.js";
+import { A as _n, m as Pt } from "./proxy-BZcQiBrp.js";
+import { a as In, t as At, g as dt, b as Pn, c as An } from "./index.esm-BaIwleSE.js";
+import * as fe from "react-dom";
+const kn = /* @__PURE__ */ new Map([
+  [
+    "bold",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M236,128a108,108,0,0,1-216,0c0-42.52,24.73-81.34,63-98.9A12,12,0,1,1,93,50.91C63.24,64.57,44,94.83,44,128a84,84,0,0,0,168,0c0-33.17-19.24-63.43-49-77.09A12,12,0,1,1,173,29.1C211.27,46.66,236,85.48,236,128Z" }))
+  ],
+  [
+    "duotone",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M224,128a96,96,0,1,1-96-96A96,96,0,0,1,224,128Z", opacity: "0.2" }), /* @__PURE__ */ c.createElement("path", { d: "M232,128a104,104,0,0,1-208,0c0-41,23.81-78.36,60.66-95.27a8,8,0,0,1,6.68,14.54C60.15,61.59,40,93.27,40,128a88,88,0,0,0,176,0c0-34.73-20.15-66.41-51.34-80.73a8,8,0,0,1,6.68-14.54C208.19,49.64,232,87,232,128Z" }))
+  ],
+  [
+    "fill",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M128,24A104,104,0,1,0,232,128,104.11,104.11,0,0,0,128,24Zm0,176A72,72,0,0,1,92,65.64a8,8,0,0,1,8,13.85,56,56,0,1,0,56,0,8,8,0,0,1,8-13.85A72,72,0,0,1,128,200Z" }))
+  ],
+  [
+    "light",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M230,128a102,102,0,0,1-204,0c0-40.18,23.35-76.86,59.5-93.45a6,6,0,0,1,5,10.9C58.61,60.09,38,92.49,38,128a90,90,0,0,0,180,0c0-35.51-20.61-67.91-52.5-82.55a6,6,0,0,1,5-10.9C206.65,51.14,230,87.82,230,128Z" }))
+  ],
+  [
+    "regular",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M232,128a104,104,0,0,1-208,0c0-41,23.81-78.36,60.66-95.27a8,8,0,0,1,6.68,14.54C60.15,61.59,40,93.27,40,128a88,88,0,0,0,176,0c0-34.73-20.15-66.41-51.34-80.73a8,8,0,0,1,6.68-14.54C208.19,49.64,232,87,232,128Z" }))
+  ],
+  [
+    "thin",
+    /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("path", { d: "M228,128a100,100,0,0,1-200,0c0-39.4,22.9-75.37,58.33-91.63a4,4,0,1,1,3.34,7.27C57.07,58.6,36,91.71,36,128a92,92,0,0,0,184,0c0-36.29-21.07-69.4-53.67-84.36a4,4,0,1,1,3.34-7.27C205.1,52.63,228,88.6,228,128Z" }))
+  ]
+]), kt = c.forwardRef((t, e) => /* @__PURE__ */ c.createElement(Rn, { ref: e, ...t, weights: kn }));
+kt.displayName = "CircleNotchIcon";
+function K(t) {
+  return t?.ownerDocument || document;
+}
+const pt = {};
+function re(t, e) {
+  const n = c.useRef(pt);
+  return n.current === pt && (n.current = t(e)), n;
+}
+const Le = c[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)], Mn = (
+  // React 17 doesn't have useInsertionEffect.
+  Le && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  Le !== c.useLayoutEffect ? Le : (t) => t()
+);
+function X(t) {
+  const e = re(Fn).current;
+  return e.next = t, Mn(e.effect), e.trampoline;
+}
+function Fn() {
+  const t = {
+    next: void 0,
+    callback: Ln,
+    trampoline: (...e) => t.callback?.(...e),
+    effect: () => {
+      t.callback = t.next;
+    }
+  };
+  return t;
+}
+function Ln() {
+  if (process.env.NODE_ENV !== "production")
+    throw (
+      /* minify-error-disabled */
+      new Error("Base UI: Cannot call an event handler while rendering.")
+    );
+}
+const Vn = () => {
+}, $ = typeof document < "u" ? c.useLayoutEffect : Vn;
+function jn() {
+}
+const W = Object.freeze({}), $n = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Bs = "none", Us = "track-press", Hs = "input-change", Bn = "focus-out", zs = "keyboard", Ws = "drag";
+function Un(t, e, n, r) {
+  let s = !1, o = !1;
+  const u = r ?? W;
+  return {
+    reason: t,
+    event: e ?? new Event("base-ui"),
+    cancel() {
+      s = !0;
+    },
+    allowPropagation() {
+      o = !0;
+    },
+    get isCanceled() {
+      return s;
+    },
+    get isPropagationAllowed() {
+      return o;
+    },
+    trigger: n,
+    ...u
+  };
+}
+function Ks(t, e, n) {
+  const r = W;
+  return {
+    reason: t,
+    event: e ?? new Event("base-ui"),
+    ...r
+  };
+}
+const We = {
+  ...c
+};
+let mt = 0;
+function Hn(t, e = "mui") {
+  const [n, r] = c.useState(t), s = t || n;
+  return c.useEffect(() => {
+    n == null && (mt += 1, r(`${e}-${mt}`));
+  }, [n, e]), s;
+}
+const ht = We.useId;
+function Xe(t, e) {
+  if (ht !== void 0) {
+    const n = ht();
+    return t ?? (e ? `${e}-${n}` : n);
+  }
+  return Hn(t, e);
+}
+function q(t, ...e) {
+  const n = new URL("https://base-ui.com/production-error");
+  return n.searchParams.set("code", t.toString()), e.forEach((r) => n.searchParams.append("args[]", r)), `Base UI error #${t}; visit ${n} for the full message.`;
+}
+function gt(t, e, n, r) {
+  const s = re(Mt).current;
+  return Wn(s, t, e, n, r) && Ft(s, [t, e, n, r]), s.callback;
+}
+function zn(t) {
+  const e = re(Mt).current;
+  return Kn(e, t) && Ft(e, t), e.callback;
+}
+function Mt() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function Wn(t, e, n, r, s) {
+  return t.refs[0] !== e || t.refs[1] !== n || t.refs[2] !== r || t.refs[3] !== s;
+}
+function Kn(t, e) {
+  return t.refs.length !== e.length || t.refs.some((n, r) => n !== e[r]);
+}
+function Ft(t, e) {
+  if (t.refs = e, e.every((n) => n == null)) {
+    t.callback = null;
+    return;
+  }
+  t.callback = (n) => {
+    if (t.cleanup && (t.cleanup(), t.cleanup = null), n != null) {
+      const r = Array(e.length).fill(null);
+      for (let s = 0; s < e.length; s += 1) {
+        const o = e[s];
+        if (o != null)
+          switch (typeof o) {
+            case "function": {
+              const u = o(n);
+              typeof u == "function" && (r[s] = u);
+              break;
+            }
+            case "object": {
+              o.current = n;
+              break;
+            }
+          }
+      }
+      t.cleanup = () => {
+        for (let s = 0; s < e.length; s += 1) {
+          const o = e[s];
+          if (o != null)
+            switch (typeof o) {
+              case "function": {
+                const u = r[s];
+                typeof u == "function" ? u() : o(null);
+                break;
+              }
+              case "object": {
+                o.current = null;
+                break;
+              }
+            }
+        }
+      };
+    }
+  };
+}
+const Gn = parseInt(c.version, 10);
+function Je(t) {
+  return Gn >= t;
+}
+function bt(t) {
+  if (!/* @__PURE__ */ c.isValidElement(t))
+    return null;
+  const e = t, n = e.props;
+  return (Je(19) ? n?.ref : e.ref) ?? null;
+}
+function Ke(t, e) {
+  if (t && !e)
+    return t;
+  if (!t && e)
+    return e;
+  if (t || e)
+    return {
+      ...t,
+      ...e
+    };
+}
+function qn(t, e) {
+  const n = {};
+  for (const r in t) {
+    const s = t[r];
+    if (e?.hasOwnProperty(r)) {
+      const o = e[r](s);
+      o != null && Object.assign(n, o);
+      continue;
+    }
+    s === !0 ? n[`data-${r.toLowerCase()}`] = "" : s && (n[`data-${r.toLowerCase()}`] = s.toString());
+  }
+  return n;
+}
+function Yn(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function Zn(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+const ue = {};
+function Lt(t, e, n, r, s) {
+  let o = {
+    ...Ge(t, ue)
+  };
+  return e && (o = Oe(o, e)), n && (o = Oe(o, n)), r && (o = Oe(o, r)), o;
+}
+function Xn(t) {
+  if (t.length === 0)
+    return ue;
+  if (t.length === 1)
+    return Ge(t[0], ue);
+  let e = {
+    ...Ge(t[0], ue)
+  };
+  for (let n = 1; n < t.length; n += 1)
+    e = Oe(e, t[n]);
+  return e;
+}
+function Oe(t, e) {
+  return Vt(e) ? e(t) : Jn(t, e);
+}
+function Jn(t, e) {
+  if (!e)
+    return t;
+  for (const n in e) {
+    const r = e[n];
+    switch (n) {
+      case "style": {
+        t[n] = Ke(t.style, r);
+        break;
+      }
+      case "className": {
+        t[n] = jt(t.className, r);
+        break;
+      }
+      default:
+        Qn(n, r) ? t[n] = er(t[n], r) : t[n] = r;
+    }
+  }
+  return t;
+}
+function Qn(t, e) {
+  const n = t.charCodeAt(0), r = t.charCodeAt(1), s = t.charCodeAt(2);
+  return n === 111 && r === 110 && s >= 65 && s <= 90 && (typeof e == "function" || typeof e > "u");
+}
+function Vt(t) {
+  return typeof t == "function";
+}
+function Ge(t, e) {
+  return Vt(t) ? t(e) : t ?? ue;
+}
+function er(t, e) {
+  return e ? t ? (n) => {
+    if (tr(n)) {
+      const s = n;
+      qe(s);
+      const o = e(s);
+      return s.baseUIHandlerPrevented || t?.(s), o;
+    }
+    const r = e(n);
+    return t?.(n), r;
+  } : e : t;
+}
+function qe(t) {
+  return t.preventBaseUIHandler = () => {
+    t.baseUIHandlerPrevented = !0;
+  }, t;
+}
+function jt(t, e) {
+  return e ? t ? e + " " + t : e : t;
+}
+function tr(t) {
+  return t != null && typeof t == "object" && "nativeEvent" in t;
+}
+function Q(t, e, n = {}) {
+  const r = e.render, s = nr(e, n);
+  if (n.enabled === !1)
+    return null;
+  const o = n.state ?? W;
+  return sr(t, r, s, o);
+}
+function nr(t, e = {}) {
+  const {
+    className: n,
+    style: r,
+    render: s
+  } = t, {
+    state: o = W,
+    ref: u,
+    props: i,
+    stateAttributesMapping: m,
+    enabled: a = !0
+  } = e, d = a ? Yn(n, o) : void 0, l = a ? Zn(r, o) : void 0, p = a ? qn(o, m) : W, f = a ? Ke(p, Array.isArray(i) ? Xn(i) : i) ?? W : W;
+  return typeof document < "u" && (a ? Array.isArray(u) ? f.ref = zn([f.ref, bt(s), ...u]) : f.ref = gt(f.ref, bt(s), u) : gt(null, null)), a ? (d !== void 0 && (f.className = jt(f.className, d)), l !== void 0 && (f.style = Ke(f.style, l)), f) : W;
+}
+const rr = /* @__PURE__ */ Symbol.for("react.lazy");
+function sr(t, e, n, r) {
+  if (e) {
+    if (typeof e == "function")
+      return e(n, r);
+    const s = Lt(n, e.props);
+    s.ref = n.ref;
+    let o = e;
+    if (o?.$$typeof === rr && (o = c.Children.toArray(e)[0]), process.env.NODE_ENV !== "production" && !/* @__PURE__ */ c.isValidElement(o))
+      throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join(`
+`));
+    return /* @__PURE__ */ c.cloneElement(o, s);
+  }
+  if (t && typeof t == "string")
+    return or(t, n);
+  throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : q(8));
+}
+function or(t, e) {
+  return t === "button" ? /* @__PURE__ */ ut("button", {
+    type: "button",
+    ...e,
+    key: e.key
+  }) : t === "img" ? /* @__PURE__ */ ut("img", {
+    alt: "",
+    ...e,
+    key: e.key
+  }) : /* @__PURE__ */ c.createElement(t, e);
+}
+const de = typeof navigator < "u", Ve = lr(), ir = dr(), ar = fr();
+typeof CSS > "u" || !CSS.supports || CSS.supports("-webkit-backdrop-filter:none");
+Ve.platform === "MacIntel" && Ve.maxTouchPoints > 1 || /iP(hone|ad|od)|iOS/.test(Ve.platform);
+const ur = de && /apple/i.test(navigator.vendor);
+de && ir.toLowerCase().startsWith("mac") && navigator.maxTouchPoints;
+const cr = ar.includes("jsdom/");
+function lr() {
+  if (!de)
+    return {
+      platform: "",
+      maxTouchPoints: -1
+    };
+  const t = navigator.userAgentData;
+  return t?.platform ? {
+    platform: t.platform,
+    maxTouchPoints: navigator.maxTouchPoints
+  } : {
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? -1
+  };
+}
+function fr() {
+  if (!de)
+    return "";
+  const t = navigator.userAgentData;
+  return t && Array.isArray(t.brands) ? t.brands.map(({
+    brand: e,
+    version: n
+  }) => `${e}/${n}`).join(" ") : navigator.userAgent;
+}
+function dr() {
+  if (!de)
+    return "";
+  const t = navigator.userAgentData;
+  return t?.platform ? t.platform : navigator.platform ?? "";
+}
+function ce(t) {
+  let e = t.activeElement;
+  for (; e?.shadowRoot?.activeElement != null; )
+    e = e.shadowRoot.activeElement;
+  return e;
+}
+function J(t, e) {
+  if (!t || !e)
+    return !1;
+  const n = e.getRootNode?.();
+  if (t.contains(e))
+    return !0;
+  if (n && In(n)) {
+    let r = e;
+    for (; r; ) {
+      if (t === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function Qe(t) {
+  return "composedPath" in t ? t.composedPath()[0] : t.target;
+}
+function Ye(t) {
+  if (!t || cr)
+    return !0;
+  try {
+    return t.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+const $t = () => ({
+  getShadowRoot: !0,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver == "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function Bt(t, e) {
+  const n = At(t, $t()), r = n.length;
+  if (r === 0)
+    return;
+  const s = ce(K(t)), o = n.indexOf(s), u = o === -1 ? e === 1 ? 0 : r - 1 : o + e;
+  return n[u];
+}
+function pr(t) {
+  return Bt(K(t).body, 1) || t;
+}
+function mr(t) {
+  return Bt(K(t).body, -1) || t;
+}
+function je(t, e) {
+  const n = e || t.currentTarget, r = t.relatedTarget;
+  return !r || !J(n, r);
+}
+function hr(t) {
+  At(t, $t()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function vt(t) {
+  t.querySelectorAll("[data-tabindex]").forEach((n) => {
+    const r = n.dataset.tabindex;
+    delete n.dataset.tabindex, r ? n.setAttribute("tabindex", r) : n.removeAttribute("tabindex");
+  });
+}
+const gr = [];
+function et(t) {
+  c.useEffect(t, gr);
+}
+const ye = null;
+let yt = globalThis.requestAnimationFrame;
+class br {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (e) => {
+    this.isScheduled = !1;
+    const n = this.callbacks, r = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, r > 0)
+      for (let s = 0; s < n.length; s += 1)
+        n[s]?.(e);
+  };
+  request(e) {
+    const n = this.nextId;
+    this.nextId += 1, this.callbacks.push(e), this.callbacksCount += 1;
+    const r = process.env.NODE_ENV !== "production" && yt !== requestAnimationFrame && (yt = requestAnimationFrame, !0);
+    return (!this.isScheduled || r) && (requestAnimationFrame(this.tick), this.isScheduled = !0), n;
+  }
+  cancel(e) {
+    const n = e - this.startId;
+    n < 0 || n >= this.callbacks.length || (this.callbacks[n] = null, this.callbacksCount -= 1);
+  }
+}
+const Ee = new br();
+class tt {
+  static create() {
+    return new tt();
+  }
+  static request(e) {
+    return Ee.request(e);
+  }
+  static cancel(e) {
+    return Ee.cancel(e);
+  }
+  currentId = ye;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(e) {
+    this.cancel(), this.currentId = Ee.request(() => {
+      this.currentId = ye, e();
+    });
+  }
+  cancel = () => {
+    this.currentId !== ye && (Ee.cancel(this.currentId), this.currentId = ye);
+  };
+  disposeEffect = () => this.cancel;
+}
+function vr() {
+  const t = re(tt.create).current;
+  return et(t.disposeEffect), t;
+}
+const yr = {
+  clipPath: "inset(50%)",
+  overflow: "hidden",
+  whiteSpace: "nowrap",
+  border: 0,
+  padding: 0,
+  width: 1,
+  height: 1,
+  margin: -1
+}, Ut = {
+  ...yr,
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Re = /* @__PURE__ */ c.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Re.displayName = "ToastContext");
+function nt() {
+  const t = c.useContext(Re);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : q(73));
+  return t;
+}
+var Er = (t, e, n) => {
+  if (e.length === 1 && e[0] === n) {
+    let r = !1;
+    try {
+      const s = {};
+      t(s) === s && (r = !0);
+    } catch {
+    }
+    if (r) {
+      let s;
+      try {
+        throw new Error();
+      } catch (o) {
+        ({ stack: s } = o);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: s }
+      );
+    }
+  }
+}, wr = (t, e, n) => {
+  const { memoize: r, memoizeOptions: s } = e, { inputSelectorResults: o, inputSelectorResultsCopy: u } = t, i = r(() => ({}), ...s);
+  if (!(i.apply(null, o) === i.apply(null, u))) {
+    let a;
+    try {
+      throw new Error();
+    } catch (d) {
+      ({ stack: a } = d);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: n,
+        firstInputs: o,
+        secondInputs: u,
+        stack: a
+      }
+    );
+  }
+}, Sr = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+}, Ce = /* @__PURE__ */ Symbol("NOT_FOUND");
+function xr(t, e = `expected a function, instead received ${typeof t}`) {
+  if (typeof t != "function")
+    throw new TypeError(e);
+}
+function Tr(t, e = `expected an object, instead received ${typeof t}`) {
+  if (typeof t != "object")
+    throw new TypeError(e);
+}
+function Or(t, e = "expected all items to be functions, instead received the following types: ") {
+  if (!t.every((n) => typeof n == "function")) {
+    const n = t.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${e}[${n}]`);
+  }
+}
+var Et = (t) => Array.isArray(t) ? t : [t];
+function Cr(t) {
+  const e = Array.isArray(t[0]) ? t[0] : t;
+  return Or(
+    e,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), e;
+}
+function wt(t, e) {
+  const n = [], { length: r } = t;
+  for (let s = 0; s < r; s++)
+    n.push(t[s].apply(null, e));
+  return n;
+}
+var Nr = (t, e) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: r } = {
+    ...Sr,
+    ...e
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && t,
+      run: Er
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && t,
+      run: wr
+    }
+  };
+};
+function Rr(t) {
+  let e;
+  return {
+    get(n) {
+      return e && t(e.key, n) ? e.value : Ce;
+    },
+    put(n, r) {
+      e = { key: n, value: r };
+    },
+    getEntries() {
+      return e ? [e] : [];
+    },
+    clear() {
+      e = void 0;
+    }
+  };
+}
+function Dr(t, e) {
+  let n = [];
+  function r(i) {
+    const m = n.findIndex((a) => e(i, a.key));
+    if (m > -1) {
+      const a = n[m];
+      return m > 0 && (n.splice(m, 1), n.unshift(a)), a.value;
+    }
+    return Ce;
+  }
+  function s(i, m) {
+    r(i) === Ce && (n.unshift({ key: i, value: m }), n.length > t && n.pop());
+  }
+  function o() {
+    return n;
+  }
+  function u() {
+    n = [];
+  }
+  return { get: r, put: s, getEntries: o, clear: u };
+}
+var _r = (t, e) => t === e;
+function Ir(t) {
+  return function(n, r) {
+    if (n === null || r === null || n.length !== r.length)
+      return !1;
+    const { length: s } = n;
+    for (let o = 0; o < s; o++)
+      if (!t(n[o], r[o]))
+        return !1;
+    return !0;
+  };
+}
+function Pr(t, e) {
+  const n = typeof e == "object" ? e : { equalityCheck: e }, {
+    equalityCheck: r = _r,
+    maxSize: s = 1,
+    resultEqualityCheck: o
+  } = n, u = Ir(r);
+  let i = 0;
+  const m = s <= 1 ? Rr(u) : Dr(s, u);
+  function a() {
+    let d = m.get(arguments);
+    if (d === Ce) {
+      if (d = t.apply(null, arguments), i++, o) {
+        const p = m.getEntries().find(
+          (f) => o(f.value, d)
+        );
+        p && (d = p.value, i !== 0 && i--);
+      }
+      m.put(arguments, d);
+    }
+    return d;
+  }
+  return a.clearCache = () => {
+    m.clear(), a.resetResultsCount();
+  }, a.resultsCount = () => i, a.resetResultsCount = () => {
+    i = 0;
+  }, a;
+}
+var Ar = class {
+  constructor(t) {
+    this.value = t;
+  }
+  deref() {
+    return this.value;
+  }
+}, kr = typeof WeakRef < "u" ? WeakRef : Ar, Mr = 0, St = 1;
+function we() {
+  return {
+    s: Mr,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function Ht(t, e = {}) {
+  let n = we();
+  const { resultEqualityCheck: r } = e;
+  let s, o = 0;
+  function u() {
+    let i = n;
+    const { length: m } = arguments;
+    for (let l = 0, p = m; l < p; l++) {
+      const f = arguments[l];
+      if (typeof f == "function" || typeof f == "object" && f !== null) {
+        let h = i.o;
+        h === null && (i.o = h = /* @__PURE__ */ new WeakMap());
+        const g = h.get(f);
+        g === void 0 ? (i = we(), h.set(f, i)) : i = g;
+      } else {
+        let h = i.p;
+        h === null && (i.p = h = /* @__PURE__ */ new Map());
+        const g = h.get(f);
+        g === void 0 ? (i = we(), h.set(f, i)) : i = g;
+      }
+    }
+    const a = i;
+    let d;
+    if (i.s === St)
+      d = i.v;
+    else if (d = t.apply(null, arguments), o++, r) {
+      const l = s?.deref?.() ?? s;
+      l != null && r(l, d) && (d = l, o !== 0 && o--), s = typeof d == "object" && d !== null || typeof d == "function" ? new kr(d) : d;
+    }
+    return a.s = St, a.v = d, d;
+  }
+  return u.clearCache = () => {
+    n = we(), u.resetResultsCount();
+  }, u.resultsCount = () => o, u.resetResultsCount = () => {
+    o = 0;
+  }, u;
+}
+function zt(t, ...e) {
+  const n = typeof t == "function" ? {
+    memoize: t,
+    memoizeOptions: e
+  } : t, r = (...s) => {
+    let o = 0, u = 0, i, m = {}, a = s.pop();
+    typeof a == "object" && (m = a, a = s.pop()), xr(
+      a,
+      `createSelector expects an output function after the inputs, but received: [${typeof a}]`
+    );
+    const d = {
+      ...n,
+      ...m
+    }, {
+      memoize: l,
+      memoizeOptions: p = [],
+      argsMemoize: f = Ht,
+      argsMemoizeOptions: h = [],
+      devModeChecks: g = {}
+    } = d, y = Et(p), x = Et(h), N = Cr(s), R = l(function() {
+      return o++, a.apply(
+        null,
+        arguments
+      );
+    }, ...y);
+    let b = !0;
+    const O = f(function() {
+      u++;
+      const C = wt(
+        N,
+        arguments
+      );
+      if (i = R.apply(null, C), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: A, inputStabilityCheck: ee } = Nr(b, g);
+        if (A.shouldRun && A.run(
+          a,
+          C,
+          i
+        ), ee.shouldRun) {
+          const Y = wt(
+            N,
+            arguments
+          );
+          ee.run(
+            { inputSelectorResults: C, inputSelectorResultsCopy: Y },
+            { memoize: l, memoizeOptions: y },
+            arguments
+          );
+        }
+        b && (b = !1);
+      }
+      return i;
+    }, ...x);
+    return Object.assign(O, {
+      resultFunc: a,
+      memoizedResultFunc: R,
+      dependencies: N,
+      dependencyRecomputations: () => u,
+      resetDependencyRecomputations: () => {
+        u = 0;
+      },
+      lastResult: () => i,
+      recomputations: () => o,
+      resetRecomputations: () => {
+        o = 0;
+      },
+      memoize: l,
+      argsMemoize: f
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var Fr = /* @__PURE__ */ zt(Ht), Lr = Object.assign(
+  (t, e = Fr) => {
+    Tr(
+      t,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof t}`
+    );
+    const n = Object.keys(t), r = n.map(
+      (o) => t[o]
+    );
+    return e(
+      r,
+      (...o) => o.reduce((u, i, m) => (u[n[m]] = i, u), {})
+    );
+  },
+  { withTypes: () => Lr }
+);
+const Vr = zt({
+  memoize: Pr,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+}), j = (t, e, n, r, s, o, ...u) => {
+  if (u.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : q(1));
+  let i;
+  if (t && e)
+    i = (m, a, d, l) => {
+      const p = t(m, a, d, l);
+      return e(p, a, d, l);
+    };
+  else if (t)
+    i = t;
+  else
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  return i;
+}, jr = (...t) => {
+  const e = /* @__PURE__ */ new WeakMap();
+  let n = 1;
+  const r = t[t.length - 1], s = t.length - 1 || 1, o = r.length - s;
+  if (o > 3)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of arguments" : q(2));
+  return (i, m, a, d) => {
+    let l = i.__cacheKey__;
+    l || (l = {
+      id: n
+    }, i.__cacheKey__ = l, n += 1);
+    let p = e.get(l);
+    if (!p) {
+      let f = t;
+      const h = [void 0, void 0, void 0];
+      switch (o) {
+        case 0:
+          break;
+        case 1: {
+          f = [...t.slice(0, -1), () => h[0], r];
+          break;
+        }
+        case 2: {
+          f = [...t.slice(0, -1), () => h[0], () => h[1], r];
+          break;
+        }
+        case 3: {
+          f = [...t.slice(0, -1), () => h[0], () => h[1], () => h[2], r];
+          break;
+        }
+        default:
+          throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of arguments" : q(2));
+      }
+      p = Vr(...f), p.selectorArgs = h, e.set(l, p);
+    }
+    switch (p.selectorArgs[0] = m, p.selectorArgs[1] = a, p.selectorArgs[2] = d, o) {
+      case 0:
+        return p(i);
+      case 1:
+        return p(i, m);
+      case 2:
+        return p(i, m, a);
+      case 3:
+        return p(i, m, a, d);
+      default:
+        throw (
+          /* minify-error-disabled */
+          new Error("unreachable")
+        );
+    }
+  };
+};
+var Se = { exports: {} }, $e = {};
+var xt;
+function $r() {
+  if (xt) return $e;
+  xt = 1;
+  var t = Ne;
+  function e(l, p) {
+    return l === p && (l !== 0 || 1 / l === 1 / p) || l !== l && p !== p;
+  }
+  var n = typeof Object.is == "function" ? Object.is : e, r = t.useState, s = t.useEffect, o = t.useLayoutEffect, u = t.useDebugValue;
+  function i(l, p) {
+    var f = p(), h = r({ inst: { value: f, getSnapshot: p } }), g = h[0].inst, y = h[1];
+    return o(
+      function() {
+        g.value = f, g.getSnapshot = p, m(g) && y({ inst: g });
+      },
+      [l, f, p]
+    ), s(
+      function() {
+        return m(g) && y({ inst: g }), l(function() {
+          m(g) && y({ inst: g });
+        });
+      },
+      [l]
+    ), u(f), f;
+  }
+  function m(l) {
+    var p = l.getSnapshot;
+    l = l.value;
+    try {
+      var f = p();
+      return !n(l, f);
+    } catch {
+      return !0;
+    }
+  }
+  function a(l, p) {
+    return p();
+  }
+  var d = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? a : i;
+  return $e.useSyncExternalStore = t.useSyncExternalStore !== void 0 ? t.useSyncExternalStore : d, $e;
+}
+var Be = {};
+var Tt;
+function Br() {
+  return Tt || (Tt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(f, h) {
+      return f === h && (f !== 0 || 1 / f === 1 / h) || f !== f && h !== h;
+    }
+    function e(f, h) {
+      d || s.startTransition === void 0 || (d = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var g = h();
+      if (!l) {
+        var y = h();
+        o(g, y) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), l = !0);
+      }
+      y = u({
+        inst: { value: g, getSnapshot: h }
+      });
+      var x = y[0].inst, N = y[1];
+      return m(
+        function() {
+          x.value = g, x.getSnapshot = h, n(x) && N({ inst: x });
+        },
+        [f, g, h]
+      ), i(
+        function() {
+          return n(x) && N({ inst: x }), f(function() {
+            n(x) && N({ inst: x });
+          });
+        },
+        [f]
+      ), a(g), g;
+    }
+    function n(f) {
+      var h = f.getSnapshot;
+      f = f.value;
+      try {
+        var g = h();
+        return !o(f, g);
+      } catch {
+        return !0;
+      }
+    }
+    function r(f, h) {
+      return h();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var s = Ne, o = typeof Object.is == "function" ? Object.is : t, u = s.useState, i = s.useEffect, m = s.useLayoutEffect, a = s.useDebugValue, d = !1, l = !1, p = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
+    Be.useSyncExternalStore = s.useSyncExternalStore !== void 0 ? s.useSyncExternalStore : p, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Be;
+}
+var Ot;
+function rt() {
+  return Ot || (Ot = 1, process.env.NODE_ENV === "production" ? Se.exports = $r() : Se.exports = Br()), Se.exports;
+}
+var Ur = rt(), xe = { exports: {} }, Ue = {};
+var Ct;
+function Hr() {
+  if (Ct) return Ue;
+  Ct = 1;
+  var t = Ne, e = rt();
+  function n(a, d) {
+    return a === d && (a !== 0 || 1 / a === 1 / d) || a !== a && d !== d;
+  }
+  var r = typeof Object.is == "function" ? Object.is : n, s = e.useSyncExternalStore, o = t.useRef, u = t.useEffect, i = t.useMemo, m = t.useDebugValue;
+  return Ue.useSyncExternalStoreWithSelector = function(a, d, l, p, f) {
+    var h = o(null);
+    if (h.current === null) {
+      var g = { hasValue: !1, value: null };
+      h.current = g;
+    } else g = h.current;
+    h = i(
+      function() {
+        function x(v) {
+          if (!N) {
+            if (N = !0, R = v, v = p(v), f !== void 0 && g.hasValue) {
+              var C = g.value;
+              if (f(C, v))
+                return b = C;
+            }
+            return b = v;
+          }
+          if (C = b, r(R, v)) return C;
+          var A = p(v);
+          return f !== void 0 && f(C, A) ? (R = v, C) : (R = v, b = A);
+        }
+        var N = !1, R, b, O = l === void 0 ? null : l;
+        return [
+          function() {
+            return x(d());
+          },
+          O === null ? void 0 : function() {
+            return x(O());
+          }
+        ];
+      },
+      [d, l, p, f]
+    );
+    var y = s(a, h[0], h[1]);
+    return u(
+      function() {
+        g.hasValue = !0, g.value = y;
+      },
+      [y]
+    ), m(y), y;
+  }, Ue;
+}
+var He = {};
+var Nt;
+function zr() {
+  return Nt || (Nt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(a, d) {
+      return a === d && (a !== 0 || 1 / a === 1 / d) || a !== a && d !== d;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var e = Ne, n = rt(), r = typeof Object.is == "function" ? Object.is : t, s = n.useSyncExternalStore, o = e.useRef, u = e.useEffect, i = e.useMemo, m = e.useDebugValue;
+    He.useSyncExternalStoreWithSelector = function(a, d, l, p, f) {
+      var h = o(null);
+      if (h.current === null) {
+        var g = { hasValue: !1, value: null };
+        h.current = g;
+      } else g = h.current;
+      h = i(
+        function() {
+          function x(v) {
+            if (!N) {
+              if (N = !0, R = v, v = p(v), f !== void 0 && g.hasValue) {
+                var C = g.value;
+                if (f(C, v))
+                  return b = C;
+              }
+              return b = v;
+            }
+            if (C = b, r(R, v))
+              return C;
+            var A = p(v);
+            return f !== void 0 && f(C, A) ? (R = v, C) : (R = v, b = A);
+          }
+          var N = !1, R, b, O = l === void 0 ? null : l;
+          return [
+            function() {
+              return x(d());
+            },
+            O === null ? void 0 : function() {
+              return x(O());
+            }
+          ];
+        },
+        [d, l, p, f]
+      );
+      var y = s(a, h[0], h[1]);
+      return u(
+        function() {
+          g.hasValue = !0, g.value = y;
+        },
+        [y]
+      ), m(y), y;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), He;
+}
+var Rt;
+function Wr() {
+  return Rt || (Rt = 1, process.env.NODE_ENV === "production" ? xe.exports = Hr() : xe.exports = zr()), xe.exports;
+}
+var Kr = Wr();
+const Gr = Je(19), qr = Gr ? Zr : Xr;
+function Wt(t, e, n, r, s) {
+  return qr(t, e, n, r, s);
+}
+function Yr(t, e, n, r, s) {
+  const o = c.useCallback(() => e(t.getSnapshot(), n, r, s), [t, e, n, r, s]);
+  return Ur.useSyncExternalStore(t.subscribe, o, o);
+}
+function Zr(t, e, n, r, s) {
+  return Yr(t, e, n, r, s);
+}
+function Xr(t, e, n, r, s) {
+  return Kr.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, (o) => e(o, n, r, s));
+}
+class Jr {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+   *
+   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+   */
+  // Internal state to handle recursive `setState()` calls
+  constructor(e) {
+    this.state = e, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  /**
+   * Registers a listener that will be called whenever the store's state changes.
+   *
+   * @param fn The listener function to be called on state changes.
+   * @returns A function to unsubscribe the listener.
+   */
+  subscribe = (e) => (this.listeners.add(e), () => {
+    this.listeners.delete(e);
+  });
+  /**
+   * Returns the current state of the store.
+   */
+  getSnapshot = () => this.state;
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(e) {
+    if (this.state === e)
+      return;
+    this.state = e, this.updateTick += 1;
+    const n = this.updateTick;
+    for (const r of this.listeners) {
+      if (n !== this.updateTick)
+        return;
+      r(e);
+    }
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   *
+   * @param changes An object containing the changes to apply to the current state.
+   */
+  update(e) {
+    for (const n in e)
+      if (!Object.is(this.state[n], e[n])) {
+        this.setState({
+          ...this.state,
+          ...e
+        });
+        return;
+      }
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   *
+   * @param key The key in the store's state to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(e, n) {
+    Object.is(this.state[e], n) || this.setState({
+      ...this.state,
+      [e]: n
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const e = {
+      ...this.state
+    };
+    this.setState(e);
+  }
+  use(e, n, r, s) {
+    return Wt(this, e, n, r, s);
+  }
+}
+class Qr extends Jr {
+  /**
+   * Creates a new ReactStore instance.
+   *
+   * @param state Initial state of the store.
+   * @param context Non-reactive context values.
+   * @param selectors Optional selectors for use with `useState`.
+   */
+  constructor(e, n = {}, r) {
+    super(e), this.context = n, this.selectors = r;
+  }
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  /**
+   * Synchronizes a single external value into the store.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValue(e, n) {
+    c.useDebugValue(e), $(() => {
+      this.state[e] !== n && this.set(e, n);
+    }, [e, n]);
+  }
+  /**
+   * Synchronizes a single external value into the store and
+   * cleans it up (sets to `undefined`) on unmount.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValueWithCleanup(e, n) {
+    const r = this;
+    $(() => (r.state[e] !== n && r.set(e, n), () => {
+      r.set(e, void 0);
+    }), [r, e, n]);
+  }
+  /**
+   * Synchronizes multiple external values into the store.
+   *
+   * Note that the while the values in `state` are updated immediately, the values returned
+   * by `useState` are updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValues(e) {
+    const n = this;
+    if (process.env.NODE_ENV !== "production") {
+      c.useDebugValue(e, (u) => Object.keys(u));
+      const s = c.useRef(Object.keys(e)).current, o = Object.keys(e);
+      (s.length !== o.length || s.some((u, i) => u !== o[i])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const r = Object.values(e);
+    $(() => {
+      n.update(e);
+    }, [n, ...r]);
+  }
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+   * is non-undefined, the store's state at `key` is updated to match `controlled`.
+   */
+  useControlledProp(e, n) {
+    c.useDebugValue(e);
+    const r = n !== void 0;
+    if ($(() => {
+      r && !Object.is(this.state[e], n) && super.setState({
+        ...this.state,
+        [e]: n
+      });
+    }, [e, n, r]), process.env.NODE_ENV !== "production") {
+      const s = this.controlledValues ??= /* @__PURE__ */ new Map();
+      s.has(e) || s.set(e, r);
+      const o = s.get(e);
+      o !== void 0 && o !== r && console.error(`A component is changing the ${r ? "" : "un"}controlled state of ${e.toString()} to be ${r ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+  }
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select(e, n, r, s) {
+    const o = this.selectors[e];
+    return o(this.state, n, r, s);
+  }
+  /**
+   * Returns a value from the store's state using a selector function.
+   * Used to subscribe to specific parts of the state.
+   * This methods causes a rerender whenever the selected state changes.
+   *
+   * @param key Key of the selector to use.
+   */
+  useState(e, n, r, s) {
+    return c.useDebugValue(e), Wt(this, this.selectors[e], n, r, s);
+  }
+  /**
+   * Wraps a function with `useStableCallback` to ensure it has a stable reference
+   * and assigns it to the context.
+   *
+   * @param key Key of the event callback. Must be a function in the context.
+   * @param fn Function to assign.
+   */
+  useContextCallback(e, n) {
+    c.useDebugValue(e);
+    const r = X(n ?? jn);
+    this.context[e] = r;
+  }
+  /**
+   * Returns a stable setter function for a specific key in the store's state.
+   * It's commonly used to pass as a ref callback to React elements.
+   *
+   * @param key Key of the state to set.
+   */
+  useStateSetter(e) {
+    const n = c.useRef(void 0);
+    return n.current === void 0 && (n.current = (r) => {
+      this.set(e, r);
+    }), n.current;
+  }
+  /**
+   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+   *
+   * @param key Key of the selector to observe.
+   * @param listener Listener function called when the selector result changes.
+   */
+  observe(e, n) {
+    let r;
+    typeof e == "function" ? r = e : r = this.selectors[e];
+    let s = r(this.state);
+    return n(s, s, this), this.subscribe((o) => {
+      const u = r(o);
+      if (!Object.is(s, u)) {
+        const i = s;
+        s = u, n(u, i, this);
+      }
+    });
+  }
+}
+const oe = 0;
+class le {
+  static create() {
+    return new le();
+  }
+  currentId = oe;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(e, n) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = oe, n();
+    }, e);
+  }
+  isStarted() {
+    return this.currentId !== oe;
+  }
+  clear = () => {
+    this.currentId !== oe && (clearTimeout(this.currentId), this.currentId = oe);
+  };
+  disposeEffect = () => this.clear;
+}
+function es() {
+  const t = re(le.create).current;
+  return et(t.disposeEffect), t;
+}
+let Dt = 0;
+function ts(t) {
+  return Dt += 1, `${t}-${Math.random().toString(36).slice(2, 6)}-${Dt}`;
+}
+function ze(t, e) {
+  if (typeof t == "string")
+    return {
+      description: t
+    };
+  if (typeof t == "function") {
+    const n = t(e);
+    return typeof n == "string" ? {
+      description: n
+    } : n;
+  }
+  return t;
+}
+const Te = jr((t) => t.toasts, (t) => {
+  const e = /* @__PURE__ */ new Map();
+  let n = 0, r = 0;
+  return t.forEach((s, o) => {
+    const u = s.transitionStatus === "ending";
+    e.set(s.id, {
+      value: s,
+      domIndex: o,
+      visibleIndex: u ? -1 : n,
+      offsetY: r
+    }), r += s.height || 0, u || (n += 1);
+  }), e;
+}), z = {
+  toasts: j((t) => t.toasts),
+  isEmpty: j((t) => t.toasts.length === 0),
+  toast: j(Te, (t, e) => t.get(e)?.value),
+  toastIndex: j(Te, (t, e) => t.get(e)?.domIndex ?? -1),
+  toastOffsetY: j(Te, (t, e) => t.get(e)?.offsetY ?? 0),
+  toastVisibleIndex: j(Te, (t, e) => t.get(e)?.visibleIndex ?? -1),
+  hovering: j((t) => t.hovering),
+  focused: j((t) => t.focused),
+  expanded: j((t) => t.hovering || t.focused),
+  expandedOrOutOfFocus: j((t) => t.hovering || t.focused || !t.isWindowFocused),
+  prevFocusElement: j((t) => t.prevFocusElement)
+};
+class ns extends Qr {
+  timers = /* @__PURE__ */ new Map();
+  areTimersPaused = !1;
+  constructor(e) {
+    super(e, {}, z);
+  }
+  setFocused(e) {
+    this.set("focused", e);
+  }
+  setHovering(e) {
+    this.set("hovering", e);
+  }
+  setIsWindowFocused(e) {
+    this.set("isWindowFocused", e);
+  }
+  setPrevFocusElement(e) {
+    this.set("prevFocusElement", e);
+  }
+  setViewport = (e) => {
+    this.set("viewport", e);
+  };
+  disposeEffect = () => () => {
+    this.timers.forEach((e) => {
+      e.timeout?.clear();
+    }), this.timers.clear();
+  };
+  removeToast(e) {
+    const n = z.toastIndex(this.state, e);
+    if (n === -1)
+      return;
+    this.state.toasts[n]?.onRemove?.();
+    const s = [...this.state.toasts];
+    s.splice(n, 1), this.setToasts(s);
+  }
+  addToast = (e) => {
+    const {
+      toasts: n,
+      timeout: r,
+      limit: s
+    } = this.state, o = e.id || ts("toast"), u = {
+      ...e,
+      id: o,
+      transitionStatus: "starting"
+    }, i = [u, ...n], m = i.filter((d) => d.transitionStatus !== "ending");
+    if (m.length > s) {
+      const d = m.length - s, l = m.slice(-d), p = new Set(l.map((f) => f.id));
+      this.setToasts(i.map((f) => {
+        const h = p.has(f.id);
+        return f.limited !== h ? {
+          ...f,
+          limited: h
+        } : f;
+      }));
+    } else
+      this.setToasts(i.map((d) => d.limited ? {
+        ...d,
+        limited: !1
+      } : d));
+    const a = u.timeout ?? r;
+    return u.type !== "loading" && a > 0 && this.scheduleTimer(o, a, () => this.closeToast(o)), z.expandedOrOutOfFocus(this.state) && this.pauseTimers(), o;
+  };
+  updateToast = (e, n) => {
+    this.updateToastInternal(e, n);
+  };
+  updateToastInternal = (e, n) => {
+    const {
+      timeout: r,
+      toasts: s
+    } = this.state, o = z.toast(this.state, e) ?? null;
+    if (!o || o.transitionStatus === "ending")
+      return;
+    const u = {
+      ...o,
+      ...n
+    };
+    this.setToasts(s.map((h) => h.id === e ? {
+      ...h,
+      ...n
+    } : h));
+    const i = u.timeout ?? r, m = o?.timeout ?? r, a = Object.hasOwn(n, "timeout"), d = u.transitionStatus !== "ending" && u.type !== "loading" && i > 0, l = this.timers.has(e), p = m !== i, f = o?.type === "loading";
+    if (!d && l) {
+      this.timers.get(e)?.timeout?.clear(), this.timers.delete(e);
+      return;
+    }
+    if (d && (!l || p || a || f)) {
+      const h = this.timers.get(e);
+      h && (h.timeout?.clear(), this.timers.delete(e)), this.scheduleTimer(e, i, () => this.closeToast(e)), z.expandedOrOutOfFocus(this.state) && this.pauseTimers();
+    }
+  };
+  closeToast = (e) => {
+    z.toast(this.state, e)?.onClose?.();
+    const {
+      limit: r,
+      toasts: s
+    } = this.state;
+    let o = 0;
+    const u = s.map((m) => {
+      if (m.id === e)
+        return {
+          ...m,
+          transitionStatus: "ending",
+          height: 0
+        };
+      if (m.transitionStatus === "ending")
+        return m;
+      const a = o >= r;
+      return o += 1, m.limited !== a ? {
+        ...m,
+        limited: a
+      } : m;
+    }), i = this.timers.get(e);
+    i && i.timeout && (i.timeout.clear(), this.timers.delete(e)), this.handleFocusManagement(e), this.setToasts(u);
+  };
+  promiseToast = (e, n) => {
+    const r = ze(n.loading), s = this.addToast({
+      ...r,
+      type: "loading"
+    }), o = e.then((u) => {
+      const i = ze(n.success, u);
+      return this.updateToast(s, {
+        ...i,
+        type: "success",
+        timeout: i.timeout
+      }), u;
+    }).catch((u) => {
+      const i = ze(n.error, u);
+      return this.updateToast(s, {
+        ...i,
+        type: "error",
+        timeout: i.timeout
+      }), Promise.reject(u);
+    });
+    return {}.hasOwnProperty.call(n, "setPromise") && n.setPromise(o), o;
+  };
+  pauseTimers() {
+    this.areTimersPaused || (this.areTimersPaused = !0, this.timers.forEach((e) => {
+      if (e.timeout) {
+        e.timeout.clear();
+        const n = Date.now() - e.start, r = e.delay - n;
+        e.remaining = r > 0 ? r : 0;
+      }
+    }));
+  }
+  resumeTimers() {
+    this.areTimersPaused && (this.areTimersPaused = !1, this.timers.forEach((e, n) => {
+      e.remaining = e.remaining > 0 ? e.remaining : e.delay, e.timeout ??= le.create(), e.timeout.start(e.remaining, () => {
+        this.timers.delete(n), e.callback();
+      }), e.start = Date.now();
+    }));
+  }
+  restoreFocusToPrevElement() {
+    this.state.prevFocusElement?.focus({
+      preventScroll: !0
+    });
+  }
+  handleDocumentPointerDown = (e) => {
+    if (e.pointerType !== "touch")
+      return;
+    const n = Qe(e);
+    J(this.state.viewport, n) || (this.resumeTimers(), this.update({
+      hovering: !1,
+      focused: !1
+    }));
+  };
+  scheduleTimer(e, n, r) {
+    const s = Date.now(), o = !z.expandedOrOutOfFocus(this.state), u = o ? le.create() : void 0;
+    u?.start(n, () => {
+      this.timers.delete(e), r();
+    }), this.timers.set(e, {
+      timeout: u,
+      start: o ? s : 0,
+      delay: n,
+      remaining: n,
+      callback: r
+    });
+  }
+  setToasts(e) {
+    const n = {
+      toasts: e
+    };
+    e.length === 0 && (n.hovering = !1, n.focused = !1), this.update(n);
+  }
+  handleFocusManagement(e) {
+    const n = ce(K(this.state.viewport));
+    if (!this.state.viewport || !J(this.state.viewport, n) || !Ye(n))
+      return;
+    const r = z.toasts(this.state), s = z.toastIndex(this.state, e);
+    let o = null, u = s + 1;
+    for (; u < r.length; ) {
+      if (r[u].transitionStatus !== "ending") {
+        o = r[u];
+        break;
+      }
+      u += 1;
+    }
+    if (!o)
+      for (u = s - 1; u >= 0; ) {
+        if (r[u].transitionStatus !== "ending") {
+          o = r[u];
+          break;
+        }
+        u -= 1;
+      }
+    o ? o.ref?.current?.focus() : this.restoreFocusToPrevElement();
+  }
+}
+const Kt = function(e) {
+  const {
+    children: n,
+    timeout: r = 5e3,
+    limit: s = 3,
+    toastManager: o
+  } = e, u = re(() => new ns({
+    timeout: r,
+    limit: s,
+    viewport: null,
+    toasts: [],
+    hovering: !1,
+    focused: !1,
+    isWindowFocused: !0,
+    prevFocusElement: null
+  })).current;
+  return et(u.disposeEffect), c.useEffect(function() {
+    return o ? o[" subscribe"](({
+      action: a,
+      options: d
+    }) => {
+      const l = d.id;
+      a === "promise" && d.promise ? u.promiseToast(d.promise, d) : a === "update" && l ? u.updateToast(l, d) : a === "close" && l ? u.closeToast(l) : u.addToast(d);
+    }) : void 0;
+  }, [u, r, o]), u.useSyncedValues({
+    timeout: r,
+    limit: s
+  }), /* @__PURE__ */ T(Re.Provider, {
+    value: u,
+    children: n
+  });
+};
+process.env.NODE_ENV !== "production" && (Kt.displayName = "ToastProvider");
+const ne = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const [r, s] = c.useState();
+  return $(() => {
+    ur && s("button");
+  }, []), /* @__PURE__ */ T("span", {
+    ...e,
+    ref: n,
+    style: Ut,
+    "aria-hidden": r ? void 0 : !0,
+    ...{
+      tabIndex: 0,
+      // Role is only for VoiceOver
+      role: r
+    },
+    "data-base-ui-focus-guard": ""
+  });
+});
+process.env.NODE_ENV !== "production" && (ne.displayName = "FocusGuard");
+let rs = /* @__PURE__ */ (function(t) {
+  return t.frontmostHeight = "--toast-frontmost-height", t;
+})({});
+const Gt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    render: r,
+    className: s,
+    children: o,
+    ...u
+  } = e, i = nt(), m = es(), a = c.useRef(!1), d = c.useRef(!1), l = i.useState("isEmpty"), p = i.useState("toasts"), f = i.useState("focused"), h = i.useState("expanded"), g = i.useState("prevFocusElement"), y = p[0]?.height ?? 0, x = c.useMemo(() => p.some((E) => E.transitionStatus === "ending"), [p]);
+  c.useEffect(() => {
+    const E = i.state.viewport;
+    if (!E)
+      return;
+    function D(k) {
+      l || k.key === "F6" && k.target !== E && (k.preventDefault(), i.setPrevFocusElement(ce(K(E))), E?.focus({
+        preventScroll: !0
+      }), i.pauseTimers(), i.setFocused(!0));
+    }
+    const I = dt(E);
+    return I.addEventListener("keydown", D), () => {
+      I.removeEventListener("keydown", D);
+    };
+  }, [i, l]), c.useEffect(() => {
+    const E = i.state.viewport;
+    if (!E || l)
+      return;
+    const D = dt(E);
+    function I(U) {
+      U.target === D && (i.setIsWindowFocused(!1), i.pauseTimers());
+    }
+    function k(U) {
+      if (U.relatedTarget || U.target === D)
+        return;
+      const te = Qe(U), se = ce(K(E));
+      (!J(E, te) || !Ye(se)) && i.resumeTimers(), m.start(0, () => i.setIsWindowFocused(!0));
+    }
+    return D.addEventListener("blur", I, !0), D.addEventListener("focus", k, !0), () => {
+      D.removeEventListener("blur", I, !0), D.removeEventListener("focus", k, !0);
+    };
+  }, [
+    i,
+    m,
+    // `store.state.viewport` isn't available on the first render,
+    // since the portal node hasn't yet been created.
+    // By adding this dependency, we ensure the window listeners
+    // are added when toasts have been created, once the ref is available.
+    l
+  ]), c.useEffect(() => {
+    const E = i.state.viewport;
+    if (!E || l)
+      return;
+    const D = K(E);
+    return D.addEventListener("pointerdown", i.handleDocumentPointerDown, !0), () => {
+      D.removeEventListener("pointerdown", i.handleDocumentPointerDown, !0);
+    };
+  }, [l, i]);
+  function N(E) {
+    const D = i.state.viewport;
+    D && (a.current = !0, E.relatedTarget === D ? p[0]?.ref?.current?.focus() : i.restoreFocusToPrevElement());
+  }
+  function R(E) {
+    E.key === "Tab" && E.shiftKey && E.target === i.state.viewport && (E.preventDefault(), i.restoreFocusToPrevElement(), i.resumeTimers());
+  }
+  c.useEffect(() => {
+    !i.state.isWindowFocused || x || !d.current || (i.resumeTimers(), i.setHovering(!1), d.current = !1);
+  }, [x, i]);
+  function b() {
+    i.pauseTimers(), i.setHovering(!0), d.current = !1;
+  }
+  function O() {
+    x ? d.current = !0 : (i.resumeTimers(), i.setHovering(!1));
+  }
+  function v() {
+    if (a.current) {
+      a.current = !1;
+      return;
+    }
+    f || Ye(K(i.state.viewport).activeElement) && (i.setFocused(!0), i.pauseTimers());
+  }
+  function C(E) {
+    !f || J(i.state.viewport, E.relatedTarget) || (i.setFocused(!1), i.resumeTimers());
+  }
+  const A = {
+    tabIndex: -1,
+    role: "region",
+    "aria-live": "polite",
+    "aria-atomic": !1,
+    "aria-relevant": "additions text",
+    "aria-label": "Notifications",
+    onMouseEnter: b,
+    onMouseMove: b,
+    onMouseLeave: O,
+    onFocus: v,
+    onBlur: C,
+    onKeyDown: R,
+    onClick: v
+  }, ee = {
+    expanded: h
+  }, Y = Q("div", e, {
+    ref: [n, i.setViewport],
+    state: ee,
+    props: [A, {
+      style: {
+        [rs.frontmostHeight]: y ? `${y}px` : void 0
+      }
+    }, u, {
+      children: /* @__PURE__ */ B(c.Fragment, {
+        children: [!l && g && /* @__PURE__ */ T(ne, {
+          onFocus: N
+        }), o, !l && g && /* @__PURE__ */ T(ne, {
+          onFocus: N
+        })]
+      })
+    }]
+  }), pe = c.useMemo(() => p.filter((E) => E.priority === "high"), [p]);
+  return /* @__PURE__ */ B(c.Fragment, {
+    children: [!l && g && /* @__PURE__ */ T(ne, {
+      onFocus: N
+    }), Y, !f && pe.length > 0 && /* @__PURE__ */ T("div", {
+      style: Ut,
+      children: pe.map((E) => /* @__PURE__ */ B("div", {
+        role: "alert",
+        "aria-atomic": !0,
+        children: [/* @__PURE__ */ T("div", {
+          children: E.title
+        }), /* @__PURE__ */ T("div", {
+          children: E.description
+        })]
+      }, E.id))
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Gt.displayName = "ToastViewport");
+function ss(t) {
+  return Je(19) ? t : t ? "true" : void 0;
+}
+const st = /* @__PURE__ */ c.createContext(void 0);
+process.env.NODE_ENV !== "production" && (st.displayName = "ToastRootContext");
+function De() {
+  const t = c.useContext(st);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ToastRootContext is missing. Toast parts must be used within <Toast.Root>." : q(66));
+  return t;
+}
+let ot = /* @__PURE__ */ (function(t) {
+  return t.startingStyle = "data-starting-style", t.endingStyle = "data-ending-style", t;
+})({});
+const os = {
+  [ot.startingStyle]: ""
+}, is = {
+  [ot.endingStyle]: ""
+}, as = {
+  transitionStatus(t) {
+    return t === "starting" ? os : t === "ending" ? is : null;
+  }
+};
+function us(t) {
+  return t == null ? t : "current" in t ? t.current : t;
+}
+function cs(t, e = !1, n = !0) {
+  const r = vr();
+  return X((s, o = null) => {
+    r.cancel();
+    function u() {
+      fe.flushSync(s);
+    }
+    const i = us(t);
+    if (i == null)
+      return;
+    const m = i;
+    if (typeof m.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED)
+      s();
+    else {
+      let a = function() {
+        const l = ot.startingStyle;
+        if (!m.hasAttribute(l)) {
+          r.request(d);
+          return;
+        }
+        const p = new MutationObserver(() => {
+          m.hasAttribute(l) || (p.disconnect(), d());
+        });
+        p.observe(m, {
+          attributes: !0,
+          attributeFilter: [l]
+        }), o?.addEventListener("abort", () => p.disconnect(), {
+          once: !0
+        });
+      }, d = function() {
+        Promise.all(m.getAnimations().map((l) => l.finished)).then(() => {
+          o?.aborted || u();
+        }).catch(() => {
+          const l = m.getAnimations();
+          if (n) {
+            if (o?.aborted)
+              return;
+            u();
+          } else l.length > 0 && l.some((p) => p.pending || p.playState !== "finished") && d();
+        });
+      };
+      if (e) {
+        a();
+        return;
+      }
+      r.request(d);
+    }
+  });
+}
+function ls(t) {
+  const {
+    enabled: e = !0,
+    open: n,
+    ref: r,
+    onComplete: s
+  } = t, o = X(s), u = cs(r, n, !1);
+  c.useEffect(() => {
+    if (!e)
+      return;
+    const i = new AbortController();
+    return u(o, i.signal), () => {
+      i.abort();
+    };
+  }, [e, n, o, u]);
+}
+let Z = /* @__PURE__ */ (function(t) {
+  return t.index = "--toast-index", t.offsetY = "--toast-offset-y", t.height = "--toast-height", t.swipeMovementX = "--toast-swipe-movement-x", t.swipeMovementY = "--toast-swipe-movement-y", t;
+})({});
+const fs = {
+  ...as,
+  swipeDirection(t) {
+    return t ? {
+      "data-swipe-direction": t
+    } : null;
+  }
+}, ie = 40, ds = 10, G = 0.5, ps = 1;
+function _t(t, e, n) {
+  switch (t) {
+    case "up":
+      return -n;
+    case "down":
+      return n;
+    case "left":
+      return -e;
+    case "right":
+      return e;
+    default:
+      return 0;
+  }
+}
+function ms(t) {
+  const n = window.getComputedStyle(t).transform;
+  let r = 0, s = 0, o = 1;
+  if (n && n !== "none") {
+    const u = n.match(/matrix(?:3d)?\(([^)]+)\)/);
+    if (u) {
+      const i = u[1].split(", ").map(parseFloat);
+      i.length === 6 ? (r = i[4], s = i[5], o = Math.sqrt(i[0] * i[0] + i[1] * i[1])) : i.length === 16 && (r = i[12], s = i[13], o = i[0]);
+    }
+  }
+  return {
+    x: r,
+    y: s,
+    scale: o
+  };
+}
+const qt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    toast: r,
+    render: s,
+    className: o,
+    swipeDirection: u = ["down", "right"],
+    ...i
+  } = e, m = r.positionerProps?.anchor !== void 0;
+  let a = [];
+  m || (a = Array.isArray(u) ? u : [u]);
+  const d = a.length > 0, l = nt(), [p, f] = c.useState(void 0), [h, g] = c.useState(!1), [y, x] = c.useState(!1), [N, R] = c.useState(!1), [b, O] = c.useState({
+    x: 0,
+    y: 0
+  }), [v, C] = c.useState({
+    x: 0,
+    y: 0,
+    scale: 1
+  }), [A, ee] = c.useState(), [Y, pe] = c.useState(), [E, D] = c.useState(null), I = c.useRef(null), k = c.useRef({
+    x: 0,
+    y: 0
+  }), U = c.useRef({
+    x: 0,
+    y: 0,
+    scale: 1
+  }), te = c.useRef(void 0), se = c.useRef(0), me = c.useRef(!1), M = c.useRef({
+    x: 0,
+    y: 0
+  }), _e = c.useRef(!1), Ie = l.useState("toastIndex", r.id), Pe = l.useState("toastVisibleIndex", r.id), sn = l.useState("toastOffsetY", r.id), on = l.useState("focused"), Ae = l.useState("expanded");
+  ls({
+    open: r.transitionStatus !== "ending",
+    ref: I,
+    onComplete() {
+      r.transitionStatus === "ending" && l.removeToast(r.id);
+    }
+  });
+  const he = X((S = !1) => {
+    const w = I.current;
+    if (!w)
+      return;
+    const _ = w.style.height;
+    w.style.height = "auto";
+    const P = w.offsetHeight;
+    w.style.height = _;
+    function F() {
+      l.updateToastInternal(r.id, {
+        ref: I,
+        height: P,
+        ...r.transitionStatus === "starting" ? {
+          transitionStatus: void 0
+        } : {}
+      });
+    }
+    S ? fe.flushSync(F) : F();
+  });
+  $(he, [he]);
+  function an(S, w) {
+    let _ = S, P = w;
+    return !a.includes("left") && !a.includes("right") ? _ = S > 0 ? S ** G : -(Math.abs(S) ** G) : (!a.includes("right") && S > 0 && (_ = S ** G), !a.includes("left") && S < 0 && (_ = -(Math.abs(S) ** G))), !a.includes("up") && !a.includes("down") ? P = w > 0 ? w ** G : -(Math.abs(w) ** G) : (!a.includes("down") && w > 0 && (P = w ** G), !a.includes("up") && w < 0 && (P = -(Math.abs(w) ** G))), {
+      x: _,
+      y: P
+    };
+  }
+  function un(S) {
+    if (S.button !== 0)
+      return;
+    S.pointerType === "touch" && l.pauseTimers();
+    const w = Qe(S.nativeEvent);
+    if (!(w && w.closest('button,a,input,textarea,[role="button"],[data-swipe-ignore]'))) {
+      if (me.current = !1, te.current = void 0, se.current = 0, k.current = {
+        x: S.clientX,
+        y: S.clientY
+      }, M.current = k.current, I.current) {
+        const P = ms(I.current);
+        U.current = P, C(P), O({
+          x: P.x,
+          y: P.y
+        });
+      }
+      l.setHovering(!0), g(!0), x(!1), D(null), _e.current = !0, I.current?.setPointerCapture(S.pointerId);
+    }
+  }
+  function cn(S) {
+    if (!h)
+      return;
+    S.preventDefault(), _e.current && (k.current = {
+      x: S.clientX,
+      y: S.clientY
+    }, _e.current = !1);
+    const {
+      clientY: w,
+      clientX: _,
+      movementX: P,
+      movementY: F
+    } = S;
+    (F < 0 && w > M.current.y || F > 0 && w < M.current.y) && (M.current = {
+      x: M.current.x,
+      y: w
+    }), (P < 0 && _ > M.current.x || P > 0 && _ < M.current.x) && (M.current = {
+      x: _,
+      y: M.current.y
+    });
+    const L = _ - k.current.x, H = w - k.current.y, gn = w - M.current.y, bn = _ - M.current.x;
+    if (!y && Math.sqrt(L * L + H * H) >= ps && (x(!0), E === null)) {
+      const ve = a.includes("left") || a.includes("right"), vn = a.includes("up") || a.includes("down");
+      if (ve && vn) {
+        const yn = Math.abs(L), En = Math.abs(H);
+        D(yn > En ? "horizontal" : "vertical");
+      }
+    }
+    let V;
+    if (!te.current)
+      E === "vertical" ? H > 0 ? V = "down" : H < 0 && (V = "up") : E === "horizontal" ? L > 0 ? V = "right" : L < 0 && (V = "left") : Math.abs(L) >= Math.abs(H) ? V = L > 0 ? "right" : "left" : V = H > 0 ? "down" : "up", V && a.includes(V) && (te.current = V, se.current = _t(V, L, H), f(V));
+    else {
+      const Fe = te.current, ve = _t(Fe, bn, gn);
+      ve > ie ? (me.current = !1, f(Fe)) : !(a.includes("left") && a.includes("right")) && !(a.includes("up") && a.includes("down")) && se.current - ve >= ds && (me.current = !0);
+    }
+    const be = an(L, H);
+    let ke = U.current.x, Me = U.current.y;
+    E === "horizontal" ? (a.includes("left") || a.includes("right")) && (ke += be.x) : (E === "vertical" || (a.includes("left") || a.includes("right")) && (ke += be.x), (a.includes("up") || a.includes("down")) && (Me += be.y)), O({
+      x: ke,
+      y: Me
+    });
+  }
+  function ln(S) {
+    if (!h)
+      return;
+    if (g(!1), x(!1), D(null), I.current?.releasePointerCapture(S.pointerId), me.current) {
+      O({
+        x: v.x,
+        y: v.y
+      }), f(void 0);
+      return;
+    }
+    let w = !1;
+    const _ = b.x - v.x, P = b.y - v.y;
+    let F;
+    for (const L of a) {
+      switch (L) {
+        case "right":
+          _ > ie && (w = !0, F = "right");
+          break;
+        case "left":
+          _ < -ie && (w = !0, F = "left");
+          break;
+        case "down":
+          P > ie && (w = !0, F = "down");
+          break;
+        case "up":
+          P < -ie && (w = !0, F = "up");
+          break;
+      }
+      if (w)
+        break;
+    }
+    w ? (f(F), R(!0), l.closeToast(r.id)) : (O({
+      x: v.x,
+      y: v.y
+    }), f(void 0));
+  }
+  function fn(S) {
+    if (S.key === "Escape") {
+      if (!I.current || !J(I.current, ce(K(I.current))))
+        return;
+      l.closeToast(r.id);
+    }
+  }
+  c.useEffect(() => {
+    if (!d)
+      return;
+    const S = I.current;
+    if (!S)
+      return;
+    function w(_) {
+      J(S, _.target) && _.preventDefault();
+    }
+    return S.addEventListener("touchmove", w, {
+      passive: !1
+    }), () => {
+      S.removeEventListener("touchmove", w);
+    };
+  }, [d]);
+  function dn() {
+    if (!h && b.x === v.x && b.y === v.y && !N)
+      return {
+        [Z.swipeMovementX]: "0px",
+        [Z.swipeMovementY]: "0px"
+      };
+    const S = b.x - v.x, w = b.y - v.y;
+    return {
+      transition: h ? "none" : void 0,
+      // While swiping, freeze the element at its current visual transform so it doesn't snap to the
+      // end position.
+      transform: h ? `translateX(${b.x}px) translateY(${b.y}px) scale(${v.scale})` : void 0,
+      [Z.swipeMovementX]: `${S}px`,
+      [Z.swipeMovementY]: `${w}px`
+    };
+  }
+  const at = r.priority === "high", pn = {
+    role: at ? "alertdialog" : "dialog",
+    tabIndex: 0,
+    "aria-modal": !1,
+    "aria-labelledby": A,
+    "aria-describedby": Y,
+    "aria-hidden": at && !on ? !0 : void 0,
+    onPointerDown: d ? un : void 0,
+    onPointerMove: d ? cn : void 0,
+    onPointerUp: d ? ln : void 0,
+    onKeyDown: fn,
+    inert: ss(r.limited),
+    style: {
+      ...dn(),
+      [Z.index]: r.transitionStatus === "ending" ? Ie : Pe,
+      [Z.offsetY]: `${sn}px`,
+      [Z.height]: r.height ? `${r.height}px` : void 0
+    }
+  }, ge = c.useMemo(() => ({
+    rootRef: I,
+    toast: r,
+    titleId: A,
+    setTitleId: ee,
+    descriptionId: Y,
+    setDescriptionId: pe,
+    swiping: h,
+    swipeDirection: p,
+    recalculateHeight: he,
+    index: Ie,
+    visibleIndex: Pe,
+    expanded: Ae
+  }), [r, A, Y, h, p, he, Ie, Pe, Ae]), mn = {
+    transitionStatus: r.transitionStatus,
+    expanded: Ae,
+    limited: r.limited || !1,
+    type: r.type,
+    swiping: ge.swiping,
+    swipeDirection: ge.swipeDirection
+  }, hn = Q("div", e, {
+    ref: [n, ge.rootRef],
+    state: mn,
+    stateAttributesMapping: fs,
+    props: [pn, i]
+  });
+  return /* @__PURE__ */ T(st.Provider, {
+    value: ge,
+    children: hn
+  });
+});
+process.env.NODE_ENV !== "production" && (qt.displayName = "ToastRoot");
+const Yt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    render: r,
+    className: s,
+    ...o
+  } = e, {
+    visibleIndex: u,
+    expanded: i,
+    recalculateHeight: m
+  } = De(), a = c.useRef(null);
+  $(() => {
+    const f = a.current;
+    if (!f || (m(), typeof ResizeObserver != "function" || typeof MutationObserver != "function"))
+      return;
+    const h = new ResizeObserver(() => m(!0)), g = new MutationObserver(() => m(!0));
+    return h.observe(f), g.observe(f, {
+      childList: !0,
+      subtree: !0,
+      characterData: !0
+    }), () => {
+      h.disconnect(), g.disconnect();
+    };
+  }, [m]);
+  const d = u > 0;
+  return Q("div", e, {
+    ref: [n, a],
+    state: {
+      expanded: i,
+      behind: d
+    },
+    props: o
+  });
+});
+process.env.NODE_ENV !== "production" && (Yt.displayName = "ToastContent");
+const Zt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    render: r,
+    className: s,
+    id: o,
+    children: u,
+    ...i
+  } = e, {
+    toast: m,
+    setDescriptionId: a
+  } = De(), d = u ?? m.description, l = !!d, p = Xe(o);
+  $(() => {
+    if (l)
+      return a(p), () => {
+        a(void 0);
+      };
+  }, [l, p, a]);
+  const f = {
+    type: m.type
+  }, h = Q("p", e, {
+    ref: n,
+    state: f,
+    props: {
+      ...i,
+      id: p,
+      children: d
+    }
+  });
+  return l ? h : null;
+});
+process.env.NODE_ENV !== "production" && (Zt.displayName = "ToastDescription");
+const Xt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    render: r,
+    className: s,
+    id: o,
+    children: u,
+    ...i
+  } = e, {
+    toast: m,
+    setTitleId: a
+  } = De(), d = u ?? m.title, l = !!d, p = Xe(o);
+  $(() => {
+    if (l)
+      return a(p), () => {
+        a(void 0);
+      };
+  }, [l, p, a]);
+  const f = {
+    type: m.type
+  }, h = Q("h2", e, {
+    ref: n,
+    state: f,
+    props: {
+      ...i,
+      id: p,
+      children: d
+    }
+  });
+  return l ? h : null;
+});
+process.env.NODE_ENV !== "production" && (Xt.displayName = "ToastTitle");
+let Ze;
+process.env.NODE_ENV !== "production" && (Ze = /* @__PURE__ */ new Set());
+function It(...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = t.join(" ");
+    Ze.has(e) || (Ze.add(e), console.error(`Base UI: ${e}`));
+  }
+}
+const Jt = /* @__PURE__ */ c.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Jt.displayName = "CompositeRootContext");
+function hs(t = !1) {
+  const e = c.useContext(Jt);
+  if (e === void 0 && !t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>." : q(16));
+  return e;
+}
+function gs(t) {
+  const {
+    focusableWhenDisabled: e,
+    disabled: n,
+    composite: r = !1,
+    tabIndex: s = 0,
+    isNativeButton: o
+  } = t, u = r && e !== !1, i = r && e === !1;
+  return {
+    props: c.useMemo(() => {
+      const a = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(d) {
+          n && e && d.key !== "Tab" && d.preventDefault();
+        }
+      };
+      return r || (a.tabIndex = s, !o && n && (a.tabIndex = e ? s : -1)), (o && (e || u) || !o && n) && (a["aria-disabled"] = n), o && (!e || i) && (a.disabled = n), a;
+    }, [r, n, e, u, i, o, s])
+  };
+}
+function bs(t = {}) {
+  const {
+    disabled: e = !1,
+    focusableWhenDisabled: n,
+    tabIndex: r = 0,
+    native: s = !0
+  } = t, o = c.useRef(null), u = hs(!0) !== void 0, i = X(() => {
+    const p = o.current;
+    return !!(p?.tagName === "A" && p?.href);
+  }), {
+    props: m
+  } = gs({
+    focusableWhenDisabled: n,
+    disabled: e,
+    composite: u,
+    tabIndex: r,
+    isNativeButton: s
+  });
+  process.env.NODE_ENV !== "production" && c.useEffect(() => {
+    if (!o.current)
+      return;
+    const p = o.current.tagName === "BUTTON";
+    if (s) {
+      if (!p) {
+        const f = We.captureOwnerStack?.() || "";
+        It(`A component that acts as a button expected a native <button> because the \`nativeButton\` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the \`render\` prop, or set \`nativeButton\` to \`false\`.${f}`);
+      }
+    } else if (p) {
+      const f = We.captureOwnerStack?.() || "";
+      It(`A component that acts as a button expected a non-<button> because the \`nativeButton\` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as \`role\` or \`aria-disabled\`). Use a non-<button> in the \`render\` prop, or set \`nativeButton\` to \`true\`.${f}`);
+    }
+  }, [s]);
+  const a = c.useCallback(() => {
+    const p = o.current;
+    vs(p) && u && e && m.disabled === void 0 && p.disabled && (p.disabled = !1);
+  }, [e, m.disabled, u]);
+  $(a, [a]);
+  const d = c.useCallback((p = {}) => {
+    const {
+      onClick: f,
+      onMouseDown: h,
+      onKeyUp: g,
+      onKeyDown: y,
+      onPointerDown: x,
+      ...N
+    } = p;
+    return Lt({
+      type: s ? "button" : void 0,
+      onClick(b) {
+        if (e) {
+          b.preventDefault();
+          return;
+        }
+        f?.(b);
+      },
+      onMouseDown(b) {
+        e || h?.(b);
+      },
+      onKeyDown(b) {
+        if (e || (qe(b), y?.(b)), b.baseUIHandlerPrevented)
+          return;
+        const O = b.target === b.currentTarget && !s && !i() && !e, v = b.key === "Enter", C = b.key === " ";
+        O && ((C || v) && b.preventDefault(), v && f?.(b));
+      },
+      onKeyUp(b) {
+        e || (qe(b), g?.(b)), !b.baseUIHandlerPrevented && b.target === b.currentTarget && !s && !e && b.key === " " && f?.(b);
+      },
+      onPointerDown(b) {
+        if (e) {
+          b.preventDefault();
+          return;
+        }
+        x?.(b);
+      }
+    }, s ? void 0 : {
+      role: "button"
+    }, m, N);
+  }, [e, m, s, i]), l = X((p) => {
+    o.current = p, a();
+  });
+  return {
+    getButtonProps: d,
+    buttonRef: l
+  };
+}
+function vs(t) {
+  return Pn(t) && t.tagName === "BUTTON";
+}
+const Qt = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    render: r,
+    className: s,
+    disabled: o,
+    nativeButton: u = !0,
+    ...i
+  } = e, m = nt(), {
+    toast: a
+  } = De(), d = m.useState("expanded"), [l, p] = c.useState(!1), {
+    getButtonProps: f,
+    buttonRef: h
+  } = bs({
+    disabled: o,
+    native: u
+  }), g = {
+    type: a.type
+  };
+  return Q("button", e, {
+    ref: [n, h],
+    state: g,
+    props: [{
+      "aria-hidden": !d && !l,
+      onClick() {
+        m.closeToast(a.id);
+      },
+      onFocus() {
+        p(!0);
+      },
+      onBlur() {
+        p(!1);
+      }
+    }, i, f]
+  });
+});
+process.env.NODE_ENV !== "production" && (Qt.displayName = "ToastClose");
+function ys(t) {
+  return `data-base-ui-${t}`;
+}
+const it = /* @__PURE__ */ c.createContext(null);
+process.env.NODE_ENV !== "production" && (it.displayName = "PortalContext");
+const Es = () => c.useContext(it), ws = ys("portal");
+function en(t = {}) {
+  const {
+    ref: e,
+    container: n,
+    componentProps: r = W,
+    elementProps: s
+  } = t, o = Xe(), i = Es()?.portalNode, [m, a] = c.useState(null), [d, l] = c.useState(null), p = X((y) => {
+    y !== null && l(y);
+  }), f = c.useRef(null);
+  $(() => {
+    if (n === null) {
+      f.current && (f.current = null, l(null), a(null));
+      return;
+    }
+    if (o == null)
+      return;
+    const y = (n && (An(n) ? n : n.current)) ?? i ?? document.body;
+    if (y == null) {
+      f.current && (f.current = null, l(null), a(null));
+      return;
+    }
+    f.current !== y && (f.current = y, l(null), a(y));
+  }, [n, i, o]);
+  const h = Q("div", r, {
+    ref: [e, p],
+    props: [{
+      id: o,
+      [ws]: ""
+    }, s]
+  });
+  return {
+    portalNode: d,
+    portalSubtree: m && h ? /* @__PURE__ */ fe.createPortal(h, m) : null
+  };
+}
+const Ss = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    children: r,
+    container: s,
+    className: o,
+    render: u,
+    renderGuards: i,
+    ...m
+  } = e, {
+    portalNode: a,
+    portalSubtree: d
+  } = en({
+    container: s,
+    ref: n,
+    componentProps: e,
+    elementProps: m
+  }), l = c.useRef(null), p = c.useRef(null), f = c.useRef(null), h = c.useRef(null), [g, y] = c.useState(null), x = g?.modal, N = g?.open, R = typeof i == "boolean" ? i : !!g && !g.modal && g.open && !!a;
+  c.useEffect(() => {
+    if (!a || x)
+      return;
+    function O(v) {
+      a && v.relatedTarget && je(v) && (v.type === "focusin" ? vt : hr)(a);
+    }
+    return a.addEventListener("focusin", O, !0), a.addEventListener("focusout", O, !0), () => {
+      a.removeEventListener("focusin", O, !0), a.removeEventListener("focusout", O, !0);
+    };
+  }, [a, x]), c.useEffect(() => {
+    !a || N || vt(a);
+  }, [N, a]);
+  const b = c.useMemo(() => ({
+    beforeOutsideRef: l,
+    afterOutsideRef: p,
+    beforeInsideRef: f,
+    afterInsideRef: h,
+    portalNode: a,
+    setFocusManagerState: y
+  }), [a]);
+  return /* @__PURE__ */ B(c.Fragment, {
+    children: [d, /* @__PURE__ */ B(it.Provider, {
+      value: b,
+      children: [R && a && /* @__PURE__ */ T(ne, {
+        "data-type": "outside",
+        ref: l,
+        onFocus: (O) => {
+          if (je(O, a))
+            f.current?.focus();
+          else {
+            const v = g ? g.domReference : null;
+            mr(v)?.focus();
+          }
+        }
+      }), R && a && /* @__PURE__ */ T("span", {
+        "aria-owns": a.id,
+        style: $n
+      }), a && /* @__PURE__ */ fe.createPortal(r, a), R && a && /* @__PURE__ */ T(ne, {
+        "data-type": "outside",
+        ref: p,
+        onFocus: (O) => {
+          if (je(O, a))
+            h.current?.focus();
+          else {
+            const v = g ? g.domReference : null;
+            pr(v)?.focus(), g?.closeOnFocusOut && g?.onOpenChange(!1, Un(Bn, O.nativeEvent));
+          }
+        }
+      })]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ss.displayName = "FloatingPortal");
+const tn = /* @__PURE__ */ c.forwardRef(function(e, n) {
+  const {
+    children: r,
+    container: s,
+    className: o,
+    render: u,
+    ...i
+  } = e, {
+    portalNode: m,
+    portalSubtree: a
+  } = en({
+    container: s,
+    ref: n,
+    componentProps: e,
+    elementProps: i
+  });
+  return !a && !m ? null : /* @__PURE__ */ B(c.Fragment, {
+    children: [a, m && /* @__PURE__ */ fe.createPortal(r, m)]
+  });
+});
+process.env.NODE_ENV !== "production" && (tn.displayName = "FloatingPortalLite");
+const xs = tn;
+function nn() {
+  const t = c.useContext(Re);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : q(73));
+  const e = t.useState("toasts");
+  return c.useMemo(() => ({
+    toasts: e,
+    add: t.addToast,
+    close: t.closeToast,
+    update: t.updateToast,
+    promise: t.promiseToast
+  }), [e, t]);
+}
+const Ts = (t) => {
+  const [e, n] = xn(!1), r = () => n(!0), s = () => n(!1);
+  return Tn(() => {
+    const o = t.current;
+    if (o)
+      return o.addEventListener("mouseenter", r), o.addEventListener("mouseleave", s), () => {
+        o.removeEventListener("mouseenter", r), o.removeEventListener("mouseleave", s);
+      };
+  }, []), e;
+}, Os = wn(
+  "relative isolate z-tooltip flex w-full flex-col overflow-hidden rounded-xl border bg-card-background backdrop-blur-md text-sm shadow-notification transition-all duration-300",
+  {
+    variants: {
+      theme: {
+        default: "border-card-border text-foreground shadow-black/5",
+        info: "bg-alert-info-bg text-alert-info-text border-alert-info-border",
+        warn: "bg-alert-warn-bg text-alert-warn-text border-alert-warn-border",
+        muted: "bg-alert-muted-bg text-alert-muted-text border-alert-muted-border",
+        danger: "bg-alert-danger-bg text-alert-danger-text border-alert-danger-border",
+        success: "bg-alert-success-bg text-alert-success-text border-alert-success-border",
+        secondary: "bg-alert-secondary-bg text-alert-secondary-text border-alert-secondary-border"
+      }
+    },
+    defaultVariants: { theme: "default" }
+  }
+), Cs = {
+  default: ae,
+  info: ae,
+  warn: lt,
+  muted: ae,
+  danger: lt,
+  success: Sn,
+  secondary: ae
+}, rn = On(() => {
+  throw new Error("Not implemented");
+}), Gs = () => Cn(rn);
+function Ns(t) {
+  const e = t.toast.data?.closable ?? !0, n = t.toast.data?.loading ?? !1, r = t.toast.data?.theme || "default", s = Os({ theme: r }), o = n ? kt : Cs[r] || ae;
+  return /* @__PURE__ */ T(qt, { toast: t.toast, swipeDirection: "right", children: /* @__PURE__ */ T(
+    Pt.li,
+    {
+      layout: !0,
+      initial: { opacity: 0, y: -20, scale: 0.95 },
+      animate: { opacity: 1, y: 0, scale: 1 },
+      exit: { opacity: 0, scale: 0.9, y: -20, transition: { duration: 0.2 } },
+      transition: {
+        type: "spring",
+        damping: 25,
+        stiffness: 300
+      },
+      className: "pointer-events-auto w-full list-none",
+      children: /* @__PURE__ */ T(Yt, { className: ft(s, "shadow-lg"), children: /* @__PURE__ */ B("div", { className: "flex items-start gap-3 p-4", children: [
+        /* @__PURE__ */ T("div", { className: ft("mt-0.5 shrink-0 opacity-80", n && "animate-spin"), children: /* @__PURE__ */ T(o, { className: "size-4" }) }),
+        /* @__PURE__ */ B("div", { className: "flex flex-1 flex-col gap-1 overflow-hidden", children: [
+          t.toast.title ? /* @__PURE__ */ T(Xt, { className: "select-text truncate font-semibold leading-tight tracking-tight" }) : null,
+          /* @__PURE__ */ T(Zt, { className: "line-clamp-2 select-text text-xs font-medium leading-relaxed opacity-90" })
+        ] }),
+        e && !n ? /* @__PURE__ */ T(Qt, { className: "-mr-1 -mt-1 shrink-0 rounded-lg p-1.5 text-foreground/40 transition hover:bg-foreground/10 hover:text-foreground", children: /* @__PURE__ */ T(Dn, { className: "size-3.5" }) }) : null
+      ] }) })
+    }
+  ) });
+}
+function Rs({ max: t = 5 }) {
+  const e = Nn(null), n = Ts(e), r = nn(), s = t ? r.toasts.slice(0, t) : r.toasts, o = n ? s : s.slice(0, 3), u = s.length - o.length;
+  return /* @__PURE__ */ B(
+    Gt,
+    {
+      ref: e,
+      className: "pointer-events-none fixed left-1/2 top-6 z-[100] flex w-full max-w-[380px] -translate-x-1/2 flex-col gap-3 overflow-visible outline-none",
+      children: [
+        /* @__PURE__ */ T(_n, { mode: "popLayout", initial: !1, children: o.map((i) => /* @__PURE__ */ T(Ns, { toast: i }, i.id)) }),
+        !n && u > 0 && /* @__PURE__ */ B(
+          Pt.div,
+          {
+            layout: !0,
+            initial: { opacity: 0, y: -10 },
+            animate: { opacity: 1, y: 0 },
+            exit: { opacity: 0, y: -10 },
+            className: "pointer-events-auto cursor-default self-center rounded-full border border-card-border bg-card-background/80 px-3 py-1 text-[10px] font-bold uppercase tracking-wider text-foreground/50 shadow-sm backdrop-blur transition-all hover:bg-card-background hover:text-foreground/80",
+            children: [
+              "+",
+              u,
+              " more"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function Ds({ children: t, max: e = 5 }) {
+  const n = nn(), r = ct(() => {
+    n.toasts.forEach((o) => n.close(o.id));
+  }, [n]), s = ct(
+    (o, u) => {
+      const i = { theme: u?.theme, closable: u?.closable, loading: u?.loading };
+      if (u?.id && n.toasts.find((d) => d.id === u.id))
+        return n.update(u.id, {
+          description: o,
+          title: u.title,
+          timeout: u.timeout,
+          data: i
+        }), { close: () => n.close(u.id), clear: r };
+      const m = n.add({
+        description: o,
+        id: u?.id,
+        title: u?.title,
+        timeout: u?.timeout,
+        data: i
+      });
+      return {
+        close: () => n.close(m),
+        clear: r
+      };
+    },
+    [n, r]
+  );
+  return /* @__PURE__ */ B(rn.Provider, { value: s, children: [
+    t,
+    /* @__PURE__ */ T(xs, { children: /* @__PURE__ */ T(Rs, { max: e }) })
+  ] });
+}
+function qs({ children: t, max: e = 5, timeout: n = 5e3 }) {
+  return /* @__PURE__ */ T(Kt, { limit: e, timeout: n, children: /* @__PURE__ */ T(Ds, { max: e, children: t }) });
+}
+export {
+  W as E,
+  jn as N,
+  $ as a,
+  X as b,
+  Xe as c,
+  ce as d,
+  Q as e,
+  q as f,
+  Un as g,
+  Ks as h,
+  Hs as i,
+  vr as j,
+  zs as k,
+  Ws as l,
+  J as m,
+  Bs as n,
+  K as o,
+  et as p,
+  Lt as q,
+  gt as r,
+  Gs as s,
+  Us as t,
+  re as u,
+  Ut as v,
+  qs as w
+};
+//# sourceMappingURL=notifications-cUdVPs-B.js.map