@worldcoin/mini-apps-ui-kit-react 1.0.0-canary.9 → 1.0.0

package/dist/node_modules/.pnpm/@radix-ui_react-toast@1.2.6_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18.3.1_mux33mveszkw5z6iia6acnivvy/node_modules/@radix-ui/react-toast/dist/index.js

@@ -1,146 +1,205 @@
 "use client";
-import * as n from "react";
-import * as we from "react-dom";
-import { composeEventHandlers as R } from "../../../../../@radix-ui_primitive@1.1.1/node_modules/@radix-ui/primitive/dist/index.js";
-import { useComposedRefs as te } from "../../../../../@radix-ui_react-compose-refs@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js";
-import { createCollection as Ee } from "../../../../../@radix-ui_react-collection@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@1_tagbd57u5fsqga6qdjecsll7fm/node_modules/@radix-ui/react-collection/dist/index.js";
-import { createContextScope as ye } from "../../../../../@radix-ui_react-context@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-context/dist/index.js";
-import { Branch as Pe, Root as Ce } from "../../../../../@radix-ui_react-dismissable-layer@1.1.5_@types_react-dom@18.3.5_@types_react@18.3.18__@types__nitdfoqpcbroetgllwgz3is5ai/node_modules/@radix-ui/react-dismissable-layer/dist/index.js";
-import { Portal as xe } from "../../../../../@radix-ui_react-portal@1.1.4_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18.3._ulc3jfxcmrz2rfz7bui53djdtu/node_modules/@radix-ui/react-portal/dist/index.js";
-import { Presence as he } from "../../../../../@radix-ui_react-presence@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18._pqwkltkxenlrsgmgun6icjiigu/node_modules/@radix-ui/react-presence/dist/index.js";
-import { Primitive as D, dispatchDiscreteCustomEvent as Re } from "../../../../../@radix-ui_react-primitive@2.0.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sejcxqoscaweil2bvgwwavaoha/node_modules/@radix-ui/react-primitive/dist/index.js";
-import { useCallbackRef as W } from "../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js";
-import { useControllableState as be } from "../../../../../@radix-ui_react-use-controllable-state@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
-import { useLayoutEffect as ge } from "../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js";
-import { VisuallyHidden as oe } from "../../../../../@radix-ui_react-visually-hidden@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_re_omyrydx3gc2oidaiqb4gsovieq/node_modules/@radix-ui/react-visually-hidden/dist/index.js";
-import { jsxs as G, jsx as l, Fragment as re } from "react/jsx-runtime";
-var J = "ToastProvider", [Q, Se, Ie] = Ee("Toast"), [ne, at] = ye("Toast", [Ie]), [Fe, U] = ne(J), se = (e) => {
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { composeEventHandlers } from "../../../../../@radix-ui_primitive@1.1.1/node_modules/@radix-ui/primitive/dist/index.js";
+import { useComposedRefs } from "../../../../../@radix-ui_react-compose-refs@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js";
+import { createCollection } from "../../../../../@radix-ui_react-collection@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@1_tagbd57u5fsqga6qdjecsll7fm/node_modules/@radix-ui/react-collection/dist/index.js";
+import { createContextScope } from "../../../../../@radix-ui_react-context@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-context/dist/index.js";
+import { Branch, Root } from "../../../../../@radix-ui_react-dismissable-layer@1.1.5_@types_react-dom@18.3.5_@types_react@18.3.18__@types__nitdfoqpcbroetgllwgz3is5ai/node_modules/@radix-ui/react-dismissable-layer/dist/index.js";
+import { Portal } from "../../../../../@radix-ui_react-portal@1.1.4_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18.3._ulc3jfxcmrz2rfz7bui53djdtu/node_modules/@radix-ui/react-portal/dist/index.js";
+import { Presence } from "../../../../../@radix-ui_react-presence@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18._pqwkltkxenlrsgmgun6icjiigu/node_modules/@radix-ui/react-presence/dist/index.js";
+import { Primitive, dispatchDiscreteCustomEvent } from "../../../../../@radix-ui_react-primitive@2.0.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sejcxqoscaweil2bvgwwavaoha/node_modules/@radix-ui/react-primitive/dist/index.js";
+import { useCallbackRef } from "../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js";
+import { useControllableState } from "../../../../../@radix-ui_react-use-controllable-state@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+import { useLayoutEffect as useLayoutEffect2 } from "../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js";
+import { VisuallyHidden } from "../../../../../@radix-ui_react-visually-hidden@1.1.2_@types_react-dom@18.3.5_@types_react@18.3.18__@types_re_omyrydx3gc2oidaiqb4gsovieq/node_modules/@radix-ui/react-visually-hidden/dist/index.js";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+var PROVIDER_NAME = "ToastProvider";
+var [Collection, useCollection, createCollectionScope] = createCollection("Toast");
+var [createToastContext, createToastScope] = createContextScope("Toast", [createCollectionScope]);
+var [ToastProviderProvider, useToastProviderContext] = createToastContext(PROVIDER_NAME);
+var ToastProvider = (props) => {
   const {
-    __scopeToast: o,
-    label: r = "Notification",
-    duration: t = 5e3,
-    swipeDirection: c = "right",
-    swipeThreshold: d = 50,
-    children: p
-  } = e, [T, v] = n.useState(null), [s, h] = n.useState(0), y = n.useRef(!1), N = n.useRef(!1);
-  return r.trim() || console.error(
-    `Invalid prop \`label\` supplied to \`${J}\`. Expected non-empty \`string\`.`
-  ), /* @__PURE__ */ l(Q.Provider, { scope: o, children: /* @__PURE__ */ l(
-    Fe,
+    __scopeToast,
+    label = "Notification",
+    duration = 5e3,
+    swipeDirection = "right",
+    swipeThreshold = 50,
+    children
+  } = props;
+  const [viewport, setViewport] = React.useState(null);
+  const [toastCount, setToastCount] = React.useState(0);
+  const isFocusedToastEscapeKeyDownRef = React.useRef(false);
+  const isClosePausedRef = React.useRef(false);
+  if (!label.trim()) {
+    console.error(
+      `Invalid prop \`label\` supplied to \`${PROVIDER_NAME}\`. Expected non-empty \`string\`.`
+    );
+  }
+  return /* @__PURE__ */ jsx(Collection.Provider, { scope: __scopeToast, children: /* @__PURE__ */ jsx(
+    ToastProviderProvider,
     {
-      scope: o,
-      label: r,
-      duration: t,
-      swipeDirection: c,
-      swipeThreshold: d,
-      toastCount: s,
-      viewport: T,
-      onViewportChange: v,
-      onToastAdd: n.useCallback(() => h((g) => g + 1), []),
-      onToastRemove: n.useCallback(() => h((g) => g - 1), []),
-      isFocusedToastEscapeKeyDownRef: y,
-      isClosePausedRef: N,
-      children: p
+      scope: __scopeToast,
+      label,
+      duration,
+      swipeDirection,
+      swipeThreshold,
+      toastCount,
+      viewport,
+      onViewportChange: setViewport,
+      onToastAdd: React.useCallback(() => setToastCount((prevCount) => prevCount + 1), []),
+      onToastRemove: React.useCallback(() => setToastCount((prevCount) => prevCount - 1), []),
+      isFocusedToastEscapeKeyDownRef,
+      isClosePausedRef,
+      children
     }
   ) });
 };
-se.displayName = J;
-var ae = "ToastViewport", _e = ["F8"], j = "toast.viewportPause", q = "toast.viewportResume", ie = n.forwardRef(
-  (e, o) => {
+ToastProvider.displayName = PROVIDER_NAME;
+var VIEWPORT_NAME = "ToastViewport";
+var VIEWPORT_DEFAULT_HOTKEY = ["F8"];
+var VIEWPORT_PAUSE = "toast.viewportPause";
+var VIEWPORT_RESUME = "toast.viewportResume";
+var ToastViewport = React.forwardRef(
+  (props, forwardedRef) => {
     const {
-      __scopeToast: r,
-      hotkey: t = _e,
-      label: c = "Notifications ({hotkey})",
-      ...d
-    } = e, p = U(ae, r), T = Se(r), v = n.useRef(null), s = n.useRef(null), h = n.useRef(null), y = n.useRef(null), N = te(o, y, p.onViewportChange), g = t.join("+").replace(/Key/g, "").replace(/Digit/g, ""), S = p.toastCount > 0;
-    n.useEffect(() => {
-      const i = (P) => {
-        var m;
-        t.length !== 0 && t.every((w) => P[w] || P.code === w) && ((m = y.current) == null || m.focus());
+      __scopeToast,
+      hotkey = VIEWPORT_DEFAULT_HOTKEY,
+      label = "Notifications ({hotkey})",
+      ...viewportProps
+    } = props;
+    const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
+    const getItems = useCollection(__scopeToast);
+    const wrapperRef = React.useRef(null);
+    const headFocusProxyRef = React.useRef(null);
+    const tailFocusProxyRef = React.useRef(null);
+    const ref = React.useRef(null);
+    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
+    const hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
+    const hasToasts = context.toastCount > 0;
+    React.useEffect(() => {
+      const handleKeyDown = (event) => {
+        var _a;
+        const isHotkeyPressed = hotkey.length !== 0 && hotkey.every((key) => event[key] || event.code === key);
+        if (isHotkeyPressed) (_a = ref.current) == null ? void 0 : _a.focus();
       };
-      return document.addEventListener("keydown", i), () => document.removeEventListener("keydown", i);
-    }, [t]), n.useEffect(() => {
-      const i = v.current, P = y.current;
-      if (S && i && P) {
-        const f = () => {
-          if (!p.isClosePausedRef.current) {
-            const C = new CustomEvent(j);
-            P.dispatchEvent(C), p.isClosePausedRef.current = !0;
+      document.addEventListener("keydown", handleKeyDown);
+      return () => document.removeEventListener("keydown", handleKeyDown);
+    }, [hotkey]);
+    React.useEffect(() => {
+      const wrapper = wrapperRef.current;
+      const viewport = ref.current;
+      if (hasToasts && wrapper && viewport) {
+        const handlePause = () => {
+          if (!context.isClosePausedRef.current) {
+            const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
+            viewport.dispatchEvent(pauseEvent);
+            context.isClosePausedRef.current = true;
           }
-        }, m = () => {
-          if (p.isClosePausedRef.current) {
-            const C = new CustomEvent(q);
-            P.dispatchEvent(C), p.isClosePausedRef.current = !1;
+        };
+        const handleResume = () => {
+          if (context.isClosePausedRef.current) {
+            const resumeEvent = new CustomEvent(VIEWPORT_RESUME);
+            viewport.dispatchEvent(resumeEvent);
+            context.isClosePausedRef.current = false;
           }
-        }, w = (C) => {
-          !i.contains(C.relatedTarget) && m();
-        }, E = () => {
-          i.contains(document.activeElement) || m();
         };
-        return i.addEventListener("focusin", f), i.addEventListener("focusout", w), i.addEventListener("pointermove", f), i.addEventListener("pointerleave", E), window.addEventListener("blur", f), window.addEventListener("focus", m), () => {
-          i.removeEventListener("focusin", f), i.removeEventListener("focusout", w), i.removeEventListener("pointermove", f), i.removeEventListener("pointerleave", E), window.removeEventListener("blur", f), window.removeEventListener("focus", m);
+        const handleFocusOutResume = (event) => {
+          const isFocusMovingOutside = !wrapper.contains(event.relatedTarget);
+          if (isFocusMovingOutside) handleResume();
+        };
+        const handlePointerLeaveResume = () => {
+          const isFocusInside = wrapper.contains(document.activeElement);
+          if (!isFocusInside) handleResume();
+        };
+        wrapper.addEventListener("focusin", handlePause);
+        wrapper.addEventListener("focusout", handleFocusOutResume);
+        wrapper.addEventListener("pointermove", handlePause);
+        wrapper.addEventListener("pointerleave", handlePointerLeaveResume);
+        window.addEventListener("blur", handlePause);
+        window.addEventListener("focus", handleResume);
+        return () => {
+          wrapper.removeEventListener("focusin", handlePause);
+          wrapper.removeEventListener("focusout", handleFocusOutResume);
+          wrapper.removeEventListener("pointermove", handlePause);
+          wrapper.removeEventListener("pointerleave", handlePointerLeaveResume);
+          window.removeEventListener("blur", handlePause);
+          window.removeEventListener("focus", handleResume);
         };
       }
-    }, [S, p.isClosePausedRef]);
-    const u = n.useCallback(
-      ({ tabbingDirection: i }) => {
-        const f = T().map((m) => {
-          const w = m.ref.current, E = [w, ...Be(w)];
-          return i === "forwards" ? E : E.reverse();
+    }, [hasToasts, context.isClosePausedRef]);
+    const getSortedTabbableCandidates = React.useCallback(
+      ({ tabbingDirection }) => {
+        const toastItems = getItems();
+        const tabbableCandidates = toastItems.map((toastItem) => {
+          const toastNode = toastItem.ref.current;
+          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)];
+          return tabbingDirection === "forwards" ? toastTabbableCandidates : toastTabbableCandidates.reverse();
         });
-        return (i === "forwards" ? f.reverse() : f).flat();
+        return (tabbingDirection === "forwards" ? tabbableCandidates.reverse() : tabbableCandidates).flat();
       },
-      [T]
+      [getItems]
     );
-    return n.useEffect(() => {
-      const i = y.current;
-      if (i) {
-        const P = (f) => {
-          var E, C, I;
-          const m = f.altKey || f.ctrlKey || f.metaKey;
-          if (f.key === "Tab" && !m) {
-            const L = document.activeElement, _ = f.shiftKey;
-            if (f.target === i && _) {
-              (E = s.current) == null || E.focus();
+    React.useEffect(() => {
+      const viewport = ref.current;
+      if (viewport) {
+        const handleKeyDown = (event) => {
+          var _a, _b, _c;
+          const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
+          const isTabKey = event.key === "Tab" && !isMetaKey;
+          if (isTabKey) {
+            const focusedElement = document.activeElement;
+            const isTabbingBackwards = event.shiftKey;
+            const targetIsViewport = event.target === viewport;
+            if (targetIsViewport && isTabbingBackwards) {
+              (_a = headFocusProxyRef.current) == null ? void 0 : _a.focus();
               return;
             }
-            const F = u({ tabbingDirection: _ ? "backwards" : "forwards" }), k = F.findIndex((a) => a === L);
-            B(F.slice(k + 1)) ? f.preventDefault() : _ ? (C = s.current) == null || C.focus() : (I = h.current) == null || I.focus();
+            const tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
+            const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });
+            const index = sortedCandidates.findIndex((candidate) => candidate === focusedElement);
+            if (focusFirst(sortedCandidates.slice(index + 1))) {
+              event.preventDefault();
+            } else {
+              isTabbingBackwards ? (_b = headFocusProxyRef.current) == null ? void 0 : _b.focus() : (_c = tailFocusProxyRef.current) == null ? void 0 : _c.focus();
+            }
           }
         };
-        return i.addEventListener("keydown", P), () => i.removeEventListener("keydown", P);
+        viewport.addEventListener("keydown", handleKeyDown);
+        return () => viewport.removeEventListener("keydown", handleKeyDown);
       }
-    }, [T, u]), /* @__PURE__ */ G(
-      Pe,
+    }, [getItems, getSortedTabbableCandidates]);
+    return /* @__PURE__ */ jsxs(
+      Branch,
       {
-        ref: v,
+        ref: wrapperRef,
         role: "region",
-        "aria-label": c.replace("{hotkey}", g),
+        "aria-label": label.replace("{hotkey}", hotkeyLabel),
         tabIndex: -1,
-        style: { pointerEvents: S ? void 0 : "none" },
+        style: { pointerEvents: hasToasts ? void 0 : "none" },
         children: [
-          S && /* @__PURE__ */ l(
-            z,
+          hasToasts && /* @__PURE__ */ jsx(
+            FocusProxy,
             {
-              ref: s,
+              ref: headFocusProxyRef,
               onFocusFromOutsideViewport: () => {
-                const i = u({
+                const tabbableCandidates = getSortedTabbableCandidates({
                   tabbingDirection: "forwards"
                 });
-                B(i);
+                focusFirst(tabbableCandidates);
               }
             }
           ),
-          /* @__PURE__ */ l(Q.Slot, { scope: r, children: /* @__PURE__ */ l(D.ol, { tabIndex: -1, ...d, ref: N }) }),
-          S && /* @__PURE__ */ l(
-            z,
+          /* @__PURE__ */ jsx(Collection.Slot, { scope: __scopeToast, children: /* @__PURE__ */ jsx(Primitive.ol, { tabIndex: -1, ...viewportProps, ref: composedRefs }) }),
+          hasToasts && /* @__PURE__ */ jsx(
+            FocusProxy,
             {
-              ref: h,
+              ref: tailFocusProxyRef,
               onFocusFromOutsideViewport: () => {
-                const i = u({
+                const tabbableCandidates = getSortedTabbableCandidates({
                   tabbingDirection: "backwards"
                 });
-                B(i);
+                focusFirst(tabbableCandidates);
               }
             }
           )
@@ -149,169 +208,259 @@ var ae = "ToastViewport", _e = ["F8"], j = "toast.viewportPause", q = "toast.vie
     );
   }
 );
-ie.displayName = ae;
-var ce = "ToastFocusProxy", z = n.forwardRef(
-  (e, o) => {
-    const { __scopeToast: r, onFocusFromOutsideViewport: t, ...c } = e, d = U(ce, r);
-    return /* @__PURE__ */ l(
-      oe,
+ToastViewport.displayName = VIEWPORT_NAME;
+var FOCUS_PROXY_NAME = "ToastFocusProxy";
+var FocusProxy = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeToast, onFocusFromOutsideViewport, ...proxyProps } = props;
+    const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
+    return /* @__PURE__ */ jsx(
+      VisuallyHidden,
       {
-        "aria-hidden": !0,
+        "aria-hidden": true,
         tabIndex: 0,
-        ...c,
-        ref: o,
+        ...proxyProps,
+        ref: forwardedRef,
         style: { position: "fixed" },
-        onFocus: (p) => {
-          var s;
-          const T = p.relatedTarget;
-          !((s = d.viewport) != null && s.contains(T)) && t();
+        onFocus: (event) => {
+          var _a;
+          const prevFocusedElement = event.relatedTarget;
+          const isFocusFromOutsideViewport = !((_a = context.viewport) == null ? void 0 : _a.contains(prevFocusedElement));
+          if (isFocusFromOutsideViewport) onFocusFromOutsideViewport();
         }
       }
     );
   }
 );
-z.displayName = ce;
-var X = "Toast", Ae = "toast.swipeStart", De = "toast.swipeMove", Ne = "toast.swipeCancel", Le = "toast.swipeEnd", ue = n.forwardRef(
-  (e, o) => {
-    const { forceMount: r, open: t, defaultOpen: c, onOpenChange: d, ...p } = e, [T = !0, v] = be({
-      prop: t,
-      defaultProp: c,
-      onChange: d
+FocusProxy.displayName = FOCUS_PROXY_NAME;
+var TOAST_NAME = "Toast";
+var TOAST_SWIPE_START = "toast.swipeStart";
+var TOAST_SWIPE_MOVE = "toast.swipeMove";
+var TOAST_SWIPE_CANCEL = "toast.swipeCancel";
+var TOAST_SWIPE_END = "toast.swipeEnd";
+var Toast = React.forwardRef(
+  (props, forwardedRef) => {
+    const { forceMount, open: openProp, defaultOpen, onOpenChange, ...toastProps } = props;
+    const [open = true, setOpen] = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen,
+      onChange: onOpenChange
     });
-    return /* @__PURE__ */ l(he, { present: r || T, children: /* @__PURE__ */ l(
-      ke,
+    return /* @__PURE__ */ jsx(Presence, { present: forceMount || open, children: /* @__PURE__ */ jsx(
+      ToastImpl,
       {
-        open: T,
-        ...p,
-        ref: o,
-        onClose: () => v(!1),
-        onPause: W(e.onPause),
-        onResume: W(e.onResume),
-        onSwipeStart: R(e.onSwipeStart, (s) => {
-          s.currentTarget.setAttribute("data-swipe", "start");
+        open,
+        ...toastProps,
+        ref: forwardedRef,
+        onClose: () => setOpen(false),
+        onPause: useCallbackRef(props.onPause),
+        onResume: useCallbackRef(props.onResume),
+        onSwipeStart: composeEventHandlers(props.onSwipeStart, (event) => {
+          event.currentTarget.setAttribute("data-swipe", "start");
         }),
-        onSwipeMove: R(e.onSwipeMove, (s) => {
-          const { x: h, y } = s.detail.delta;
-          s.currentTarget.setAttribute("data-swipe", "move"), s.currentTarget.style.setProperty("--radix-toast-swipe-move-x", `${h}px`), s.currentTarget.style.setProperty("--radix-toast-swipe-move-y", `${y}px`);
+        onSwipeMove: composeEventHandlers(props.onSwipeMove, (event) => {
+          const { x, y } = event.detail.delta;
+          event.currentTarget.setAttribute("data-swipe", "move");
+          event.currentTarget.style.setProperty("--radix-toast-swipe-move-x", `${x}px`);
+          event.currentTarget.style.setProperty("--radix-toast-swipe-move-y", `${y}px`);
         }),
-        onSwipeCancel: R(e.onSwipeCancel, (s) => {
-          s.currentTarget.setAttribute("data-swipe", "cancel"), s.currentTarget.style.removeProperty("--radix-toast-swipe-move-x"), s.currentTarget.style.removeProperty("--radix-toast-swipe-move-y"), s.currentTarget.style.removeProperty("--radix-toast-swipe-end-x"), s.currentTarget.style.removeProperty("--radix-toast-swipe-end-y");
+        onSwipeCancel: composeEventHandlers(props.onSwipeCancel, (event) => {
+          event.currentTarget.setAttribute("data-swipe", "cancel");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-x");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-y");
         }),
-        onSwipeEnd: R(e.onSwipeEnd, (s) => {
-          const { x: h, y } = s.detail.delta;
-          s.currentTarget.setAttribute("data-swipe", "end"), s.currentTarget.style.removeProperty("--radix-toast-swipe-move-x"), s.currentTarget.style.removeProperty("--radix-toast-swipe-move-y"), s.currentTarget.style.setProperty("--radix-toast-swipe-end-x", `${h}px`), s.currentTarget.style.setProperty("--radix-toast-swipe-end-y", `${y}px`), v(!1);
+        onSwipeEnd: composeEventHandlers(props.onSwipeEnd, (event) => {
+          const { x, y } = event.detail.delta;
+          event.currentTarget.setAttribute("data-swipe", "end");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
+          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
+          event.currentTarget.style.setProperty("--radix-toast-swipe-end-x", `${x}px`);
+          event.currentTarget.style.setProperty("--radix-toast-swipe-end-y", `${y}px`);
+          setOpen(false);
         })
       }
     ) });
   }
 );
-ue.displayName = X;
-var [Me, Oe] = ne(X, {
+Toast.displayName = TOAST_NAME;
+var [ToastInteractiveProvider, useToastInteractiveContext] = createToastContext(TOAST_NAME, {
   onClose() {
   }
-}), ke = n.forwardRef(
-  (e, o) => {
+});
+var ToastImpl = React.forwardRef(
+  (props, forwardedRef) => {
     const {
-      __scopeToast: r,
-      type: t = "foreground",
-      duration: c,
-      open: d,
-      onClose: p,
-      onEscapeKeyDown: T,
-      onPause: v,
-      onResume: s,
-      onSwipeStart: h,
-      onSwipeMove: y,
-      onSwipeCancel: N,
-      onSwipeEnd: g,
-      ...S
-    } = e, u = U(X, r), [i, P] = n.useState(null), f = te(o, (a) => P(a)), m = n.useRef(null), w = n.useRef(null), E = c || u.duration, C = n.useRef(0), I = n.useRef(E), L = n.useRef(0), { onToastAdd: _, onToastRemove: Y } = u, A = W(() => {
-      var x;
-      (i == null ? void 0 : i.contains(document.activeElement)) && ((x = u.viewport) == null || x.focus()), p();
-    }), F = n.useCallback(
-      (a) => {
-        !a || a === 1 / 0 || (window.clearTimeout(L.current), C.current = (/* @__PURE__ */ new Date()).getTime(), L.current = window.setTimeout(A, a));
+      __scopeToast,
+      type = "foreground",
+      duration: durationProp,
+      open,
+      onClose,
+      onEscapeKeyDown,
+      onPause,
+      onResume,
+      onSwipeStart,
+      onSwipeMove,
+      onSwipeCancel,
+      onSwipeEnd,
+      ...toastProps
+    } = props;
+    const context = useToastProviderContext(TOAST_NAME, __scopeToast);
+    const [node, setNode] = React.useState(null);
+    const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
+    const pointerStartRef = React.useRef(null);
+    const swipeDeltaRef = React.useRef(null);
+    const duration = durationProp || context.duration;
+    const closeTimerStartTimeRef = React.useRef(0);
+    const closeTimerRemainingTimeRef = React.useRef(duration);
+    const closeTimerRef = React.useRef(0);
+    const { onToastAdd, onToastRemove } = context;
+    const handleClose = useCallbackRef(() => {
+      var _a;
+      const isFocusInToast = node == null ? void 0 : node.contains(document.activeElement);
+      if (isFocusInToast) (_a = context.viewport) == null ? void 0 : _a.focus();
+      onClose();
+    });
+    const startTimer = React.useCallback(
+      (duration2) => {
+        if (!duration2 || duration2 === Infinity) return;
+        window.clearTimeout(closeTimerRef.current);
+        closeTimerStartTimeRef.current = (/* @__PURE__ */ new Date()).getTime();
+        closeTimerRef.current = window.setTimeout(handleClose, duration2);
       },
-      [A]
+      [handleClose]
     );
-    n.useEffect(() => {
-      const a = u.viewport;
-      if (a) {
-        const x = () => {
-          F(I.current), s == null || s();
-        }, b = () => {
-          const M = (/* @__PURE__ */ new Date()).getTime() - C.current;
-          I.current = I.current - M, window.clearTimeout(L.current), v == null || v();
+    React.useEffect(() => {
+      const viewport = context.viewport;
+      if (viewport) {
+        const handleResume = () => {
+          startTimer(closeTimerRemainingTimeRef.current);
+          onResume == null ? void 0 : onResume();
+        };
+        const handlePause = () => {
+          const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTimeRef.current;
+          closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
+          window.clearTimeout(closeTimerRef.current);
+          onPause == null ? void 0 : onPause();
         };
-        return a.addEventListener(j, b), a.addEventListener(q, x), () => {
-          a.removeEventListener(j, b), a.removeEventListener(q, x);
+        viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
+        viewport.addEventListener(VIEWPORT_RESUME, handleResume);
+        return () => {
+          viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);
+          viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
         };
       }
-    }, [u.viewport, E, v, s, F]), n.useEffect(() => {
-      d && !u.isClosePausedRef.current && F(E);
-    }, [d, E, u.isClosePausedRef, F]), n.useEffect(() => (_(), () => Y()), [_, Y]);
-    const k = n.useMemo(() => i ? me(i) : null, [i]);
-    return u.viewport ? /* @__PURE__ */ G(re, { children: [
-      k && /* @__PURE__ */ l(
-        Ve,
+    }, [context.viewport, duration, onPause, onResume, startTimer]);
+    React.useEffect(() => {
+      if (open && !context.isClosePausedRef.current) startTimer(duration);
+    }, [open, duration, context.isClosePausedRef, startTimer]);
+    React.useEffect(() => {
+      onToastAdd();
+      return () => onToastRemove();
+    }, [onToastAdd, onToastRemove]);
+    const announceTextContent = React.useMemo(() => {
+      return node ? getAnnounceTextContent(node) : null;
+    }, [node]);
+    if (!context.viewport) return null;
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      announceTextContent && /* @__PURE__ */ jsx(
+        ToastAnnounce,
         {
-          __scopeToast: r,
+          __scopeToast,
           role: "status",
-          "aria-live": t === "foreground" ? "assertive" : "polite",
-          "aria-atomic": !0,
-          children: k
+          "aria-live": type === "foreground" ? "assertive" : "polite",
+          "aria-atomic": true,
+          children: announceTextContent
         }
       ),
-      /* @__PURE__ */ l(Me, { scope: r, onClose: A, children: we.createPortal(
-        /* @__PURE__ */ l(Q.ItemSlot, { scope: r, children: /* @__PURE__ */ l(
-          Ce,
+      /* @__PURE__ */ jsx(ToastInteractiveProvider, { scope: __scopeToast, onClose: handleClose, children: ReactDOM.createPortal(
+        /* @__PURE__ */ jsx(Collection.ItemSlot, { scope: __scopeToast, children: /* @__PURE__ */ jsx(
+          Root,
           {
-            asChild: !0,
-            onEscapeKeyDown: R(T, () => {
-              u.isFocusedToastEscapeKeyDownRef.current || A(), u.isFocusedToastEscapeKeyDownRef.current = !1;
+            asChild: true,
+            onEscapeKeyDown: composeEventHandlers(onEscapeKeyDown, () => {
+              if (!context.isFocusedToastEscapeKeyDownRef.current) handleClose();
+              context.isFocusedToastEscapeKeyDownRef.current = false;
             }),
-            children: /* @__PURE__ */ l(
-              D.li,
+            children: /* @__PURE__ */ jsx(
+              Primitive.li,
               {
                 role: "status",
                 "aria-live": "off",
-                "aria-atomic": !0,
+                "aria-atomic": true,
                 tabIndex: 0,
-                "data-state": d ? "open" : "closed",
-                "data-swipe-direction": u.swipeDirection,
-                ...S,
-                ref: f,
-                style: { userSelect: "none", touchAction: "none", ...e.style },
-                onKeyDown: R(e.onKeyDown, (a) => {
-                  a.key === "Escape" && (T == null || T(a.nativeEvent), a.nativeEvent.defaultPrevented || (u.isFocusedToastEscapeKeyDownRef.current = !0, A()));
+                "data-state": open ? "open" : "closed",
+                "data-swipe-direction": context.swipeDirection,
+                ...toastProps,
+                ref: composedRefs,
+                style: { userSelect: "none", touchAction: "none", ...props.style },
+                onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+                  if (event.key !== "Escape") return;
+                  onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(event.nativeEvent);
+                  if (!event.nativeEvent.defaultPrevented) {
+                    context.isFocusedToastEscapeKeyDownRef.current = true;
+                    handleClose();
+                  }
                 }),
-                onPointerDown: R(e.onPointerDown, (a) => {
-                  a.button === 0 && (m.current = { x: a.clientX, y: a.clientY });
+                onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
+                  if (event.button !== 0) return;
+                  pointerStartRef.current = { x: event.clientX, y: event.clientY };
                 }),
-                onPointerMove: R(e.onPointerMove, (a) => {
-                  if (!m.current) return;
-                  const x = a.clientX - m.current.x, b = a.clientY - m.current.y, M = !!w.current, O = ["left", "right"].includes(u.swipeDirection), V = ["left", "up"].includes(u.swipeDirection) ? Math.min : Math.max, Te = O ? V(0, x) : 0, ve = O ? 0 : V(0, b), $ = a.pointerType === "touch" ? 10 : 2, K = { x: Te, y: ve }, Z = { originalEvent: a, delta: K };
-                  M ? (w.current = K, H(De, y, Z, {
-                    discrete: !1
-                  })) : ee(K, u.swipeDirection, $) ? (w.current = K, H(Ae, h, Z, {
-                    discrete: !1
-                  }), a.target.setPointerCapture(a.pointerId)) : (Math.abs(x) > $ || Math.abs(b) > $) && (m.current = null);
+                onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
+                  if (!pointerStartRef.current) return;
+                  const x = event.clientX - pointerStartRef.current.x;
+                  const y = event.clientY - pointerStartRef.current.y;
+                  const hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);
+                  const isHorizontalSwipe = ["left", "right"].includes(context.swipeDirection);
+                  const clamp = ["left", "up"].includes(context.swipeDirection) ? Math.min : Math.max;
+                  const clampedX = isHorizontalSwipe ? clamp(0, x) : 0;
+                  const clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;
+                  const moveStartBuffer = event.pointerType === "touch" ? 10 : 2;
+                  const delta = { x: clampedX, y: clampedY };
+                  const eventDetail = { originalEvent: event, delta };
+                  if (hasSwipeMoveStarted) {
+                    swipeDeltaRef.current = delta;
+                    handleAndDispatchCustomEvent(TOAST_SWIPE_MOVE, onSwipeMove, eventDetail, {
+                      discrete: false
+                    });
+                  } else if (isDeltaInDirection(delta, context.swipeDirection, moveStartBuffer)) {
+                    swipeDeltaRef.current = delta;
+                    handleAndDispatchCustomEvent(TOAST_SWIPE_START, onSwipeStart, eventDetail, {
+                      discrete: false
+                    });
+                    event.target.setPointerCapture(event.pointerId);
+                  } else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) {
+                    pointerStartRef.current = null;
+                  }
                 }),
-                onPointerUp: R(e.onPointerUp, (a) => {
-                  const x = w.current, b = a.target;
-                  if (b.hasPointerCapture(a.pointerId) && b.releasePointerCapture(a.pointerId), w.current = null, m.current = null, x) {
-                    const M = a.currentTarget, O = { originalEvent: a, delta: x };
-                    ee(x, u.swipeDirection, u.swipeThreshold) ? H(Le, g, O, {
-                      discrete: !0
-                    }) : H(
-                      Ne,
-                      N,
-                      O,
-                      {
-                        discrete: !0
-                      }
-                    ), M.addEventListener("click", (V) => V.preventDefault(), {
-                      once: !0
+                onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {
+                  const delta = swipeDeltaRef.current;
+                  const target = event.target;
+                  if (target.hasPointerCapture(event.pointerId)) {
+                    target.releasePointerCapture(event.pointerId);
+                  }
+                  swipeDeltaRef.current = null;
+                  pointerStartRef.current = null;
+                  if (delta) {
+                    const toast = event.currentTarget;
+                    const eventDetail = { originalEvent: event, delta };
+                    if (isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold)) {
+                      handleAndDispatchCustomEvent(TOAST_SWIPE_END, onSwipeEnd, eventDetail, {
+                        discrete: true
+                      });
+                    } else {
+                      handleAndDispatchCustomEvent(
+                        TOAST_SWIPE_CANCEL,
+                        onSwipeCancel,
+                        eventDetail,
+                        {
+                          discrete: true
+                        }
+                      );
+                    }
+                    toast.addEventListener("click", (event2) => event2.preventDefault(), {
+                      once: true
                     });
                   }
                 })
@@ -319,130 +468,175 @@ var [Me, Oe] = ne(X, {
             )
           }
         ) }),
-        u.viewport
+        context.viewport
       ) })
-    ] }) : null;
+    ] });
   }
-), Ve = (e) => {
-  const { __scopeToast: o, children: r, ...t } = e, c = U(X, o), [d, p] = n.useState(!1), [T, v] = n.useState(!1);
-  return Ye(() => p(!0)), n.useEffect(() => {
-    const s = window.setTimeout(() => v(!0), 1e3);
-    return () => window.clearTimeout(s);
-  }, []), T ? null : /* @__PURE__ */ l(xe, { asChild: !0, children: /* @__PURE__ */ l(oe, { ...t, children: d && /* @__PURE__ */ G(re, { children: [
-    c.label,
+);
+var ToastAnnounce = (props) => {
+  const { __scopeToast, children, ...announceProps } = props;
+  const context = useToastProviderContext(TOAST_NAME, __scopeToast);
+  const [renderAnnounceText, setRenderAnnounceText] = React.useState(false);
+  const [isAnnounced, setIsAnnounced] = React.useState(false);
+  useNextFrame(() => setRenderAnnounceText(true));
+  React.useEffect(() => {
+    const timer = window.setTimeout(() => setIsAnnounced(true), 1e3);
+    return () => window.clearTimeout(timer);
+  }, []);
+  return isAnnounced ? null : /* @__PURE__ */ jsx(Portal, { asChild: true, children: /* @__PURE__ */ jsx(VisuallyHidden, { ...announceProps, children: renderAnnounceText && /* @__PURE__ */ jsxs(Fragment, { children: [
+    context.label,
     " ",
-    r
+    children
   ] }) }) });
-}, Ke = "ToastTitle", He = n.forwardRef(
-  (e, o) => {
-    const { __scopeToast: r, ...t } = e;
-    return /* @__PURE__ */ l(D.div, { ...t, ref: o });
+};
+var TITLE_NAME = "ToastTitle";
+var ToastTitle = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeToast, ...titleProps } = props;
+    return /* @__PURE__ */ jsx(Primitive.div, { ...titleProps, ref: forwardedRef });
   }
 );
-He.displayName = Ke;
-var We = "ToastDescription", Ue = n.forwardRef(
-  (e, o) => {
-    const { __scopeToast: r, ...t } = e;
-    return /* @__PURE__ */ l(D.div, { ...t, ref: o });
+ToastTitle.displayName = TITLE_NAME;
+var DESCRIPTION_NAME = "ToastDescription";
+var ToastDescription = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeToast, ...descriptionProps } = props;
+    return /* @__PURE__ */ jsx(Primitive.div, { ...descriptionProps, ref: forwardedRef });
   }
 );
-Ue.displayName = We;
-var le = "ToastAction", Xe = n.forwardRef(
-  (e, o) => {
-    const { altText: r, ...t } = e;
-    return r.trim() ? /* @__PURE__ */ l(fe, { altText: r, asChild: !0, children: /* @__PURE__ */ l(pe, { ...t, ref: o }) }) : (console.error(
-      `Invalid prop \`altText\` supplied to \`${le}\`. Expected non-empty \`string\`.`
-    ), null);
+ToastDescription.displayName = DESCRIPTION_NAME;
+var ACTION_NAME = "ToastAction";
+var ToastAction = React.forwardRef(
+  (props, forwardedRef) => {
+    const { altText, ...actionProps } = props;
+    if (!altText.trim()) {
+      console.error(
+        `Invalid prop \`altText\` supplied to \`${ACTION_NAME}\`. Expected non-empty \`string\`.`
+      );
+      return null;
+    }
+    return /* @__PURE__ */ jsx(ToastAnnounceExclude, { altText, asChild: true, children: /* @__PURE__ */ jsx(ToastClose, { ...actionProps, ref: forwardedRef }) });
   }
 );
-Xe.displayName = le;
-var de = "ToastClose", pe = n.forwardRef(
-  (e, o) => {
-    const { __scopeToast: r, ...t } = e, c = Oe(de, r);
-    return /* @__PURE__ */ l(fe, { asChild: !0, children: /* @__PURE__ */ l(
-      D.button,
+ToastAction.displayName = ACTION_NAME;
+var CLOSE_NAME = "ToastClose";
+var ToastClose = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeToast, ...closeProps } = props;
+    const interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);
+    return /* @__PURE__ */ jsx(ToastAnnounceExclude, { asChild: true, children: /* @__PURE__ */ jsx(
+      Primitive.button,
       {
         type: "button",
-        ...t,
-        ref: o,
-        onClick: R(e.onClick, c.onClose)
+        ...closeProps,
+        ref: forwardedRef,
+        onClick: composeEventHandlers(props.onClick, interactiveContext.onClose)
       }
     ) });
   }
 );
-pe.displayName = de;
-var fe = n.forwardRef((e, o) => {
-  const { __scopeToast: r, altText: t, ...c } = e;
-  return /* @__PURE__ */ l(
-    D.div,
+ToastClose.displayName = CLOSE_NAME;
+var ToastAnnounceExclude = React.forwardRef((props, forwardedRef) => {
+  const { __scopeToast, altText, ...announceExcludeProps } = props;
+  return /* @__PURE__ */ jsx(
+    Primitive.div,
     {
       "data-radix-toast-announce-exclude": "",
-      "data-radix-toast-announce-alt": t || void 0,
-      ...c,
-      ref: o
+      "data-radix-toast-announce-alt": altText || void 0,
+      ...announceExcludeProps,
+      ref: forwardedRef
     }
   );
 });
-function me(e) {
-  const o = [];
-  return Array.from(e.childNodes).forEach((t) => {
-    if (t.nodeType === t.TEXT_NODE && t.textContent && o.push(t.textContent), $e(t)) {
-      const c = t.ariaHidden || t.hidden || t.style.display === "none", d = t.dataset.radixToastAnnounceExclude === "";
-      if (!c)
-        if (d) {
-          const p = t.dataset.radixToastAnnounceAlt;
-          p && o.push(p);
-        } else
-          o.push(...me(t));
+function getAnnounceTextContent(container) {
+  const textContent = [];
+  const childNodes = Array.from(container.childNodes);
+  childNodes.forEach((node) => {
+    if (node.nodeType === node.TEXT_NODE && node.textContent) textContent.push(node.textContent);
+    if (isHTMLElement(node)) {
+      const isHidden = node.ariaHidden || node.hidden || node.style.display === "none";
+      const isExcluded = node.dataset.radixToastAnnounceExclude === "";
+      if (!isHidden) {
+        if (isExcluded) {
+          const altText = node.dataset.radixToastAnnounceAlt;
+          if (altText) textContent.push(altText);
+        } else {
+          textContent.push(...getAnnounceTextContent(node));
+        }
+      }
     }
-  }), o;
+  });
+  return textContent;
 }
-function H(e, o, r, { discrete: t }) {
-  const c = r.originalEvent.currentTarget, d = new CustomEvent(e, { bubbles: !0, cancelable: !0, detail: r });
-  o && c.addEventListener(e, o, { once: !0 }), t ? Re(c, d) : c.dispatchEvent(d);
+function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
+  const currentTarget = detail.originalEvent.currentTarget;
+  const event = new CustomEvent(name, { bubbles: true, cancelable: true, detail });
+  if (handler) currentTarget.addEventListener(name, handler, { once: true });
+  if (discrete) {
+    dispatchDiscreteCustomEvent(currentTarget, event);
+  } else {
+    currentTarget.dispatchEvent(event);
+  }
 }
-var ee = (e, o, r = 0) => {
-  const t = Math.abs(e.x), c = Math.abs(e.y), d = t > c;
-  return o === "left" || o === "right" ? d && t > r : !d && c > r;
+var isDeltaInDirection = (delta, direction, threshold = 0) => {
+  const deltaX = Math.abs(delta.x);
+  const deltaY = Math.abs(delta.y);
+  const isDeltaX = deltaX > deltaY;
+  if (direction === "left" || direction === "right") {
+    return isDeltaX && deltaX > threshold;
+  } else {
+    return !isDeltaX && deltaY > threshold;
+  }
 };
-function Ye(e = () => {
+function useNextFrame(callback = () => {
 }) {
-  const o = W(e);
-  ge(() => {
-    let r = 0, t = 0;
-    return r = window.requestAnimationFrame(() => t = window.requestAnimationFrame(o)), () => {
-      window.cancelAnimationFrame(r), window.cancelAnimationFrame(t);
+  const fn = useCallbackRef(callback);
+  useLayoutEffect2(() => {
+    let raf1 = 0;
+    let raf2 = 0;
+    raf1 = window.requestAnimationFrame(() => raf2 = window.requestAnimationFrame(fn));
+    return () => {
+      window.cancelAnimationFrame(raf1);
+      window.cancelAnimationFrame(raf2);
     };
-  }, [o]);
+  }, [fn]);
 }
-function $e(e) {
-  return e.nodeType === e.ELEMENT_NODE;
+function isHTMLElement(node) {
+  return node.nodeType === node.ELEMENT_NODE;
 }
-function Be(e) {
-  const o = [], r = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
-    acceptNode: (t) => {
-      const c = t.tagName === "INPUT" && t.type === "hidden";
-      return t.disabled || t.hidden || c ? NodeFilter.FILTER_SKIP : t.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
     }
   });
-  for (; r.nextNode(); ) o.push(r.currentNode);
-  return o;
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
 }
-function B(e) {
-  const o = document.activeElement;
-  return e.some((r) => r === o ? !0 : (r.focus(), document.activeElement !== o));
+function focusFirst(candidates) {
+  const previouslyFocusedElement = document.activeElement;
+  return candidates.some((candidate) => {
+    if (candidate === previouslyFocusedElement) return true;
+    candidate.focus();
+    return document.activeElement !== previouslyFocusedElement;
+  });
 }
-var it = se, ct = ie, ut = ue;
+var Provider = ToastProvider;
+var Viewport = ToastViewport;
+var Root2 = Toast;
 export {
-  it as Provider,
-  ut as Root,
-  ue as Toast,
-  Xe as ToastAction,
-  pe as ToastClose,
-  Ue as ToastDescription,
-  se as ToastProvider,
-  He as ToastTitle,
-  ie as ToastViewport,
-  ct as Viewport,
-  at as createToastScope
+  Provider,
+  Root2 as Root,
+  Toast,
+  ToastAction,
+  ToastClose,
+  ToastDescription,
+  ToastProvider,
+  ToastTitle,
+  ToastViewport,
+  Viewport,
+  createToastScope
 };