@sprawlify/primitives 0.0.109 → 0.0.111

package/dist/machines/bottom-sheet/index.mjs

@@ -1,662 +0,0 @@
-import { t as createAnatomy } from "../../create-anatomy-Dr0evdYy.mjs";
-import { St as isLeftClick, W as raf, ht as getEventTarget, m as resizeObserverBorderBox, pt as getEventPoint, ut as addDomEvent } from "../../dom-query-s2ESLR2U.mjs";
-import { t as _defineProperty } from "../../defineProperty-D5oW_HU_.mjs";
-import { t as ariaHidden } from "../../aria-hidden-BX4SWNE_.mjs";
-import { H as toPx, u as createSplitProps } from "../../utils-VVoZ_v29.mjs";
-import { a as createMachine } from "../../core-BmIEKqtP.mjs";
-import "../../interact-outside-2qkUnl4N.mjs";
-import { n as trackDismissableElement } from "../../dismissable-DWfZGIA7.mjs";
-import { t as trapFocus } from "../../focus-trap-DzBvBlTH.mjs";
-import { t as createProps } from "../../create-props-DFW8DUsC.mjs";
-import { t as preventBodyScroll } from "../../remove-scroll-HcSiTbd5.mjs";
-//#region src/machines/bottom-sheet/bottom-sheet.anatomy.ts
-const anatomy = createAnatomy("bottom-sheet").parts("content", "title", "trigger", "backdrop", "grabber", "grabberIndicator", "closeTrigger");
-const parts = anatomy.build();
-//#endregion
-//#region src/machines/bottom-sheet/bottom-sheet.dom.ts
-const getContentId = (ctx) => ctx.ids?.content ?? `bottom-sheet:${ctx.id}:content`;
-const getTitleId = (ctx) => ctx.ids?.title ?? `bottom-sheet:${ctx.id}:title`;
-const getTriggerId = (ctx) => ctx.ids?.trigger ?? `bottom-sheet:${ctx.id}:trigger`;
-const getBackdropId = (ctx) => ctx.ids?.backdrop ?? `bottom-sheet:${ctx.id}:backdrop`;
-const getGrabberId = (ctx) => ctx.ids?.grabber ?? `bottom-sheet:${ctx.id}:grabber`;
-const getGrabberIndicatorId = (ctx) => ctx.ids?.grabberIndicator ?? `bottom-sheet:${ctx.id}:grabber-indicator`;
-const getCloseTriggerId = (ctx) => ctx.ids?.closeTrigger ?? `bottom-sheet:${ctx.id}:close-trigger`;
-const getContentEl = (ctx) => ctx.getById(getContentId(ctx));
-const getTriggerEl = (ctx) => ctx.getById(getTriggerId(ctx));
-const getCloseTriggerEl = (ctx) => ctx.getById(getCloseTriggerId(ctx));
-//#endregion
-//#region src/machines/bottom-sheet/bottom-sheet.connect.ts
-function connect(service, normalize) {
-	const { state, send, context, scope, prop } = service;
-	const open = state.hasTag("open");
-	const dragOffset = context.get("dragOffset");
-	const dragging = dragOffset !== null;
-	const activeSnapPoint = context.get("activeSnapPoint");
-	const resolvedActiveSnapPoint = context.get("resolvedActiveSnapPoint");
-	const translate = dragOffset ?? resolvedActiveSnapPoint?.offset;
-	function onPointerDown(event) {
-		if (!isLeftClick(event)) return;
-		const target = getEventTarget(event);
-		if (target?.hasAttribute("data-no-drag") || target?.closest("[data-no-drag]")) return;
-		if (state.matches("closing")) return;
-		send({
-			type: "POINTER_DOWN",
-			point: getEventPoint(event)
-		});
-	}
-	return {
-		open,
-		dragging,
-		setOpen(nextOpen) {
-			if (state.hasTag("open") === nextOpen) return;
-			send({ type: nextOpen ? "OPEN" : "CLOSE" });
-		},
-		snapPoints: prop("snapPoints"),
-		activeSnapPoint,
-		setActiveSnapPoint(snapPoint) {
-			if (context.get("activeSnapPoint") === snapPoint) return;
-			send({
-				type: "ACTIVE_SNAP_POINT.SET",
-				snapPoint
-			});
-		},
-		getOpenPercentage() {
-			if (!open) return 0;
-			const contentHeight = context.get("contentHeight");
-			if (!contentHeight) return 0;
-			const currentOffset = translate ?? 0;
-			return Math.max(0, Math.min(1, 1 - currentOffset / contentHeight));
-		},
-		getActiveSnapIndex() {
-			return prop("snapPoints").indexOf(activeSnapPoint);
-		},
-		getContentHeight() {
-			return context.get("contentHeight");
-		},
-		getContentProps(props = { draggable: true }) {
-			return normalize.element({
-				...parts.content.attrs,
-				dir: prop("dir"),
-				id: getContentId(scope),
-				tabIndex: -1,
-				role: "dialog",
-				"aria-modal": prop("modal"),
-				"aria-labelledby": getTitleId(scope),
-				hidden: !open,
-				"data-state": open ? "open" : "closed",
-				style: {
-					transform: "translate3d(0, var(--bottom-sheet-translate, 0), 0)",
-					transitionDuration: dragging ? "0s" : void 0,
-					"--bottom-sheet-translate": toPx(translate),
-					willChange: "transform"
-				},
-				onPointerDown(event) {
-					if (!props.draggable) return;
-					onPointerDown(event);
-				}
-			});
-		},
-		getTitleProps() {
-			return normalize.element({
-				...parts.title.attrs,
-				id: getTitleId(scope),
-				dir: prop("dir")
-			});
-		},
-		getTriggerProps() {
-			return normalize.button({
-				...parts.trigger.attrs,
-				id: getTriggerId(scope),
-				type: "button",
-				onClick() {
-					send({ type: open ? "CLOSE" : "OPEN" });
-				}
-			});
-		},
-		getBackdropProps() {
-			return normalize.element({
-				...parts.backdrop.attrs,
-				id: getBackdropId(scope),
-				hidden: !open,
-				"data-state": open ? "open" : "closed",
-				style: { willChange: "opacity" }
-			});
-		},
-		getGrabberProps() {
-			return normalize.element({
-				...parts.grabber.attrs,
-				id: getGrabberId(scope),
-				onPointerDown(event) {
-					onPointerDown(event);
-				},
-				style: { touchAction: "none" }
-			});
-		},
-		getGrabberIndicatorProps() {
-			return normalize.element({
-				...parts.grabberIndicator.attrs,
-				id: getGrabberIndicatorId(scope)
-			});
-		},
-		getCloseTriggerProps() {
-			return normalize.button({
-				...parts.closeTrigger.attrs,
-				id: getCloseTriggerId(scope),
-				onClick() {
-					send({ type: "CLOSE" });
-				}
-			});
-		}
-	};
-}
-//#endregion
-//#region src/machines/bottom-sheet/utils/find-closest-snap-point.ts
-function findClosestSnapPoint(offset, snapPoints) {
-	return snapPoints.reduce((acc, curr) => {
-		const closestDiff = Math.abs(offset - acc.offset);
-		return Math.abs(offset - curr.offset) < closestDiff ? curr : acc;
-	});
-}
-//#endregion
-//#region src/machines/bottom-sheet/utils/get-scroll-info.ts
-function isScrollContainer(element) {
-	const overflow = getComputedStyle(element).overflowY;
-	return overflow === "auto" || overflow === "scroll";
-}
-function getScrollInfo(target, container) {
-	let element = target;
-	let availableScroll = 0;
-	let availableScrollTop = 0;
-	while (element) {
-		const { clientHeight, scrollTop, scrollHeight } = element;
-		const scrolled = scrollHeight - scrollTop - clientHeight;
-		if ((scrollTop !== 0 || scrolled !== 0) && isScrollContainer(element)) {
-			availableScroll += scrolled;
-			availableScrollTop += scrollTop;
-		}
-		if (element === container || element === document.documentElement) break;
-		element = element.parentNode;
-	}
-	return {
-		availableScroll,
-		availableScrollTop
-	};
-}
-//#endregion
-//#region src/machines/bottom-sheet/utils/drag-manager.ts
-const DRAG_START_THRESHOLD = .3;
-var DragManager = class {
-	constructor() {
-		_defineProperty(this, "pointerStart", null);
-		_defineProperty(this, "dragOffset", null);
-		_defineProperty(this, "lastPoint", null);
-		_defineProperty(this, "lastTimestamp", null);
-		_defineProperty(this, "velocity", null);
-	}
-	setPointerStart(point) {
-		this.pointerStart = point;
-	}
-	clearPointerStart() {
-		this.pointerStart = null;
-	}
-	getPointerStart() {
-		return this.pointerStart;
-	}
-	setDragOffset(point, resolvedActiveSnapPointOffset) {
-		if (!this.pointerStart) return;
-		const currentTimestamp = (/* @__PURE__ */ new Date()).getTime();
-		if (this.lastPoint) {
-			const dy = point.y - this.lastPoint.y;
-			if (this.lastTimestamp) {
-				const dt = currentTimestamp - this.lastTimestamp;
-				if (dt > 0) {
-					const calculatedVelocity = dy / dt * 1e3;
-					this.velocity = Number.isFinite(calculatedVelocity) ? calculatedVelocity : 0;
-				}
-			}
-		}
-		this.lastPoint = point;
-		this.lastTimestamp = currentTimestamp;
-		let delta = this.pointerStart.y - point.y - resolvedActiveSnapPointOffset;
-		if (delta > 0) delta = 0;
-		this.dragOffset = -delta;
-	}
-	getDragOffset() {
-		return this.dragOffset;
-	}
-	clearDragOffset() {
-		this.dragOffset = null;
-	}
-	getVelocity() {
-		return this.velocity;
-	}
-	clearVelocityTracking() {
-		this.lastPoint = null;
-		this.lastTimestamp = null;
-		this.velocity = null;
-	}
-	clear() {
-		this.clearPointerStart();
-		this.clearDragOffset();
-		this.clearVelocityTracking();
-	}
-	shouldStartDragging(point, target, container, preventDragOnScroll) {
-		if (!this.pointerStart || !container) return false;
-		if (preventDragOnScroll) {
-			const delta = this.pointerStart.y - point.y;
-			if (Math.abs(delta) < DRAG_START_THRESHOLD) return false;
-			const { availableScroll, availableScrollTop } = getScrollInfo(target, container);
-			if (delta > 0 && Math.abs(availableScroll) > 1 || delta < 0 && Math.abs(availableScrollTop) > 0) return false;
-		}
-		return true;
-	}
-	findClosestSnapPoint(snapPoints) {
-		if (this.dragOffset === null) return snapPoints[0]?.value ?? 1;
-		return findClosestSnapPoint(this.dragOffset, snapPoints).value;
-	}
-	shouldDismiss(contentHeight, snapPoints, swipeVelocityThreshold, closeThreshold) {
-		if (this.dragOffset === null || this.velocity === null || contentHeight === null) return false;
-		const visibleHeight = contentHeight - this.dragOffset;
-		const smallestSnapPoint = snapPoints.reduce((acc, curr) => curr.offset > acc.offset ? curr : acc);
-		const isFastSwipe = this.velocity > 0 && this.velocity >= swipeVelocityThreshold;
-		const closeThresholdInPixels = contentHeight * (1 - closeThreshold);
-		const isBelowSmallestSnapPoint = visibleHeight < contentHeight - smallestSnapPoint.offset;
-		return isFastSwipe || visibleHeight < closeThresholdInPixels && isBelowSmallestSnapPoint || visibleHeight === 0;
-	}
-};
-//#endregion
-//#region src/machines/bottom-sheet/utils/resolve-snap-point.ts
-function resolveSnapPoint(snapPoint, containerHeight) {
-	if (typeof snapPoint === "number") return {
-		value: snapPoint,
-		offset: containerHeight - snapPoint * containerHeight
-	};
-	if (typeof snapPoint === "string") return {
-		value: snapPoint,
-		offset: containerHeight - parseFloat(snapPoint)
-	};
-	throw new Error(`Invalid snap point: ${snapPoint}`);
-}
-//#endregion
-//#region src/machines/bottom-sheet/bottom-sheet.machine.ts
-const machine = createMachine({
-	props({ props, scope }) {
-		const initialFocusEl = props.role === "alertdialog" ? () => getCloseTriggerEl(scope) : void 0;
-		const modal = typeof props.modal === "boolean" ? props.modal : true;
-		return {
-			modal,
-			trapFocus: modal,
-			preventScroll: modal,
-			closeOnInteractOutside: true,
-			closeOnEscape: true,
-			restoreFocus: true,
-			initialFocusEl,
-			snapPoints: [1],
-			defaultActiveSnapPoint: 1,
-			swipeVelocityThreshold: 700,
-			closeThreshold: .25,
-			preventDragOnScroll: true,
-			...props
-		};
-	},
-	context({ bindable, prop }) {
-		return {
-			dragOffset: bindable(() => ({ defaultValue: null })),
-			activeSnapPoint: bindable(() => ({
-				defaultValue: prop("defaultActiveSnapPoint"),
-				value: prop("activeSnapPoint"),
-				onChange(value) {
-					return prop("onActiveSnapPointChange")?.({ snapPoint: value });
-				}
-			})),
-			resolvedActiveSnapPoint: bindable(() => ({ defaultValue: null })),
-			contentHeight: bindable(() => ({ defaultValue: null }))
-		};
-	},
-	refs() {
-		return { dragManager: new DragManager() };
-	},
-	computed: { resolvedSnapPoints({ context, prop }) {
-		const contentHeight = context.get("contentHeight");
-		if (contentHeight === null) return [];
-		return prop("snapPoints").map((snapPoint) => resolveSnapPoint(snapPoint, contentHeight));
-	} },
-	watch({ track, context, prop, action }) {
-		track([() => context.get("activeSnapPoint"), () => context.get("contentHeight")], () => {
-			const activeSnapPoint = context.get("activeSnapPoint");
-			const contentHeight = context.get("contentHeight");
-			if (contentHeight === null) return;
-			const resolvedActiveSnapPoint = resolveSnapPoint(activeSnapPoint, contentHeight);
-			context.set("resolvedActiveSnapPoint", resolvedActiveSnapPoint);
-		});
-		track([() => prop("open")], () => {
-			action(["toggleVisibility"]);
-		});
-	},
-	initialState({ prop }) {
-		return prop("open") || prop("defaultOpen") ? "open" : "closed";
-	},
-	on: { "ACTIVE_SNAP_POINT.SET": { actions: ["setActiveSnapPoint"] } },
-	states: {
-		open: {
-			tags: ["open"],
-			effects: [
-				"trackDismissableElement",
-				"preventScroll",
-				"trapFocus",
-				"hideContentBelow",
-				"trackPointerMove",
-				"trackContentHeight"
-			],
-			on: {
-				"CONTROLLED.CLOSE": { target: "closed" },
-				POINTER_DOWN: { actions: ["setPointerStart"] },
-				POINTER_MOVE: [{
-					guard: "isDragging",
-					actions: ["setDragOffset"]
-				}, {
-					guard: "shouldStartDragging",
-					actions: ["setDragOffset"]
-				}],
-				POINTER_UP: [
-					{
-						guard: "shouldCloseOnSwipe",
-						target: "closing"
-					},
-					{
-						guard: "isDragging",
-						actions: [
-							"setClosestSnapPoint",
-							"clearPointerStart",
-							"clearDragOffset"
-						]
-					},
-					{ actions: ["clearPointerStart", "clearDragOffset"] }
-				],
-				CLOSE: [{
-					guard: "isOpenControlled",
-					actions: ["invokeOnClose"]
-				}, {
-					target: "closing",
-					actions: ["invokeOnClose"]
-				}]
-			}
-		},
-		closing: {
-			effects: ["trackExitAnimation"],
-			on: { ANIMATION_END: {
-				target: "closed",
-				actions: [
-					"invokeOnClose",
-					"clearPointerStart",
-					"clearDragOffset",
-					"clearActiveSnapPoint",
-					"clearResolvedActiveSnapPoint",
-					"clearContentHeight",
-					"clearVelocityTracking"
-				]
-			} }
-		},
-		closed: {
-			tags: ["closed"],
-			on: {
-				"CONTROLLED.OPEN": { target: "open" },
-				OPEN: [{
-					guard: "isOpenControlled",
-					actions: ["invokeOnOpen"]
-				}, {
-					target: "open",
-					actions: ["invokeOnOpen"]
-				}]
-			}
-		}
-	},
-	implementations: {
-		guards: {
-			isOpenControlled: ({ prop }) => prop("open") !== void 0,
-			isDragging({ context }) {
-				return context.get("dragOffset") !== null;
-			},
-			shouldStartDragging({ prop, refs, event, scope }) {
-				return refs.get("dragManager").shouldStartDragging(event.point, event.target, getContentEl(scope), prop("preventDragOnScroll"));
-			},
-			shouldCloseOnSwipe({ prop, context, computed, refs }) {
-				return refs.get("dragManager").shouldDismiss(context.get("contentHeight"), computed("resolvedSnapPoints"), prop("swipeVelocityThreshold"), prop("closeThreshold"));
-			}
-		},
-		actions: {
-			invokeOnOpen({ prop }) {
-				prop("onOpenChange")?.({ open: true });
-			},
-			invokeOnClose({ prop }) {
-				prop("onOpenChange")?.({ open: false });
-			},
-			setActiveSnapPoint({ context, event }) {
-				context.set("activeSnapPoint", event.snapPoint);
-			},
-			setPointerStart({ event, refs }) {
-				refs.get("dragManager").setPointerStart(event.point);
-			},
-			setDragOffset({ context, event, refs }) {
-				const dragManager = refs.get("dragManager");
-				dragManager.setDragOffset(event.point, context.get("resolvedActiveSnapPoint")?.offset || 0);
-				context.set("dragOffset", dragManager.getDragOffset());
-			},
-			setClosestSnapPoint({ computed, context, refs }) {
-				const snapPoints = computed("resolvedSnapPoints");
-				const contentHeight = context.get("contentHeight");
-				if (!snapPoints.length || contentHeight === null) return;
-				const closestSnapPoint = refs.get("dragManager").findClosestSnapPoint(snapPoints);
-				context.set("activeSnapPoint", closestSnapPoint);
-				const resolved = resolveSnapPoint(closestSnapPoint, contentHeight);
-				context.set("resolvedActiveSnapPoint", resolved);
-			},
-			clearDragOffset({ context, refs }) {
-				refs.get("dragManager").clearDragOffset();
-				context.set("dragOffset", null);
-			},
-			clearActiveSnapPoint({ context, prop }) {
-				context.set("activeSnapPoint", prop("defaultActiveSnapPoint"));
-			},
-			clearResolvedActiveSnapPoint({ context }) {
-				context.set("resolvedActiveSnapPoint", null);
-			},
-			clearPointerStart({ refs }) {
-				refs.get("dragManager").clearPointerStart();
-			},
-			clearContentHeight({ context }) {
-				context.set("contentHeight", null);
-			},
-			clearVelocityTracking({ refs }) {
-				refs.get("dragManager").clearVelocityTracking();
-			},
-			toggleVisibility({ event, send, prop }) {
-				send({
-					type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
-					previousEvent: event
-				});
-			}
-		},
-		effects: {
-			trackDismissableElement({ scope, prop, send }) {
-				const getContentEl$1 = () => getContentEl(scope);
-				return trackDismissableElement(getContentEl$1, {
-					defer: true,
-					exclude: [getTriggerEl(scope)],
-					onInteractOutside(event) {
-						prop("onInteractOutside")?.(event);
-						if (!prop("closeOnInteractOutside")) event.preventDefault();
-					},
-					onFocusOutside: prop("onFocusOutside"),
-					onEscapeKeyDown(event) {
-						prop("onEscapeKeyDown")?.(event);
-						if (!prop("closeOnEscape")) event.preventDefault();
-					},
-					onPointerDownOutside: prop("onPointerDownOutside"),
-					onRequestDismiss: prop("onRequestDismiss"),
-					onDismiss() {
-						send({
-							type: "CLOSE",
-							src: "interact-outside"
-						});
-					}
-				});
-			},
-			preventScroll({ scope, prop }) {
-				if (!prop("preventScroll")) return;
-				return preventBodyScroll(scope.getDoc());
-			},
-			trapFocus({ scope, prop }) {
-				if (!prop("trapFocus")) return;
-				const contentEl = () => getContentEl(scope);
-				return trapFocus(contentEl, {
-					preventScroll: true,
-					returnFocusOnDeactivate: !!prop("restoreFocus"),
-					initialFocus: prop("initialFocusEl"),
-					setReturnFocus: (el) => prop("finalFocusEl")?.() || el,
-					getShadowRoot: true
-				});
-			},
-			hideContentBelow({ scope, prop }) {
-				if (!prop("modal")) return;
-				const getElements = () => [getContentEl(scope)];
-				return ariaHidden(getElements, { defer: true });
-			},
-			trackPointerMove({ scope, send, prop }) {
-				let lastY = 0;
-				function onPointerMove(event) {
-					send({
-						type: "POINTER_MOVE",
-						point: getEventPoint(event),
-						target: getEventTarget(event)
-					});
-				}
-				function onPointerUp(event) {
-					if (event.pointerType === "touch") return;
-					send({
-						type: "POINTER_UP",
-						point: getEventPoint(event)
-					});
-				}
-				function onTouchStart(event) {
-					if (!event.touches[0]) return;
-					lastY = event.touches[0].clientY;
-				}
-				function onTouchMove(event) {
-					if (!event.touches[0]) return;
-					const point = getEventPoint(event);
-					const target = event.target;
-					if (!prop("preventDragOnScroll")) {
-						send({
-							type: "POINTER_MOVE",
-							point,
-							target
-						});
-						return;
-					}
-					const contentEl = getContentEl(scope);
-					if (!contentEl) return;
-					let el = target;
-					while (el && el !== contentEl && el.scrollHeight <= el.clientHeight) el = el.parentElement;
-					if (el && el !== contentEl) {
-						const scrollTop = el.scrollTop;
-						const y = event.touches[0].clientY;
-						if (scrollTop <= 0 && y > lastY) event.preventDefault();
-						lastY = y;
-					}
-					send({
-						type: "POINTER_MOVE",
-						point,
-						target
-					});
-				}
-				function onTouchEnd(event) {
-					if (event.touches.length !== 0) return;
-					send({
-						type: "POINTER_UP",
-						point: getEventPoint(event)
-					});
-				}
-				const doc = scope.getDoc();
-				const cleanups = [
-					addDomEvent(doc, "pointermove", onPointerMove),
-					addDomEvent(doc, "pointerup", onPointerUp),
-					addDomEvent(doc, "touchstart", onTouchStart, { passive: false }),
-					addDomEvent(doc, "touchmove", onTouchMove, { passive: false }),
-					addDomEvent(doc, "touchend", onTouchEnd)
-				];
-				return () => {
-					cleanups.forEach((cleanup) => cleanup());
-				};
-			},
-			trackContentHeight({ context, scope }) {
-				const contentEl = getContentEl(scope);
-				if (!contentEl) return;
-				const updateHeight = () => {
-					const rect = contentEl.getBoundingClientRect();
-					context.set("contentHeight", rect.height);
-				};
-				updateHeight();
-				return resizeObserverBorderBox.observe(contentEl, updateHeight);
-			},
-			trackExitAnimation({ send, scope }) {
-				let cleanup;
-				const rafCleanup = raf(() => {
-					const contentEl = getContentEl(scope);
-					if (!contentEl) return;
-					const animationName = getComputedStyle(contentEl).animationName;
-					if (!animationName || animationName === "none") {
-						send({ type: "ANIMATION_END" });
-						return;
-					}
-					const onEnd = (event) => {
-						if (getEventTarget(event) === contentEl) send({ type: "ANIMATION_END" });
-					};
-					contentEl.addEventListener("animationend", onEnd);
-					cleanup = () => {
-						contentEl.removeEventListener("animationend", onEnd);
-					};
-				});
-				return () => {
-					rafCleanup();
-					cleanup?.();
-				};
-			}
-		}
-	}
-});
-//#endregion
-//#region src/machines/bottom-sheet/bottom-sheet.props.ts
-const props = createProps()([
-	"id",
-	"ids",
-	"dir",
-	"modal",
-	"initialFocusEl",
-	"finalFocusEl",
-	"open",
-	"defaultOpen",
-	"getRootNode",
-	"snapPoints",
-	"swipeVelocityThreshold",
-	"closeThreshold",
-	"preventDragOnScroll",
-	"closeOnEscape",
-	"closeOnInteractOutside",
-	"onEscapeKeyDown",
-	"onFocusOutside",
-	"onInteractOutside",
-	"onOpenChange",
-	"onPointerDownOutside",
-	"onRequestDismiss",
-	"preventScroll",
-	"restoreFocus",
-	"role",
-	"trapFocus",
-	"defaultActiveSnapPoint",
-	"activeSnapPoint",
-	"onActiveSnapPointChange"
-]);
-const splitProps = createSplitProps(props);
-//#endregion
-export { anatomy, connect, machine, props, splitProps };