@monimesl/dot-renderer-react 0.1.0-alpha.7 → 0.1.0-alpha.9

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

@@ -0,0 +1,22 @@
+import { transitionStatusMapping } from "../internals/stateAttributesMapping.js";
+import { anchorHidden, closed, open } from "./CommonPopupDataAttributes.js";
+import "./CommonTriggerDataAttributes.js";
+const POPUP_OPEN_HOOK = { [open]: "" };
+const POPUP_CLOSED_HOOK = { [closed]: "" };
+const ANCHOR_HIDDEN_HOOK = { [anchorHidden]: "" };
+const popupStateMapping = {
+	open(value) {
+		if (value) return POPUP_OPEN_HOOK;
+		return POPUP_CLOSED_HOOK;
+	},
+	anchorHidden(value) {
+		if (value) return ANCHOR_HIDDEN_HOOK;
+		return null;
+	}
+};
+const popupTransitionStateMapping = {
+	...popupStateMapping,
+	...transitionStatusMapping
+};
+//#endregion
+export { popupStateMapping, popupTransitionStateMapping };

package/dist/vendor/@base-ui/react/utils/popups/popupStoreUtils.js

@@ -0,0 +1,247 @@
+"use client";
+import { useRefWithInit } from "../../../utils/useRefWithInit.js";
+import { EMPTY_OBJECT } from "../../../utils/empty.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { none } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { useId as useId$1 } from "../../../utils/useId.js";
+import { FOCUSABLE_ATTRIBUTE } from "../../floating-ui-react/utils/constants.js";
+import { useFloatingParentNodeId } from "../../floating-ui-react/components/FloatingTree.js";
+import { useSyncedFloatingRootContext } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { useTransitionStatus } from "../../internals/useTransitionStatus.js";
+import { useOpenChangeComplete } from "../../internals/useOpenChangeComplete.js";
+import * as React from "react";
+import "react-dom";
+//#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/utils/popups/popupStoreUtils.mjs
+const FOCUSABLE_POPUP_PROPS = {
+	tabIndex: -1,
+	[FOCUSABLE_ATTRIBUTE]: ""
+};
+/**
+* Returns the default `initialFocus` resolver for a popup. When opened by touch it focuses the
+* popup element itself to prevent the virtual keyboard from opening (required for Android
+* specifically; iOS handles this automatically). Otherwise it falls back to the default behavior.
+*/
+function createDefaultInitialFocus(popupRef) {
+	return (interactionType) => interactionType === "touch" ? popupRef.current : true;
+}
+/**
+* The subset of a popup handle that a Root needs to bind its store to. Both the real handle classes
+* and any test double satisfy it.
+*/
+/**
+* Creates and owns a popup store on behalf of a Root part. The store is created exactly once, with
+* controlled props and root state synced separately after creation. Sets up the synced floating
+* root context and returns the store.
+*
+* @param createStore Factory that builds the store. Called exactly once, receiving the floating id
+* and whether the popup is nested inside another floating element, both resolved on the first render.
+* @param treatPopupAsFloatingElement Whether the popup element is passed to Floating UI as the
+* floating element instead of the default positioner.
+*/
+function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
+	const floatingId = useId$1();
+	const nested = useFloatingParentNodeId() != null;
+	const store = useRefWithInit(() => createStore(floatingId, nested)).current;
+	useSyncedFloatingRootContext({
+		popupStore: store,
+		treatPopupAsFloatingElement,
+		floatingRootContext: store.state.floatingRootContext,
+		floatingId,
+		nested,
+		onOpenChange: store.setOpen
+	});
+	return store;
+}
+/**
+* Attaches a Root's store to a handle for this component's committed lifetime. Popup Roots render
+* it before their interactions and user children so its layout effect runs before descendant layout
+* effects. This lets descendants call the handle during the Root's initial commit without attaching
+* during render, which would leak suspended or abandoned stores. Store subscribers are notified by
+* `attachStore` in this ordinary layout phase, where React permits synchronous updates.
+*
+* Popup Roots must render this component only when a handle is present so handle-less Roots avoid
+* mounting an extra fiber and layout effect.
+*/
+function PopupHandleAttachment({ handle, store }) {
+	useIsoLayoutEffect(() => {
+		return handle.attachStore(store);
+	}, [handle, store]);
+	return null;
+}
+function createPopupOpenState(state, open, trigger, preventUnmountOnClose = false) {
+	let preventUnmountingOnClose = state.preventUnmountingOnClose;
+	if (open) preventUnmountingOnClose = false;
+	else if (preventUnmountOnClose) preventUnmountingOnClose = true;
+	const triggerId = trigger?.id ?? null;
+	let activeTriggerId = state.activeTriggerId;
+	let activeTriggerElement = state.activeTriggerElement;
+	if (triggerId || open) {
+		activeTriggerId = triggerId;
+		activeTriggerElement = trigger ?? null;
+	}
+	return {
+		open,
+		preventUnmountingOnClose,
+		activeTriggerId,
+		activeTriggerElement
+	};
+}
+/**
+* Keeps trigger registration state synchronized while the popup is open.
+*
+* When a popup opens without an explicit trigger id and exactly one trigger is registered, that
+* trigger is claimed as the active trigger. When the active trigger id is still registered but its
+* element changed, the active element is refreshed. When the active trigger id is missing from the
+* registry but the same element is still registered under a different id (e.g. the rendered trigger
+* carries its own DOM `id` that differs from Base UI's internal trigger id), the active id is
+* reassociated to the registered id instead of being treated as lost. When the active trigger
+* unregisters, the default path preserves existing ownership so non-closing popup families do not
+* silently claim a different trigger while staying open.
+*
+* If `closeOnActiveTriggerUnmount` is enabled, unregistering a previously resolved active trigger
+* requests a close after a microtask so a same-tick replacement trigger with the same id can
+* register first. An active trigger id that has not matched a registered trigger yet is treated as
+* pending and does not request a close.
+*
+* This should be called on the Root part.
+*
+* @param store The Store instance managing the popup state.
+* @param options Options for active trigger unmount behavior.
+*/
+function useImplicitActiveTrigger(store, options = {}) {
+	const { closeOnActiveTriggerUnmount = false } = options;
+	const resolvedActiveTriggerIdRef = React.useRef(null);
+	const open = store.useState("open");
+	const reactiveTriggerCount = store.useState("triggerCount");
+	const activeTriggerId = store.useState("activeTriggerId");
+	const reactiveActiveTriggerElement = store.useState("activeTriggerElement");
+	useIsoLayoutEffect(() => {
+		if (!open) {
+			resolvedActiveTriggerIdRef.current = null;
+			if (store.state.triggerCount !== 0) store.set("triggerCount", 0);
+			return;
+		}
+		const triggerCount = store.context.triggerElements.size;
+		const stateUpdates = {};
+		if (store.state.triggerCount !== triggerCount) stateUpdates.triggerCount = triggerCount;
+		const currentActiveTriggerId = store.select("activeTriggerId");
+		let lostActiveTriggerId = null;
+		if (currentActiveTriggerId) {
+			const activeTriggerElement = store.context.triggerElements.getById(currentActiveTriggerId);
+			if (!activeTriggerElement) {
+				for (const [triggerId, triggerElement] of store.context.triggerElements.entries()) if (triggerElement === store.state.activeTriggerElement) {
+					stateUpdates.activeTriggerId = triggerId;
+					stateUpdates.activeTriggerElement = triggerElement;
+					resolvedActiveTriggerIdRef.current = triggerId;
+					break;
+				}
+				if (stateUpdates.activeTriggerId === void 0) {
+					if (resolvedActiveTriggerIdRef.current === currentActiveTriggerId) lostActiveTriggerId = currentActiveTriggerId;
+					else resolvedActiveTriggerIdRef.current = null;
+				}
+			} else {
+				resolvedActiveTriggerIdRef.current = currentActiveTriggerId;
+				if (activeTriggerElement !== store.state.activeTriggerElement) stateUpdates.activeTriggerElement = activeTriggerElement;
+			}
+		} else resolvedActiveTriggerIdRef.current = null;
+		if (!lostActiveTriggerId && !currentActiveTriggerId && triggerCount === 1) {
+			const iteratorResult = store.context.triggerElements.entries().next();
+			if (!iteratorResult.done) {
+				const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
+				stateUpdates.activeTriggerId = implicitTriggerId;
+				stateUpdates.activeTriggerElement = implicitTriggerElement;
+				resolvedActiveTriggerIdRef.current = implicitTriggerId;
+			}
+		}
+		if (stateUpdates.triggerCount !== void 0 || stateUpdates.activeTriggerId !== void 0 || stateUpdates.activeTriggerElement !== void 0) store.update(stateUpdates);
+		if (lostActiveTriggerId) {
+			if (closeOnActiveTriggerUnmount) queueMicrotask(() => {
+				if (store.select("open") && store.select("activeTriggerId") === lostActiveTriggerId && !store.context.triggerElements.getById(lostActiveTriggerId)) {
+					const eventDetails = createChangeEventDetails(none);
+					store.setOpen(false, eventDetails);
+					if (!eventDetails.isCanceled) store.update({
+						activeTriggerId: null,
+						activeTriggerElement: null
+					});
+				}
+			});
+		}
+	}, [
+		open,
+		store,
+		reactiveTriggerCount,
+		activeTriggerId,
+		reactiveActiveTriggerElement,
+		closeOnActiveTriggerUnmount
+	]);
+}
+/**
+* Manages the mounted state of the popup.
+* Sets up the transition status listeners and handles unmounting when needed.
+* Updates the `mounted`, `transitionStatus`, and `preventUnmountingOnClose` states in the store.
+*
+* @param open Whether the popup is open.
+* @param store The Store instance managing the popup state.
+* @param onUnmount Optional callback to be called when the popup is unmounted.
+* @param animateInitialOpen Whether a popup that mounts already open should still play its enter
+*   transition. Defaults to `false`, so content that was open on the first render (a `defaultOpen`
+*   popup on page load, SSR'd markup) appears without animating. Opt in for popups whose subtree
+*   only mounts in response to something the user did, such as a submenu inside a menu popup.
+*
+* @returns A function to forcibly unmount the popup.
+*/
+function useOpenStateTransitions(open, store, onUnmount, animateInitialOpen) {
+	const { mounted, setMounted, transitionStatus } = useTransitionStatus(open, false, false, animateInitialOpen);
+	const preventUnmountingOnClose = store.useState("preventUnmountingOnClose");
+	const syncedPreventUnmountingOnClose = open ? false : preventUnmountingOnClose;
+	store.useSyncedValues({
+		mounted,
+		transitionStatus,
+		preventUnmountingOnClose: syncedPreventUnmountingOnClose
+	});
+	const forceUnmount = useStableCallback(() => {
+		setMounted(false);
+		store.update({
+			activeTriggerId: null,
+			activeTriggerElement: null,
+			mounted: false,
+			preventUnmountingOnClose: false
+		});
+		onUnmount?.();
+		store.context.onOpenChangeComplete?.(false);
+	});
+	useOpenChangeComplete({
+		enabled: mounted && !open && !syncedPreventUnmountingOnClose,
+		open,
+		ref: store.context.popupRef,
+		onComplete() {
+			if (!open) forceUnmount();
+		}
+	});
+	return {
+		forceUnmount,
+		transitionStatus
+	};
+}
+function usePopupInteractionProps(store, statePart) {
+	store.useSyncedValues(statePart);
+	useIsoLayoutEffect(() => () => {
+		store.update({
+			activeTriggerProps: EMPTY_OBJECT,
+			inactiveTriggerProps: EMPTY_OBJECT,
+			popupProps: EMPTY_OBJECT
+		});
+	}, [store]);
+}
+function usePopupRootSync(store, open) {
+	useIsoLayoutEffect(() => {
+		if (!open && store.state.openMethod !== null) store.set("openMethod", null);
+	}, [open, store]);
+	useIsoLayoutEffect(() => () => {
+		if (store.state.openMethod !== null) store.set("openMethod", null);
+	}, [store]);
+}
+//#endregion
+export { FOCUSABLE_POPUP_PROPS, PopupHandleAttachment, createDefaultInitialFocus, createPopupOpenState, useImplicitActiveTrigger, useOpenStateTransitions, usePopupInteractionProps, usePopupRootStore, usePopupRootSync };

package/dist/vendor/@base-ui/react/utils/popups/popupTriggerMap.js

@@ -0,0 +1,96 @@
+//#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/utils/popups/popupTriggerMap.mjs
+/**
+* Development-only reverse index of element to registered id, keyed by the owning map.
+*
+* Registration would otherwise have to scan every entry to detect an element claimed by two ids,
+* making the mount of many triggers sharing one handle quadratic. Kept module-scoped, lazily
+* initialized, and read only from `process.env.NODE_ENV` guards so production builds drop it along
+* with the checks.
+*/
+let devElementIdsByMap;
+function getDevElementIds(map) {
+	devElementIdsByMap ??= /* @__PURE__ */ new WeakMap();
+	let elementIds = devElementIdsByMap.get(map);
+	if (!elementIds) {
+		elementIds = /* @__PURE__ */ new WeakMap();
+		devElementIdsByMap.set(map, elementIds);
+	}
+	return elementIds;
+}
+/**
+* Data structure to keep track of popup trigger elements by their IDs.
+*
+* Element lookups iterate the id map rather than maintaining a parallel Set. Registration is O(1),
+* while `hasElement` and `hasMatchingElement` are linear in the number of triggers.
+*/
+var PopupTriggerMap = class {
+	constructor() {
+		this.idMap = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Adds a trigger element with the given ID.
+	*
+	* Note: The provided element is assumed to not be registered under multiple IDs.
+	*/
+	add(id, element) {
+		if (process.env.NODE_ENV !== "production") {
+			const elementIds = getDevElementIds(this);
+			const existingId = elementIds.get(element);
+			if (existingId !== void 0 && existingId !== id) throw new Error("Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.");
+			const previousElement = this.idMap.get(id);
+			if (previousElement !== void 0 && previousElement !== element) elementIds.delete(previousElement);
+			elementIds.set(element, id);
+		}
+		this.idMap.set(id, element);
+	}
+	/**
+	* Removes the trigger element with the given ID.
+	*/
+	delete(id) {
+		if (process.env.NODE_ENV !== "production") {
+			const element = this.idMap.get(id);
+			if (element !== void 0) devElementIdsByMap?.get(this)?.delete(element);
+		}
+		this.idMap.delete(id);
+	}
+	/**
+	* Whether the given element is registered as a trigger.
+	*/
+	hasElement(element) {
+		for (const registered of this.idMap.values()) if (registered === element) return true;
+		return false;
+	}
+	/**
+	* Whether there is a registered trigger element matching the given predicate.
+	*/
+	hasMatchingElement(predicate) {
+		for (const element of this.idMap.values()) if (predicate(element)) return true;
+		return false;
+	}
+	/**
+	* Returns the trigger element associated with the given ID, or undefined if no such element exists.
+	*/
+	getById(id) {
+		return this.idMap.get(id);
+	}
+	/**
+	* Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
+	*/
+	entries() {
+		return this.idMap.entries();
+	}
+	/**
+	* Returns an iterable of all registered trigger elements.
+	*/
+	elements() {
+		return this.idMap.values();
+	}
+	/**
+	* Returns the number of registered trigger elements.
+	*/
+	get size() {
+		return this.idMap.size;
+	}
+};
+//#endregion
+export { PopupTriggerMap };

package/dist/vendor/@base-ui/react/utils/popups/store.js

@@ -0,0 +1,94 @@
+import { EMPTY_OBJECT } from "../../../utils/empty.js";
+import { FloatingRootStore } from "../../floating-ui-react/components/FloatingRootStore.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/utils/popups/store.mjs
+/**
+* State common to all popup stores.
+*/
+function createInitialPopupStoreState(triggerElements, floatingId, nested = false) {
+	return {
+		open: false,
+		openProp: void 0,
+		mounted: false,
+		transitionStatus: void 0,
+		floatingRootContext: new FloatingRootStore({
+			open: false,
+			transitionStatus: void 0,
+			floatingElement: null,
+			referenceElement: null,
+			triggerElements,
+			floatingId,
+			syncOnly: true,
+			nested,
+			onOpenChange: void 0
+		}),
+		floatingId,
+		triggerCount: 0,
+		preventUnmountingOnClose: false,
+		payload: void 0,
+		activeTriggerId: null,
+		activeTriggerElement: null,
+		triggerIdProp: void 0,
+		popupElement: null,
+		positionerElement: null,
+		activeTriggerProps: EMPTY_OBJECT,
+		inactiveTriggerProps: EMPTY_OBJECT,
+		popupProps: EMPTY_OBJECT
+	};
+}
+const activeTriggerIdSelector = (state) => state.triggerIdProp ?? state.activeTriggerId;
+const openSelector = (state) => state.openProp ?? state.open;
+const popupIdSelector = (state) => {
+	return (state.popupElement?.id ?? state.floatingId) || void 0;
+};
+function triggerOwnsOpenPopup(state, triggerId) {
+	return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
+}
+function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
+	if (triggerOwnsOpenPopup(state, triggerId)) return true;
+	return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) == null && state.triggerCount === 1;
+}
+const popupStoreSelectors = {
+	open: openSelector,
+	mounted: (state) => state.mounted,
+	transitionStatus: (state) => state.transitionStatus,
+	floatingRootContext: (state) => state.floatingRootContext,
+	triggerCount: (state) => state.triggerCount,
+	preventUnmountingOnClose: (state) => state.preventUnmountingOnClose,
+	payload: (state) => state.payload,
+	activeTriggerId: activeTriggerIdSelector,
+	activeTriggerElement: (state) => state.mounted ? state.activeTriggerElement : null,
+	popupId: popupIdSelector,
+	/**
+	* Whether the trigger with the given ID was used to open the popup.
+	*/
+	isTriggerActive: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId,
+	/**
+	* Whether the popup is open and was activated by a trigger with the given ID.
+	*/
+	isOpenedByTrigger: (state, triggerId) => triggerOwnsOpenPopup(state, triggerId),
+	/**
+	* Whether the popup is mounted and was activated by a trigger with the given ID.
+	*/
+	isMountedByTrigger: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId && state.mounted,
+	triggerProps: (state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps,
+	/**
+	* Popup id for the trigger that currently owns the open popup.
+	*/
+	triggerPopupId: (state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : void 0,
+	popupProps: (state) => state.popupProps,
+	popupElement: (state) => state.popupElement,
+	positionerElement: (state) => state.positionerElement
+};
+/**
+* Store members a detached handle-backed trigger reads or invokes for trigger registration and data
+* forwarding. `set`/`update` are included only for trigger-count and trigger-data bookkeeping; on a
+* detached (inert) store they are intentionally no-ops, so a write through them is not guaranteed to
+* be durable. Component handle-store views Pick these from their concrete store (preserving its
+* context and selectors) and add any component-specific trigger-invoked members such as `setOpen`.
+*/
+/**
+* The subset of a popup store that trigger registration and data forwarding rely on. Narrow enough
+* that an inert store can be passed while detached.
+*/
+//#endregion
+export { createInitialPopupStoreState, popupStoreSelectors };

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

@@ -0,0 +1,13 @@
+//#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/utils/resolveClassName.mjs
+/**
+* If the provided className is a string, it will be returned as is.
+* Otherwise, the function will call the className function with the state as the first argument.
+*
+* @param className
+* @param state
+*/
+function resolveClassName(className, state) {
+	return typeof className === "function" ? className(state) : className;
+}
+//#endregion
+export { resolveClassName };

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

@@ -0,0 +1,11 @@
+//#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/utils/resolveRef.mjs
+/**
+* If the provided argument is a ref object, returns its `current` value.
+* Otherwise, returns the argument itself.
+*/
+function resolveRef(maybeRef) {
+	if (maybeRef == null) return maybeRef;
+	return "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+//#endregion
+export { resolveRef };

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

@@ -0,0 +1,13 @@
+//#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/utils/resolveStyle.mjs
+/**
+* If the provided style is an object, it will be returned as is.
+* Otherwise, the function will call the style function with the state as the first argument.
+*
+* @param style
+* @param state
+*/
+function resolveStyle(style, state) {
+	return typeof style === "function" ? style(state) : style;
+}
+//#endregion
+export { resolveStyle };

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

@@ -0,0 +1,30 @@
+"use client";
+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/utils/useFocusableWhenDisabled.mjs
+function useFocusableWhenDisabled(parameters) {
+	const { focusableWhenDisabled, disabled, composite = false, tabIndex: tabIndexProp = 0, isNativeButton } = parameters;
+	const isFocusableComposite = composite && focusableWhenDisabled !== false;
+	const isNonFocusableComposite = composite && focusableWhenDisabled === false;
+	return { props: React.useMemo(() => {
+		const additionalProps = { onKeyDown(event) {
+			if (disabled && focusableWhenDisabled && event.key !== "Tab") event.preventDefault();
+		} };
+		if (!composite) {
+			additionalProps.tabIndex = tabIndexProp;
+			if (!isNativeButton && disabled) additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+		}
+		if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled) additionalProps["aria-disabled"] = disabled;
+		if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) additionalProps.disabled = disabled;
+		return additionalProps;
+	}, [
+		composite,
+		disabled,
+		focusableWhenDisabled,
+		isFocusableComposite,
+		isNonFocusableComposite,
+		isNativeButton,
+		tabIndexProp
+	]) };
+}
+//#endregion
+export { useFocusableWhenDisabled };

package/dist/vendor/@base-ui/utils/addEventListener.js

@@ -0,0 +1,12 @@
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/addEventListener.mjs
+/**
+* Adds an event listener and returns a cleanup function to remove it.
+*/
+function addEventListener(target, type, listener, options) {
+	target.addEventListener(type, listener, options);
+	return () => {
+		target.removeEventListener(type, listener, options);
+	};
+}
+//#endregion
+export { addEventListener };

package/dist/vendor/@base-ui/utils/createLogOnce.js

@@ -0,0 +1,20 @@
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/createLogOnce.mjs
+let loggedMessages;
+if (process.env.NODE_ENV !== "production") loggedMessages = /* @__PURE__ */ new Set();
+/** Creates a dev-only logger that writes each unique message to `console[severity]` once. */
+function createLogOnce(severity, prefix) {
+	return function logOnce(...messages) {
+		if (process.env.NODE_ENV !== "production") {
+			const message = messages.join(" ");
+			const output = prefix ? `${prefix}: ${message}` : message;
+			const key = `${severity}:${output}`;
+			if (!loggedMessages.has(key)) {
+				loggedMessages.add(key);
+				if (severity === "warn") console.warn(output);
+				else console.error(output);
+			}
+		}
+	};
+}
+//#endregion
+export { createLogOnce };

package/dist/vendor/@base-ui/utils/empty.js

@@ -0,0 +1,6 @@
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/empty.mjs
+function NOOP() {}
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze({});
+//#endregion
+export { EMPTY_ARRAY, EMPTY_OBJECT, NOOP };

package/dist/vendor/@base-ui/utils/error.js

@@ -0,0 +1,5 @@
+import { createLogOnce } from "./createLogOnce.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/error.mjs
+const error = createLogOnce("error", "Base UI");
+//#endregion
+export { error };

package/dist/vendor/@base-ui/utils/fastHooks.js

@@ -0,0 +1,68 @@
+import { useRefWithInit } from "./useRefWithInit.js";
+import "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/fastHooks.mjs
+const hooks = [];
+let currentInstance = void 0;
+function getInstance() {
+	return currentInstance;
+}
+function register(hook) {
+	hooks.push(hook);
+}
+/**
+* Wraps a component function to enable performance optimizations for internal hooks.
+*
+* **Performance Optimization:**
+* Components wrapped with `fastComponent` have access to a shared "instance" context that enables
+* specialized hook implementations to batch operations and reduce overhead. The wrapper creates a
+* stable instance object that persists across renders, sets it as the current context, calls
+* registered hooks before and after rendering, then clears the context. The primary benefit is
+* with `useStore`, where multiple store subscriptions within the same component are collapsed into
+* a single `useSyncExternalStore` subscription per store, significantly reducing re-render overhead.
+* This optimization is only active on React 19+; on earlier versions `useStore` falls back to a
+* separate subscription per call.
+*
+* **Requirements:**
+* - The component function should follow standard React component patterns
+* - `useStore` calls must keep a stable order and count across renders, as batched hooks are
+*   matched by call index
+* - Do not rely on the instance context outside of specialized hooks
+*
+* @param fn - The component function to wrap
+* @returns A wrapped component with the same signature as the input function
+*
+* @example
+* ```tsx
+* // Wrapping a component to enable optimized useStore batching
+* export const TooltipRoot = fastComponent(function TooltipRoot(props) {
+*   // These useStore calls share a single subscription
+*   const open = useStore(store, (state) => state.open);
+*   const disabled = useStore(store, (state) => state.disabled);
+*   const value = useStore(store, (state) => state.value);
+*   // ...
+* });
+* ```
+*/
+function fastComponent(fn) {
+	const FastComponent = (props, forwardedRef) => {
+		const instance = useRefWithInit(createInstance).current;
+		let result;
+		try {
+			currentInstance = instance;
+			for (const hook of hooks) hook.before(instance);
+			result = fn(props, forwardedRef);
+			for (const hook of hooks) hook.after(instance);
+			instance.didInitialize = true;
+		} finally {
+			currentInstance = void 0;
+		}
+		return result;
+	};
+	FastComponent.displayName = fn.displayName || fn.name;
+	return FastComponent;
+}
+function createInstance() {
+	return { didInitialize: false };
+}
+//#endregion
+export { fastComponent, getInstance, register };