@serendie/ui 0.1.12 → 0.1.13

package/dist/node_modules/@zag-js/toast/dist/index.js

@@ -0,0 +1,785 @@
+import { createMachine as P, isMachine as k, guards as U } from "../../core/dist/index.js";
+import { createScope as C, contains as N, dataAttr as y, MAX_Z_INDEX as F, raf as A, queryAll as H } from "../../dom-query/dist/index.js";
+import { runIfFn as v, compact as L, uuid as G, warn as B } from "../../utils/dist/index.js";
+import { createAnatomy as $ } from "../../anatomy/dist/index.js";
+import { trackDismissableBranch as V } from "../../dismissable/dist/index.js";
+import { addDomEvent as D } from "../../dom-event/dist/index.js";
+import { subscribe as w, ref as x } from "../../store/dist/index.js";
+var K = $("toast").parts(
+  "group",
+  "root",
+  "title",
+  "description",
+  "actionTrigger",
+  "closeTrigger"
+), T = K.build(), f = C({
+  getRegionId: (s) => `toast-group:${s}`,
+  getRegionEl: (s, r) => f.getById(s, `toast-group:${r}`),
+  getRootId: (s) => `toast:${s.id}`,
+  getRootEl: (s) => f.getById(s, f.getRootId(s)),
+  getTitleId: (s) => `toast:${s.id}:title`,
+  getDescriptionId: (s) => `toast:${s.id}:description`,
+  getCloseTriggerId: (s) => `toast${s.id}:close`
+});
+function b(s, r) {
+  return s.filter((t) => t.state.context.placement === r);
+}
+var O = {
+  info: 5e3,
+  error: 5e3,
+  success: 2e3,
+  loading: 1 / 0,
+  DEFAULT: 5e3
+};
+function _(s, r) {
+  return s ?? O[r] ?? O.DEFAULT;
+}
+function W(s, r) {
+  var o;
+  const t = s.offsets, e = typeof t == "string" ? { left: t, right: t, bottom: t, top: t } : t, i = s.dir === "rtl", c = r.replace("-start", i ? "-right" : "-left").replace("-end", i ? "-left" : "-right"), u = c.includes("right"), h = c.includes("left"), d = {
+    position: "fixed",
+    pointerEvents: s.count > 0 ? void 0 : "none",
+    display: "flex",
+    flexDirection: "column",
+    "--gap": `${s.gap}px`,
+    "--first-height": `${((o = s.heights[0]) == null ? void 0 : o.height) || 0}px`,
+    zIndex: F
+  };
+  let a = "center";
+  if (u && (a = "flex-end"), h && (a = "flex-start"), d.alignItems = a, c.includes("top")) {
+    const n = e.top;
+    d.top = `max(env(safe-area-inset-top, 0px), ${n})`;
+  }
+  if (c.includes("bottom")) {
+    const n = e.bottom;
+    d.bottom = `max(env(safe-area-inset-bottom, 0px), ${n})`;
+  }
+  if (!c.includes("left")) {
+    const n = e.right;
+    d.insetInlineEnd = `calc(env(safe-area-inset-right, 0px) + ${n})`;
+  }
+  if (!c.includes("right")) {
+    const n = e.left;
+    d.insetInlineStart = `calc(env(safe-area-inset-left, 0px) + ${n})`;
+  }
+  return d;
+}
+function j(s, r) {
+  const [t] = s.placement.split("-"), e = !s.frontmost, i = !s.stacked, c = {
+    position: "absolute",
+    pointerEvents: "auto",
+    "--opacity": "0",
+    "--remove-delay": `${s.removeDelay}ms`,
+    "--duration": `${s.type === "loading" ? Number.MAX_SAFE_INTEGER : s.duration}ms`,
+    "--initial-height": `${s.height}px`,
+    "--offset": `${s.offset}px`,
+    "--index": s.index,
+    "--z-index": s.zIndex,
+    "--lift-amount": "calc(var(--lift) * var(--gap))",
+    "--y": "100%",
+    "--x": "0"
+  }, u = (h) => Object.assign(c, h);
+  return t === "top" ? u({
+    top: "0",
+    "--sign": "-1",
+    "--y": "-100%",
+    "--lift": "1"
+  }) : t === "bottom" && u({
+    bottom: "0",
+    "--sign": "1",
+    "--y": "100%",
+    "--lift": "-1"
+  }), s.mounted && (u({
+    "--y": "0",
+    "--opacity": "1"
+  }), s.stacked && u({
+    "--y": "calc(var(--lift) * var(--offset))",
+    "--height": "var(--initial-height)"
+  })), r || u({
+    "--opacity": "0",
+    pointerEvents: "none"
+  }), e && i && (u({
+    "--base-scale": "var(--index) * 0.05 + 1",
+    "--y": "calc(var(--lift-amount) * var(--index))",
+    "--scale": "calc(-1 * var(--base-scale))",
+    "--height": "var(--first-height)"
+  }), r || u({
+    "--y": "calc(var(--sign) * 40%)"
+  })), e && s.stacked && !r && u({
+    "--y": "calc(var(--lift) * var(--offset) + var(--lift) * -100%)"
+  }), s.frontmost && !r && u({
+    "--y": "calc(var(--lift) * -100%)"
+  }), c;
+}
+function X(s, r) {
+  const t = {
+    position: "absolute",
+    inset: "0",
+    scale: "1 2",
+    pointerEvents: r ? "none" : "auto"
+  }, e = (i) => Object.assign(t, i);
+  return s.frontmost && !r && e({
+    height: "calc(var(--initial-height) + 80%)"
+  }), t;
+}
+function Y(s, r) {
+  return {
+    position: "absolute",
+    left: "0",
+    height: "calc(var(--gap) + 2px)",
+    bottom: "100%",
+    width: "100%"
+  };
+}
+function q(s, r, t) {
+  function e() {
+    return k(s) ? s.getState() : s;
+  }
+  function i(o) {
+    return b(e().context.toasts, o);
+  }
+  function c(o) {
+    const n = e().context.toasts;
+    return n.length ? !!n.find((l) => l.id == o) : !1;
+  }
+  function u(o) {
+    const n = `toast:${G()}`, l = o.id ? o.id : n;
+    return c(l) || r({ type: "ADD_TOAST", toast: { ...o, id: l } }), l;
+  }
+  function h(o, n) {
+    return c(o) && r({ type: "UPDATE_TOAST", id: o, toast: n }), o;
+  }
+  function d(o) {
+    const { id: n } = o;
+    return (n ? c(n) : !1) && n != null ? h(n, o) : u(o);
+  }
+  function a(o) {
+    o == null ? r("DISMISS_ALL") : c(o) && r({ type: "DISMISS_TOAST", id: o });
+  }
+  return {
+    getCount() {
+      return e().context.count;
+    },
+    getPlacements() {
+      const n = e().context.toasts.map((l) => l.state.context.placement);
+      return Array.from(new Set(n));
+    },
+    getToastsByPlacement: i,
+    isVisible: c,
+    create: u,
+    update: h,
+    upsert: d,
+    dismiss: a,
+    remove(o) {
+      o == null ? r("REMOVE_ALL") : c(o) && r({ type: "REMOVE_TOAST", id: o });
+    },
+    dismissByPlacement(o) {
+      i(o).forEach((l) => a(l.id));
+    },
+    loading(o) {
+      return d({ ...o, type: "loading" });
+    },
+    success(o) {
+      return d({ ...o, type: "success" });
+    },
+    error(o) {
+      return d({ ...o, type: "error" });
+    },
+    promise(o, n, l = {}) {
+      const g = d({ ...l, ...n.loading, type: "loading" });
+      return v(o).then((p) => {
+        const m = v(n.success, p);
+        d({ ...l, ...m, id: g, type: "success" });
+      }).catch((p) => {
+        const m = v(n.error, p);
+        d({ ...l, ...m, id: g, type: "error" });
+      }).finally(() => {
+        var p;
+        (p = n.finally) == null || p.call(n);
+      }), g;
+    },
+    pause(o) {
+      o == null ? r("PAUSE_ALL") : c(o) && r({ type: "PAUSE_TOAST", id: o });
+    },
+    resume(o) {
+      o == null ? r("RESUME_ALL") : c(o) && r({ type: "RESUME_TOAST", id: o });
+    },
+    getGroupProps(o) {
+      const { placement: n, label: l = "Notifications" } = o, g = e(), p = g.context.hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, ""), [m, S = "center"] = n.split("-");
+      return t.element({
+        ...T.group.attrs,
+        dir: g.context.dir,
+        tabIndex: -1,
+        "aria-label": `${n} ${l} ${p}`,
+        id: f.getRegionId(n),
+        "data-placement": n,
+        "data-side": m,
+        "data-align": S,
+        "aria-live": "polite",
+        role: "region",
+        style: W(g.context, n),
+        onMouseMove() {
+          r({ type: "REGION.POINTER_ENTER", placement: n });
+        },
+        onMouseLeave() {
+          r({ type: "REGION.POINTER_LEAVE", placement: n });
+        },
+        onFocus(E) {
+          r({ type: "REGION.FOCUS", target: E.relatedTarget });
+        },
+        onBlur(E) {
+          g.context.isFocusWithin && !N(E.currentTarget, E.relatedTarget) && r({ type: "REGION.BLUR" });
+        }
+      });
+    },
+    subscribe(o) {
+      const n = e();
+      return w(n.context.toasts, () => {
+        const g = i(n.context.placement).map((p) => p.getState().context);
+        o(g);
+      });
+    }
+  };
+}
+var { not: Z, and: J, or: Q } = U;
+function z(s) {
+  const { type: r = "info", duration: t, id: e = "1", placement: i = "bottom", removeDelay: c = 200, ...u } = s, h = L(u), d = _(t, r);
+  return P(
+    {
+      id: e,
+      context: {
+        id: e,
+        type: r,
+        remaining: d,
+        duration: d,
+        removeDelay: c,
+        createdAt: Date.now(),
+        placement: i,
+        ...h,
+        height: 0,
+        offset: 0,
+        frontmost: !1,
+        mounted: !1,
+        index: -1,
+        zIndex: 0
+      },
+      initial: r === "loading" ? "visible:persist" : "visible",
+      on: {
+        UPDATE: [
+          {
+            guard: J("hasTypeChanged", "isChangingToLoading"),
+            target: "visible:persist",
+            actions: ["setContext"]
+          },
+          {
+            guard: Q("hasDurationChanged", "hasTypeChanged"),
+            target: "visible:updating",
+            actions: ["setContext"]
+          },
+          {
+            actions: ["setContext"]
+          }
+        ],
+        MEASURE: {
+          actions: ["measureHeight"]
+        }
+      },
+      entry: ["invokeOnVisible"],
+      activities: ["trackHeight"],
+      states: {
+        "visible:updating": {
+          tags: ["visible", "updating"],
+          after: {
+            0: "visible"
+          }
+        },
+        "visible:persist": {
+          tags: ["visible", "paused"],
+          on: {
+            RESUME: {
+              guard: Z("isLoadingType"),
+              target: "visible",
+              actions: ["setCreatedAt"]
+            },
+            DISMISS: "dismissing"
+          }
+        },
+        visible: {
+          tags: ["visible"],
+          after: {
+            VISIBLE_DURATION: "dismissing"
+          },
+          on: {
+            DISMISS: "dismissing",
+            PAUSE: {
+              target: "visible:persist",
+              actions: "setRemainingDuration"
+            }
+          }
+        },
+        dismissing: {
+          entry: "invokeOnDismiss",
+          after: {
+            REMOVE_DELAY: {
+              target: "unmounted",
+              actions: "notifyParentToRemove"
+            }
+          }
+        },
+        unmounted: {
+          entry: "invokeOnUnmount",
+          type: "final"
+        }
+      }
+    },
+    {
+      activities: {
+        trackHeight(a, o, { self: n }) {
+          let l;
+          return A(() => {
+            const g = f.getRootEl(a);
+            if (!g) return;
+            a.mounted = !0;
+            const p = H(g, "[data-ghost]");
+            B(
+              p.length !== 2,
+              "[toast] No ghost element found in toast. Render the `ghostBefore` and `ghostAfter` elements"
+            );
+            const m = () => {
+              const M = g.style.height;
+              g.style.height = "auto";
+              const R = g.getBoundingClientRect().height;
+              g.style.height = M, a.height = R, n.sendParent({ type: "UPDATE_HEIGHT", id: n.id, height: R, placement: a.placement });
+            };
+            m();
+            const S = f.getWin(a), E = new S.MutationObserver(m);
+            E.observe(g, { childList: !0, subtree: !0, characterData: !0 }), l = () => E.disconnect();
+          }), () => l == null ? void 0 : l();
+        }
+      },
+      guards: {
+        isChangingToLoading: (a, o) => {
+          var n;
+          return ((n = o.toast) == null ? void 0 : n.type) === "loading";
+        },
+        isLoadingType: (a) => a.type === "loading",
+        hasTypeChanged: (a, o) => {
+          var n;
+          return ((n = o.toast) == null ? void 0 : n.type) != null && o.toast.type !== a.type;
+        },
+        hasDurationChanged: (a, o) => {
+          var n;
+          return ((n = o.toast) == null ? void 0 : n.duration) != null && o.toast.duration !== a.duration;
+        }
+      },
+      delays: {
+        VISIBLE_DURATION: (a) => a.remaining,
+        REMOVE_DELAY: (a) => a.removeDelay
+      },
+      actions: {
+        measureHeight(a, o, { self: n }) {
+          A(() => {
+            const l = f.getRootEl(a);
+            if (!l) return;
+            a.mounted = !0;
+            const g = l.style.height;
+            l.style.height = "auto";
+            const p = l.getBoundingClientRect().height;
+            l.style.height = g, a.height = p, n.sendParent({ type: "UPDATE_HEIGHT", id: n.id, height: p, placement: a.placement });
+          });
+        },
+        setRemainingDuration(a) {
+          a.remaining -= Date.now() - a.createdAt;
+        },
+        setCreatedAt(a) {
+          a.createdAt = Date.now();
+        },
+        notifyParentToRemove(a, o, { self: n }) {
+          n.sendParent({ type: "REMOVE_TOAST", id: n.id });
+        },
+        invokeOnDismiss(a) {
+          var o;
+          (o = a.onStatusChange) == null || o.call(a, { status: "dismissing" });
+        },
+        invokeOnUnmount(a) {
+          var o;
+          (o = a.onStatusChange) == null || o.call(a, { status: "unmounted" });
+        },
+        invokeOnVisible(a) {
+          var o;
+          (o = a.onStatusChange) == null || o.call(a, { status: "visible" });
+        },
+        setContext(a, o) {
+          var p, m;
+          const n = (p = o.toast) == null ? void 0 : p.duration, l = ((m = o.toast) == null ? void 0 : m.type) ?? a.type, g = _(n, l);
+          Object.assign(a, {
+            ...o.toast,
+            duration: g,
+            remaining: g
+          });
+        }
+      }
+    }
+  );
+}
+function tt(s) {
+  const r = L(s);
+  return P(
+    {
+      id: "toaster",
+      initial: r.overlap ? "overlap" : "stack",
+      context: {
+        dir: "ltr",
+        max: Number.MAX_SAFE_INTEGER,
+        gap: 16,
+        pauseOnPageIdle: !1,
+        hotkey: ["altKey", "KeyT"],
+        offsets: "1rem",
+        placement: "bottom",
+        removeDelay: 200,
+        ...r,
+        toasts: [],
+        lastFocusedEl: null,
+        isFocusWithin: !1,
+        heights: []
+      },
+      computed: {
+        count: (t) => t.toasts.length
+      },
+      activities: ["trackDocumentVisibility", "trackHotKeyPress"],
+      watch: {
+        toasts: ["collapsedIfEmpty", "setDismissableBranch"]
+      },
+      exit: ["removeToasts", "clearDismissableBranch", "clearLastFocusedEl"],
+      on: {
+        PAUSE_TOAST: {
+          actions: ["pauseToast"]
+        },
+        PAUSE_ALL: {
+          actions: ["pauseToasts"]
+        },
+        RESUME_TOAST: {
+          actions: ["resumeToast"]
+        },
+        RESUME_ALL: {
+          actions: ["resumeToasts"]
+        },
+        ADD_TOAST: {
+          guard: "isWithinRange",
+          actions: ["createToast", "syncToastIndex"]
+        },
+        UPDATE_TOAST: {
+          actions: ["updateToast"]
+        },
+        DISMISS_TOAST: {
+          actions: ["dismissToast"]
+        },
+        DISMISS_ALL: {
+          actions: ["dismissToasts"]
+        },
+        REMOVE_TOAST: {
+          actions: ["removeToast", "syncToastIndex", "syncToastOffset"]
+        },
+        REMOVE_ALL: {
+          actions: ["removeToasts"]
+        },
+        UPDATE_HEIGHT: {
+          actions: ["syncHeights", "syncToastOffset"]
+        },
+        "DOC.HOTKEY": {
+          actions: ["focusRegionEl"]
+        },
+        "REGION.BLUR": [
+          {
+            guard: "isOverlapping",
+            target: "overlap",
+            actions: ["resumeToasts", "restoreLastFocusedEl"]
+          },
+          {
+            actions: ["resumeToasts", "restoreLastFocusedEl"]
+          }
+        ]
+      },
+      states: {
+        stack: {
+          entry: ["expandToasts"],
+          on: {
+            "REGION.POINTER_LEAVE": [
+              {
+                guard: "isOverlapping",
+                target: "overlap",
+                actions: ["resumeToasts"]
+              },
+              {
+                actions: ["resumeToasts"]
+              }
+            ],
+            "REGION.OVERLAP": {
+              target: "overlap"
+            },
+            "REGION.FOCUS": {
+              actions: ["setLastFocusedEl", "pauseToasts"]
+            },
+            "REGION.POINTER_ENTER": {
+              actions: ["pauseToasts"]
+            }
+          }
+        },
+        overlap: {
+          entry: ["collapseToasts"],
+          on: {
+            "REGION.STACK": {
+              target: "stack"
+            },
+            "REGION.POINTER_ENTER": {
+              target: "stack",
+              actions: ["pauseToasts"]
+            },
+            "REGION.FOCUS": {
+              target: "stack",
+              actions: ["setLastFocusedEl", "pauseToasts"]
+            }
+          }
+        }
+      }
+    },
+    {
+      guards: {
+        isWithinRange: (t) => t.toasts.length < t.max,
+        isOverlapping: (t) => !!t.overlap
+      },
+      activities: {
+        trackHotKeyPress(t, e, { send: i }) {
+          return D(document, "keydown", (u) => {
+            t.hotkey.every((d) => u[d] || u.code === d) && i({ type: "DOC.HOTKEY" });
+          }, { capture: !0 });
+        },
+        trackDocumentVisibility(t, e, { send: i }) {
+          if (!t.pauseOnPageIdle) return;
+          const c = f.getDoc(t);
+          return D(c, "visibilitychange", () => {
+            i(c.visibilityState === "hidden" ? "PAUSE_ALL" : "RESUME_ALL");
+          });
+        }
+      },
+      actions: {
+        setDismissableBranch(t) {
+          var u;
+          const i = b(t.toasts, t.placement).length > 0;
+          if (!i) {
+            (u = t._cleanup) == null || u.call(t);
+            return;
+          }
+          if (i && t._cleanup)
+            return;
+          const c = () => f.getRegionEl(t, t.placement);
+          t._cleanup = V(c, { defer: !0 });
+        },
+        clearDismissableBranch(t) {
+          var e;
+          (e = t._cleanup) == null || e.call(t);
+        },
+        focusRegionEl(t) {
+          queueMicrotask(() => {
+            var e;
+            (e = f.getRegionEl(t, t.placement)) == null || e.focus();
+          });
+        },
+        expandToasts(t) {
+          I(t, (e) => {
+            e.state.context.stacked = !0;
+          });
+        },
+        collapseToasts(t) {
+          I(t, (e) => {
+            e.state.context.stacked = !1;
+          });
+        },
+        collapsedIfEmpty(t, e, { send: i }) {
+          !t.overlap || t.toasts.length > 1 || i("REGION.OVERLAP");
+        },
+        pauseToast(t, e, { self: i }) {
+          i.sendChild("PAUSE", e.id);
+        },
+        pauseToasts(t) {
+          t.toasts.forEach((e) => e.send("PAUSE"));
+        },
+        resumeToast(t, e, { self: i }) {
+          i.sendChild("RESUME", e.id);
+        },
+        resumeToasts(t) {
+          t.toasts.forEach((e) => e.send("RESUME"));
+        },
+        measureToasts(t) {
+          t.toasts.forEach((e) => e.send("MEASURE"));
+        },
+        createToast(t, e, { self: i, getState: c }) {
+          const u = {
+            placement: t.placement,
+            duration: t.duration,
+            removeDelay: t.removeDelay,
+            ...e.toast,
+            dir: t.dir,
+            getRootNode: t.getRootNode,
+            stacked: c().matches("stack")
+          }, h = z(u), d = i.spawn(h);
+          t.toasts = [d, ...t.toasts];
+        },
+        updateToast(t, e, { self: i }) {
+          i.sendChild({ type: "UPDATE", toast: e.toast }, e.id);
+        },
+        dismissToast(t, e, { self: i }) {
+          i.sendChild("DISMISS", e.id);
+        },
+        dismissToasts(t) {
+          t.toasts.forEach((e) => e.send("DISMISS"));
+        },
+        removeToast(t, e, { self: i }) {
+          i.stopChild(e.id), t.toasts = t.toasts.filter((c) => c.id !== e.id), t.heights = t.heights.filter((c) => c.id !== e.id);
+        },
+        removeToasts(t, e, { self: i }) {
+          t.toasts.forEach((c) => i.stopChild(c.id)), t.toasts = [], t.heights = [];
+        },
+        syncHeights(t, e) {
+          const i = t.heights.find((c) => c.id === e.id);
+          if (i)
+            i.height = e.height, i.placement = e.placement;
+          else {
+            const c = { id: e.id, height: e.height, placement: e.placement };
+            t.heights = [c, ...t.heights];
+          }
+        },
+        syncToastIndex(t) {
+          I(t, (e, i, c) => {
+            e.state.context.index = i, e.state.context.frontmost = i === 0, e.state.context.zIndex = c.length - i;
+          });
+        },
+        syncToastOffset(t, e) {
+          const i = e.placement ?? t.placement;
+          I({ ...t, placement: i }, (c) => {
+            const u = Math.max(
+              t.heights.findIndex((d) => d.id === c.id),
+              0
+            ), h = t.heights.reduce((d, a, o) => o >= u ? d : d + a.height, 0);
+            c.state.context.offset = u * t.gap + h;
+          });
+        },
+        setLastFocusedEl(t, e) {
+          t.isFocusWithin || !e.target || (t.isFocusWithin = !0, t.lastFocusedEl = x(e.target));
+        },
+        restoreLastFocusedEl(t) {
+          t.isFocusWithin = !1, t.lastFocusedEl && (t.lastFocusedEl.focus({ preventScroll: !0 }), t.lastFocusedEl = null);
+        },
+        clearLastFocusedEl(t) {
+          t.lastFocusedEl && (t.lastFocusedEl.focus({ preventScroll: !0 }), t.lastFocusedEl = null, t.isFocusWithin = !1);
+        }
+      }
+    }
+  );
+}
+function I(s, r) {
+  b(s.toasts, s.placement).forEach(r);
+}
+function ct(s, r, t) {
+  const e = s.hasTag("visible"), i = s.hasTag("paused"), c = s.context.placement, u = s.context.type, [h, d = "center"] = c.split("-");
+  return {
+    type: u,
+    title: s.context.title,
+    description: s.context.description,
+    placement: c,
+    visible: e,
+    paused: i,
+    pause() {
+      r("PAUSE");
+    },
+    resume() {
+      r("RESUME");
+    },
+    dismiss() {
+      r("DISMISS");
+    },
+    getRootProps() {
+      return t.element({
+        ...T.root.attrs,
+        dir: s.context.dir,
+        id: f.getRootId(s.context),
+        "data-state": e ? "open" : "closed",
+        "data-type": u,
+        "data-placement": c,
+        "data-align": d,
+        "data-side": h,
+        "data-mounted": y(s.context.mounted),
+        "data-paused": y(i),
+        "data-first": y(s.context.frontmost),
+        "data-sibling": y(!s.context.frontmost),
+        "data-stack": y(s.context.stacked),
+        "data-overlap": y(!s.context.stacked),
+        role: "status",
+        "aria-atomic": "true",
+        "aria-describedby": s.context.description ? f.getDescriptionId(s.context) : void 0,
+        "aria-labelledby": s.context.title ? f.getTitleId(s.context) : void 0,
+        tabIndex: 0,
+        style: j(s.context, e),
+        onKeyDown(a) {
+          a.defaultPrevented || a.key == "Escape" && (r("DISMISS"), a.preventDefault());
+        }
+      });
+    },
+    /* Leave a ghost div to avoid setting hover to false when transitioning out */
+    getGhostBeforeProps() {
+      return t.element({
+        "data-ghost": "before",
+        style: X(s.context, e)
+      });
+    },
+    /* Needed to avoid setting hover to false when in between toasts */
+    getGhostAfterProps() {
+      return t.element({
+        "data-ghost": "after",
+        style: Y(s.context)
+      });
+    },
+    getTitleProps() {
+      return t.element({
+        ...T.title.attrs,
+        id: f.getTitleId(s.context)
+      });
+    },
+    getDescriptionProps() {
+      return t.element({
+        ...T.description.attrs,
+        id: f.getDescriptionId(s.context)
+      });
+    },
+    getActionTriggerProps() {
+      return t.button({
+        ...T.actionTrigger.attrs,
+        type: "button",
+        onClick(a) {
+          a.defaultPrevented || r("DISMISS");
+        }
+      });
+    },
+    getCloseTriggerProps() {
+      return t.button({
+        id: f.getCloseTriggerId(s.context),
+        ...T.closeTrigger.attrs,
+        type: "button",
+        "aria-label": "Dismiss notification",
+        onClick(a) {
+          a.defaultPrevented || r("DISMISS");
+        }
+      });
+    }
+  };
+}
+var lt = {
+  connect: q,
+  machine: tt
+};
+export {
+  K as anatomy,
+  ct as connect,
+  z as createMachine,
+  lt as group
+};