solid-baseui 0.1.0-alpha.0

package/dist/lib/server/toast/index.js

@@ -0,0 +1,1588 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { getStateAttributesProps } from "../internals/getStateAttributesProps.js";
+import { n as resolveClass, t as resolveStyle } from "../resolveStyle-XCSFDHAL.js";
+import { transitionStatusMapping } from "../internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "../internals/composeEventHandlers.js";
+import { t as runOnceAnimationsFinish } from "../runOnceAnimationsFinish-DCHzXWZU.js";
+import { a as isElement, m as ownerWindow, n as contains, p as ownerDocument, r as getEventTarget, t as activeElement } from "../dom-Crg_2R-j.js";
+import { t as createAnchorPositioning } from "../createAnchorPositioning-C-cVOPwz.js";
+import { _ as ReactiveStore, g as FocusGuard, n as popupStateMapping, o as PopupPortal } from "../popupStateMapping-nKoUwoke.js";
+import { a as stopButtonInteraction, i as preventDisabledButtonKeyDown, n as handleNonNativeButtonKeyUp, r as preventButtonInteraction, t as handleNonNativeButtonKeyDown } from "../buttonSemantics-BSwDxJhh.js";
+import { t as setRef } from "../setRef-Bt70sW7c.js";
+import { n as useDirection } from "../DirectionContext-YORWLF08.js";
+import { a as getElementTransform, i as getDisplacement, n as LEGACY_SWIPE_IGNORE_SELECTOR, t as BASE_UI_SWIPE_IGNORE_SELECTOR } from "../constants-9H__9xbS.js";
+import { Dynamic, escape, memo, mergeProps, ssr, ssrHydrationKey, ssrStyle } from "@solidjs/web";
+import { For, Show, children, createContext, createEffect, createMemo, createSignal, createUniqueId, flush, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/toast/utils/focusVisible.ts
+/**
+* Whether the element is focus-visible. Environments that cannot evaluate
+* `:focus-visible` (JSDOM) report `true` so keyboard-driven behavior stays
+* testable, matching Base UI.
+*/
+function isFocusVisible(element) {
+	if (!element) return true;
+	try {
+		return element.matches(":focus-visible");
+	} catch {
+		return true;
+	}
+}
+//#endregion
+//#region src/toast/utils/generateToastId.ts
+var counter = 0;
+/**
+* Generates an id for a toast created outside of a component, where Solid's
+* `createUniqueId` has no owner to scope to.
+*/
+function generateToastId(prefix = "toast") {
+	counter += 1;
+	return `${prefix}-${Math.random().toString(36).slice(2, 6)}-${counter}`;
+}
+//#endregion
+//#region src/toast/utils/resolvePromiseOptions.ts
+function resolvePromiseOptions(options, result) {
+	if (typeof options === "string") return { description: options };
+	if (typeof options === "function") {
+		const resolvedOptions = options(result);
+		return typeof resolvedOptions === "string" ? { description: resolvedOptions } : resolvedOptions;
+	}
+	return options;
+}
+//#endregion
+//#region src/toast/store/ToastStore.ts
+function createToastMetadata(toasts) {
+	const metadata = /* @__PURE__ */ new Map();
+	let visibleIndex = 0;
+	let offsetY = 0;
+	toasts.forEach((toast, toastIndex) => {
+		const isEnding = toast.transitionStatus === "ending";
+		metadata.set(toast.id, {
+			value: toast,
+			domIndex: toastIndex,
+			visibleIndex: isEnding ? -1 : visibleIndex,
+			offsetY
+		});
+		offsetY += toast.height || 0;
+		if (!isEnding) visibleIndex += 1;
+	});
+	return metadata;
+}
+/**
+* Marks the active (non-ending) toasts beyond `limit` as limited. Callers pass toasts in
+* newest-first order, so the newest `limit` toasts stay visible and the rest are flagged.
+* Returns the same toast reference when its `limited` flag is unchanged.
+*/
+function applyLimited(toasts, limit) {
+	let activeIndex = 0;
+	return toasts.map((toast) => {
+		if (toast.transitionStatus === "ending") return toast;
+		const limited = activeIndex >= limit;
+		activeIndex += 1;
+		return toast.limited === limited ? toast : {
+			...toast,
+			limited
+		};
+	});
+}
+var selectors = {
+	toasts: (state) => state.toasts,
+	isEmpty: (state) => state.toasts.length === 0,
+	toast: (state, id) => state.toastMetadata.get(id)?.value,
+	toastIndex: (state, id) => state.toastMetadata.get(id)?.domIndex ?? -1,
+	toastOffsetY: (state, id) => state.toastMetadata.get(id)?.offsetY ?? 0,
+	toastVisibleIndex: (state, id) => state.toastMetadata.get(id)?.visibleIndex ?? -1,
+	focused: (state) => state.focused,
+	expanded: (state) => state.hovering || state.focused,
+	expandedOrOutOfFocus: (state) => state.hovering || state.focused || !state.isWindowFocused,
+	prevFocusElement: (state) => state.prevFocusElement
+};
+var ToastStore = class extends ReactiveStore {
+	timers = /* @__PURE__ */ new Map();
+	areTimersPaused = false;
+	constructor(initialState) {
+		super({
+			...initialState,
+			toastMetadata: createToastMetadata(initialState.toasts)
+		}, {});
+	}
+	setViewport = (viewport) => {
+		this.set("viewport", viewport);
+	};
+	syncProviderProps(timeout, limit) {
+		const limitChanged = this.state.limit !== limit;
+		if (this.state.timeout === timeout && !limitChanged) return;
+		const updates = {
+			timeout,
+			limit
+		};
+		if (limitChanged) {
+			const newToasts = applyLimited(this.state.toasts, limit);
+			updates.toasts = newToasts;
+			updates.toastMetadata = createToastMetadata(newToasts);
+		}
+		this.update(updates);
+	}
+	dispose = () => {
+		this.timers.forEach((timer) => this.stopTimer(timer));
+		this.timers.clear();
+	};
+	removeToast(toastId, skipOnRemove = false) {
+		const index = selectors.toastIndex(this.state, toastId);
+		if (index === -1) return;
+		const toast = this.state.toasts[index];
+		if (!skipOnRemove) toast?.onRemove?.();
+		const newToasts = [...this.state.toasts];
+		newToasts.splice(index, 1);
+		this.setToasts(newToasts);
+	}
+	addToast = (toast) => {
+		const { timeout, limit } = this.state;
+		const id = toast.id || generateToastId();
+		if (toast.id) {
+			const existingToast = selectors.toast(this.state, toast.id);
+			if (existingToast) {
+				if (existingToast.transitionStatus === "ending") this.removeToast(toast.id, true);
+				else {
+					const updates = { ...toast };
+					delete updates.id;
+					delete updates.transitionStatus;
+					this.updateToastInternal(toast.id, updates, true, true);
+					return toast.id;
+				}
+			}
+		}
+		const toastToAdd = {
+			...toast,
+			id,
+			updateKey: 0,
+			transitionStatus: "starting"
+		};
+		const updatedToasts = [toastToAdd, ...this.state.toasts];
+		this.setToasts(applyLimited(updatedToasts, limit));
+		const duration = toastToAdd.timeout ?? timeout;
+		if (toastToAdd.type !== "loading" && duration > 0) this.scheduleTimer(id, duration, () => this.closeToast(id));
+		if (selectors.expandedOrOutOfFocus(this.state)) this.pauseTimers();
+		return id;
+	};
+	updateToast = (id, updates) => {
+		this.updateToastInternal(id, updates, false, true);
+	};
+	updateToastInternal = (id, updates, resetTimer = false, markUpdated = false) => {
+		const { timeout, toasts } = this.state;
+		const prevToast = selectors.toast(this.state, id);
+		if (!prevToast) return;
+		if (prevToast.transitionStatus === "ending") return;
+		const nextToast = {
+			...prevToast,
+			...updates,
+			...markUpdated && { updateKey: prevToast.updateKey + 1 }
+		};
+		this.setToasts(toasts.map((toast) => toast.id === id ? nextToast : toast));
+		const nextTimeout = nextToast.timeout ?? timeout;
+		const prevTimeout = prevToast.timeout ?? timeout;
+		const timeoutUpdated = Object.hasOwn(updates, "timeout");
+		const shouldHaveTimer = nextToast.transitionStatus !== "ending" && nextToast.type !== "loading" && nextTimeout > 0;
+		const hasTimer = this.timers.has(id);
+		const timeoutChanged = prevTimeout !== nextTimeout;
+		const wasLoading = prevToast.type === "loading";
+		if (!shouldHaveTimer && hasTimer) {
+			this.clearTimer(id);
+			return;
+		}
+		if (shouldHaveTimer && (!hasTimer || timeoutChanged || timeoutUpdated || wasLoading || resetTimer)) {
+			this.clearTimer(id);
+			this.scheduleTimer(id, nextTimeout, () => this.closeToast(id));
+			if (selectors.expandedOrOutOfFocus(this.state)) this.pauseTimers();
+		}
+	};
+	closeToast = (toastId) => {
+		const closeAll = toastId === void 0;
+		const { limit, toasts } = this.state;
+		let toastsToClose;
+		if (closeAll) {
+			toastsToClose = toasts;
+			this.clearTimers();
+		} else {
+			const toast = selectors.toast(this.state, toastId);
+			if (!toast) return;
+			toastsToClose = [toast];
+			this.clearTimer(toastId);
+		}
+		const newToasts = applyLimited(toasts.map((item) => closeAll || item.id === toastId ? {
+			...item,
+			transitionStatus: "ending",
+			height: 0
+		} : item), limit);
+		this.setToasts(newToasts, !newToasts.some((toast) => toast.transitionStatus !== "ending"));
+		toastsToClose.forEach((toast) => {
+			if (toast.transitionStatus !== "ending") toast.onClose?.();
+		});
+		this.handleFocusManagement(toastId);
+	};
+	promiseToast = (promiseValue, options) => {
+		const loadingOptions = resolvePromiseOptions(options.loading);
+		const id = this.addToast({
+			...loadingOptions,
+			type: "loading"
+		});
+		const handledPromise = promiseValue.then((result) => {
+			const successOptions = resolvePromiseOptions(options.success, result);
+			this.updateToast(id, {
+				...successOptions,
+				type: "success",
+				timeout: successOptions.timeout
+			});
+			return result;
+		}).catch((error) => {
+			const errorOptions = resolvePromiseOptions(options.error, error);
+			this.updateToast(id, {
+				...errorOptions,
+				type: "error",
+				timeout: errorOptions.timeout
+			});
+			return Promise.reject(error);
+		});
+		if (Object.hasOwn(options, "setPromise")) options.setPromise(handledPromise);
+		return handledPromise;
+	};
+	pauseTimers() {
+		if (this.areTimersPaused) return;
+		this.areTimersPaused = true;
+		this.timers.forEach((timer) => {
+			if (timer.scheduled) {
+				this.stopTimer(timer);
+				timer.remaining = Math.max(timer.remaining - (Date.now() - timer.start), 0);
+			}
+		});
+	}
+	resumeTimers() {
+		if (!this.areTimersPaused) return;
+		this.areTimersPaused = false;
+		this.timers.forEach((timer, id) => {
+			timer.remaining = timer.remaining > 0 ? timer.remaining : timer.delay;
+			timer.scheduled = true;
+			this.stopTimer(timer);
+			timer.handle = setTimeout(() => {
+				timer.handle = void 0;
+				this.handleTimerFired(id);
+				timer.callback();
+			}, timer.remaining);
+			timer.start = Date.now();
+		});
+	}
+	restoreFocusToPrevElement() {
+		this.state.prevFocusElement?.focus({ preventScroll: true });
+	}
+	handleDocumentPointerDown = (event) => {
+		if (event.pointerType !== "touch") return;
+		const target = getEventTarget(event);
+		if (contains(this.state.viewport, target)) return;
+		this.resumeTimers();
+		this.update({
+			hovering: false,
+			focused: false
+		});
+	};
+	scheduleTimer(id, delay, callback) {
+		const start = Date.now();
+		const shouldStartActive = !selectors.expandedOrOutOfFocus(this.state);
+		const timer = {
+			scheduled: shouldStartActive,
+			handle: void 0,
+			start,
+			delay,
+			remaining: delay,
+			callback
+		};
+		if (shouldStartActive) timer.handle = setTimeout(() => {
+			timer.handle = void 0;
+			this.handleTimerFired(id);
+			callback();
+		}, delay);
+		this.timers.set(id, timer);
+	}
+	stopTimer(timer) {
+		if (timer.handle !== void 0) {
+			clearTimeout(timer.handle);
+			timer.handle = void 0;
+		}
+	}
+	clearTimers() {
+		this.timers.forEach((timer) => this.stopTimer(timer));
+		this.timers.clear();
+		this.areTimersPaused = false;
+	}
+	clearTimer(id) {
+		const timer = this.timers.get(id);
+		if (timer) this.stopTimer(timer);
+		this.timers.delete(id);
+		this.resetPausedStateIfNoTimersRemain();
+	}
+	handleTimerFired(id) {
+		this.timers.delete(id);
+		this.resetPausedStateIfNoTimersRemain();
+	}
+	resetPausedStateIfNoTimersRemain() {
+		if (this.timers.size === 0) this.areTimersPaused = false;
+	}
+	setToasts(newToasts, clearInteraction = newToasts.length === 0) {
+		const updates = {
+			toasts: newToasts,
+			toastMetadata: createToastMetadata(newToasts)
+		};
+		if (clearInteraction) {
+			updates.hovering = false;
+			updates.focused = false;
+		}
+		this.update(updates);
+	}
+	handleFocusManagement(toastId) {
+		const activeEl = activeElement(ownerDocument(this.state.viewport));
+		if (!this.state.viewport || !contains(this.state.viewport, activeEl) || !isFocusVisible(activeEl)) return;
+		if (toastId === void 0) {
+			this.restoreFocusToPrevElement();
+			return;
+		}
+		const toasts = selectors.toasts(this.state);
+		const currentIndex = selectors.toastIndex(this.state, toastId);
+		const scan = (from, step) => {
+			for (let index = from; index >= 0 && index < toasts.length; index += step) if (toasts[index].transitionStatus !== "ending") return toasts[index];
+			return null;
+		};
+		const nextToast = scan(currentIndex + 1, 1) ?? scan(currentIndex - 1, -1);
+		if (nextToast) nextToast.element?.focus();
+		else this.restoreFocusToPrevElement();
+	}
+};
+//#endregion
+//#region src/toast/provider/ToastProviderContext.ts
+var MISSING_CONTEXT$2 = Symbol("ToastProviderContext");
+var ToastProviderContext = createContext(MISSING_CONTEXT$2);
+function useToastProviderContext() {
+	const context = useContext(ToastProviderContext);
+	if (context === MISSING_CONTEXT$2) throw new Error("Base UI: useToastManager must be used within <Toast.Provider>.");
+	return context;
+}
+//#endregion
+//#region src/toast/provider/ToastProvider.tsx
+/** Provides a context for creating and managing toasts. */
+function ToastProvider(props) {
+	const store = new ToastStore({
+		timeout: untrack(() => props.timeout ?? 5e3),
+		limit: untrack(() => props.limit ?? 3),
+		viewport: null,
+		toasts: [],
+		hovering: false,
+		focused: false,
+		isWindowFocused: true,
+		prevFocusElement: null
+	});
+	onCleanup(store.dispose);
+	createEffect(() => ({
+		timeout: props.timeout ?? 5e3,
+		limit: props.limit ?? 3
+	}), ({ timeout, limit }) => {
+		store.syncProviderProps(timeout, limit);
+	});
+	createEffect(() => props.toastManager, (toastManager) => {
+		if (!toastManager) return;
+		return toastManager[" subscribe"](({ action, options }) => {
+			const id = options.id;
+			if (action === "promise" && options.promise) store.promiseToast(options.promise, options);
+			else if (action === "update" && id) store.updateToast(id, options);
+			else if (action === "close") store.closeToast(id);
+			else store.addToast(options);
+		});
+	});
+	return ToastProviderContext({
+		value: store,
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+//#region src/toast/utils/mergeToastStyles.ts
+function mergeToastStyles(internal, external) {
+	if (typeof external === "string") {
+		const serialized = Object.entries(internal).filter((entry) => entry[1] != null).map(([property, value]) => `${property}:${String(value)}`).join(";");
+		return serialized ? `${serialized};${external}` : external;
+	}
+	return {
+		...internal,
+		...external || void 0
+	};
+}
+//#endregion
+//#region src/toast/viewport/ToastViewport.tsx
+var _tmpl$ = [
+	"<div",
+	" style=\"",
+	"\">",
+	"</div>"
+];
+var _tmpl$2 = [
+	"<div",
+	" role=\"alert\" aria-atomic=\"true\"><div>",
+	"</div><div>",
+	"</div></div>"
+];
+var visuallyHidden = {
+	"clip-path": "inset(50%)",
+	overflow: "hidden",
+	"white-space": "nowrap",
+	border: 0,
+	padding: 0,
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	position: "fixed",
+	top: 0,
+	left: 0
+};
+/** A container viewport for toasts. */
+function ToastViewport(props) {
+	var _v$, _v$2;
+	const store = useToastProviderContext();
+	const internalProps = props;
+	const allProps = props;
+	let handlingFocusGuard = false;
+	let markedReadyForMouseLeave = false;
+	let touchActive = false;
+	let windowFocusTimeout;
+	const viewportElement = createMemo(() => store.track().viewport);
+	const isEmpty = createMemo(() => selectors.isEmpty(store.track()));
+	const toasts = createMemo(() => selectors.toasts(store.track()));
+	const focused = createMemo(() => selectors.focused(store.track()));
+	const expanded = createMemo(() => selectors.expanded(store.track()));
+	const prevFocusElement = createMemo(() => selectors.prevFocusElement(store.track()));
+	const frontmostHeight = createMemo(() => toasts()[0]?.height);
+	const hasTransitioningToasts = createMemo(() => toasts().some((toast) => toast.transitionStatus === "ending"));
+	const highPriorityToasts = createMemo(() => toasts().filter((toast) => toast.priority === "high"));
+	createEffect(() => ({
+		empty: isEmpty(),
+		viewport: viewportElement()
+	}), ({ empty, viewport }) => {
+		if (!viewport || empty) return;
+		const element = viewport;
+		const win = ownerWindow(element);
+		const doc = ownerDocument(element);
+		function handleGlobalKeyDown(event) {
+			if (event.key === "F6" && getEventTarget(event) !== element) {
+				event.preventDefault();
+				store.set("prevFocusElement", activeElement(doc));
+				element.focus({ preventScroll: true });
+				store.pauseTimers();
+				store.set("focused", true);
+			}
+		}
+		function handleWindowBlur(event) {
+			if (getEventTarget(event) !== win) return;
+			store.set("isWindowFocused", false);
+			store.pauseTimers();
+		}
+		function handleWindowFocus(event) {
+			if (event.relatedTarget) return;
+			const target = getEventTarget(event);
+			const activeEl = activeElement(ownerDocument(element));
+			if (target === win || !contains(element, target) || !isFocusVisible(activeEl)) store.resumeTimers();
+			clearTimeout(windowFocusTimeout);
+			windowFocusTimeout = setTimeout(() => store.set("isWindowFocused", true), 0);
+		}
+		win.addEventListener("keydown", handleGlobalKeyDown);
+		win.addEventListener("blur", handleWindowBlur, true);
+		win.addEventListener("focus", handleWindowFocus, true);
+		doc.addEventListener("pointerdown", store.handleDocumentPointerDown, true);
+		return () => {
+			win.removeEventListener("keydown", handleGlobalKeyDown);
+			win.removeEventListener("blur", handleWindowBlur, true);
+			win.removeEventListener("focus", handleWindowFocus, true);
+			doc.removeEventListener("pointerdown", store.handleDocumentPointerDown, true);
+			clearTimeout(windowFocusTimeout);
+		};
+	});
+	function handleFocusGuard(event) {
+		handlingFocusGuard = true;
+		const firstFocusableToast = event.relatedTarget === store.state.viewport ? untrack(toasts).find((toast) => toast.transitionStatus !== "ending" && !toast.limited) : void 0;
+		if (firstFocusableToast) firstFocusableToast.element?.focus();
+		else store.restoreFocusToPrevElement();
+	}
+	function handleKeyDown(event) {
+		if (event.key === "Tab" && event.shiftKey && getEventTarget(event) === store.state.viewport) {
+			event.preventDefault();
+			store.restoreFocusToPrevElement();
+		}
+	}
+	function flushMouseLeave() {
+		if (store.state.toasts.some((toast) => toast.transitionStatus === "ending") || touchActive || !markedReadyForMouseLeave) return;
+		if (store.state.isWindowFocused) store.resumeTimers();
+		store.set("hovering", false);
+		markedReadyForMouseLeave = false;
+	}
+	createEffect(() => hasTransitioningToasts(), () => {
+		flushMouseLeave();
+	});
+	function handleMouseEnter() {
+		store.pauseTimers();
+		store.set("hovering", true);
+		markedReadyForMouseLeave = false;
+	}
+	function resumeTimersIfWindowFocused() {
+		if (store.state.isWindowFocused) store.resumeTimers();
+	}
+	function handleMouseLeave() {
+		markedReadyForMouseLeave = true;
+		flushMouseLeave();
+	}
+	function handlePointerDown(event) {
+		if (event.pointerType === "touch") touchActive = true;
+	}
+	function handlePointerEnd(event) {
+		if (event.pointerType !== "touch") return;
+		touchActive = false;
+		flushMouseLeave();
+	}
+	function handleFocus() {
+		if (handlingFocusGuard) {
+			handlingFocusGuard = false;
+			return;
+		}
+		if (untrack(focused)) return;
+		if (isFocusVisible(activeElement(ownerDocument(store.state.viewport)))) {
+			store.set("focused", true);
+			store.pauseTimers();
+		}
+	}
+	function handleBlur(event) {
+		if (!untrack(focused) || contains(store.state.viewport, event.relatedTarget)) return;
+		store.set("focused", false);
+		resumeTimersIfWindowFocused();
+	}
+	const state = createMemo(() => ({ expanded: expanded() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeToastStyles({ "--toast-frontmost-height": frontmostHeight() ? `${frontmostHeight()}px` : void 0 }, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const showFocusGuard = createMemo(() => !isEmpty() && Boolean(prevFocusElement()));
+	const others = omit(allProps, "as", "children", "class", "onBlur", "onClick", "onFocus", "onKeyDown", "onMouseEnter", "onMouseLeave", "onMouseMove", "onPointerCancel", "onPointerDown", "onPointerUp", "ref", "style");
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => handleBlur);
+	const onClick = composeEventHandlers(() => internalProps.onClick, () => handleFocus);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => handleFocus);
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown);
+	const onMouseEnter = composeEventHandlers(() => internalProps.onMouseEnter, () => handleMouseEnter);
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => handleMouseEnter);
+	const onMouseLeave = composeEventHandlers(() => internalProps.onMouseLeave, () => handleMouseLeave);
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => handlePointerDown);
+	const onPointerUp = composeEventHandlers(() => internalProps.onPointerUp, () => handlePointerEnd);
+	const onPointerCancel = composeEventHandlers(() => internalProps.onPointerCancel, () => handlePointerEnd);
+	return [
+		Show({
+			get when() {
+				return showFocusGuard();
+			},
+			get children() {
+				return FocusGuard({ onFocus: handleFocusGuard });
+			}
+		}),
+		Dynamic(mergeProps({
+			get component() {
+				return props.as ?? "div";
+			},
+			ref: [store.setViewport, internalProps.ref],
+			tabIndex: -1,
+			role: "region",
+			"aria-live": "polite",
+			"aria-atomic": "false",
+			"aria-relevant": "additions text",
+			"aria-label": "Notifications",
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			},
+			onBlur,
+			onClick,
+			onFocus,
+			onKeyDown,
+			onMouseEnter,
+			onMouseLeave,
+			onMouseMove,
+			onPointerCancel,
+			onPointerDown,
+			onPointerUp
+		}, stateAttributes, others, { get children() {
+			return [
+				Show({
+					get when() {
+						return showFocusGuard();
+					},
+					get children() {
+						return FocusGuard({ onFocus: handleFocusGuard });
+					}
+				}),
+				memo(() => {
+					return escape(props.children);
+				}),
+				Show({
+					get when() {
+						return showFocusGuard();
+					},
+					get children() {
+						return FocusGuard({ onFocus: handleFocusGuard });
+					}
+				})
+			];
+		} })),
+		Show({
+			get when() {
+				return memo(() => {
+					return !focused();
+				})() && highPriorityToasts().length > 0;
+			},
+			get children() {
+				return _v$ = ssrHydrationKey(), _v$2 = escape(For({
+					get each() {
+						return highPriorityToasts();
+					},
+					keyed: (toast) => toast.id,
+					children: (toast) => {
+						var _v$3, _v$4, _v$5;
+						return _v$3 = ssrHydrationKey(), _v$4 = () => {
+							return escape(toast().title);
+						}, _v$5 = () => {
+							return escape(toast().description);
+						}, ssr(_tmpl$2, _v$3, _v$4, _v$5);
+					}
+				})), ssr(_tmpl$, _v$, ssrStyle(visuallyHidden), _v$2);
+			}
+		})
+	];
+}
+//#endregion
+//#region src/toast/root/ToastRootContext.ts
+var MISSING_CONTEXT$1 = Symbol("ToastRootContext");
+var ToastRootContext = createContext(MISSING_CONTEXT$1);
+function useToastRootContext() {
+	const context = useContext(ToastRootContext);
+	if (context === MISSING_CONTEXT$1) throw new Error("Base UI: ToastRootContext is missing. Toast parts must be used within <Toast.Root>.");
+	return context;
+}
+//#endregion
+//#region src/toast/root/ToastRoot.tsx
+var toastRootStateAttributesMapping = {
+	...transitionStatusMapping,
+	swipeDirection(value) {
+		return value ? { "data-swipe-direction": value } : null;
+	}
+};
+var SWIPE_THRESHOLD = 40;
+var REVERSE_CANCEL_THRESHOLD = 10;
+var OPPOSITE_DIRECTION_DAMPING_FACTOR = .5;
+var MIN_DRAG_THRESHOLD = 1;
+var INTERACTIVE_SELECTOR = `button,a,input,textarea,[role="button"],${`${BASE_UI_SWIPE_IGNORE_SELECTOR},${LEGACY_SWIPE_IGNORE_SELECTOR}`}`;
+var DEFAULT_SWIPE_DIRECTION = ["down", "right"];
+/** Groups all parts of an individual toast. */
+function ToastRoot(props) {
+	const store = useToastProviderContext();
+	const internalProps = props;
+	const allProps = props;
+	const toast = () => internalProps.toast;
+	const isAnchored = () => toast().positionerProps?.anchor !== void 0;
+	const swipeDirections = createMemo(() => {
+		if (isAnchored()) return [];
+		const value = internalProps.swipeDirection ?? DEFAULT_SWIPE_DIRECTION;
+		return Array.isArray(value) ? value : [value];
+	});
+	const swipeEnabled = createMemo(() => swipeDirections().length > 0);
+	const [rootElement, setRootElement] = createSignal(null, { ownedWrite: true });
+	const [currentSwipeDirection, setCurrentSwipeDirection] = createSignal(void 0, { ownedWrite: true });
+	const [isSwiping, setIsSwiping] = createSignal(false, { ownedWrite: true });
+	const [isRealSwipe, setIsRealSwipe] = createSignal(false, { ownedWrite: true });
+	const [dragOffset, setDragOffset] = createSignal({
+		x: 0,
+		y: 0
+	}, { ownedWrite: true });
+	const [initialTransform, setInitialTransform] = createSignal({
+		x: 0,
+		y: 0,
+		scale: 1
+	}, { ownedWrite: true });
+	const [titleId, setTitleId] = createSignal(void 0, { ownedWrite: true });
+	const [descriptionId, setDescriptionId] = createSignal(void 0, { ownedWrite: true });
+	const [lockedDirection, setLockedDirection] = createSignal(null, { ownedWrite: true });
+	let lastToastId;
+	let dragStartPos = {
+		x: 0,
+		y: 0
+	};
+	let initialTransformRef = {
+		x: 0,
+		y: 0,
+		scale: 1
+	};
+	let intendedSwipeDirection;
+	let maxSwipeDisplacement = 0;
+	let cancelledSwipe = false;
+	let swipeCancelBaseline = {
+		x: 0,
+		y: 0
+	};
+	let isFirstPointerMove = false;
+	let dragOffsetRef = {
+		x: 0,
+		y: 0
+	};
+	let activePointerId = null;
+	let dragAbortController = null;
+	const toastId = createMemo(() => toast().id);
+	const transitionStatus = createMemo(() => toast().transitionStatus);
+	const isOpen = createMemo(() => transitionStatus() !== "ending");
+	const domIndex = createMemo(() => selectors.toastIndex(store.track(), toast().id));
+	const visibleIndex = createMemo(() => selectors.toastVisibleIndex(store.track(), toast().id));
+	const offsetY = createMemo(() => selectors.toastOffsetY(store.track(), toast().id));
+	const focused = createMemo(() => selectors.focused(store.track()));
+	const expanded = createMemo(() => selectors.expanded(store.track()));
+	createEffect(() => ({
+		open: isOpen(),
+		element: rootElement()
+	}), ({ open, element }) => {
+		if (!element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(element, () => {
+			const current = untrack(toast);
+			if (current.transitionStatus === "ending") store.removeToast(current.id);
+		}, controller.signal, { waitForStartingStyleRemoved: open });
+		return () => controller.abort();
+	});
+	/**
+	* Recalculates the natural height of the toast and updates it in the toast manager. The store
+	* ignores this write while the toast is transitioning out.
+	*/
+	function recalculateHeight(flushSync = false) {
+		const element = untrack(rootElement);
+		if (!element) return;
+		const previousHeight = element.style.height;
+		element.style.height = "auto";
+		const height = element.offsetHeight;
+		element.style.height = previousHeight;
+		store.updateToastInternal(untrack(toast).id, {
+			element,
+			height,
+			transitionStatus: void 0
+		});
+		if (flushSync) flush();
+	}
+	createEffect(() => ({
+		id: toastId(),
+		status: transitionStatus()
+	}), ({ id, status }) => {
+		const previousToastId = lastToastId;
+		if (status !== "starting" && previousToastId === id) return;
+		if (previousToastId !== void 0) {
+			setCurrentSwipeDirection(void 0);
+			setInitialTransform({
+				x: 0,
+				y: 0,
+				scale: 1
+			});
+			setResolvedDragOffset({
+				x: 0,
+				y: 0
+			});
+		}
+		lastToastId = id;
+		recalculateHeight();
+	});
+	onCleanup(() => {
+		dragAbortController?.abort();
+	});
+	function setResolvedDragOffset(nextDragOffset) {
+		dragOffsetRef = nextDragOffset;
+		setDragOffset(nextDragOffset);
+	}
+	function applyDirectionalDamping(deltaX, deltaY) {
+		const directions = untrack(swipeDirections);
+		const damp = (delta) => delta > 0 ? delta ** OPPOSITE_DIRECTION_DAMPING_FACTOR : -(Math.abs(delta) ** OPPOSITE_DIRECTION_DAMPING_FACTOR);
+		const dampX = deltaX > 0 && !directions.includes("right") || deltaX < 0 && !directions.includes("left");
+		const dampY = deltaY > 0 && !directions.includes("down") || deltaY < 0 && !directions.includes("up");
+		return {
+			x: dampX ? damp(deltaX) : deltaX,
+			y: dampY ? damp(deltaY) : deltaY
+		};
+	}
+	function handleSwipeEnd(event) {
+		if (event.pointerId !== activePointerId) return;
+		activePointerId = null;
+		dragAbortController?.abort();
+		dragAbortController = null;
+		setIsSwiping(false);
+		setIsRealSwipe(false);
+		setLockedDirection(null);
+		const resolvedInitialTransform = initialTransformRef;
+		if (event.type === "pointercancel" || cancelledSwipe) {
+			setResolvedDragOffset({
+				x: resolvedInitialTransform.x,
+				y: resolvedInitialTransform.y
+			});
+			setCurrentSwipeDirection(void 0);
+			return;
+		}
+		const resolvedDragOffset = dragOffsetRef;
+		const deltaX = resolvedDragOffset.x - resolvedInitialTransform.x;
+		const deltaY = resolvedDragOffset.y - resolvedInitialTransform.y;
+		let dismissDirection;
+		for (const direction of untrack(swipeDirections)) if (getDisplacement(direction, deltaX, deltaY) > SWIPE_THRESHOLD) {
+			dismissDirection = direction;
+			break;
+		}
+		if (dismissDirection) {
+			setCurrentSwipeDirection(dismissDirection);
+			store.closeToast(untrack(toast).id);
+		} else {
+			setResolvedDragOffset({
+				x: resolvedInitialTransform.x,
+				y: resolvedInitialTransform.y
+			});
+			setCurrentSwipeDirection(void 0);
+		}
+	}
+	function handlePointerDown(event) {
+		if (event.button !== 0) return;
+		if (event.pointerType === "touch") store.pauseTimers();
+		if (getEventTarget(event)?.closest(INTERACTIVE_SELECTOR)) return;
+		cancelledSwipe = false;
+		intendedSwipeDirection = void 0;
+		maxSwipeDisplacement = 0;
+		activePointerId = event.pointerId;
+		dragStartPos = {
+			x: event.clientX,
+			y: event.clientY
+		};
+		swipeCancelBaseline = dragStartPos;
+		const element = event.currentTarget;
+		const transform = getElementTransform(element);
+		initialTransformRef = transform;
+		setInitialTransform(transform);
+		setResolvedDragOffset({
+			x: transform.x,
+			y: transform.y
+		});
+		store.set("hovering", true);
+		setIsSwiping(true);
+		setIsRealSwipe(false);
+		setLockedDirection(null);
+		isFirstPointerMove = true;
+		dragAbortController?.abort();
+		const controller = new AbortController();
+		dragAbortController = controller;
+		const doc = ownerDocument(element);
+		doc.addEventListener("pointerup", handleSwipeEnd, { signal: controller.signal });
+		doc.addEventListener("pointercancel", handleSwipeEnd, { signal: controller.signal });
+		element.setPointerCapture?.(event.pointerId);
+	}
+	function handlePointerMove(event) {
+		if (event.pointerId !== activePointerId) return;
+		event.preventDefault();
+		if (isFirstPointerMove) {
+			dragStartPos = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			isFirstPointerMove = false;
+		}
+		const { clientY, clientX, movementX, movementY } = event;
+		const directions = untrack(swipeDirections);
+		if (movementY < 0 && clientY > swipeCancelBaseline.y || movementY > 0 && clientY < swipeCancelBaseline.y) swipeCancelBaseline = {
+			x: swipeCancelBaseline.x,
+			y: clientY
+		};
+		if (movementX < 0 && clientX > swipeCancelBaseline.x || movementX > 0 && clientX < swipeCancelBaseline.x) swipeCancelBaseline = {
+			x: clientX,
+			y: swipeCancelBaseline.y
+		};
+		const deltaX = clientX - dragStartPos.x;
+		const deltaY = clientY - dragStartPos.y;
+		const cancelDeltaY = clientY - swipeCancelBaseline.y;
+		const cancelDeltaX = clientX - swipeCancelBaseline.x;
+		let resolvedLockedDirection = untrack(lockedDirection);
+		if (!untrack(isRealSwipe)) {
+			if (Math.sqrt(deltaX * deltaX + deltaY * deltaY) >= MIN_DRAG_THRESHOLD) {
+				setIsRealSwipe(true);
+				const hasHorizontal = directions.includes("left") || directions.includes("right");
+				const hasVertical = directions.includes("up") || directions.includes("down");
+				if (hasHorizontal && hasVertical) {
+					resolvedLockedDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "horizontal" : "vertical";
+					setLockedDirection(resolvedLockedDirection);
+				}
+			}
+		}
+		let candidate;
+		if (!intendedSwipeDirection) {
+			if (resolvedLockedDirection === "vertical") {
+				if (deltaY > 0) candidate = "down";
+				else if (deltaY < 0) candidate = "up";
+			} else if (resolvedLockedDirection === "horizontal") {
+				if (deltaX > 0) candidate = "right";
+				else if (deltaX < 0) candidate = "left";
+			} else if (Math.abs(deltaX) >= Math.abs(deltaY)) candidate = deltaX > 0 ? "right" : "left";
+			else candidate = deltaY > 0 ? "down" : "up";
+			if (candidate && directions.includes(candidate)) {
+				intendedSwipeDirection = candidate;
+				maxSwipeDisplacement = getDisplacement(candidate, deltaX, deltaY);
+				setCurrentSwipeDirection(candidate);
+			}
+		} else {
+			const direction = intendedSwipeDirection;
+			const currentDisplacement = getDisplacement(direction, cancelDeltaX, cancelDeltaY);
+			if (currentDisplacement > SWIPE_THRESHOLD) {
+				cancelledSwipe = false;
+				setCurrentSwipeDirection(direction);
+			} else if (!(directions.includes("left") && directions.includes("right")) && !(directions.includes("up") && directions.includes("down")) && maxSwipeDisplacement - currentDisplacement >= REVERSE_CANCEL_THRESHOLD) cancelledSwipe = true;
+		}
+		const dampedDelta = applyDirectionalDamping(deltaX, deltaY);
+		let newOffsetX = initialTransformRef.x;
+		let newOffsetY = initialTransformRef.y;
+		const hasHorizontalDir = directions.includes("left") || directions.includes("right");
+		const hasVerticalDir = directions.includes("up") || directions.includes("down");
+		if (resolvedLockedDirection !== "vertical" && hasHorizontalDir) newOffsetX += dampedDelta.x;
+		if (resolvedLockedDirection !== "horizontal" && hasVerticalDir) newOffsetY += dampedDelta.y;
+		setResolvedDragOffset({
+			x: newOffsetX,
+			y: newOffsetY
+		});
+	}
+	function handleKeyDown(event) {
+		if (event.key !== "Escape") return;
+		const element = untrack(rootElement);
+		if (!element || !contains(element, activeElement(ownerDocument(element)))) return;
+		store.closeToast(untrack(toast).id);
+	}
+	createEffect(() => ({
+		enabled: swipeEnabled(),
+		element: rootElement()
+	}), ({ enabled, element }) => {
+		if (!enabled || !element) return;
+		function preventDefaultTouchMove(event) {
+			if (activePointerId === null || !contains(element, getEventTarget(event))) return;
+			event.preventDefault();
+		}
+		element.addEventListener("touchmove", preventDefaultTouchMove, { passive: false });
+		return () => element.removeEventListener("touchmove", preventDefaultTouchMove);
+	});
+	function getDragStyles() {
+		const offset = dragOffset();
+		const transform = initialTransform();
+		const deltaX = offset.x - transform.x;
+		const deltaY = offset.y - transform.y;
+		return {
+			transition: isSwiping() ? "none" : void 0,
+			transform: isSwiping() ? `translateX(${offset.x}px) translateY(${offset.y}px) scale(${transform.scale})` : void 0,
+			"--toast-swipe-movement-x": `${deltaX}px`,
+			"--toast-swipe-movement-y": `${deltaY}px`
+		};
+	}
+	const isHighPriority = createMemo(() => toast().priority === "high");
+	const state = createMemo(() => ({
+		transitionStatus: toast().transitionStatus,
+		expanded: expanded(),
+		limited: toast().limited || false,
+		type: toast().type,
+		swiping: isSwiping(),
+		swipeDirection: currentSwipeDirection()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeToastStyles({
+		...getDragStyles(),
+		"--toast-index": String(toast().transitionStatus === "ending" ? domIndex() : visibleIndex()),
+		"--toast-offset-y": `${offsetY()}px`,
+		"--toast-height": toast().height ? `${toast().height}px` : void 0
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), toastRootStateAttributesMapping));
+	const others = omit(allProps, "as", "class", "onKeyDown", "onPointerCancel", "onPointerDown", "onPointerMove", "onPointerUp", "ref", "style", "swipeDirection", "toast");
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown);
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => untrack(() => swipeEnabled() ? handlePointerDown : void 0));
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => untrack(() => swipeEnabled() ? handlePointerMove : void 0));
+	const onPointerUp = composeEventHandlers(() => internalProps.onPointerUp, () => untrack(() => swipeEnabled() ? handleSwipeEnd : void 0));
+	const onPointerCancel = composeEventHandlers(() => internalProps.onPointerCancel, () => untrack(() => swipeEnabled() ? handleSwipeEnd : void 0));
+	return ToastRootContext({
+		value: {
+			toast,
+			setTitleId,
+			setDescriptionId,
+			visibleIndex,
+			expanded,
+			recalculateHeight
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((element) => setRootElement(element)), internalProps.ref],
+				get role() {
+					return isHighPriority() ? "alertdialog" : "dialog";
+				},
+				tabIndex: 0,
+				"aria-modal": "false",
+				get ["aria-labelledby"]() {
+					return titleId();
+				},
+				get ["aria-describedby"]() {
+					return descriptionId();
+				},
+				get ["aria-hidden"]() {
+					return isHighPriority() && !focused() ? "true" : void 0;
+				},
+				get inert() {
+					return toast().limited || void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onKeyDown,
+				onPointerDown,
+				onPointerMove,
+				onPointerUp,
+				onPointerCancel
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/toast/content/ToastContent.tsx
+/** A container for the contents of a toast. Its size drives the measured toast height. */
+function ToastContent(props) {
+	const context = useToastRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const [contentElement, setContentElement] = createSignal(null, { ownedWrite: true });
+	createEffect(() => contentElement(), (element) => {
+		context.recalculateHeight();
+		if (!element || typeof ResizeObserver !== "function" || typeof MutationObserver !== "function") return;
+		const resizeObserver = new ResizeObserver(() => context.recalculateHeight(true));
+		const mutationObserver = new MutationObserver(() => context.recalculateHeight(true));
+		resizeObserver.observe(element);
+		mutationObserver.observe(element, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+		return () => {
+			resizeObserver.disconnect();
+			mutationObserver.disconnect();
+		};
+	});
+	const state = createMemo(() => ({
+		expanded: context.expanded(),
+		behind: context.visibleIndex() > 0
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => setContentElement(element)), internalProps.ref],
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/toast/utils/isRenderableNode.ts
+/**
+* Mirrors Base UI's renderable-node check for resolved Solid children: `null`,
+* `undefined`, booleans, and the empty string render nothing, and an array is
+* renderable when any entry is.
+*/
+function isRenderableNode(node) {
+	if (node == null || typeof node === "boolean" || node === "") return false;
+	if (Array.isArray(node)) return node.some(isRenderableNode);
+	return true;
+}
+//#endregion
+//#region src/toast/utils/createToastLabelPart.ts
+/**
+* Shared logic for `Toast.Title` and `Toast.Description`, which differ only by the rendered tag,
+* the fallback content, and which id setter they register with. The part mounts only while it
+* carries renderable content, and registers its id with the root for that time.
+*/
+function createToastLabelPart(props, part) {
+	const context = useToastRootContext();
+	const setId = part === "title" ? context.setTitleId : context.setDescriptionId;
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const id = createMemo(() => props.id || generatedId);
+	const content = children(() => props.children ?? (part === "title" ? context.toast().title : context.toast().description));
+	const shouldRender = createMemo(() => isRenderableNode(content()));
+	createEffect(() => shouldRender() ? id() : void 0, (current) => {
+		if (current === void 0) return;
+		setId(current);
+		return () => setId((existing) => existing === current ? void 0 : existing);
+	});
+	return {
+		id,
+		content,
+		shouldRender,
+		type: () => context.toast().type
+	};
+}
+//#endregion
+//#region src/toast/description/ToastDescription.tsx
+/**
+* A description that describes the toast. Can be used as the default message for the toast when
+* no title is provided. Renders nothing when it has no content.
+*/
+function ToastDescription(props) {
+	const internalProps = props;
+	const allProps = props;
+	const part = createToastLabelPart(props, "description");
+	const state = createMemo(() => ({ type: part.type() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "children", "class", "id", "ref", "style");
+	return Show({
+		get when() {
+			return part.shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "p";
+				},
+				ref: [internalProps.ref],
+				get id() {
+					return part.id();
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others, { get children() {
+				return part.content();
+			} }));
+		}
+	});
+}
+//#endregion
+//#region src/toast/title/ToastTitle.tsx
+/** A title that labels the toast. Renders nothing when it has no content. */
+function ToastTitle(props) {
+	const internalProps = props;
+	const allProps = props;
+	const part = createToastLabelPart(props, "title");
+	const state = createMemo(() => ({ type: part.type() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "children", "class", "id", "ref", "style");
+	return Show({
+		get when() {
+			return part.shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "h2";
+				},
+				ref: [internalProps.ref],
+				get id() {
+					return part.id();
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others, { get children() {
+				return part.content();
+			} }));
+		}
+	});
+}
+//#endregion
+//#region src/toast/close/ToastClose.tsx
+/** Closes the toast when clicked. */
+function ToastClose(props) {
+	const store = useToastProviderContext();
+	const context = useToastRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const [hasFocus, setHasFocus] = createSignal(false, { ownedWrite: true });
+	const disabled = createMemo(() => internalProps.disabled ?? false);
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const state = createMemo(() => ({ type: context.toast().type }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "disabled", "nativeButton", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseDown", "onPointerDown", "ref", "style");
+	function handleClick() {
+		store.closeToast(context.toast().id);
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => () => setHasFocus(true));
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => () => setHasFocus(false));
+	const onPointerDown = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onPointerDown);
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onMouseDown);
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledButtonKeyDown : void 0), () => internalProps.onKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyUp));
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "button";
+		},
+		ref: [internalProps.ref],
+		get type() {
+			return nativeButton() ? "button" : void 0;
+		},
+		get role() {
+			return nativeButton() ? void 0 : "button";
+		},
+		get tabIndex() {
+			return !nativeButton() && disabled() ? -1 : 0;
+		},
+		get disabled() {
+			return (memo(() => {
+				return !!nativeButton();
+			})() ? disabled() : nativeButton()) || void 0;
+		},
+		get ["aria-disabled"]() {
+			return !nativeButton() && disabled() ? "true" : void 0;
+		},
+		get ["aria-hidden"]() {
+			return !context.expanded() && !hasFocus() ? "true" : "false";
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onBlur,
+		onClick,
+		onFocus,
+		onKeyDown,
+		onKeyUp,
+		onMouseDown,
+		onPointerDown
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/toast/action/ToastAction.tsx
+/**
+* Performs an action when clicked. Renders nothing when neither the toast nor the part supplies
+* action content.
+*/
+function ToastAction(props) {
+	const context = useToastRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const actionProps = () => context.toast().actionProps;
+	const content = children(() => actionProps()?.children ?? props.children);
+	const shouldRender = createMemo(() => isRenderableNode(content()));
+	const disabled = createMemo(() => internalProps.disabled ?? false);
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const state = createMemo(() => ({ type: context.toast().type }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "children", "class", "disabled", "nativeButton", "onClick", "onKeyDown", "onKeyUp", "onMouseDown", "onPointerDown", "ref", "style");
+	const managerProps = createMemo(() => {
+		const value = actionProps();
+		if (!value) return;
+		return omit(value, "children", "onClick", "onKeyDown", "onKeyUp", "onMouseDown", "onPointerDown");
+	});
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => actionProps()?.onClick);
+	const onPointerDown = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onPointerDown, () => actionProps()?.onPointerDown);
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onMouseDown, () => actionProps()?.onMouseDown);
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledButtonKeyDown : void 0), () => internalProps.onKeyDown, () => actionProps()?.onKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => actionProps()?.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyUp));
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "button";
+				},
+				ref: [internalProps.ref],
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				get role() {
+					return nativeButton() ? void 0 : "button";
+				},
+				get tabIndex() {
+					return !nativeButton() && disabled() ? -1 : 0;
+				},
+				get disabled() {
+					return (memo(() => {
+						return !!nativeButton();
+					})() ? disabled() : nativeButton()) || void 0;
+				},
+				get ["aria-disabled"]() {
+					return !nativeButton() && disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onClick,
+				onKeyDown,
+				onKeyUp,
+				onMouseDown,
+				onPointerDown
+			}, stateAttributes, others, managerProps, { get children() {
+				return content();
+			} }));
+		}
+	});
+}
+//#endregion
+//#region src/toast/portal/ToastPortal.tsx
+/**
+* A portal element that moves the viewport to a different part of the DOM. By default, the
+* portal element is appended to `<body>`.
+*/
+function ToastPortal(props) {
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "container", "ref", "style");
+	return PopupPortal(mergeProps({
+		get as() {
+			return props.as;
+		},
+		lite: true,
+		get container() {
+			return internalProps.container;
+		},
+		ref: (element) => {
+			if (internalProps.ref) setRef(internalProps.ref, element);
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others, { get children() {
+		return props.children;
+	} }));
+}
+//#endregion
+//#region src/toast/positioner/ToastPositionerContext.ts
+var MISSING_CONTEXT = Symbol("ToastPositionerContext");
+var ToastPositionerContext = createContext(MISSING_CONTEXT);
+function useToastPositionerContext() {
+	const context = useContext(ToastPositionerContext);
+	if (context === MISSING_CONTEXT) throw new Error("Base UI: ToastPositionerContext is missing. ToastPositioner parts must be placed within <Toast.Positioner>.");
+	return context;
+}
+//#endregion
+//#region src/toast/positioner/ToastPositioner.tsx
+var EMPTY_POSITIONER_PROPS = {};
+/** Positions the toast against the anchor. */
+function ToastPositioner(props) {
+	const store = useToastProviderContext();
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const toast = () => internalProps.toast;
+	const positionerProps = () => toast().positionerProps ?? EMPTY_POSITIONER_PROPS;
+	const anchor = createMemo(() => {
+		const value = internalProps.anchor ?? positionerProps().anchor;
+		return isElement(value) ? value : null;
+	});
+	const positioning = createAnchorPositioning({
+		reference: anchor,
+		floating: element,
+		mounted: () => true,
+		direction,
+		positionMethod: () => internalProps.positionMethod ?? positionerProps().positionMethod ?? "absolute",
+		side: () => internalProps.side ?? positionerProps().side ?? "top",
+		sideOffset: () => internalProps.sideOffset ?? positionerProps().sideOffset ?? 0,
+		align: () => internalProps.align ?? positionerProps().align ?? "center",
+		alignOffset: () => internalProps.alignOffset ?? positionerProps().alignOffset ?? 0,
+		collisionBoundary: () => internalProps.collisionBoundary ?? positionerProps().collisionBoundary ?? "clipping-ancestors",
+		collisionPadding: () => internalProps.collisionPadding ?? positionerProps().collisionPadding ?? 5,
+		arrowPadding: () => internalProps.arrowPadding ?? positionerProps().arrowPadding ?? 5,
+		sticky: () => internalProps.sticky ?? positionerProps().sticky ?? false,
+		disableAnchorTracking: () => internalProps.disableAnchorTracking ?? positionerProps().disableAnchorTracking ?? false,
+		collisionAvoidance: () => internalProps.collisionAvoidance ?? positionerProps().collisionAvoidance ?? { fallbackAxisSide: "end" }
+	});
+	const domIndex = createMemo(() => selectors.toastIndex(store.track(), toast().id));
+	const visibleIndex = createMemo(() => selectors.toastVisibleIndex(store.track(), toast().id));
+	const state = createMemo(() => ({
+		side: positioning.renderedSide(),
+		align: positioning.renderedAlign(),
+		anchorHidden: positioning.anchorHidden()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeToastStyles({
+		...positioning.styles(),
+		"--toast-index": String(toast().transitionStatus === "ending" ? domIndex() : visibleIndex()),
+		...toast().transitionStatus === "starting" ? { transition: "none" } : void 0
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupStateMapping));
+	const others = omit(allProps, "align", "alignOffset", "anchor", "arrowPadding", "as", "class", "collisionAvoidance", "collisionBoundary", "collisionPadding", "disableAnchorTracking", "positionMethod", "ref", "side", "sideOffset", "sticky", "style", "toast");
+	return ToastPositionerContext({
+		value: positioning,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => setElement(value)), internalProps.ref],
+				role: "presentation",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/toast/arrow/ToastArrow.tsx
+/** Displays an element positioned against the toast anchor. */
+function ToastArrow(props) {
+	const positioner = useToastPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		side: positioner.renderedSide(),
+		align: positioner.renderedAlign(),
+		uncentered: positioner.arrowUncentered()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeToastStyles(positioner.arrowStyles(), resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let arrowElement = null;
+	onCleanup(() => {
+		if (arrowElement) positioner.setArrowElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			arrowElement = element;
+			positioner.setArrowElement(element);
+		}), internalProps.ref],
+		"aria-hidden": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/toast/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Action: () => ToastAction,
+	Arrow: () => ToastArrow,
+	Close: () => ToastClose,
+	Content: () => ToastContent,
+	Description: () => ToastDescription,
+	Portal: () => ToastPortal,
+	Positioner: () => ToastPositioner,
+	Provider: () => ToastProvider,
+	Root: () => ToastRoot,
+	Title: () => ToastTitle,
+	Viewport: () => ToastViewport
+});
+//#endregion
+//#region src/toast/useToastManager.ts
+/** Returns an accessor for the toasts along with methods to manage them. */
+function useToastManager() {
+	const store = useToastProviderContext();
+	return {
+		toasts: store.access(selectors.toasts),
+		add: store.addToast,
+		close: store.closeToast,
+		update: store.updateToast,
+		promise: store.promiseToast
+	};
+}
+//#endregion
+//#region src/toast/createToastManager.ts
+/** Creates a toast manager usable outside of a component. */
+function createToastManager() {
+	const listeners = /* @__PURE__ */ new Set();
+	function emit(data) {
+		listeners.forEach((listener) => listener(data));
+	}
+	return {
+		" subscribe": function subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		add(options) {
+			const id = options.id || generateToastId();
+			emit({
+				action: "add",
+				options: {
+					...options,
+					id,
+					transitionStatus: "starting"
+				}
+			});
+			return id;
+		},
+		close(id) {
+			emit({
+				action: "close",
+				options: { id }
+			});
+		},
+		update(id, updates) {
+			emit({
+				action: "update",
+				options: {
+					...updates,
+					id
+				}
+			});
+		},
+		promise(promiseValue, options) {
+			let handledPromise = promiseValue;
+			emit({
+				action: "promise",
+				options: {
+					...options,
+					promise: promiseValue,
+					setPromise(promise) {
+						handledPromise = promise;
+					}
+				}
+			});
+			return handledPromise;
+		}
+	};
+}
+//#endregion
+export { index_parts_exports as Toast, createToastManager, useToastManager };