@drfed/web 0.0.0-stage → 0.1.0-dev.561

package/.output/server/_ssr/Toast-Bb1gcxED.mjs

@@ -0,0 +1,947 @@
+import { r as __toESM } from "../_runtime.mjs";
+import { n as require_relay_runtime } from "../_libs/relay-runtime.mjs";
+import { $ as splitProps, D as Show, F as createContext, H as createUniqueId, I as createEffect, J as onCleanup, K as mergeProps, L as createMemo, N as createComponent, V as createSignal, Y as onMount, h as ssr, l as Portal, n as createStore, nt as useContext, q as on, tt as untrack, v as ssrHydrationKey, w as For } from "../_libs/solid-js.mjs";
+import { D as mergeDefaultProps, S as isFunction, a as __export, c as contains, h as getDocument, i as Polymorphic, l as createGenerateId, n as ButtonRoot, o as callHandler, u as createRegisterId, v as getWindow } from "./JNCCF6MP-BAZlBnvx.mjs";
+import { _ as safeParse, b as string, d as object, h as pipe, l as nonEmpty, m as picklist, p as parseJson } from "../_libs/valibot.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/InstanceActorListQuery.graphql-Co_KwEO-.js
+var import_relay_runtime = /* @__PURE__ */ __toESM(require_relay_runtime());
+/**
+* @generated SignedSource<<2cf63a91cd9704068a66b688800ac78d>>
+* @lightSyntaxTransform
+*/
+var { ConcreteRequest } = import_relay_runtime?.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime?.default?.__esModule ? import_relay_runtime.default : import_relay_runtime;
+var node = function() {
+	var v0 = [{
+		"defaultValue": null,
+		"kind": "LocalArgument",
+		"name": "instanceId"
+	}], v1 = [{
+		"kind": "Variable",
+		"name": "id",
+		"variableName": "instanceId"
+	}], v2 = {
+		"alias": null,
+		"args": null,
+		"kind": "ScalarField",
+		"name": "id",
+		"storageKey": null
+	}, v3 = {
+		"alias": null,
+		"args": null,
+		"kind": "ScalarField",
+		"name": "host",
+		"storageKey": null
+	}, v4 = {
+		"alias": null,
+		"args": null,
+		"kind": "ScalarField",
+		"name": "url",
+		"storageKey": null
+	}, v5 = {
+		"alias": null,
+		"args": [{
+			"kind": "Literal",
+			"name": "first",
+			"value": 100
+		}],
+		"concreteType": "InstanceActorsConnection",
+		"kind": "LinkedField",
+		"name": "actors",
+		"plural": false,
+		"selections": [{
+			"alias": null,
+			"args": null,
+			"kind": "ScalarField",
+			"name": "totalCount",
+			"storageKey": null
+		}, {
+			"alias": null,
+			"args": null,
+			"concreteType": "InstanceActorsConnectionEdge",
+			"kind": "LinkedField",
+			"name": "edges",
+			"plural": true,
+			"selections": [{
+				"alias": null,
+				"args": null,
+				"concreteType": "Actor",
+				"kind": "LinkedField",
+				"name": "node",
+				"plural": false,
+				"selections": [
+					{
+						"alias": null,
+						"args": null,
+						"kind": "ScalarField",
+						"name": "handle",
+						"storageKey": null
+					},
+					{
+						"alias": null,
+						"args": null,
+						"kind": "ScalarField",
+						"name": "iri",
+						"storageKey": null
+					},
+					v2
+				],
+				"storageKey": null
+			}],
+			"storageKey": null
+		}],
+		"storageKey": "actors(first:100)"
+	};
+	return {
+		"fragment": {
+			"argumentDefinitions": v0,
+			"kind": "Fragment",
+			"metadata": null,
+			"name": "InstanceActorListQuery",
+			"selections": [{
+				"alias": "instance",
+				"args": v1,
+				"concreteType": null,
+				"kind": "LinkedField",
+				"name": "node",
+				"plural": false,
+				"selections": [{
+					"kind": "InlineFragment",
+					"selections": [
+						v2,
+						v3,
+						v4,
+						v5
+					],
+					"type": "Instance",
+					"abstractKey": null
+				}],
+				"storageKey": null
+			}],
+			"type": "Query",
+			"abstractKey": null
+		},
+		"kind": "Request",
+		"operation": {
+			"argumentDefinitions": v0,
+			"kind": "Operation",
+			"name": "InstanceActorListQuery",
+			"selections": [{
+				"alias": "instance",
+				"args": v1,
+				"concreteType": null,
+				"kind": "LinkedField",
+				"name": "node",
+				"plural": false,
+				"selections": [
+					{
+						"alias": null,
+						"args": null,
+						"kind": "ScalarField",
+						"name": "__typename",
+						"storageKey": null
+					},
+					v2,
+					{
+						"kind": "InlineFragment",
+						"selections": [
+							v3,
+							v4,
+							v5
+						],
+						"type": "Instance",
+						"abstractKey": null
+					}
+				],
+				"storageKey": null
+			}]
+		},
+		"params": {
+			"cacheID": "2362d2d169cd79f7485c1243b70c22d7",
+			"id": null,
+			"metadata": {},
+			"name": "InstanceActorListQuery",
+			"operationKind": "query",
+			"text": "query InstanceActorListQuery(\n  $instanceId: ID!\n) {\n  instance: node(id: $instanceId) {\n    __typename\n    ... on Instance {\n      id\n      host\n      url\n      actors(first: 100) {\n        totalCount\n        edges {\n          node {\n            handle\n            iri\n            id\n          }\n        }\n      }\n    }\n    id\n  }\n}\n"
+		}
+	};
+}();
+node.hash = "dfa1afc83b486dcdebbeb32921ca4595";
+//#endregion
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/Toast-Bb1gcxED.js
+var extractCSSregex = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+/**
+* converts inline string styles to object form
+* @example
+* const styles = stringStyleToObject("margin: 24px; border: 1px solid #121212");
+* styles; // { margin: "24px", border: "1px solid #121212" }
+* */
+function stringStyleToObject(style) {
+	const object = {};
+	let match;
+	while (match = extractCSSregex.exec(style)) object[match[1]] = match[2];
+	return object;
+}
+function combineStyle(a, b) {
+	if (typeof a === "string") {
+		if (typeof b === "string") return `${a};${b}`;
+		a = stringStyleToObject(a);
+	} else if (typeof b === "string") b = stringStyleToObject(b);
+	return {
+		...a,
+		...b
+	};
+}
+var DATA_TOP_LAYER_ATTR = "data-kb-top-layer";
+var originalBodyPointerEvents;
+var hasDisabledBodyPointerEvents = false;
+var layers = [];
+function indexOf(node) {
+	return layers.findIndex((layer) => layer.node === node);
+}
+function find(node) {
+	return layers[indexOf(node)];
+}
+function isTopMostLayer(node) {
+	return layers.length > 0 && layers[layers.length - 1].node === node;
+}
+function getPointerBlockingLayers() {
+	return layers.filter((layer) => layer.isPointerBlocking);
+}
+function getTopMostPointerBlockingLayer() {
+	return [...getPointerBlockingLayers()].slice(-1)[0];
+}
+function hasPointerBlockingLayer() {
+	return getPointerBlockingLayers().length > 0;
+}
+function isBelowPointerBlockingLayer(node) {
+	const highestBlockingIndex = indexOf(getTopMostPointerBlockingLayer()?.node);
+	return indexOf(node) < highestBlockingIndex;
+}
+function addLayer(layer) {
+	layers.push(layer);
+}
+function removeLayer(node) {
+	const index = indexOf(node);
+	if (index < 0) return;
+	layers.splice(index, 1);
+}
+function assignPointerEventToLayers() {
+	for (const { node } of layers) node.style.pointerEvents = isBelowPointerBlockingLayer(node) ? "none" : "auto";
+}
+function disableBodyPointerEvents(node) {
+	if (hasPointerBlockingLayer() && !hasDisabledBodyPointerEvents) {
+		const ownerDocument = getDocument(node);
+		originalBodyPointerEvents = document.body.style.pointerEvents;
+		ownerDocument.body.style.pointerEvents = "none";
+		hasDisabledBodyPointerEvents = true;
+	}
+}
+function restoreBodyPointerEvents(node) {
+	if (hasPointerBlockingLayer()) return;
+	const ownerDocument = getDocument(node);
+	ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+	if (ownerDocument.body.style.length === 0) ownerDocument.body.removeAttribute("style");
+	hasDisabledBodyPointerEvents = false;
+}
+var layerStack = {
+	layers,
+	isTopMostLayer,
+	hasPointerBlockingLayer,
+	isBelowPointerBlockingLayer,
+	addLayer,
+	removeLayer,
+	indexOf,
+	find,
+	assignPointerEventToLayers,
+	disableBodyPointerEvents,
+	restoreBodyPointerEvents
+};
+var access = (v) => typeof v === "function" ? v() : v;
+var createPresence = (props) => {
+	const refStyles = createMemo(() => {
+		const element = access(props.element);
+		if (!element) return;
+		return getComputedStyle(element);
+	});
+	const getAnimationName = () => {
+		return refStyles()?.animationName ?? "none";
+	};
+	const [presentState, setPresentStateInternal] = createSignal(access(props.show) ? "present" : "hidden");
+	const setPresentState = (state) => {
+		setPresentStateInternal(state);
+		props.onStateChange?.(state);
+	};
+	let animationName = "none";
+	createEffect((prevShow) => {
+		const show = access(props.show);
+		untrack(() => {
+			if (prevShow === show) return show;
+			const prevAnimationName = animationName;
+			const currentAnimationName = getAnimationName();
+			if (show) setPresentState("present");
+			else if (currentAnimationName === "none" || refStyles()?.display === "none") setPresentState("hidden");
+			else if (prevShow === true && prevAnimationName !== currentAnimationName) setPresentState("hiding");
+			else setPresentState("hidden");
+		});
+		return show;
+	}, access(props.show));
+	createEffect(() => {
+		const element = access(props.element);
+		if (!element) return;
+		const handleAnimationStart = (event) => {
+			if (event.target === element) animationName = getAnimationName();
+		};
+		const handleAnimationEnd = (event) => {
+			const isCurrentAnimation = getAnimationName().includes(event.animationName);
+			if (event.target === element && isCurrentAnimation && presentState() === "hiding") setPresentState("hidden");
+		};
+		element.addEventListener("animationstart", handleAnimationStart);
+		element.addEventListener("animationcancel", handleAnimationEnd);
+		element.addEventListener("animationend", handleAnimationEnd);
+		onCleanup(() => {
+			element.removeEventListener("animationstart", handleAnimationStart);
+			element.removeEventListener("animationcancel", handleAnimationEnd);
+			element.removeEventListener("animationend", handleAnimationEnd);
+		});
+	});
+	return {
+		present: () => presentState() === "present" || presentState() === "hiding",
+		state: presentState
+	};
+};
+var index_default = createPresence;
+__export({}, {
+	CloseButton: () => ToastCloseButton,
+	Description: () => ToastDescription,
+	List: () => ToastList,
+	ProgressFill: () => ToastProgressFill,
+	ProgressTrack: () => ToastProgressTrack,
+	Region: () => ToastRegion$1,
+	Root: () => ToastRoot,
+	Title: () => ToastTitle,
+	Toast: () => Toast,
+	toaster: () => toaster,
+	useToastContext: () => useToastContext
+});
+var ToastContext = createContext();
+function useToastContext() {
+	const context = useContext(ToastContext);
+	if (context === void 0) throw new Error("[kobalte]: `useToastContext` must be used within a `Toast.Root` component");
+	return context;
+}
+function ToastCloseButton(props) {
+	const context = useToastContext();
+	const [local, others] = splitProps(props, ["aria-label", "onClick"]);
+	const onClick = (e) => {
+		callHandler(e, local.onClick);
+		context.close();
+	};
+	return createComponent(ButtonRoot, mergeProps({
+		get ["aria-label"]() {
+			return local["aria-label"] || context.translations().close;
+		},
+		onClick
+	}, others));
+}
+function ToastDescription(props) {
+	const context = useToastContext();
+	const [local, others] = splitProps(mergeDefaultProps({ id: context.generateId("description") }, props), ["id"]);
+	createEffect(() => onCleanup(context.registerDescriptionId(local.id)));
+	return createComponent(Polymorphic, mergeProps({
+		as: "div",
+		get id() {
+			return local.id;
+		}
+	}, others));
+}
+var ToastRegionContext = createContext();
+function useToastRegionContext() {
+	const context = useContext(ToastRegionContext);
+	if (context === void 0) throw new Error("[kobalte]: `useToastRegionContext` must be used within a `Toast.Region` component");
+	return context;
+}
+function ToastList(props) {
+	let ref;
+	const context = useToastRegionContext();
+	const [local, others] = splitProps(props, [
+		"ref",
+		"onFocusIn",
+		"onFocusOut",
+		"onPointerMove",
+		"onPointerLeave"
+	]);
+	const onFocusIn = (e) => {
+		callHandler(e, local.onFocusIn);
+		if (context.pauseOnInteraction() && !context.isPaused()) context.pauseAllTimer();
+	};
+	const onFocusOut = (e) => {
+		callHandler(e, local.onFocusOut);
+		if (!contains(ref, e.relatedTarget)) context.resumeAllTimer();
+	};
+	const onPointerMove = (e) => {
+		callHandler(e, local.onPointerMove);
+		if (context.pauseOnInteraction() && !context.isPaused()) context.pauseAllTimer();
+	};
+	const onPointerLeave = (e) => {
+		callHandler(e, local.onPointerLeave);
+		if (!contains(ref, getDocument(ref).activeElement)) context.resumeAllTimer();
+	};
+	createEffect(on([() => ref, () => context.hotkey()], ([ref2, hotkey]) => {}));
+	createEffect(() => {
+		if (!context.pauseOnPageIdle()) return;
+		const win = getWindow(ref);
+		win.addEventListener("blur", context.pauseAllTimer);
+		win.addEventListener("focus", context.resumeAllTimer);
+		onCleanup(() => {
+			win.removeEventListener("blur", context.pauseAllTimer);
+			win.removeEventListener("focus", context.resumeAllTimer);
+		});
+	});
+	return createComponent(Polymorphic, mergeProps({
+		as: "ol",
+		tabIndex: -1,
+		onFocusIn,
+		onFocusOut,
+		onPointerMove,
+		onPointerLeave
+	}, others, { get children() {
+		return createComponent(For, {
+			get each() {
+				return context.toasts();
+			},
+			children: (toast) => toast.toastComponent({ get toastId() {
+				return toast.id;
+			} })
+		});
+	} }));
+}
+function ToastProgressFill(props) {
+	const rootContext = useToastRegionContext();
+	const context = useToastContext();
+	const [local, others] = splitProps(props, ["style"]);
+	const [lifeTime, setLifeTime] = createSignal(100);
+	let totalElapsedTime = 0;
+	createEffect(() => {
+		if (rootContext.isPaused() || context.isPersistent()) return;
+		const intervalId = setInterval(() => {
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - context.closeTimerStartTime() + totalElapsedTime;
+			const life = Math.trunc(100 - elapsedTime / context.duration() * 100);
+			setLifeTime(life < 0 ? 0 : life);
+		});
+		onCleanup(() => {
+			totalElapsedTime += (/* @__PURE__ */ new Date()).getTime() - context.closeTimerStartTime();
+			clearInterval(intervalId);
+		});
+	});
+	return createComponent(Polymorphic, mergeProps({
+		as: "div",
+		get style() {
+			return combineStyle({ "--kb-toast-progress-fill-width": `${lifeTime()}%` }, local.style);
+		}
+	}, others));
+}
+function ToastProgressTrack(props) {
+	return createComponent(Polymorphic, mergeProps({
+		as: "div",
+		"aria-hidden": "true",
+		role: "presentation"
+	}, props));
+}
+var [state, setState] = createStore({ toasts: [] });
+function add(toast) {
+	setState("toasts", (prev) => [...prev, toast]);
+}
+function get(id) {
+	return state.toasts.find((toast) => toast.id === id);
+}
+function update(id, toast) {
+	const index = state.toasts.findIndex((toast2) => toast2.id === id);
+	if (index !== -1) setState("toasts", (prev) => [
+		...prev.slice(0, index),
+		toast,
+		...prev.slice(index + 1)
+	]);
+}
+function dismiss(id) {
+	setState("toasts", (toast) => toast.id === id, "dismiss", true);
+}
+function remove(id) {
+	setState("toasts", (prev) => prev.filter((toast) => toast.id !== id));
+}
+function clear() {
+	setState("toasts", []);
+}
+var toastStore = {
+	toasts: () => state.toasts,
+	add,
+	get,
+	update,
+	dismiss,
+	remove,
+	clear
+};
+var TOAST_HOTKEY_PLACEHOLDER = "{hotkey}";
+var TOAST_INTL_TRANSLATIONS = { close: "Close" };
+var TOAST_REGION_INTL_TRANSLATIONS = { notifications: (hotkeyPlaceholder) => `Notifications (${hotkeyPlaceholder})` };
+function ToastRegion$1(props) {
+	const [local, others] = splitProps(mergeDefaultProps({
+		id: `toast-region-${createUniqueId()}`,
+		hotkey: ["altKey", "KeyT"],
+		duration: 5e3,
+		limit: 3,
+		swipeDirection: "right",
+		swipeThreshold: 50,
+		pauseOnInteraction: true,
+		pauseOnPageIdle: true,
+		topLayer: true,
+		translations: TOAST_REGION_INTL_TRANSLATIONS
+	}, props), [
+		"translations",
+		"style",
+		"hotkey",
+		"duration",
+		"limit",
+		"swipeDirection",
+		"swipeThreshold",
+		"pauseOnInteraction",
+		"pauseOnPageIdle",
+		"topLayer",
+		"aria-label",
+		"regionId"
+	]);
+	const toasts = createMemo(() => toastStore.toasts().filter((toast) => toast.region === local.regionId && toast.dismiss === false).slice(0, local.limit));
+	const [isPaused, setIsPaused] = createSignal(false);
+	const hasToasts = () => toasts().length > 0;
+	const hotkeyLabel = () => {
+		return local.hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
+	};
+	const ariaLabel = () => {
+		return (local["aria-label"] || local.translations.notifications(TOAST_HOTKEY_PLACEHOLDER)).replace(TOAST_HOTKEY_PLACEHOLDER, hotkeyLabel());
+	};
+	const topLayerAttr = () => ({ [DATA_TOP_LAYER_ATTR]: local.topLayer ? "" : void 0 });
+	const context = {
+		isPaused,
+		toasts,
+		hotkey: () => local.hotkey,
+		duration: () => local.duration,
+		swipeDirection: () => local.swipeDirection,
+		swipeThreshold: () => local.swipeThreshold,
+		pauseOnInteraction: () => local.pauseOnInteraction,
+		pauseOnPageIdle: () => local.pauseOnPageIdle,
+		pauseAllTimer: () => setIsPaused(true),
+		resumeAllTimer: () => setIsPaused(false),
+		generateId: createGenerateId(() => others.id)
+	};
+	return createComponent(ToastRegionContext.Provider, {
+		value: context,
+		get children() {
+			return createComponent(Polymorphic, mergeProps({
+				as: "div",
+				role: "region",
+				tabIndex: -1,
+				get ["aria-label"]() {
+					return ariaLabel();
+				},
+				get style() {
+					return combineStyle({ "pointer-events": hasToasts() ? local.topLayer ? "auto" : void 0 : "none" }, local.style);
+				}
+			}, topLayerAttr, others));
+		}
+	});
+}
+var TOAST_SWIPE_START_EVENT = "toast.swipeStart";
+var TOAST_SWIPE_MOVE_EVENT = "toast.swipeMove";
+var TOAST_SWIPE_CANCEL_EVENT = "toast.swipeCancel";
+var TOAST_SWIPE_END_EVENT = "toast.swipeEnd";
+function ToastRoot(props) {
+	const rootContext = useToastRegionContext();
+	const [local, others] = splitProps(mergeDefaultProps({
+		id: `toast-${createUniqueId()}`,
+		priority: "high",
+		translations: TOAST_INTL_TRANSLATIONS
+	}, props), [
+		"ref",
+		"translations",
+		"toastId",
+		"style",
+		"priority",
+		"duration",
+		"persistent",
+		"onPause",
+		"onResume",
+		"onSwipeStart",
+		"onSwipeMove",
+		"onSwipeCancel",
+		"onSwipeEnd",
+		"onEscapeKeyDown",
+		"onKeyDown",
+		"onPointerDown",
+		"onPointerMove",
+		"onPointerUp"
+	]);
+	const [isOpen, setIsOpen] = createSignal(true);
+	const [titleId, setTitleId] = createSignal();
+	const [descriptionId, setDescriptionId] = createSignal();
+	const [isAnimationEnabled, setIsAnimationEnabled] = createSignal(true);
+	const [ref, setRef] = createSignal();
+	const { present } = index_default({
+		show: isOpen,
+		element: () => ref() ?? null
+	});
+	const duration = createMemo(() => local.duration || rootContext.duration());
+	let closeTimerId;
+	let closeTimerStartTime = 0;
+	let closeTimerRemainingTime = duration();
+	let pointerStart = null;
+	let swipeDelta = null;
+	const close = () => {
+		setIsOpen(false);
+		setIsAnimationEnabled(true);
+	};
+	const deleteToast = () => {
+		toastStore.remove(local.toastId);
+	};
+	const startTimer = (duration2) => {
+		if (!duration2 || local.persistent) return;
+		window.clearTimeout(closeTimerId);
+		closeTimerStartTime = (/* @__PURE__ */ new Date()).getTime();
+		closeTimerId = window.setTimeout(close, duration2);
+	};
+	const resumeTimer = () => {
+		startTimer(closeTimerRemainingTime);
+		local.onResume?.();
+	};
+	const pauseTimer = () => {
+		const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTime;
+		closeTimerRemainingTime = closeTimerRemainingTime - elapsedTime;
+		window.clearTimeout(closeTimerId);
+		local.onPause?.();
+	};
+	const onKeyDown = (e) => {
+		callHandler(e, local.onKeyDown);
+		if (e.key !== "Escape") return;
+		local.onEscapeKeyDown?.(e);
+		if (!e.defaultPrevented) close();
+	};
+	const onPointerDown = (e) => {
+		callHandler(e, local.onPointerDown);
+		if (e.button !== 0) return;
+		pointerStart = {
+			x: e.clientX,
+			y: e.clientY
+		};
+	};
+	const onPointerMove = (e) => {
+		callHandler(e, local.onPointerMove);
+		if (!pointerStart) return;
+		const x = e.clientX - pointerStart.x;
+		const y = e.clientY - pointerStart.y;
+		const hasSwipeMoveStarted = Boolean(swipeDelta);
+		const isHorizontalSwipe = ["left", "right"].includes(rootContext.swipeDirection());
+		const clamp = ["left", "up"].includes(rootContext.swipeDirection()) ? Math.min : Math.max;
+		const clampedX = isHorizontalSwipe ? clamp(0, x) : 0;
+		const clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;
+		const moveStartBuffer = e.pointerType === "touch" ? 10 : 2;
+		const delta = {
+			x: clampedX,
+			y: clampedY
+		};
+		const eventDetail = {
+			originalEvent: e,
+			delta
+		};
+		if (hasSwipeMoveStarted) {
+			swipeDelta = delta;
+			handleAndDispatchCustomEvent(TOAST_SWIPE_MOVE_EVENT, local.onSwipeMove, eventDetail);
+			const { x: x2, y: y2 } = delta;
+			e.currentTarget.setAttribute("data-swipe", "move");
+			e.currentTarget.style.setProperty("--kb-toast-swipe-move-x", `${x2}px`);
+			e.currentTarget.style.setProperty("--kb-toast-swipe-move-y", `${y2}px`);
+		} else if (isDeltaInDirection(delta, rootContext.swipeDirection(), moveStartBuffer)) {
+			swipeDelta = delta;
+			handleAndDispatchCustomEvent(TOAST_SWIPE_START_EVENT, local.onSwipeStart, eventDetail);
+			e.currentTarget.setAttribute("data-swipe", "start");
+			e.target.setPointerCapture(e.pointerId);
+		} else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) pointerStart = null;
+	};
+	const onPointerUp = (e) => {
+		callHandler(e, local.onPointerUp);
+		const delta = swipeDelta;
+		const target = e.target;
+		if (target.hasPointerCapture(e.pointerId)) target.releasePointerCapture(e.pointerId);
+		swipeDelta = null;
+		pointerStart = null;
+		if (delta) {
+			const toast = e.currentTarget;
+			const eventDetail = {
+				originalEvent: e,
+				delta
+			};
+			if (isDeltaInDirection(delta, rootContext.swipeDirection(), rootContext.swipeThreshold())) {
+				handleAndDispatchCustomEvent(TOAST_SWIPE_END_EVENT, local.onSwipeEnd, eventDetail);
+				const { x, y } = delta;
+				e.currentTarget.setAttribute("data-swipe", "end");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-move-x");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-move-y");
+				e.currentTarget.style.setProperty("--kb-toast-swipe-end-x", `${x}px`);
+				e.currentTarget.style.setProperty("--kb-toast-swipe-end-y", `${y}px`);
+				close();
+			} else {
+				handleAndDispatchCustomEvent(TOAST_SWIPE_CANCEL_EVENT, local.onSwipeCancel, eventDetail);
+				e.currentTarget.setAttribute("data-swipe", "cancel");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-move-x");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-move-y");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-end-x");
+				e.currentTarget.style.removeProperty("--kb-toast-swipe-end-y");
+			}
+			toast.addEventListener("click", (event) => event.preventDefault(), { once: true });
+		}
+	};
+	onMount(() => {
+		if (rootContext.toasts().find((toast) => toast.id === local.toastId && toast.update)) setIsAnimationEnabled(false);
+	});
+	createEffect(on(() => rootContext.isPaused(), (isPaused) => {
+		if (isPaused) pauseTimer();
+		else resumeTimer();
+	}, { defer: true }));
+	createEffect(on([isOpen, duration], ([isOpen2, duration2]) => {
+		if (isOpen2 && !rootContext.isPaused()) startTimer(duration2);
+	}));
+	createEffect(on(() => toastStore.get(local.toastId)?.dismiss, (dismiss3) => dismiss3 && close()));
+	createEffect(on(() => present(), (isPresent) => !isPresent && deleteToast()));
+	const context = {
+		translations: () => local.translations,
+		close,
+		duration,
+		isPersistent: () => local.persistent ?? false,
+		closeTimerStartTime: () => closeTimerStartTime,
+		generateId: createGenerateId(() => others.id),
+		registerTitleId: createRegisterId(setTitleId),
+		registerDescriptionId: createRegisterId(setDescriptionId)
+	};
+	return createComponent(Show, {
+		get when() {
+			return present();
+		},
+		get children() {
+			return createComponent(ToastContext.Provider, {
+				value: context,
+				get children() {
+					return createComponent(Polymorphic, mergeProps({
+						as: "li",
+						role: "status",
+						tabIndex: 0,
+						get style() {
+							return combineStyle({
+								animation: isAnimationEnabled() ? void 0 : "none",
+								"user-select": "none",
+								"touch-action": "none"
+							}, local.style);
+						},
+						get ["aria-live"]() {
+							return local.priority === "high" ? "assertive" : "polite";
+						},
+						"aria-atomic": "true",
+						get ["aria-labelledby"]() {
+							return titleId();
+						},
+						get ["aria-describedby"]() {
+							return descriptionId();
+						},
+						get ["data-opened"]() {
+							return isOpen() ? "" : void 0;
+						},
+						get ["data-closed"]() {
+							return !isOpen() ? "" : void 0;
+						},
+						get ["data-swipe-direction"]() {
+							return rootContext.swipeDirection();
+						},
+						onKeyDown,
+						onPointerDown,
+						onPointerMove,
+						onPointerUp
+					}, others));
+				}
+			});
+		}
+	});
+}
+function 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;
+	return !isDeltaX && deltaY > threshold;
+}
+function handleAndDispatchCustomEvent(name, handler, detail) {
+	const currentTarget = detail.originalEvent.currentTarget;
+	const event = new CustomEvent(name, {
+		bubbles: true,
+		cancelable: true,
+		detail
+	});
+	if (handler) currentTarget.addEventListener(name, handler, { once: true });
+	currentTarget.dispatchEvent(event);
+}
+function ToastTitle(props) {
+	const context = useToastContext();
+	const [local, others] = splitProps(mergeDefaultProps({ id: context.generateId("title") }, props), ["id"]);
+	createEffect(() => onCleanup(context.registerTitleId(local.id)));
+	return createComponent(Polymorphic, mergeProps({
+		as: "div",
+		get id() {
+			return local.id;
+		}
+	}, others));
+}
+var toastsCounter = 0;
+function show(toastComponent, options) {
+	const id = toastsCounter++;
+	toastStore.add({
+		id,
+		toastComponent,
+		dismiss: false,
+		update: false,
+		region: options?.region
+	});
+	return id;
+}
+function update2(id, toastComponent) {
+	toastStore.update(id, {
+		id,
+		toastComponent,
+		dismiss: false,
+		update: true
+	});
+}
+function promise(promise2, toastComponent, options) {
+	const id = show((props) => {
+		return toastComponent({
+			get toastId() {
+				return props.toastId;
+			},
+			state: "pending"
+		});
+	}, options);
+	(isFunction(promise2) ? promise2() : promise2).then((data) => update2(id, (props) => {
+		return toastComponent({
+			get toastId() {
+				return props.toastId;
+			},
+			state: "fulfilled",
+			data
+		});
+	})).catch((error) => update2(id, (props) => {
+		return toastComponent({
+			get toastId() {
+				return props.toastId;
+			},
+			state: "rejected",
+			error
+		});
+	}));
+	return id;
+}
+function dismiss2(id) {
+	toastStore.dismiss(id);
+	return id;
+}
+function clear2() {
+	toastStore.clear();
+}
+var toaster = {
+	show,
+	update: update2,
+	promise,
+	dismiss: dismiss2,
+	clear: clear2
+};
+var Toast = Object.assign(ToastRoot, {
+	CloseButton: ToastCloseButton,
+	Description: ToastDescription,
+	List: ToastList,
+	ProgressFill: ToastProgressFill,
+	ProgressTrack: ToastProgressTrack,
+	Region: ToastRegion$1,
+	Title: ToastTitle,
+	toaster
+});
+var toast_module_default = {
+	region: "_region_3lsca_19",
+	list: "_list_3lsca_27",
+	toast: "_toast_3lsca_36",
+	success: "_success_3lsca_48",
+	fail: "_fail_3lsca_52",
+	title: "_title_3lsca_56",
+	close: "_close_3lsca_62"
+};
+var _tmpl$ = ["<span", " aria-hidden=\"true\">×</span>"];
+var pendingToastKey = "drfed:toast:";
+var toastMessage = pipe(string(), nonEmpty());
+var storedToastSchema = pipe(string(), parseJson(), object({
+	message: toastMessage,
+	status: picklist(["success", "fail"])
+}));
+function ToastRegion() {
+	onMount(() => {
+		const key = pendingToastKey + globalThis.location.pathname;
+		try {
+			const stored = sessionStorage.getItem(key);
+			sessionStorage.removeItem(key);
+			const result = safeParse(storedToastSchema, stored);
+			if (result.success) showToast(result.output.message, result.output.status);
+		} catch {}
+	});
+	return createComponent(Portal, { get children() {
+		return createComponent(Toast.Region, {
+			get ["class"]() {
+				return toast_module_default.region;
+			},
+			duration: 5e3,
+			get children() {
+				return createComponent(Toast.List, { get ["class"]() {
+					return toast_module_default.list;
+				} });
+			}
+		});
+	} });
+}
+function showToast(message, status) {
+	return toaster.show((props) => createComponent(Toast, {
+		get toastId() {
+			return props.toastId;
+		},
+		get ["class"]() {
+			return `${toast_module_default.toast} ${toast_module_default[status]}`;
+		},
+		get children() {
+			return [createComponent(Toast.Title, {
+				get ["class"]() {
+					return toast_module_default.title;
+				},
+				children: message
+			}), createComponent(Toast.CloseButton, {
+				get ["class"]() {
+					return toast_module_default.close;
+				},
+				"aria-label": "Dismiss notification",
+				get children() {
+					return ssr(_tmpl$, ssrHydrationKey());
+				}
+			})];
+		}
+	}));
+}
+/** Load a fresh page and show a one-time notification there. */
+function navigateWithToast(path, message, status) {
+	try {
+		sessionStorage.setItem(pendingToastKey + path, JSON.stringify({
+			message,
+			status
+		}));
+	} catch {}
+	globalThis.location.assign(path);
+}
+//#endregion
+export { index_default as a, node as c, combineStyle as i, ToastRegion as n, layerStack as o, access as r, navigateWithToast as s, DATA_TOP_LAYER_ATTR as t };