@monimesl/dot-renderer-react 0.1.0-alpha.10

package/dist/vendor/@base-ui/react/floating-ui-react/components/FloatingRootStore.js

@@ -0,0 +1,65 @@
+import { isClickLikeEvent } from "../utils/event.js";
+import { createEventEmitter } from "../utils/createEventEmitter.js";
+import { ReactStore } from "../../../utils/store/ReactStore.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/components/FloatingRootStore.mjs
+const selectors = {
+	open: (state) => state.open,
+	transitionStatus: (state) => state.transitionStatus,
+	domReferenceElement: (state) => state.domReferenceElement,
+	referenceElement: (state) => state.positionReference ?? state.referenceElement,
+	floatingElement: (state) => state.floatingElement,
+	floatingId: (state) => state.floatingId
+};
+var FloatingRootStore = class extends ReactStore {
+	constructor(options) {
+		const { syncOnly, nested, onOpenChange, triggerElements, ...initialState } = options;
+		super({
+			...initialState,
+			positionReference: initialState.referenceElement,
+			domReferenceElement: initialState.referenceElement
+		}, {
+			onOpenChange,
+			dataRef: { current: {} },
+			events: createEventEmitter(),
+			nested,
+			triggerElements
+		}, selectors);
+		this.syncOnly = syncOnly;
+	}
+	/**
+	* Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
+	*/
+	syncOpenEvent = (newOpen, event) => {
+		if (!newOpen || !this.state.open || event != null && isClickLikeEvent(event)) this.context.dataRef.current.openEvent = newOpen ? event : void 0;
+	};
+	/**
+	* Runs the root-owned side effects for an open state change.
+	*/
+	dispatchOpenChange = (newOpen, eventDetails) => {
+		this.syncOpenEvent(newOpen, eventDetails.event);
+		const details = {
+			open: newOpen,
+			reason: eventDetails.reason,
+			nativeEvent: eventDetails.event,
+			nested: this.context.nested,
+			triggerElement: eventDetails.trigger
+		};
+		this.context.events.emit("openchange", details);
+	};
+	/**
+	* Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
+	*
+	* @param newOpen The new open state.
+	* @param eventDetails Details about the event that triggered the open state change.
+	*/
+	setOpen = (newOpen, eventDetails) => {
+		if (this.syncOnly) {
+			this.context.onOpenChange?.(newOpen, eventDetails);
+			return;
+		}
+		this.dispatchOpenChange(newOpen, eventDetails);
+		this.context.onOpenChange?.(newOpen, eventDetails);
+	};
+};
+//#endregion
+export { FloatingRootStore };

package/dist/vendor/@base-ui/react/floating-ui-react/components/FloatingTree.js

@@ -0,0 +1,22 @@
+"use client";
+import * as React from "react";
+import "react/jsx-runtime";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/components/FloatingTree.mjs
+const FloatingNodeContext = /*#__PURE__*/ React.createContext(null);
+if (process.env.NODE_ENV !== "production") FloatingNodeContext.displayName = "FloatingNodeContext";
+const FloatingTreeContext = /*#__PURE__*/ React.createContext(null);
+/**
+* Returns the parent node id for nested floating elements, if available.
+* Returns `null` for top-level floating elements.
+*/
+if (process.env.NODE_ENV !== "production") FloatingTreeContext.displayName = "FloatingTreeContext";
+const useFloatingParentNodeId = () => React.useContext(FloatingNodeContext)?.id || null;
+/**
+* Returns the nearest floating tree context, if available.
+*/
+const useFloatingTree = (externalTree) => {
+	const contextTree = React.useContext(FloatingTreeContext);
+	return externalTree ?? contextTree;
+};
+//#endregion
+export { useFloatingParentNodeId, useFloatingTree };

package/dist/vendor/@base-ui/react/floating-ui-react/hooks/useDismiss.js

@@ -0,0 +1,373 @@
+"use client";
+import { getComputedStyle, getParentNode, isElement, isHTMLElement, isLastTraversableNode, isShadowRoot } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { ownerDocument } from "../../../utils/owner.js";
+import { escapeKey, outsidePress, triggerPress } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { Timeout, useTimeout } from "../../../utils/useTimeout.js";
+import { webkit } from "../../../utils/platform/engine.js";
+import { isReactEvent, isVirtualClick } from "../utils/event.js";
+import { contains, getTarget } from "../../../utils/shadowDom.js";
+import { isEventTargetWithin, isRootElement } from "../utils/element.js";
+import { addEventListener } from "../../../utils/addEventListener.js";
+import { mergeCleanups } from "../../../utils/mergeCleanups.js";
+import { getNodeChildren } from "../utils/nodes.js";
+import { createAttribute } from "../utils/createAttribute.js";
+import { useFloatingTree } from "../components/FloatingTree.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/hooks/useDismiss.mjs
+function alwaysFalse() {
+	return false;
+}
+function normalizeProp(normalizable) {
+	return {
+		escapeKey: typeof normalizable === "boolean" ? normalizable : normalizable?.escapeKey ?? false,
+		outsidePress: typeof normalizable === "boolean" ? normalizable : normalizable?.outsidePress ?? true
+	};
+}
+/**
+* Closes the floating element when a dismissal is requested — by default, when
+* the user presses the `escape` key or outside of the floating element.
+* @see https://floating-ui.com/docs/useDismiss
+*/
+function useDismiss(context, props = {}) {
+	const { enabled = true, escapeKey: escapeKey$1 = true, outsidePress: outsidePressProp = true, outsidePressEvent = "sloppy", referencePress = alwaysFalse, bubbles, externalTree } = props;
+	const store = "rootStore" in context ? context.rootStore : context;
+	const open = store.useState("open");
+	const floatingElement = store.useState("floatingElement");
+	const { dataRef, events } = store.context;
+	const tree = useFloatingTree(externalTree);
+	const outsidePressFn = useStableCallback(typeof outsidePressProp === "function" ? outsidePressProp : () => false);
+	const outsidePress$1 = typeof outsidePressProp === "function" ? outsidePressFn : outsidePressProp;
+	const outsidePressEnabled = outsidePress$1 !== false;
+	const getOutsidePressEventProp = useStableCallback(() => outsidePressEvent);
+	const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = normalizeProp(bubbles);
+	const pressStartedInsideRef = React.useRef(false);
+	const pressStartPreventedRef = React.useRef(false);
+	const suppressNextOutsideClickRef = React.useRef(false);
+	const sawPressWhileOpenRef = React.useRef(false);
+	const isComposingRef = React.useRef(false);
+	const currentPointerTypeRef = React.useRef("");
+	const touchStateRef = React.useRef(null);
+	const cancelDismissOnEndTimeout = useTimeout();
+	const clearInsideReactTreeTimeout = useTimeout();
+	const clearInsideReactTree = useStableCallback(() => {
+		clearInsideReactTreeTimeout.clear();
+		dataRef.current.insideReactTree = false;
+	});
+	const hasBlockingChild = useStableCallback((bubbleKey) => {
+		const nodeId = dataRef.current.floatingContext?.nodeId;
+		return (tree ? getNodeChildren(tree.nodesRef.current, nodeId) : []).some((child) => child.context?.open && !child.context.dataRef.current[bubbleKey]);
+	});
+	const isEventWithinOwnElements = useStableCallback((event) => {
+		return isEventTargetWithin(event, store.select("floatingElement")) || isEventTargetWithin(event, store.select("domReferenceElement"));
+	});
+	const closeOnReferencePress = useStableCallback((event) => {
+		if (!referencePress()) return;
+		store.setOpen(false, createChangeEventDetails(triggerPress, event.nativeEvent));
+	});
+	const closeOnEscapeKeyDown = useStableCallback((event) => {
+		if (!open || !enabled || !escapeKey$1 || event.key !== "Escape") return;
+		if (isComposingRef.current) return;
+		if (!escapeKeyBubbles && hasBlockingChild("__escapeKeyBubbles")) return;
+		const native = isReactEvent(event) ? event.nativeEvent : event;
+		const eventDetails = createChangeEventDetails(escapeKey, native);
+		store.setOpen(false, eventDetails);
+		if (!eventDetails.isCanceled) event.preventDefault();
+		if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) event.stopPropagation();
+	});
+	const markInsideReactTree = useStableCallback(() => {
+		dataRef.current.insideReactTree = true;
+		clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
+	});
+	const markPressStartedInsideReactTree = useStableCallback((event) => {
+		if (!open || !enabled || event.button !== 0) return;
+		const target = getTarget(event.nativeEvent);
+		if (!contains(store.select("floatingElement"), target)) return;
+		if (!pressStartedInsideRef.current) {
+			pressStartedInsideRef.current = true;
+			pressStartPreventedRef.current = false;
+		}
+	});
+	const markInsidePressStartPrevented = useStableCallback((event) => {
+		if (!open || !enabled) return;
+		if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) return;
+		if (pressStartedInsideRef.current) pressStartPreventedRef.current = true;
+	});
+	React.useEffect(() => {
+		function handleOpenChange(details) {
+			if (!details.open) sawPressWhileOpenRef.current = false;
+		}
+		events.on("openchange", handleOpenChange);
+		return () => {
+			events.off("openchange", handleOpenChange);
+		};
+	}, [events]);
+	React.useEffect(() => {
+		if (!open || !enabled) {
+			if (!open) sawPressWhileOpenRef.current = false;
+			return clearInsideReactTree;
+		}
+		dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+		dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+		const compositionTimeout = new Timeout();
+		const preventedPressSuppressionTimeout = new Timeout();
+		const doc = ownerDocument(floatingElement);
+		function handleCompositionStart() {
+			compositionTimeout.clear();
+			isComposingRef.current = true;
+		}
+		function handleCompositionEnd() {
+			compositionTimeout.start(webkit ? 5 : 0, () => {
+				isComposingRef.current = false;
+			});
+		}
+		function suppressImmediateOutsideClickAfterPreventedStart() {
+			suppressNextOutsideClickRef.current = true;
+			preventedPressSuppressionTimeout.start(0, () => {
+				suppressNextOutsideClickRef.current = false;
+			});
+		}
+		function resetPressStartState() {
+			pressStartedInsideRef.current = false;
+			pressStartPreventedRef.current = false;
+		}
+		function getOutsidePressEvent() {
+			const type = currentPointerTypeRef.current;
+			const computedType = type === "pen" || !type ? "mouse" : type;
+			const outsidePressEventValue = getOutsidePressEventProp();
+			const resolved = typeof outsidePressEventValue === "function" ? outsidePressEventValue() : outsidePressEventValue;
+			if (typeof resolved === "string") return resolved;
+			return resolved[computedType];
+		}
+		function shouldIgnoreEvent(event) {
+			const computedOutsidePressEvent = getOutsidePressEvent();
+			return computedOutsidePressEvent === "intentional" && event.type !== "click" || computedOutsidePressEvent === "sloppy" && event.type === "click";
+		}
+		function isEventWithinFloatingTree(event) {
+			const nodeId = dataRef.current.floatingContext?.nodeId;
+			const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => isEventTargetWithin(event, node.context?.elements.floating));
+			return isEventWithinOwnElements(event) || targetIsInsideChildren;
+		}
+		function closeOnPressOutside(event) {
+			if (shouldIgnoreEvent(event)) {
+				if (event.type !== "click" && !isEventWithinOwnElements(event)) {
+					preventedPressSuppressionTimeout.clear();
+					suppressNextOutsideClickRef.current = false;
+				}
+				clearInsideReactTree();
+				return;
+			}
+			if (dataRef.current.insideReactTree) {
+				clearInsideReactTree();
+				return;
+			}
+			const target = getTarget(event);
+			const inertSelector = `[${createAttribute("inert")}]`;
+			const targetRoot = isElement(target) ? target.getRootNode() : null;
+			const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select("floatingElement"))).querySelectorAll(inertSelector));
+			const triggers = store.context.triggerElements;
+			if (target && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger) => contains(trigger, target)))) return;
+			let targetRootAncestor = isElement(target) ? target : null;
+			while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+				const nextParent = getParentNode(targetRootAncestor);
+				if (isLastTraversableNode(nextParent) || !isElement(nextParent)) break;
+				targetRootAncestor = nextParent;
+			}
+			if (markers.length && isElement(target) && !isRootElement(target) && !contains(target, store.select("floatingElement")) && markers.every((marker) => !contains(targetRootAncestor, marker))) return;
+			if (isHTMLElement(target) && !("touches" in event)) {
+				const lastTraversableNode = isLastTraversableNode(target);
+				const style = getComputedStyle(target);
+				const scrollRe = /auto|scroll/;
+				const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
+				const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
+				const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
+				const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
+				const isRTL = style.direction === "rtl";
+				const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
+				const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
+				if (pressedVerticalScrollbar || pressedHorizontalScrollbar) return;
+			}
+			if (isEventWithinFloatingTree(event)) return;
+			if (getOutsidePressEvent() === "intentional") {
+				if (event.detail !== 0 && !isVirtualClick(event) && !sawPressWhileOpenRef.current) return;
+				if (suppressNextOutsideClickRef.current) {
+					preventedPressSuppressionTimeout.clear();
+					suppressNextOutsideClickRef.current = false;
+					return;
+				}
+			}
+			if (typeof outsidePress$1 === "function" && !outsidePress$1(event)) return;
+			if (hasBlockingChild("__outsidePressBubbles")) return;
+			store.setOpen(false, createChangeEventDetails(outsidePress, event));
+			clearInsideReactTree();
+		}
+		function handlePointerDown(event) {
+			if (getOutsidePressEvent() !== "sloppy" || event.pointerType === "touch" || !store.select("open") || !enabled || isEventWithinOwnElements(event)) return;
+			closeOnPressOutside(event);
+		}
+		function handleTouchStart(event) {
+			if (getOutsidePressEvent() !== "sloppy" || !store.select("open") || !enabled || isEventWithinOwnElements(event)) return;
+			const touch = event.touches[0];
+			if (touch) {
+				touchStateRef.current = {
+					startTime: Date.now(),
+					startX: touch.clientX,
+					startY: touch.clientY,
+					dismissOnTouchEnd: false,
+					dismissOnMouseDown: true
+				};
+				cancelDismissOnEndTimeout.start(1e3, () => {
+					if (touchStateRef.current) {
+						touchStateRef.current.dismissOnTouchEnd = false;
+						touchStateRef.current.dismissOnMouseDown = false;
+					}
+				});
+			}
+		}
+		function addTargetEventListenerOnce(event, listener) {
+			const target = getTarget(event);
+			if (!target) return;
+			const unsubscribe = addEventListener(target, event.type, () => {
+				listener(event);
+				unsubscribe();
+			});
+		}
+		function handleTouchStartCapture(event) {
+			currentPointerTypeRef.current = "touch";
+			addTargetEventListenerOnce(event, handleTouchStart);
+		}
+		function closeOnPressOutsideCapture(event) {
+			cancelDismissOnEndTimeout.clear();
+			if (event.type === "pointerdown") {
+				if (event.button === 0) sawPressWhileOpenRef.current = true;
+				currentPointerTypeRef.current = event.pointerType;
+			}
+			if (event.type === "mousedown" && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) return;
+			addTargetEventListenerOnce(event, (targetEvent) => {
+				if (targetEvent.type === "pointerdown") handlePointerDown(targetEvent);
+				else closeOnPressOutside(targetEvent);
+			});
+		}
+		function handlePressEndCapture(event) {
+			if (event.type === "pointercancel") sawPressWhileOpenRef.current = false;
+			if (!pressStartedInsideRef.current) return;
+			const pressStartedInsideDefaultPrevented = pressStartPreventedRef.current;
+			resetPressStartState();
+			if (getOutsidePressEvent() !== "intentional") return;
+			if (event.type === "pointercancel") {
+				if (pressStartedInsideDefaultPrevented) suppressImmediateOutsideClickAfterPreventedStart();
+				return;
+			}
+			if (isEventWithinFloatingTree(event)) return;
+			if (pressStartedInsideDefaultPrevented) {
+				suppressImmediateOutsideClickAfterPreventedStart();
+				return;
+			}
+			if (typeof outsidePress$1 === "function" && !outsidePress$1(event)) return;
+			preventedPressSuppressionTimeout.clear();
+			suppressNextOutsideClickRef.current = true;
+			clearInsideReactTree();
+		}
+		function handleTouchMove(event) {
+			if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) return;
+			const touch = event.touches[0];
+			if (!touch) return;
+			const deltaX = Math.abs(touch.clientX - touchStateRef.current.startX);
+			const deltaY = Math.abs(touch.clientY - touchStateRef.current.startY);
+			const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+			if (distance > 5) touchStateRef.current.dismissOnTouchEnd = true;
+			if (distance > 10) {
+				closeOnPressOutside(event);
+				cancelDismissOnEndTimeout.clear();
+				touchStateRef.current = null;
+			}
+		}
+		function handleTouchMoveCapture(event) {
+			addTargetEventListenerOnce(event, handleTouchMove);
+		}
+		function handleTouchEnd(event) {
+			if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) return;
+			if (touchStateRef.current.dismissOnTouchEnd) closeOnPressOutside(event);
+			cancelDismissOnEndTimeout.clear();
+			touchStateRef.current = null;
+		}
+		function handleTouchEndCapture(event) {
+			addTargetEventListenerOnce(event, handleTouchEnd);
+		}
+		const unsubscribe = mergeCleanups(escapeKey$1 && mergeCleanups(addEventListener(doc, "keydown", closeOnEscapeKeyDown), addEventListener(doc, "compositionstart", handleCompositionStart), addEventListener(doc, "compositionend", handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, "click", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerdown", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerup", handlePressEndCapture, true), addEventListener(doc, "pointercancel", handlePressEndCapture, true), addEventListener(doc, "mousedown", closeOnPressOutsideCapture, true), addEventListener(doc, "mouseup", handlePressEndCapture, true), addEventListener(doc, "touchstart", handleTouchStartCapture, {
+			capture: true,
+			passive: true
+		}), addEventListener(doc, "touchmove", handleTouchMoveCapture, {
+			capture: true,
+			passive: true
+		}), addEventListener(doc, "touchend", handleTouchEndCapture, {
+			capture: true,
+			passive: true
+		})));
+		return () => {
+			unsubscribe();
+			compositionTimeout.clear();
+			preventedPressSuppressionTimeout.clear();
+			resetPressStartState();
+			suppressNextOutsideClickRef.current = false;
+			clearInsideReactTree();
+		};
+	}, [
+		dataRef,
+		floatingElement,
+		escapeKey$1,
+		outsidePressEnabled,
+		outsidePress$1,
+		open,
+		enabled,
+		escapeKeyBubbles,
+		outsidePressBubbles,
+		closeOnEscapeKeyDown,
+		clearInsideReactTree,
+		getOutsidePressEventProp,
+		hasBlockingChild,
+		isEventWithinOwnElements,
+		tree,
+		store,
+		cancelDismissOnEndTimeout
+	]);
+	const reference = React.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		onPointerDown: closeOnReferencePress,
+		onClick: closeOnReferencePress
+	}), [closeOnEscapeKeyDown, closeOnReferencePress]);
+	const floating = React.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		onPointerDown: markInsidePressStartPrevented,
+		onMouseDown: markInsidePressStartPrevented,
+		onClickCapture: markInsideReactTree,
+		onMouseDownCapture(event) {
+			markInsideReactTree();
+			markPressStartedInsideReactTree(event);
+		},
+		onPointerDownCapture(event) {
+			markInsideReactTree();
+			markPressStartedInsideReactTree(event);
+		},
+		onMouseUpCapture: markInsideReactTree,
+		onTouchEndCapture: markInsideReactTree,
+		onTouchMoveCapture: markInsideReactTree
+	}), [
+		closeOnEscapeKeyDown,
+		markInsideReactTree,
+		markPressStartedInsideReactTree,
+		markInsidePressStartPrevented
+	]);
+	return React.useMemo(() => enabled ? {
+		reference,
+		floating,
+		trigger: reference
+	} : {}, [
+		enabled,
+		reference,
+		floating
+	]);
+}
+//#endregion
+export { normalizeProp, useDismiss };

package/dist/vendor/@base-ui/react/floating-ui-react/hooks/useSyncedFloatingRootContext.js

@@ -0,0 +1,58 @@
+"use client";
+import { isElement } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { FloatingRootStore } from "../components/FloatingRootStore.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/hooks/useSyncedFloatingRootContext.mjs
+/**
+* Narrowed to the store members this hook uses so consumers do not need to provide
+* unrelated store capabilities.
+*/
+/**
+* Keeps a FloatingRootStore in sync with the provided PopupStore.
+* Uses the provided FloatingRootStore when one exists, otherwise creates one once and updates it on every render.
+*/
+function useSyncedFloatingRootContext(options) {
+	const { popupStore, treatPopupAsFloatingElement = false, floatingRootContext: floatingRootContextProp, floatingId, nested, onOpenChange } = options;
+	const open = popupStore.useState("open");
+	const referenceElement = popupStore.useState("activeTriggerElement");
+	const floatingElement = popupStore.useState(treatPopupAsFloatingElement ? "popupElement" : "positionerElement");
+	const triggerElements = popupStore.context.triggerElements;
+	const handleOpenChange = onOpenChange;
+	const internalStoreRef = React.useRef(null);
+	if (floatingRootContextProp === void 0 && internalStoreRef.current === null) internalStoreRef.current = new FloatingRootStore({
+		open,
+		transitionStatus: void 0,
+		referenceElement,
+		floatingElement,
+		triggerElements,
+		onOpenChange: handleOpenChange,
+		floatingId,
+		syncOnly: true,
+		nested
+	});
+	const store = floatingRootContextProp ?? internalStoreRef.current;
+	popupStore.useSyncedValue("floatingId", floatingId);
+	useIsoLayoutEffect(() => {
+		const valuesToSync = {
+			open,
+			floatingId,
+			referenceElement,
+			floatingElement
+		};
+		if (isElement(referenceElement)) valuesToSync.domReferenceElement = referenceElement;
+		if (store.state.positionReference === store.state.referenceElement) valuesToSync.positionReference = referenceElement;
+		store.update(valuesToSync);
+	}, [
+		open,
+		floatingId,
+		referenceElement,
+		floatingElement,
+		store
+	]);
+	store.context.onOpenChange = handleOpenChange;
+	store.context.nested = nested;
+	return store;
+}
+//#endregion
+export { useSyncedFloatingRootContext };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/composite.js

@@ -0,0 +1,40 @@
+import { getComputedStyle } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/composite.mjs
+function isIndexOutOfListBounds(list, index) {
+	return index < 0 || index >= list.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef.current, { disabledIndices });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef.current, {
+		decrement: true,
+		startingIndex: listRef.current.length,
+		disabledIndices
+	});
+}
+function findNonDisabledListIndex(list, { startingIndex = -1, decrement = false, disabledIndices, amount = 1 } = {}) {
+	let index = startingIndex;
+	do
+		index += decrement ? -amount : amount;
+	while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
+	return index;
+}
+function isListIndexDisabled(list, index, disabledIndices) {
+	if (typeof disabledIndices === "function" ? disabledIndices(index) : disabledIndices?.includes(index) ?? false) return true;
+	const element = list[index];
+	if (!element) return false;
+	if (!isElementVisible(element)) return true;
+	if (element.matches(":disabled")) return true;
+	return !disabledIndices && (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true");
+}
+function isHiddenByStyles(styles) {
+	return styles.visibility === "hidden" || styles.visibility === "collapse";
+}
+function isElementVisible(element, styles = element ? getComputedStyle(element) : null) {
+	if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) return false;
+	if (typeof element.checkVisibility === "function") return element.checkVisibility();
+	return styles.display !== "none" && styles.display !== "contents";
+}
+//#endregion
+export { findNonDisabledListIndex, getMaxListIndex, getMinListIndex, isElementVisible, isHiddenByStyles, isIndexOutOfListBounds, isListIndexDisabled };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/constants.js

@@ -0,0 +1,5 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/constants.mjs
+const FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+//#endregion
+export { FOCUSABLE_ATTRIBUTE, TYPEABLE_SELECTOR };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/createAttribute.js

@@ -0,0 +1,6 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/createAttribute.mjs
+function createAttribute(name) {
+	return `data-base-ui-${name}`;
+}
+//#endregion
+export { createAttribute };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/createEventEmitter.js

@@ -0,0 +1,18 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/createEventEmitter.mjs
+function createEventEmitter() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		emit(event, data) {
+			map.get(event)?.forEach((listener) => listener(data));
+		},
+		on(event, listener) {
+			if (!map.has(event)) map.set(event, /* @__PURE__ */ new Set());
+			map.get(event).add(listener);
+		},
+		off(event, listener) {
+			map.get(event)?.delete(listener);
+		}
+	};
+}
+//#endregion
+export { createEventEmitter };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/element.js

@@ -0,0 +1,26 @@
+import { isHTMLElement } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { activeElement, contains, getTarget } from "../../../utils/shadowDom.js";
+import "./constants.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/element.mjs
+function isEventTargetWithin(event, node) {
+	if (node == null) return false;
+	if ("composedPath" in event) return event.composedPath().includes(node);
+	const eventAgain = event;
+	return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+	return element.matches("html,body");
+}
+function isTypeableElement(element) {
+	return isHTMLElement(element) && element.matches("input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])");
+}
+function isTypeableCombobox(element) {
+	if (!element) return false;
+	return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function getFloatingFocusElement(floatingElement) {
+	if (!floatingElement) return null;
+	return floatingElement.hasAttribute("data-base-ui-focusable") ? floatingElement : floatingElement.querySelector(`[data-base-ui-focusable]`) || floatingElement;
+}
+//#endregion
+export { activeElement, contains, getFloatingFocusElement, getTarget, isEventTargetWithin, isRootElement, isTypeableCombobox, isTypeableElement };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/enqueueFocus.js

@@ -0,0 +1,25 @@
+import { NOOP } from "../../../utils/empty.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/enqueueFocus.mjs
+let rafId = 0;
+function enqueueFocus(el, options = {}) {
+	const { preventScroll = false, sync = false, shouldFocus } = options;
+	cancelAnimationFrame(rafId);
+	function exec() {
+		if (shouldFocus && !shouldFocus()) return;
+		el?.focus({ preventScroll });
+	}
+	if (sync) {
+		exec();
+		return NOOP;
+	}
+	const currentRafId = requestAnimationFrame(exec);
+	rafId = currentRafId;
+	return () => {
+		if (rafId === currentRafId) {
+			cancelAnimationFrame(currentRafId);
+			rafId = 0;
+		}
+	};
+}
+//#endregion
+export { enqueueFocus };