@g4rcez/components 3.0.1 → 3.0.2

package/dist/notifications-NPuFDsBp.js

@@ -0,0 +1,2550 @@
+import { jsx as x, jsxs as U } from "react/jsx-runtime";
+import { c as on } from "./index-DJSMaZR4.js";
+import * as u from "react";
+import { createElement as et, useState as an, useEffect as cn, createContext as un, useContext as ln, useCallback as tt, useRef as dn } from "react";
+import { c as nt } from "./dom-Dl8XH0CK.js";
+import { A as fn, m as yt } from "./proxy-BZcQiBrp.js";
+import { c as pn } from "./createLucideIcon-CP-mMPfa.js";
+import { I as ae } from "./info-N5jWZg2A.js";
+import { C as hn } from "./circle-check-big-3M5lhTxx.js";
+import { T as st } from "./triangle-alert-CHMhQ6yd.js";
+import { X as mn } from "./x-B9bYxG31.js";
+import { w as gn, s as bn } from "./index-DE4shK8D.js";
+import { a as yn, t as vt, g as rt, b as vn, c as wn } from "./index.esm-BaIwleSE.js";
+import * as de from "react-dom";
+const En = [["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]], xn = pn("loader-circle", En);
+function K(t) {
+  return t?.ownerDocument || document;
+}
+const ot = {};
+function se(t, e) {
+  const n = u.useRef(ot);
+  return n.current === ot && (n.current = t(e)), n;
+}
+const Me = u[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)], Tn = (
+  // React 17 doesn't have useInsertionEffect.
+  Me && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  Me !== u.useLayoutEffect ? Me : (t) => t()
+);
+function J(t) {
+  const e = se(Sn).current;
+  return e.next = t, Tn(e.effect), e.trampoline;
+}
+function Sn() {
+  const t = {
+    next: void 0,
+    callback: Nn,
+    trampoline: (...e) => t.callback?.(...e),
+    effect: () => {
+      t.callback = t.next;
+    }
+  };
+  return t;
+}
+function Nn() {
+  if (process.env.NODE_ENV !== "production")
+    throw (
+      /* minify-error-disabled */
+      new Error("Base UI: Cannot call an event handler while rendering.")
+    );
+}
+const Cn = () => {
+}, $ = typeof document < "u" ? u.useLayoutEffect : Cn;
+function In() {
+}
+const W = Object.freeze({}), Dn = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Tr = "none", Sr = "track-press", Nr = "input-change", Rn = "focus-out", Cr = "keyboard", Ir = "drag";
+function On(t, e, n, s) {
+  let r = !1, o = !1;
+  const c = s ?? W;
+  return {
+    reason: t,
+    event: e ?? new Event("base-ui"),
+    cancel() {
+      r = !0;
+    },
+    allowPropagation() {
+      o = !0;
+    },
+    get isCanceled() {
+      return r;
+    },
+    get isPropagationAllowed() {
+      return o;
+    },
+    trigger: n,
+    ...c
+  };
+}
+function Dr(t, e, n) {
+  const s = W;
+  return {
+    reason: t,
+    event: e ?? new Event("base-ui"),
+    ...s
+  };
+}
+const Le = {
+  ...u
+};
+let it = 0;
+function Pn(t, e = "mui") {
+  const [n, s] = u.useState(t), r = t || n;
+  return u.useEffect(() => {
+    n == null && (it += 1, s(`${e}-${it}`));
+  }, [n, e]), r;
+}
+const at = Le.useId;
+function He(t, e) {
+  if (at !== void 0) {
+    const n = at();
+    return t ?? (e ? `${e}-${n}` : n);
+  }
+  return Pn(t, e);
+}
+function Y(t, ...e) {
+  const n = new URL("https://base-ui.com/production-error");
+  return n.searchParams.set("code", t.toString()), e.forEach((s) => n.searchParams.append("args[]", s)), `Base UI error #${t}; visit ${n} for the full message.`;
+}
+function ct(t, e, n, s) {
+  const r = se(wt).current;
+  return Fn(r, t, e, n, s) && Et(r, [t, e, n, s]), r.callback;
+}
+function kn(t) {
+  const e = se(wt).current;
+  return Mn(e, t) && Et(e, t), e.callback;
+}
+function wt() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function Fn(t, e, n, s, r) {
+  return t.refs[0] !== e || t.refs[1] !== n || t.refs[2] !== s || t.refs[3] !== r;
+}
+function Mn(t, e) {
+  return t.refs.length !== e.length || t.refs.some((n, s) => n !== e[s]);
+}
+function Et(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 s = Array(e.length).fill(null);
+      for (let r = 0; r < e.length; r += 1) {
+        const o = e[r];
+        if (o != null)
+          switch (typeof o) {
+            case "function": {
+              const c = o(n);
+              typeof c == "function" && (s[r] = c);
+              break;
+            }
+            case "object": {
+              o.current = n;
+              break;
+            }
+          }
+      }
+      t.cleanup = () => {
+        for (let r = 0; r < e.length; r += 1) {
+          const o = e[r];
+          if (o != null)
+            switch (typeof o) {
+              case "function": {
+                const c = s[r];
+                typeof c == "function" ? c() : o(null);
+                break;
+              }
+              case "object": {
+                o.current = null;
+                break;
+              }
+            }
+        }
+      };
+    }
+  };
+}
+const An = parseInt(u.version, 10);
+function We(t) {
+  return An >= t;
+}
+function ut(t) {
+  if (!/* @__PURE__ */ u.isValidElement(t))
+    return null;
+  const e = t, n = e.props;
+  return (We(19) ? n?.ref : e.ref) ?? null;
+}
+function $e(t, e) {
+  if (t && !e)
+    return t;
+  if (!t && e)
+    return e;
+  if (t || e)
+    return {
+      ...t,
+      ...e
+    };
+}
+function Vn(t, e) {
+  const n = {};
+  for (const s in t) {
+    const r = t[s];
+    if (e?.hasOwnProperty(s)) {
+      const o = e[s](r);
+      o != null && Object.assign(n, o);
+      continue;
+    }
+    r === !0 ? n[`data-${s.toLowerCase()}`] = "" : r && (n[`data-${s.toLowerCase()}`] = r.toString());
+  }
+  return n;
+}
+function _n(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function Ln(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+const ce = {};
+function xt(t, e, n, s, r) {
+  let o = {
+    ...Ue(t, ce)
+  };
+  return e && (o = Te(o, e)), n && (o = Te(o, n)), s && (o = Te(o, s)), o;
+}
+function $n(t) {
+  if (t.length === 0)
+    return ce;
+  if (t.length === 1)
+    return Ue(t[0], ce);
+  let e = {
+    ...Ue(t[0], ce)
+  };
+  for (let n = 1; n < t.length; n += 1)
+    e = Te(e, t[n]);
+  return e;
+}
+function Te(t, e) {
+  return Tt(e) ? e(t) : Un(t, e);
+}
+function Un(t, e) {
+  if (!e)
+    return t;
+  for (const n in e) {
+    const s = e[n];
+    switch (n) {
+      case "style": {
+        t[n] = $e(t.style, s);
+        break;
+      }
+      case "className": {
+        t[n] = St(t.className, s);
+        break;
+      }
+      default:
+        jn(n, s) ? t[n] = Bn(t[n], s) : t[n] = s;
+    }
+  }
+  return t;
+}
+function jn(t, e) {
+  const n = t.charCodeAt(0), s = t.charCodeAt(1), r = t.charCodeAt(2);
+  return n === 111 && s === 110 && r >= 65 && r <= 90 && (typeof e == "function" || typeof e > "u");
+}
+function Tt(t) {
+  return typeof t == "function";
+}
+function Ue(t, e) {
+  return Tt(t) ? t(e) : t ?? ce;
+}
+function Bn(t, e) {
+  return e ? t ? (n) => {
+    if (zn(n)) {
+      const r = n;
+      je(r);
+      const o = e(r);
+      return r.baseUIHandlerPrevented || t?.(r), o;
+    }
+    const s = e(n);
+    return t?.(n), s;
+  } : e : t;
+}
+function je(t) {
+  return t.preventBaseUIHandler = () => {
+    t.baseUIHandlerPrevented = !0;
+  }, t;
+}
+function St(t, e) {
+  return e ? t ? e + " " + t : e : t;
+}
+function zn(t) {
+  return t != null && typeof t == "object" && "nativeEvent" in t;
+}
+function Q(t, e, n = {}) {
+  const s = e.render, r = Hn(e, n);
+  if (n.enabled === !1)
+    return null;
+  const o = n.state ?? W;
+  return Kn(t, s, r, o);
+}
+function Hn(t, e = {}) {
+  const {
+    className: n,
+    style: s,
+    render: r
+  } = t, {
+    state: o = W,
+    ref: c,
+    props: i,
+    stateAttributesMapping: l,
+    enabled: a = !0
+  } = e, d = a ? _n(n, o) : void 0, f = a ? Ln(s, o) : void 0, p = a ? Vn(o, l) : W, h = a ? $e(p, Array.isArray(i) ? $n(i) : i) ?? W : W;
+  return typeof document < "u" && (a ? Array.isArray(c) ? h.ref = kn([h.ref, ut(r), ...c]) : h.ref = ct(h.ref, ut(r), c) : ct(null, null)), a ? (d !== void 0 && (h.className = St(h.className, d)), f !== void 0 && (h.style = $e(h.style, f)), h) : W;
+}
+const Wn = /* @__PURE__ */ Symbol.for("react.lazy");
+function Kn(t, e, n, s) {
+  if (e) {
+    if (typeof e == "function")
+      return e(n, s);
+    const r = xt(n, e.props);
+    r.ref = n.ref;
+    let o = e;
+    if (o?.$$typeof === Wn && (o = u.Children.toArray(e)[0]), process.env.NODE_ENV !== "production" && !/* @__PURE__ */ u.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__ */ u.cloneElement(o, r);
+  }
+  if (t && typeof t == "string")
+    return qn(t, n);
+  throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : Y(8));
+}
+function qn(t, e) {
+  return t === "button" ? /* @__PURE__ */ et("button", {
+    type: "button",
+    ...e,
+    key: e.key
+  }) : t === "img" ? /* @__PURE__ */ et("img", {
+    alt: "",
+    ...e,
+    key: e.key
+  }) : /* @__PURE__ */ u.createElement(t, e);
+}
+const fe = typeof navigator < "u", Ae = Zn(), Yn = es(), Gn = Qn();
+typeof CSS > "u" || !CSS.supports || CSS.supports("-webkit-backdrop-filter:none");
+Ae.platform === "MacIntel" && Ae.maxTouchPoints > 1 || /iP(hone|ad|od)|iOS/.test(Ae.platform);
+const Xn = fe && /apple/i.test(navigator.vendor);
+fe && Yn.toLowerCase().startsWith("mac") && navigator.maxTouchPoints;
+const Jn = Gn.includes("jsdom/");
+function Zn() {
+  if (!fe)
+    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 Qn() {
+  if (!fe)
+    return "";
+  const t = navigator.userAgentData;
+  return t && Array.isArray(t.brands) ? t.brands.map(({
+    brand: e,
+    version: n
+  }) => `${e}/${n}`).join(" ") : navigator.userAgent;
+}
+function es() {
+  if (!fe)
+    return "";
+  const t = navigator.userAgentData;
+  return t?.platform ? t.platform : navigator.platform ?? "";
+}
+function ue(t) {
+  let e = t.activeElement;
+  for (; e?.shadowRoot?.activeElement != null; )
+    e = e.shadowRoot.activeElement;
+  return e;
+}
+function Z(t, e) {
+  if (!t || !e)
+    return !1;
+  const n = e.getRootNode?.();
+  if (t.contains(e))
+    return !0;
+  if (n && yn(n)) {
+    let s = e;
+    for (; s; ) {
+      if (t === s)
+        return !0;
+      s = s.parentNode || s.host;
+    }
+  }
+  return !1;
+}
+function Ke(t) {
+  return "composedPath" in t ? t.composedPath()[0] : t.target;
+}
+function Be(t) {
+  if (!t || Jn)
+    return !0;
+  try {
+    return t.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+const Nt = () => ({
+  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 Ct(t, e) {
+  const n = vt(t, Nt()), s = n.length;
+  if (s === 0)
+    return;
+  const r = ue(K(t)), o = n.indexOf(r), c = o === -1 ? e === 1 ? 0 : s - 1 : o + e;
+  return n[c];
+}
+function ts(t) {
+  return Ct(K(t).body, 1) || t;
+}
+function ns(t) {
+  return Ct(K(t).body, -1) || t;
+}
+function Ve(t, e) {
+  const n = e || t.currentTarget, s = t.relatedTarget;
+  return !s || !Z(n, s);
+}
+function ss(t) {
+  vt(t, Nt()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function lt(t) {
+  t.querySelectorAll("[data-tabindex]").forEach((n) => {
+    const s = n.dataset.tabindex;
+    delete n.dataset.tabindex, s ? n.setAttribute("tabindex", s) : n.removeAttribute("tabindex");
+  });
+}
+const rs = [];
+function qe(t) {
+  u.useEffect(t, rs);
+}
+const ve = null;
+let dt = globalThis.requestAnimationFrame;
+class os {
+  /* 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, s = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, s > 0)
+      for (let r = 0; r < n.length; r += 1)
+        n[r]?.(e);
+  };
+  request(e) {
+    const n = this.nextId;
+    this.nextId += 1, this.callbacks.push(e), this.callbacksCount += 1;
+    const s = process.env.NODE_ENV !== "production" && dt !== requestAnimationFrame && (dt = requestAnimationFrame, !0);
+    return (!this.isScheduled || s) && (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 we = new os();
+class Ye {
+  static create() {
+    return new Ye();
+  }
+  static request(e) {
+    return we.request(e);
+  }
+  static cancel(e) {
+    return we.cancel(e);
+  }
+  currentId = ve;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(e) {
+    this.cancel(), this.currentId = we.request(() => {
+      this.currentId = ve, e();
+    });
+  }
+  cancel = () => {
+    this.currentId !== ve && (we.cancel(this.currentId), this.currentId = ve);
+  };
+  disposeEffect = () => this.cancel;
+}
+function is() {
+  const t = se(Ye.create).current;
+  return qe(t.disposeEffect), t;
+}
+const as = {
+  clipPath: "inset(50%)",
+  overflow: "hidden",
+  whiteSpace: "nowrap",
+  border: 0,
+  padding: 0,
+  width: 1,
+  height: 1,
+  margin: -1
+}, It = {
+  ...as,
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Ne = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ne.displayName = "ToastContext");
+function Ge() {
+  const t = u.useContext(Ne);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : Y(73));
+  return t;
+}
+var cs = (t, e, n) => {
+  if (e.length === 1 && e[0] === n) {
+    let s = !1;
+    try {
+      const r = {};
+      t(r) === r && (s = !0);
+    } catch {
+    }
+    if (s) {
+      let r;
+      try {
+        throw new Error();
+      } catch (o) {
+        ({ stack: r } = 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: r }
+      );
+    }
+  }
+}, us = (t, e, n) => {
+  const { memoize: s, memoizeOptions: r } = e, { inputSelectorResults: o, inputSelectorResultsCopy: c } = t, i = s(() => ({}), ...r);
+  if (!(i.apply(null, o) === i.apply(null, c))) {
+    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: c,
+        stack: a
+      }
+    );
+  }
+}, ls = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+}, Se = /* @__PURE__ */ Symbol("NOT_FOUND");
+function ds(t, e = `expected a function, instead received ${typeof t}`) {
+  if (typeof t != "function")
+    throw new TypeError(e);
+}
+function fs(t, e = `expected an object, instead received ${typeof t}`) {
+  if (typeof t != "object")
+    throw new TypeError(e);
+}
+function ps(t, e = "expected all items to be functions, instead received the following types: ") {
+  if (!t.every((n) => typeof n == "function")) {
+    const n = t.map(
+      (s) => typeof s == "function" ? `function ${s.name || "unnamed"}()` : typeof s
+    ).join(", ");
+    throw new TypeError(`${e}[${n}]`);
+  }
+}
+var ft = (t) => Array.isArray(t) ? t : [t];
+function hs(t) {
+  const e = Array.isArray(t[0]) ? t[0] : t;
+  return ps(
+    e,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), e;
+}
+function pt(t, e) {
+  const n = [], { length: s } = t;
+  for (let r = 0; r < s; r++)
+    n.push(t[r].apply(null, e));
+  return n;
+}
+var ms = (t, e) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: s } = {
+    ...ls,
+    ...e
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && t,
+      run: cs
+    },
+    inputStabilityCheck: {
+      shouldRun: s === "always" || s === "once" && t,
+      run: us
+    }
+  };
+};
+function gs(t) {
+  let e;
+  return {
+    get(n) {
+      return e && t(e.key, n) ? e.value : Se;
+    },
+    put(n, s) {
+      e = { key: n, value: s };
+    },
+    getEntries() {
+      return e ? [e] : [];
+    },
+    clear() {
+      e = void 0;
+    }
+  };
+}
+function bs(t, e) {
+  let n = [];
+  function s(i) {
+    const l = n.findIndex((a) => e(i, a.key));
+    if (l > -1) {
+      const a = n[l];
+      return l > 0 && (n.splice(l, 1), n.unshift(a)), a.value;
+    }
+    return Se;
+  }
+  function r(i, l) {
+    s(i) === Se && (n.unshift({ key: i, value: l }), n.length > t && n.pop());
+  }
+  function o() {
+    return n;
+  }
+  function c() {
+    n = [];
+  }
+  return { get: s, put: r, getEntries: o, clear: c };
+}
+var ys = (t, e) => t === e;
+function vs(t) {
+  return function(n, s) {
+    if (n === null || s === null || n.length !== s.length)
+      return !1;
+    const { length: r } = n;
+    for (let o = 0; o < r; o++)
+      if (!t(n[o], s[o]))
+        return !1;
+    return !0;
+  };
+}
+function ws(t, e) {
+  const n = typeof e == "object" ? e : { equalityCheck: e }, {
+    equalityCheck: s = ys,
+    maxSize: r = 1,
+    resultEqualityCheck: o
+  } = n, c = vs(s);
+  let i = 0;
+  const l = r <= 1 ? gs(c) : bs(r, c);
+  function a() {
+    let d = l.get(arguments);
+    if (d === Se) {
+      if (d = t.apply(null, arguments), i++, o) {
+        const p = l.getEntries().find(
+          (h) => o(h.value, d)
+        );
+        p && (d = p.value, i !== 0 && i--);
+      }
+      l.put(arguments, d);
+    }
+    return d;
+  }
+  return a.clearCache = () => {
+    l.clear(), a.resetResultsCount();
+  }, a.resultsCount = () => i, a.resetResultsCount = () => {
+    i = 0;
+  }, a;
+}
+var Es = class {
+  constructor(t) {
+    this.value = t;
+  }
+  deref() {
+    return this.value;
+  }
+}, xs = typeof WeakRef < "u" ? WeakRef : Es, Ts = 0, ht = 1;
+function Ee() {
+  return {
+    s: Ts,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function Dt(t, e = {}) {
+  let n = Ee();
+  const { resultEqualityCheck: s } = e;
+  let r, o = 0;
+  function c() {
+    let i = n;
+    const { length: l } = arguments;
+    for (let f = 0, p = l; f < p; f++) {
+      const h = arguments[f];
+      if (typeof h == "function" || typeof h == "object" && h !== null) {
+        let m = i.o;
+        m === null && (i.o = m = /* @__PURE__ */ new WeakMap());
+        const v = m.get(h);
+        v === void 0 ? (i = Ee(), m.set(h, i)) : i = v;
+      } else {
+        let m = i.p;
+        m === null && (i.p = m = /* @__PURE__ */ new Map());
+        const v = m.get(h);
+        v === void 0 ? (i = Ee(), m.set(h, i)) : i = v;
+      }
+    }
+    const a = i;
+    let d;
+    if (i.s === ht)
+      d = i.v;
+    else if (d = t.apply(null, arguments), o++, s) {
+      const f = r?.deref?.() ?? r;
+      f != null && s(f, d) && (d = f, o !== 0 && o--), r = typeof d == "object" && d !== null || typeof d == "function" ? new xs(d) : d;
+    }
+    return a.s = ht, a.v = d, d;
+  }
+  return c.clearCache = () => {
+    n = Ee(), c.resetResultsCount();
+  }, c.resultsCount = () => o, c.resetResultsCount = () => {
+    o = 0;
+  }, c;
+}
+function Rt(t, ...e) {
+  const n = typeof t == "function" ? {
+    memoize: t,
+    memoizeOptions: e
+  } : t, s = (...r) => {
+    let o = 0, c = 0, i, l = {}, a = r.pop();
+    typeof a == "object" && (l = a, a = r.pop()), ds(
+      a,
+      `createSelector expects an output function after the inputs, but received: [${typeof a}]`
+    );
+    const d = {
+      ...n,
+      ...l
+    }, {
+      memoize: f,
+      memoizeOptions: p = [],
+      argsMemoize: h = Dt,
+      argsMemoizeOptions: m = [],
+      devModeChecks: v = {}
+    } = d, T = ft(p), R = ft(m), O = hs(r), F = f(function() {
+      return o++, a.apply(
+        null,
+        arguments
+      );
+    }, ...T);
+    let g = !0;
+    const S = h(function() {
+      c++;
+      const P = pt(
+        O,
+        arguments
+      );
+      if (i = F.apply(null, P), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: j, inputStabilityCheck: ee } = ms(g, v);
+        if (j.shouldRun && j.run(
+          a,
+          P,
+          i
+        ), ee.shouldRun) {
+          const G = pt(
+            O,
+            arguments
+          );
+          ee.run(
+            { inputSelectorResults: P, inputSelectorResultsCopy: G },
+            { memoize: f, memoizeOptions: T },
+            arguments
+          );
+        }
+        g && (g = !1);
+      }
+      return i;
+    }, ...R);
+    return Object.assign(S, {
+      resultFunc: a,
+      memoizedResultFunc: F,
+      dependencies: O,
+      dependencyRecomputations: () => c,
+      resetDependencyRecomputations: () => {
+        c = 0;
+      },
+      lastResult: () => i,
+      recomputations: () => o,
+      resetRecomputations: () => {
+        o = 0;
+      },
+      memoize: f,
+      argsMemoize: h
+    });
+  };
+  return Object.assign(s, {
+    withTypes: () => s
+  }), s;
+}
+var Ss = /* @__PURE__ */ Rt(Dt), Ns = Object.assign(
+  (t, e = Ss) => {
+    fs(
+      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), s = n.map(
+      (o) => t[o]
+    );
+    return e(
+      s,
+      (...o) => o.reduce((c, i, l) => (c[n[l]] = i, c), {})
+    );
+  },
+  { withTypes: () => Ns }
+);
+const Cs = Rt({
+  memoize: ws,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+}), L = (t, e, n, s, r, o, ...c) => {
+  if (c.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : Y(1));
+  let i;
+  if (t && e)
+    i = (l, a, d, f) => {
+      const p = t(l, a, d, f);
+      return e(p, a, d, f);
+    };
+  else if (t)
+    i = t;
+  else
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  return i;
+}, Is = (...t) => {
+  const e = /* @__PURE__ */ new WeakMap();
+  let n = 1;
+  const s = t[t.length - 1], r = t.length - 1 || 1, o = s.length - r;
+  if (o > 3)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of arguments" : Y(2));
+  return (i, l, a, d) => {
+    let f = i.__cacheKey__;
+    f || (f = {
+      id: n
+    }, i.__cacheKey__ = f, n += 1);
+    let p = e.get(f);
+    if (!p) {
+      let h = t;
+      const m = [void 0, void 0, void 0];
+      switch (o) {
+        case 0:
+          break;
+        case 1: {
+          h = [...t.slice(0, -1), () => m[0], s];
+          break;
+        }
+        case 2: {
+          h = [...t.slice(0, -1), () => m[0], () => m[1], s];
+          break;
+        }
+        case 3: {
+          h = [...t.slice(0, -1), () => m[0], () => m[1], () => m[2], s];
+          break;
+        }
+        default:
+          throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of arguments" : Y(2));
+      }
+      p = Cs(...h), p.selectorArgs = m, e.set(f, p);
+    }
+    switch (p.selectorArgs[0] = l, p.selectorArgs[1] = a, p.selectorArgs[2] = d, o) {
+      case 0:
+        return p(i);
+      case 1:
+        return p(i, l);
+      case 2:
+        return p(i, l, a);
+      case 3:
+        return p(i, l, a, d);
+      default:
+        throw (
+          /* minify-error-disabled */
+          new Error("unreachable")
+        );
+    }
+  };
+}, Ds = We(19), Rs = Ds ? Ps : ks;
+function Ot(t, e, n, s, r) {
+  return Rs(t, e, n, s, r);
+}
+function Os(t, e, n, s, r) {
+  const o = u.useCallback(() => e(t.getSnapshot(), n, s, r), [t, e, n, s, r]);
+  return bn.useSyncExternalStore(t.subscribe, o, o);
+}
+function Ps(t, e, n, s, r) {
+  return Os(t, e, n, s, r);
+}
+function ks(t, e, n, s, r) {
+  return gn.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, (o) => e(o, n, s, r));
+}
+class Fs {
+  /**
+   * 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 s of this.listeners) {
+      if (n !== this.updateTick)
+        return;
+      s(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, s, r) {
+    return Ot(this, e, n, s, r);
+  }
+}
+class Ms extends Fs {
+  /**
+   * 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 = {}, s) {
+    super(e), this.context = n, this.selectors = s;
+  }
+  /**
+   * 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) {
+    u.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 s = this;
+    $(() => (s.state[e] !== n && s.set(e, n), () => {
+      s.set(e, void 0);
+    }), [s, 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") {
+      u.useDebugValue(e, (c) => Object.keys(c));
+      const r = u.useRef(Object.keys(e)).current, o = Object.keys(e);
+      (r.length !== o.length || r.some((c, i) => c !== o[i])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const s = Object.values(e);
+    $(() => {
+      n.update(e);
+    }, [n, ...s]);
+  }
+  /**
+   * 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) {
+    u.useDebugValue(e);
+    const s = n !== void 0;
+    if ($(() => {
+      s && !Object.is(this.state[e], n) && super.setState({
+        ...this.state,
+        [e]: n
+      });
+    }, [e, n, s]), process.env.NODE_ENV !== "production") {
+      const r = this.controlledValues ??= /* @__PURE__ */ new Map();
+      r.has(e) || r.set(e, s);
+      const o = r.get(e);
+      o !== void 0 && o !== s && console.error(`A component is changing the ${s ? "" : "un"}controlled state of ${e.toString()} to be ${s ? "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, s, r) {
+    const o = this.selectors[e];
+    return o(this.state, n, s, r);
+  }
+  /**
+   * 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, s, r) {
+    return u.useDebugValue(e), Ot(this, this.selectors[e], n, s, r);
+  }
+  /**
+   * 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) {
+    u.useDebugValue(e);
+    const s = J(n ?? In);
+    this.context[e] = s;
+  }
+  /**
+   * 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 = u.useRef(void 0);
+    return n.current === void 0 && (n.current = (s) => {
+      this.set(e, s);
+    }), 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 s;
+    typeof e == "function" ? s = e : s = this.selectors[e];
+    let r = s(this.state);
+    return n(r, r, this), this.subscribe((o) => {
+      const c = s(o);
+      if (!Object.is(r, c)) {
+        const i = r;
+        r = c, n(c, 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 As() {
+  const t = se(le.create).current;
+  return qe(t.disposeEffect), t;
+}
+let mt = 0;
+function Vs(t) {
+  return mt += 1, `${t}-${Math.random().toString(36).slice(2, 6)}-${mt}`;
+}
+function _e(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 xe = Is((t) => t.toasts, (t) => {
+  const e = /* @__PURE__ */ new Map();
+  let n = 0, s = 0;
+  return t.forEach((r, o) => {
+    const c = r.transitionStatus === "ending";
+    e.set(r.id, {
+      value: r,
+      domIndex: o,
+      visibleIndex: c ? -1 : n,
+      offsetY: s
+    }), s += r.height || 0, c || (n += 1);
+  }), e;
+}), H = {
+  toasts: L((t) => t.toasts),
+  isEmpty: L((t) => t.toasts.length === 0),
+  toast: L(xe, (t, e) => t.get(e)?.value),
+  toastIndex: L(xe, (t, e) => t.get(e)?.domIndex ?? -1),
+  toastOffsetY: L(xe, (t, e) => t.get(e)?.offsetY ?? 0),
+  toastVisibleIndex: L(xe, (t, e) => t.get(e)?.visibleIndex ?? -1),
+  hovering: L((t) => t.hovering),
+  focused: L((t) => t.focused),
+  expanded: L((t) => t.hovering || t.focused),
+  expandedOrOutOfFocus: L((t) => t.hovering || t.focused || !t.isWindowFocused),
+  prevFocusElement: L((t) => t.prevFocusElement)
+};
+class _s extends Ms {
+  timers = /* @__PURE__ */ new Map();
+  areTimersPaused = !1;
+  constructor(e) {
+    super(e, {}, H);
+  }
+  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 = H.toastIndex(this.state, e);
+    if (n === -1)
+      return;
+    this.state.toasts[n]?.onRemove?.();
+    const r = [...this.state.toasts];
+    r.splice(n, 1), this.setToasts(r);
+  }
+  addToast = (e) => {
+    const {
+      toasts: n,
+      timeout: s,
+      limit: r
+    } = this.state, o = e.id || Vs("toast"), c = {
+      ...e,
+      id: o,
+      transitionStatus: "starting"
+    }, i = [c, ...n], l = i.filter((d) => d.transitionStatus !== "ending");
+    if (l.length > r) {
+      const d = l.length - r, f = l.slice(-d), p = new Set(f.map((h) => h.id));
+      this.setToasts(i.map((h) => {
+        const m = p.has(h.id);
+        return h.limited !== m ? {
+          ...h,
+          limited: m
+        } : h;
+      }));
+    } else
+      this.setToasts(i.map((d) => d.limited ? {
+        ...d,
+        limited: !1
+      } : d));
+    const a = c.timeout ?? s;
+    return c.type !== "loading" && a > 0 && this.scheduleTimer(o, a, () => this.closeToast(o)), H.expandedOrOutOfFocus(this.state) && this.pauseTimers(), o;
+  };
+  updateToast = (e, n) => {
+    this.updateToastInternal(e, n);
+  };
+  updateToastInternal = (e, n) => {
+    const {
+      timeout: s,
+      toasts: r
+    } = this.state, o = H.toast(this.state, e) ?? null;
+    if (!o || o.transitionStatus === "ending")
+      return;
+    const c = {
+      ...o,
+      ...n
+    };
+    this.setToasts(r.map((m) => m.id === e ? {
+      ...m,
+      ...n
+    } : m));
+    const i = c.timeout ?? s, l = o?.timeout ?? s, a = Object.hasOwn(n, "timeout"), d = c.transitionStatus !== "ending" && c.type !== "loading" && i > 0, f = this.timers.has(e), p = l !== i, h = o?.type === "loading";
+    if (!d && f) {
+      this.timers.get(e)?.timeout?.clear(), this.timers.delete(e);
+      return;
+    }
+    if (d && (!f || p || a || h)) {
+      const m = this.timers.get(e);
+      m && (m.timeout?.clear(), this.timers.delete(e)), this.scheduleTimer(e, i, () => this.closeToast(e)), H.expandedOrOutOfFocus(this.state) && this.pauseTimers();
+    }
+  };
+  closeToast = (e) => {
+    H.toast(this.state, e)?.onClose?.();
+    const {
+      limit: s,
+      toasts: r
+    } = this.state;
+    let o = 0;
+    const c = r.map((l) => {
+      if (l.id === e)
+        return {
+          ...l,
+          transitionStatus: "ending",
+          height: 0
+        };
+      if (l.transitionStatus === "ending")
+        return l;
+      const a = o >= s;
+      return o += 1, l.limited !== a ? {
+        ...l,
+        limited: a
+      } : l;
+    }), i = this.timers.get(e);
+    i && i.timeout && (i.timeout.clear(), this.timers.delete(e)), this.handleFocusManagement(e), this.setToasts(c);
+  };
+  promiseToast = (e, n) => {
+    const s = _e(n.loading), r = this.addToast({
+      ...s,
+      type: "loading"
+    }), o = e.then((c) => {
+      const i = _e(n.success, c);
+      return this.updateToast(r, {
+        ...i,
+        type: "success",
+        timeout: i.timeout
+      }), c;
+    }).catch((c) => {
+      const i = _e(n.error, c);
+      return this.updateToast(r, {
+        ...i,
+        type: "error",
+        timeout: i.timeout
+      }), Promise.reject(c);
+    });
+    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, s = e.delay - n;
+        e.remaining = s > 0 ? s : 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 = Ke(e);
+    Z(this.state.viewport, n) || (this.resumeTimers(), this.update({
+      hovering: !1,
+      focused: !1
+    }));
+  };
+  scheduleTimer(e, n, s) {
+    const r = Date.now(), o = !H.expandedOrOutOfFocus(this.state), c = o ? le.create() : void 0;
+    c?.start(n, () => {
+      this.timers.delete(e), s();
+    }), this.timers.set(e, {
+      timeout: c,
+      start: o ? r : 0,
+      delay: n,
+      remaining: n,
+      callback: s
+    });
+  }
+  setToasts(e) {
+    const n = {
+      toasts: e
+    };
+    e.length === 0 && (n.hovering = !1, n.focused = !1), this.update(n);
+  }
+  handleFocusManagement(e) {
+    const n = ue(K(this.state.viewport));
+    if (!this.state.viewport || !Z(this.state.viewport, n) || !Be(n))
+      return;
+    const s = H.toasts(this.state), r = H.toastIndex(this.state, e);
+    let o = null, c = r + 1;
+    for (; c < s.length; ) {
+      if (s[c].transitionStatus !== "ending") {
+        o = s[c];
+        break;
+      }
+      c += 1;
+    }
+    if (!o)
+      for (c = r - 1; c >= 0; ) {
+        if (s[c].transitionStatus !== "ending") {
+          o = s[c];
+          break;
+        }
+        c -= 1;
+      }
+    o ? o.ref?.current?.focus() : this.restoreFocusToPrevElement();
+  }
+}
+const Pt = function(e) {
+  const {
+    children: n,
+    timeout: s = 5e3,
+    limit: r = 3,
+    toastManager: o
+  } = e, c = se(() => new _s({
+    timeout: s,
+    limit: r,
+    viewport: null,
+    toasts: [],
+    hovering: !1,
+    focused: !1,
+    isWindowFocused: !0,
+    prevFocusElement: null
+  })).current;
+  return qe(c.disposeEffect), u.useEffect(function() {
+    return o ? o[" subscribe"](({
+      action: a,
+      options: d
+    }) => {
+      const f = d.id;
+      a === "promise" && d.promise ? c.promiseToast(d.promise, d) : a === "update" && f ? c.updateToast(f, d) : a === "close" && f ? c.closeToast(f) : c.addToast(d);
+    }) : void 0;
+  }, [c, s, o]), c.useSyncedValues({
+    timeout: s,
+    limit: r
+  }), /* @__PURE__ */ x(Ne.Provider, {
+    value: c,
+    children: n
+  });
+};
+process.env.NODE_ENV !== "production" && (Pt.displayName = "ToastProvider");
+const ne = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const [s, r] = u.useState();
+  return $(() => {
+    Xn && r("button");
+  }, []), /* @__PURE__ */ x("span", {
+    ...e,
+    ref: n,
+    style: It,
+    "aria-hidden": s ? void 0 : !0,
+    ...{
+      tabIndex: 0,
+      // Role is only for VoiceOver
+      role: s
+    },
+    "data-base-ui-focus-guard": ""
+  });
+});
+process.env.NODE_ENV !== "production" && (ne.displayName = "FocusGuard");
+let Ls = /* @__PURE__ */ (function(t) {
+  return t.frontmostHeight = "--toast-frontmost-height", t;
+})({});
+const kt = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    render: s,
+    className: r,
+    children: o,
+    ...c
+  } = e, i = Ge(), l = As(), a = u.useRef(!1), d = u.useRef(!1), f = i.useState("isEmpty"), p = i.useState("toasts"), h = i.useState("focused"), m = i.useState("expanded"), v = i.useState("prevFocusElement"), T = p[0]?.height ?? 0, R = u.useMemo(() => p.some((b) => b.transitionStatus === "ending"), [p]);
+  u.useEffect(() => {
+    const b = i.state.viewport;
+    if (!b)
+      return;
+    function N(k) {
+      f || k.key === "F6" && k.target !== b && (k.preventDefault(), i.setPrevFocusElement(ue(K(b))), b?.focus({
+        preventScroll: !0
+      }), i.pauseTimers(), i.setFocused(!0));
+    }
+    const I = rt(b);
+    return I.addEventListener("keydown", N), () => {
+      I.removeEventListener("keydown", N);
+    };
+  }, [i, f]), u.useEffect(() => {
+    const b = i.state.viewport;
+    if (!b || f)
+      return;
+    const N = rt(b);
+    function I(B) {
+      B.target === N && (i.setIsWindowFocused(!1), i.pauseTimers());
+    }
+    function k(B) {
+      if (B.relatedTarget || B.target === N)
+        return;
+      const te = Ke(B), re = ue(K(b));
+      (!Z(b, te) || !Be(re)) && i.resumeTimers(), l.start(0, () => i.setIsWindowFocused(!0));
+    }
+    return N.addEventListener("blur", I, !0), N.addEventListener("focus", k, !0), () => {
+      N.removeEventListener("blur", I, !0), N.removeEventListener("focus", k, !0);
+    };
+  }, [
+    i,
+    l,
+    // `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.
+    f
+  ]), u.useEffect(() => {
+    const b = i.state.viewport;
+    if (!b || f)
+      return;
+    const N = K(b);
+    return N.addEventListener("pointerdown", i.handleDocumentPointerDown, !0), () => {
+      N.removeEventListener("pointerdown", i.handleDocumentPointerDown, !0);
+    };
+  }, [f, i]);
+  function O(b) {
+    const N = i.state.viewport;
+    N && (a.current = !0, b.relatedTarget === N ? p[0]?.ref?.current?.focus() : i.restoreFocusToPrevElement());
+  }
+  function F(b) {
+    b.key === "Tab" && b.shiftKey && b.target === i.state.viewport && (b.preventDefault(), i.restoreFocusToPrevElement(), i.resumeTimers());
+  }
+  u.useEffect(() => {
+    !i.state.isWindowFocused || R || !d.current || (i.resumeTimers(), i.setHovering(!1), d.current = !1);
+  }, [R, i]);
+  function g() {
+    i.pauseTimers(), i.setHovering(!0), d.current = !1;
+  }
+  function S() {
+    R ? d.current = !0 : (i.resumeTimers(), i.setHovering(!1));
+  }
+  function E() {
+    if (a.current) {
+      a.current = !1;
+      return;
+    }
+    h || Be(K(i.state.viewport).activeElement) && (i.setFocused(!0), i.pauseTimers());
+  }
+  function P(b) {
+    !h || Z(i.state.viewport, b.relatedTarget) || (i.setFocused(!1), i.resumeTimers());
+  }
+  const j = {
+    tabIndex: -1,
+    role: "region",
+    "aria-live": "polite",
+    "aria-atomic": !1,
+    "aria-relevant": "additions text",
+    "aria-label": "Notifications",
+    onMouseEnter: g,
+    onMouseMove: g,
+    onMouseLeave: S,
+    onFocus: E,
+    onBlur: P,
+    onKeyDown: F,
+    onClick: E
+  }, ee = {
+    expanded: m
+  }, G = Q("div", e, {
+    ref: [n, i.setViewport],
+    state: ee,
+    props: [j, {
+      style: {
+        [Ls.frontmostHeight]: T ? `${T}px` : void 0
+      }
+    }, c, {
+      children: /* @__PURE__ */ U(u.Fragment, {
+        children: [!f && v && /* @__PURE__ */ x(ne, {
+          onFocus: O
+        }), o, !f && v && /* @__PURE__ */ x(ne, {
+          onFocus: O
+        })]
+      })
+    }]
+  }), pe = u.useMemo(() => p.filter((b) => b.priority === "high"), [p]);
+  return /* @__PURE__ */ U(u.Fragment, {
+    children: [!f && v && /* @__PURE__ */ x(ne, {
+      onFocus: O
+    }), G, !h && pe.length > 0 && /* @__PURE__ */ x("div", {
+      style: It,
+      children: pe.map((b) => /* @__PURE__ */ U("div", {
+        role: "alert",
+        "aria-atomic": !0,
+        children: [/* @__PURE__ */ x("div", {
+          children: b.title
+        }), /* @__PURE__ */ x("div", {
+          children: b.description
+        })]
+      }, b.id))
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (kt.displayName = "ToastViewport");
+function $s(t) {
+  return We(19) ? t : t ? "true" : void 0;
+}
+const Xe = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Xe.displayName = "ToastRootContext");
+function Ce() {
+  const t = u.useContext(Xe);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ToastRootContext is missing. Toast parts must be used within <Toast.Root>." : Y(66));
+  return t;
+}
+let Je = /* @__PURE__ */ (function(t) {
+  return t.startingStyle = "data-starting-style", t.endingStyle = "data-ending-style", t;
+})({});
+const Us = {
+  [Je.startingStyle]: ""
+}, js = {
+  [Je.endingStyle]: ""
+}, Bs = {
+  transitionStatus(t) {
+    return t === "starting" ? Us : t === "ending" ? js : null;
+  }
+};
+function zs(t) {
+  return t == null ? t : "current" in t ? t.current : t;
+}
+function Hs(t, e = !1, n = !0) {
+  const s = is();
+  return J((r, o = null) => {
+    s.cancel();
+    function c() {
+      de.flushSync(r);
+    }
+    const i = zs(t);
+    if (i == null)
+      return;
+    const l = i;
+    if (typeof l.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED)
+      r();
+    else {
+      let a = function() {
+        const f = Je.startingStyle;
+        if (!l.hasAttribute(f)) {
+          s.request(d);
+          return;
+        }
+        const p = new MutationObserver(() => {
+          l.hasAttribute(f) || (p.disconnect(), d());
+        });
+        p.observe(l, {
+          attributes: !0,
+          attributeFilter: [f]
+        }), o?.addEventListener("abort", () => p.disconnect(), {
+          once: !0
+        });
+      }, d = function() {
+        Promise.all(l.getAnimations().map((f) => f.finished)).then(() => {
+          o?.aborted || c();
+        }).catch(() => {
+          const f = l.getAnimations();
+          if (n) {
+            if (o?.aborted)
+              return;
+            c();
+          } else f.length > 0 && f.some((p) => p.pending || p.playState !== "finished") && d();
+        });
+      };
+      if (e) {
+        a();
+        return;
+      }
+      s.request(d);
+    }
+  });
+}
+function Ws(t) {
+  const {
+    enabled: e = !0,
+    open: n,
+    ref: s,
+    onComplete: r
+  } = t, o = J(r), c = Hs(s, n, !1);
+  u.useEffect(() => {
+    if (!e)
+      return;
+    const i = new AbortController();
+    return c(o, i.signal), () => {
+      i.abort();
+    };
+  }, [e, n, o, c]);
+}
+let X = /* @__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 Ks = {
+  ...Bs,
+  swipeDirection(t) {
+    return t ? {
+      "data-swipe-direction": t
+    } : null;
+  }
+}, ie = 40, qs = 10, q = 0.5, Ys = 1;
+function gt(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 Gs(t) {
+  const n = window.getComputedStyle(t).transform;
+  let s = 0, r = 0, o = 1;
+  if (n && n !== "none") {
+    const c = n.match(/matrix(?:3d)?\(([^)]+)\)/);
+    if (c) {
+      const i = c[1].split(", ").map(parseFloat);
+      i.length === 6 ? (s = i[4], r = i[5], o = Math.sqrt(i[0] * i[0] + i[1] * i[1])) : i.length === 16 && (s = i[12], r = i[13], o = i[0]);
+    }
+  }
+  return {
+    x: s,
+    y: r,
+    scale: o
+  };
+}
+const Ft = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    toast: s,
+    render: r,
+    className: o,
+    swipeDirection: c = ["down", "right"],
+    ...i
+  } = e, l = s.positionerProps?.anchor !== void 0;
+  let a = [];
+  l || (a = Array.isArray(c) ? c : [c]);
+  const d = a.length > 0, f = Ge(), [p, h] = u.useState(void 0), [m, v] = u.useState(!1), [T, R] = u.useState(!1), [O, F] = u.useState(!1), [g, S] = u.useState({
+    x: 0,
+    y: 0
+  }), [E, P] = u.useState({
+    x: 0,
+    y: 0,
+    scale: 1
+  }), [j, ee] = u.useState(), [G, pe] = u.useState(), [b, N] = u.useState(null), I = u.useRef(null), k = u.useRef({
+    x: 0,
+    y: 0
+  }), B = u.useRef({
+    x: 0,
+    y: 0,
+    scale: 1
+  }), te = u.useRef(void 0), re = u.useRef(0), he = u.useRef(!1), M = u.useRef({
+    x: 0,
+    y: 0
+  }), Ie = u.useRef(!1), De = f.useState("toastIndex", s.id), Re = f.useState("toastVisibleIndex", s.id), zt = f.useState("toastOffsetY", s.id), Ht = f.useState("focused"), Oe = f.useState("expanded");
+  Ws({
+    open: s.transitionStatus !== "ending",
+    ref: I,
+    onComplete() {
+      s.transitionStatus === "ending" && f.removeToast(s.id);
+    }
+  });
+  const me = J((w = !1) => {
+    const y = I.current;
+    if (!y)
+      return;
+    const C = y.style.height;
+    y.style.height = "auto";
+    const D = y.offsetHeight;
+    y.style.height = C;
+    function A() {
+      f.updateToastInternal(s.id, {
+        ref: I,
+        height: D,
+        ...s.transitionStatus === "starting" ? {
+          transitionStatus: void 0
+        } : {}
+      });
+    }
+    w ? de.flushSync(A) : A();
+  });
+  $(me, [me]);
+  function Wt(w, y) {
+    let C = w, D = y;
+    return !a.includes("left") && !a.includes("right") ? C = w > 0 ? w ** q : -(Math.abs(w) ** q) : (!a.includes("right") && w > 0 && (C = w ** q), !a.includes("left") && w < 0 && (C = -(Math.abs(w) ** q))), !a.includes("up") && !a.includes("down") ? D = y > 0 ? y ** q : -(Math.abs(y) ** q) : (!a.includes("down") && y > 0 && (D = y ** q), !a.includes("up") && y < 0 && (D = -(Math.abs(y) ** q))), {
+      x: C,
+      y: D
+    };
+  }
+  function Kt(w) {
+    if (w.button !== 0)
+      return;
+    w.pointerType === "touch" && f.pauseTimers();
+    const y = Ke(w.nativeEvent);
+    if (!(y && y.closest('button,a,input,textarea,[role="button"],[data-swipe-ignore]'))) {
+      if (he.current = !1, te.current = void 0, re.current = 0, k.current = {
+        x: w.clientX,
+        y: w.clientY
+      }, M.current = k.current, I.current) {
+        const D = Gs(I.current);
+        B.current = D, P(D), S({
+          x: D.x,
+          y: D.y
+        });
+      }
+      f.setHovering(!0), v(!0), R(!1), N(null), Ie.current = !0, I.current?.setPointerCapture(w.pointerId);
+    }
+  }
+  function qt(w) {
+    if (!m)
+      return;
+    w.preventDefault(), Ie.current && (k.current = {
+      x: w.clientX,
+      y: w.clientY
+    }, Ie.current = !1);
+    const {
+      clientY: y,
+      clientX: C,
+      movementX: D,
+      movementY: A
+    } = w;
+    (A < 0 && y > M.current.y || A > 0 && y < M.current.y) && (M.current = {
+      x: M.current.x,
+      y
+    }), (D < 0 && C > M.current.x || D > 0 && C < M.current.x) && (M.current = {
+      x: C,
+      y: M.current.y
+    });
+    const V = C - k.current.x, z = y - k.current.y, en = y - M.current.y, tn = C - M.current.x;
+    if (!T && Math.sqrt(V * V + z * z) >= Ys && (R(!0), b === null)) {
+      const ye = a.includes("left") || a.includes("right"), nn = a.includes("up") || a.includes("down");
+      if (ye && nn) {
+        const sn = Math.abs(V), rn = Math.abs(z);
+        N(sn > rn ? "horizontal" : "vertical");
+      }
+    }
+    let _;
+    if (!te.current)
+      b === "vertical" ? z > 0 ? _ = "down" : z < 0 && (_ = "up") : b === "horizontal" ? V > 0 ? _ = "right" : V < 0 && (_ = "left") : Math.abs(V) >= Math.abs(z) ? _ = V > 0 ? "right" : "left" : _ = z > 0 ? "down" : "up", _ && a.includes(_) && (te.current = _, re.current = gt(_, V, z), h(_));
+    else {
+      const Fe = te.current, ye = gt(Fe, tn, en);
+      ye > ie ? (he.current = !1, h(Fe)) : !(a.includes("left") && a.includes("right")) && !(a.includes("up") && a.includes("down")) && re.current - ye >= qs && (he.current = !0);
+    }
+    const be = Wt(V, z);
+    let Pe = B.current.x, ke = B.current.y;
+    b === "horizontal" ? (a.includes("left") || a.includes("right")) && (Pe += be.x) : (b === "vertical" || (a.includes("left") || a.includes("right")) && (Pe += be.x), (a.includes("up") || a.includes("down")) && (ke += be.y)), S({
+      x: Pe,
+      y: ke
+    });
+  }
+  function Yt(w) {
+    if (!m)
+      return;
+    if (v(!1), R(!1), N(null), I.current?.releasePointerCapture(w.pointerId), he.current) {
+      S({
+        x: E.x,
+        y: E.y
+      }), h(void 0);
+      return;
+    }
+    let y = !1;
+    const C = g.x - E.x, D = g.y - E.y;
+    let A;
+    for (const V of a) {
+      switch (V) {
+        case "right":
+          C > ie && (y = !0, A = "right");
+          break;
+        case "left":
+          C < -ie && (y = !0, A = "left");
+          break;
+        case "down":
+          D > ie && (y = !0, A = "down");
+          break;
+        case "up":
+          D < -ie && (y = !0, A = "up");
+          break;
+      }
+      if (y)
+        break;
+    }
+    y ? (h(A), F(!0), f.closeToast(s.id)) : (S({
+      x: E.x,
+      y: E.y
+    }), h(void 0));
+  }
+  function Gt(w) {
+    if (w.key === "Escape") {
+      if (!I.current || !Z(I.current, ue(K(I.current))))
+        return;
+      f.closeToast(s.id);
+    }
+  }
+  u.useEffect(() => {
+    if (!d)
+      return;
+    const w = I.current;
+    if (!w)
+      return;
+    function y(C) {
+      Z(w, C.target) && C.preventDefault();
+    }
+    return w.addEventListener("touchmove", y, {
+      passive: !1
+    }), () => {
+      w.removeEventListener("touchmove", y);
+    };
+  }, [d]);
+  function Xt() {
+    if (!m && g.x === E.x && g.y === E.y && !O)
+      return {
+        [X.swipeMovementX]: "0px",
+        [X.swipeMovementY]: "0px"
+      };
+    const w = g.x - E.x, y = g.y - E.y;
+    return {
+      transition: m ? "none" : void 0,
+      // While swiping, freeze the element at its current visual transform so it doesn't snap to the
+      // end position.
+      transform: m ? `translateX(${g.x}px) translateY(${g.y}px) scale(${E.scale})` : void 0,
+      [X.swipeMovementX]: `${w}px`,
+      [X.swipeMovementY]: `${y}px`
+    };
+  }
+  const Qe = s.priority === "high", Jt = {
+    role: Qe ? "alertdialog" : "dialog",
+    tabIndex: 0,
+    "aria-modal": !1,
+    "aria-labelledby": j,
+    "aria-describedby": G,
+    "aria-hidden": Qe && !Ht ? !0 : void 0,
+    onPointerDown: d ? Kt : void 0,
+    onPointerMove: d ? qt : void 0,
+    onPointerUp: d ? Yt : void 0,
+    onKeyDown: Gt,
+    inert: $s(s.limited),
+    style: {
+      ...Xt(),
+      [X.index]: s.transitionStatus === "ending" ? De : Re,
+      [X.offsetY]: `${zt}px`,
+      [X.height]: s.height ? `${s.height}px` : void 0
+    }
+  }, ge = u.useMemo(() => ({
+    rootRef: I,
+    toast: s,
+    titleId: j,
+    setTitleId: ee,
+    descriptionId: G,
+    setDescriptionId: pe,
+    swiping: m,
+    swipeDirection: p,
+    recalculateHeight: me,
+    index: De,
+    visibleIndex: Re,
+    expanded: Oe
+  }), [s, j, G, m, p, me, De, Re, Oe]), Zt = {
+    transitionStatus: s.transitionStatus,
+    expanded: Oe,
+    limited: s.limited || !1,
+    type: s.type,
+    swiping: ge.swiping,
+    swipeDirection: ge.swipeDirection
+  }, Qt = Q("div", e, {
+    ref: [n, ge.rootRef],
+    state: Zt,
+    stateAttributesMapping: Ks,
+    props: [Jt, i]
+  });
+  return /* @__PURE__ */ x(Xe.Provider, {
+    value: ge,
+    children: Qt
+  });
+});
+process.env.NODE_ENV !== "production" && (Ft.displayName = "ToastRoot");
+const Mt = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    render: s,
+    className: r,
+    ...o
+  } = e, {
+    visibleIndex: c,
+    expanded: i,
+    recalculateHeight: l
+  } = Ce(), a = u.useRef(null);
+  $(() => {
+    const h = a.current;
+    if (!h || (l(), typeof ResizeObserver != "function" || typeof MutationObserver != "function"))
+      return;
+    const m = new ResizeObserver(() => l(!0)), v = new MutationObserver(() => l(!0));
+    return m.observe(h), v.observe(h, {
+      childList: !0,
+      subtree: !0,
+      characterData: !0
+    }), () => {
+      m.disconnect(), v.disconnect();
+    };
+  }, [l]);
+  const d = c > 0;
+  return Q("div", e, {
+    ref: [n, a],
+    state: {
+      expanded: i,
+      behind: d
+    },
+    props: o
+  });
+});
+process.env.NODE_ENV !== "production" && (Mt.displayName = "ToastContent");
+const At = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    render: s,
+    className: r,
+    id: o,
+    children: c,
+    ...i
+  } = e, {
+    toast: l,
+    setDescriptionId: a
+  } = Ce(), d = c ?? l.description, f = !!d, p = He(o);
+  $(() => {
+    if (f)
+      return a(p), () => {
+        a(void 0);
+      };
+  }, [f, p, a]);
+  const h = {
+    type: l.type
+  }, m = Q("p", e, {
+    ref: n,
+    state: h,
+    props: {
+      ...i,
+      id: p,
+      children: d
+    }
+  });
+  return f ? m : null;
+});
+process.env.NODE_ENV !== "production" && (At.displayName = "ToastDescription");
+const Vt = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    render: s,
+    className: r,
+    id: o,
+    children: c,
+    ...i
+  } = e, {
+    toast: l,
+    setTitleId: a
+  } = Ce(), d = c ?? l.title, f = !!d, p = He(o);
+  $(() => {
+    if (f)
+      return a(p), () => {
+        a(void 0);
+      };
+  }, [f, p, a]);
+  const h = {
+    type: l.type
+  }, m = Q("h2", e, {
+    ref: n,
+    state: h,
+    props: {
+      ...i,
+      id: p,
+      children: d
+    }
+  });
+  return f ? m : null;
+});
+process.env.NODE_ENV !== "production" && (Vt.displayName = "ToastTitle");
+let ze;
+process.env.NODE_ENV !== "production" && (ze = /* @__PURE__ */ new Set());
+function bt(...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = t.join(" ");
+    ze.has(e) || (ze.add(e), console.error(`Base UI: ${e}`));
+  }
+}
+const _t = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (_t.displayName = "CompositeRootContext");
+function Xs(t = !1) {
+  const e = u.useContext(_t);
+  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>." : Y(16));
+  return e;
+}
+function Js(t) {
+  const {
+    focusableWhenDisabled: e,
+    disabled: n,
+    composite: s = !1,
+    tabIndex: r = 0,
+    isNativeButton: o
+  } = t, c = s && e !== !1, i = s && e === !1;
+  return {
+    props: u.useMemo(() => {
+      const a = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(d) {
+          n && e && d.key !== "Tab" && d.preventDefault();
+        }
+      };
+      return s || (a.tabIndex = r, !o && n && (a.tabIndex = e ? r : -1)), (o && (e || c) || !o && n) && (a["aria-disabled"] = n), o && (!e || i) && (a.disabled = n), a;
+    }, [s, n, e, c, i, o, r])
+  };
+}
+function Zs(t = {}) {
+  const {
+    disabled: e = !1,
+    focusableWhenDisabled: n,
+    tabIndex: s = 0,
+    native: r = !0
+  } = t, o = u.useRef(null), c = Xs(!0) !== void 0, i = J(() => {
+    const p = o.current;
+    return !!(p?.tagName === "A" && p?.href);
+  }), {
+    props: l
+  } = Js({
+    focusableWhenDisabled: n,
+    disabled: e,
+    composite: c,
+    tabIndex: s,
+    isNativeButton: r
+  });
+  process.env.NODE_ENV !== "production" && u.useEffect(() => {
+    if (!o.current)
+      return;
+    const p = o.current.tagName === "BUTTON";
+    if (r) {
+      if (!p) {
+        const h = Le.captureOwnerStack?.() || "";
+        bt(`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\`.${h}`);
+      }
+    } else if (p) {
+      const h = Le.captureOwnerStack?.() || "";
+      bt(`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\`.${h}`);
+    }
+  }, [r]);
+  const a = u.useCallback(() => {
+    const p = o.current;
+    Qs(p) && c && e && l.disabled === void 0 && p.disabled && (p.disabled = !1);
+  }, [e, l.disabled, c]);
+  $(a, [a]);
+  const d = u.useCallback((p = {}) => {
+    const {
+      onClick: h,
+      onMouseDown: m,
+      onKeyUp: v,
+      onKeyDown: T,
+      onPointerDown: R,
+      ...O
+    } = p;
+    return xt({
+      type: r ? "button" : void 0,
+      onClick(g) {
+        if (e) {
+          g.preventDefault();
+          return;
+        }
+        h?.(g);
+      },
+      onMouseDown(g) {
+        e || m?.(g);
+      },
+      onKeyDown(g) {
+        if (e || (je(g), T?.(g)), g.baseUIHandlerPrevented)
+          return;
+        const S = g.target === g.currentTarget && !r && !i() && !e, E = g.key === "Enter", P = g.key === " ";
+        S && ((P || E) && g.preventDefault(), E && h?.(g));
+      },
+      onKeyUp(g) {
+        e || (je(g), v?.(g)), !g.baseUIHandlerPrevented && g.target === g.currentTarget && !r && !e && g.key === " " && h?.(g);
+      },
+      onPointerDown(g) {
+        if (e) {
+          g.preventDefault();
+          return;
+        }
+        R?.(g);
+      }
+    }, r ? void 0 : {
+      role: "button"
+    }, l, O);
+  }, [e, l, r, i]), f = J((p) => {
+    o.current = p, a();
+  });
+  return {
+    getButtonProps: d,
+    buttonRef: f
+  };
+}
+function Qs(t) {
+  return vn(t) && t.tagName === "BUTTON";
+}
+const Lt = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    render: s,
+    className: r,
+    disabled: o,
+    nativeButton: c = !0,
+    ...i
+  } = e, l = Ge(), {
+    toast: a
+  } = Ce(), d = l.useState("expanded"), [f, p] = u.useState(!1), {
+    getButtonProps: h,
+    buttonRef: m
+  } = Zs({
+    disabled: o,
+    native: c
+  }), v = {
+    type: a.type
+  };
+  return Q("button", e, {
+    ref: [n, m],
+    state: v,
+    props: [{
+      "aria-hidden": !d && !f,
+      onClick() {
+        l.closeToast(a.id);
+      },
+      onFocus() {
+        p(!0);
+      },
+      onBlur() {
+        p(!1);
+      }
+    }, i, h]
+  });
+});
+process.env.NODE_ENV !== "production" && (Lt.displayName = "ToastClose");
+function er(t) {
+  return `data-base-ui-${t}`;
+}
+const Ze = /* @__PURE__ */ u.createContext(null);
+process.env.NODE_ENV !== "production" && (Ze.displayName = "PortalContext");
+const tr = () => u.useContext(Ze), nr = er("portal");
+function $t(t = {}) {
+  const {
+    ref: e,
+    container: n,
+    componentProps: s = W,
+    elementProps: r
+  } = t, o = He(), i = tr()?.portalNode, [l, a] = u.useState(null), [d, f] = u.useState(null), p = J((T) => {
+    T !== null && f(T);
+  }), h = u.useRef(null);
+  $(() => {
+    if (n === null) {
+      h.current && (h.current = null, f(null), a(null));
+      return;
+    }
+    if (o == null)
+      return;
+    const T = (n && (wn(n) ? n : n.current)) ?? i ?? document.body;
+    if (T == null) {
+      h.current && (h.current = null, f(null), a(null));
+      return;
+    }
+    h.current !== T && (h.current = T, f(null), a(T));
+  }, [n, i, o]);
+  const m = Q("div", s, {
+    ref: [e, p],
+    props: [{
+      id: o,
+      [nr]: ""
+    }, r]
+  });
+  return {
+    portalNode: d,
+    portalSubtree: l && m ? /* @__PURE__ */ de.createPortal(m, l) : null
+  };
+}
+const sr = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    children: s,
+    container: r,
+    className: o,
+    render: c,
+    renderGuards: i,
+    ...l
+  } = e, {
+    portalNode: a,
+    portalSubtree: d
+  } = $t({
+    container: r,
+    ref: n,
+    componentProps: e,
+    elementProps: l
+  }), f = u.useRef(null), p = u.useRef(null), h = u.useRef(null), m = u.useRef(null), [v, T] = u.useState(null), R = v?.modal, O = v?.open, F = typeof i == "boolean" ? i : !!v && !v.modal && v.open && !!a;
+  u.useEffect(() => {
+    if (!a || R)
+      return;
+    function S(E) {
+      a && E.relatedTarget && Ve(E) && (E.type === "focusin" ? lt : ss)(a);
+    }
+    return a.addEventListener("focusin", S, !0), a.addEventListener("focusout", S, !0), () => {
+      a.removeEventListener("focusin", S, !0), a.removeEventListener("focusout", S, !0);
+    };
+  }, [a, R]), u.useEffect(() => {
+    !a || O || lt(a);
+  }, [O, a]);
+  const g = u.useMemo(() => ({
+    beforeOutsideRef: f,
+    afterOutsideRef: p,
+    beforeInsideRef: h,
+    afterInsideRef: m,
+    portalNode: a,
+    setFocusManagerState: T
+  }), [a]);
+  return /* @__PURE__ */ U(u.Fragment, {
+    children: [d, /* @__PURE__ */ U(Ze.Provider, {
+      value: g,
+      children: [F && a && /* @__PURE__ */ x(ne, {
+        "data-type": "outside",
+        ref: f,
+        onFocus: (S) => {
+          if (Ve(S, a))
+            h.current?.focus();
+          else {
+            const E = v ? v.domReference : null;
+            ns(E)?.focus();
+          }
+        }
+      }), F && a && /* @__PURE__ */ x("span", {
+        "aria-owns": a.id,
+        style: Dn
+      }), a && /* @__PURE__ */ de.createPortal(s, a), F && a && /* @__PURE__ */ x(ne, {
+        "data-type": "outside",
+        ref: p,
+        onFocus: (S) => {
+          if (Ve(S, a))
+            m.current?.focus();
+          else {
+            const E = v ? v.domReference : null;
+            ts(E)?.focus(), v?.closeOnFocusOut && v?.onOpenChange(!1, On(Rn, S.nativeEvent));
+          }
+        }
+      })]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (sr.displayName = "FloatingPortal");
+const Ut = /* @__PURE__ */ u.forwardRef(function(e, n) {
+  const {
+    children: s,
+    container: r,
+    className: o,
+    render: c,
+    ...i
+  } = e, {
+    portalNode: l,
+    portalSubtree: a
+  } = $t({
+    container: r,
+    ref: n,
+    componentProps: e,
+    elementProps: i
+  });
+  return !a && !l ? null : /* @__PURE__ */ U(u.Fragment, {
+    children: [a, l && /* @__PURE__ */ de.createPortal(s, l)]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ut.displayName = "FloatingPortalLite");
+const rr = Ut;
+function jt() {
+  const t = u.useContext(Ne);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : Y(73));
+  const e = t.useState("toasts");
+  return u.useMemo(() => ({
+    toasts: e,
+    add: t.addToast,
+    close: t.closeToast,
+    update: t.updateToast,
+    promise: t.promiseToast
+  }), [e, t]);
+}
+const or = (t) => {
+  const [e, n] = an(!1), s = () => n(!0), r = () => n(!1);
+  return cn(() => {
+    const o = t.current;
+    if (o)
+      return o.addEventListener("mouseenter", s), o.addEventListener("mouseleave", r), () => {
+        o.removeEventListener("mouseenter", s), o.removeEventListener("mouseleave", r);
+      };
+  }, []), e;
+}, ir = on(
+  "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" }
+  }
+), ar = {
+  default: ae,
+  info: ae,
+  warn: st,
+  muted: ae,
+  danger: st,
+  success: hn,
+  secondary: ae
+}, Bt = un(() => {
+  throw new Error("Not implemented");
+}), Rr = () => ln(Bt);
+function cr(t) {
+  const e = t.toast.data?.closable ?? !0, n = t.toast.data?.loading ?? !1, s = t.toast.data?.theme || "default", r = ir({ theme: s }), o = n ? xn : ar[s] || ae;
+  return /* @__PURE__ */ x(Ft, { toast: t.toast, swipeDirection: "right", children: /* @__PURE__ */ x(
+    yt.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__ */ x(Mt, { className: nt(r, "shadow-lg"), children: /* @__PURE__ */ U("div", { className: "flex items-start gap-3 p-4", children: [
+        /* @__PURE__ */ x("div", { className: nt("mt-0.5 shrink-0 opacity-80", n && "animate-spin"), children: /* @__PURE__ */ x(o, { className: "size-4" }) }),
+        /* @__PURE__ */ U("div", { className: "flex flex-1 flex-col gap-1 overflow-hidden", children: [
+          t.toast.title ? /* @__PURE__ */ x(Vt, { className: "select-text truncate font-semibold leading-tight tracking-tight" }) : null,
+          /* @__PURE__ */ x(At, { className: "line-clamp-2 select-text text-xs font-medium leading-relaxed opacity-90" })
+        ] }),
+        e && !n ? /* @__PURE__ */ x(Lt, { 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__ */ x(mn, { className: "size-3.5" }) }) : null
+      ] }) })
+    }
+  ) });
+}
+function ur({ max: t = 5 }) {
+  const e = dn(null), n = or(e), s = jt(), r = t ? s.toasts.slice(0, t) : s.toasts, o = n ? r : r.slice(0, 3), c = r.length - o.length;
+  return /* @__PURE__ */ U(
+    kt,
+    {
+      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__ */ x(fn, { mode: "popLayout", initial: !1, children: o.map((i) => /* @__PURE__ */ x(cr, { toast: i }, i.id)) }),
+        !n && c > 0 && /* @__PURE__ */ U(
+          yt.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: [
+              "+",
+              c,
+              " more"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function lr({ children: t, max: e = 5 }) {
+  const n = jt(), s = tt(() => {
+    n.toasts.forEach((o) => n.close(o.id));
+  }, [n]), r = tt(
+    (o, c) => {
+      const i = { theme: c?.theme, closable: c?.closable, loading: c?.loading };
+      if (c?.id && n.toasts.find((d) => d.id === c.id))
+        return n.update(c.id, {
+          description: o,
+          title: c.title,
+          timeout: c.timeout,
+          data: i
+        }), { close: () => n.close(c.id), clear: s };
+      const l = n.add({
+        description: o,
+        id: c?.id,
+        title: c?.title,
+        timeout: c?.timeout,
+        data: i
+      });
+      return {
+        close: () => n.close(l),
+        clear: s
+      };
+    },
+    [n, s]
+  );
+  return /* @__PURE__ */ U(Bt.Provider, { value: r, children: [
+    t,
+    /* @__PURE__ */ x(rr, { children: /* @__PURE__ */ x(ur, { max: e }) })
+  ] });
+}
+function Or({ children: t, max: e = 5, timeout: n = 5e3 }) {
+  return /* @__PURE__ */ x(Pt, { limit: e, timeout: n, children: /* @__PURE__ */ x(lr, { max: e, children: t }) });
+}
+export {
+  W as E,
+  In as N,
+  $ as a,
+  J as b,
+  He as c,
+  ue as d,
+  Q as e,
+  Y as f,
+  On as g,
+  Dr as h,
+  Nr as i,
+  is as j,
+  Cr as k,
+  Ir as l,
+  Z as m,
+  Tr as n,
+  K as o,
+  qe as p,
+  xt as q,
+  ct as r,
+  Rr as s,
+  Sr as t,
+  se as u,
+  It as v,
+  Or as w
+};
+//# sourceMappingURL=notifications-NPuFDsBp.js.map