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

package/dist/vendor/@base-ui/react/switch/thumb/SwitchThumb.js

@@ -0,0 +1,25 @@
+"use client";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useSwitchRootContext } from "../root/SwitchRootContext.js";
+import { stateAttributesMapping } from "../stateAttributesMapping.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/switch/thumb/SwitchThumb.mjs
+/**
+* The movable part of the switch that indicates whether the switch is on or off.
+* Renders a `<span>`.
+*
+* Documentation: [Base UI Switch](https://base-ui.com/react/components/switch)
+*/
+const SwitchThumb = /*#__PURE__*/ React.forwardRef(function SwitchThumb(componentProps, forwardedRef) {
+	const { render, className, style, ...elementProps } = componentProps;
+	const state = useSwitchRootContext();
+	return useRenderElement("span", componentProps, {
+		state,
+		ref: forwardedRef,
+		stateAttributesMapping,
+		props: elementProps
+	});
+});
+if (process.env.NODE_ENV !== "production") SwitchThumb.displayName = "SwitchThumb";
+//#endregion
+export { SwitchThumb };

package/dist/vendor/@base-ui/react/tabs/list/TabsList.js

@@ -0,0 +1,98 @@
+"use client";
+import { EMPTY_ARRAY } from "../../../utils/empty.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { useTabsRootContext } from "../root/TabsRootContext.js";
+import { tabsStateAttributesMapping } from "../root/stateAttributesMapping.js";
+import { TabsListContext } from "./TabsListContext.js";
+import { CompositeRoot } from "../../internals/composite/root/CompositeRoot.js";
+import * as React from "react";
+import { jsx } from "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/tabs/list/TabsList.mjs
+/**
+* Groups the individual tab buttons.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+const TabsList = /*#__PURE__*/ React.forwardRef(function TabsList(componentProps, forwardedRef) {
+	const { activateOnFocus = false, className, loopFocus = true, render, style, ...elementProps } = componentProps;
+	const { orientation, setTabMap, tabActivationDirection } = useTabsRootContext();
+	const [highlightedTabIndex, setHighlightedTabIndex] = React.useState(0);
+	const [tabsListElement, setTabsListElement] = React.useState(null);
+	const indicatorUpdateListenersRef = React.useRef(/* @__PURE__ */ new Set());
+	const tabResizeObserverElementsRef = React.useRef(/* @__PURE__ */ new Set());
+	const resizeObserverRef = React.useRef(null);
+	useIsoLayoutEffect(() => {
+		if (typeof ResizeObserver === "undefined") return;
+		const resizeObserver = new ResizeObserver(() => {
+			indicatorUpdateListenersRef.current.forEach((listener) => {
+				listener();
+			});
+		});
+		resizeObserverRef.current = resizeObserver;
+		if (tabsListElement) resizeObserver.observe(tabsListElement);
+		tabResizeObserverElementsRef.current.forEach((element) => {
+			resizeObserver.observe(element);
+		});
+		return () => {
+			resizeObserver.disconnect();
+			resizeObserverRef.current = null;
+		};
+	}, [tabsListElement]);
+	const registerIndicatorUpdateListener = useStableCallback((listener) => {
+		indicatorUpdateListenersRef.current.add(listener);
+		return () => {
+			indicatorUpdateListenersRef.current.delete(listener);
+		};
+	});
+	const registerTabResizeObserverElement = useStableCallback((element) => {
+		tabResizeObserverElementsRef.current.add(element);
+		resizeObserverRef.current?.observe(element);
+		return () => {
+			tabResizeObserverElementsRef.current.delete(element);
+			resizeObserverRef.current?.unobserve(element);
+		};
+	});
+	const state = {
+		orientation,
+		tabActivationDirection
+	};
+	const defaultProps = {
+		"aria-orientation": orientation === "vertical" ? "vertical" : void 0,
+		role: "tablist"
+	};
+	const tabsListContextValue = React.useMemo(() => ({
+		activateOnFocus,
+		registerIndicatorUpdateListener,
+		registerTabResizeObserverElement,
+		tabsListElement
+	}), [
+		activateOnFocus,
+		registerIndicatorUpdateListener,
+		registerTabResizeObserverElement,
+		tabsListElement
+	]);
+	return /*#__PURE__*/ jsx(TabsListContext.Provider, {
+		value: tabsListContextValue,
+		children: /*#__PURE__*/ jsx(CompositeRoot, {
+			render,
+			className,
+			style,
+			state,
+			refs: [forwardedRef, setTabsListElement],
+			props: [defaultProps, elementProps],
+			stateAttributesMapping: tabsStateAttributesMapping,
+			highlightedIndex: highlightedTabIndex,
+			enableHomeAndEndKeys: true,
+			loopFocus,
+			orientation,
+			onHighlightedIndexChange: setHighlightedTabIndex,
+			onMapChange: setTabMap,
+			disabledIndices: EMPTY_ARRAY
+		})
+	});
+});
+if (process.env.NODE_ENV !== "production") TabsList.displayName = "TabsList";
+//#endregion
+export { TabsList };

package/dist/vendor/@base-ui/react/tabs/list/TabsListContext.js

@@ -0,0 +1,13 @@
+"use client";
+import formatErrorMessage from "../../../utils/formatErrorMessage.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/tabs/list/TabsListContext.mjs
+const TabsListContext = /*#__PURE__*/ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TabsListContext.displayName = "TabsListContext";
+function useTabsListContext() {
+	const context = React.useContext(TabsListContext);
+	if (context === void 0) throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsListContext is missing. TabsList parts must be placed within <Tabs.List>." : formatErrorMessage(65));
+	return context;
+}
+//#endregion
+export { TabsListContext, useTabsListContext };

package/dist/vendor/@base-ui/react/tabs/root/TabsRoot.js

@@ -0,0 +1,213 @@
+"use client";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { disabled, initial, missing } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { useControlled } from "../../../utils/useControlled.js";
+import { CompositeList } from "../../internals/composite/list/CompositeList.js";
+import { TabsRootContext } from "./TabsRootContext.js";
+import { tabsStateAttributesMapping } from "./stateAttributesMapping.js";
+import * as React from "react";
+import { jsx } from "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/tabs/root/TabsRoot.mjs
+/**
+* Groups the tabs and the corresponding panels.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+const TabsRoot = /*#__PURE__*/ React.forwardRef(function TabsRoot(componentProps, forwardedRef) {
+	const { className, defaultValue: defaultValueProp = 0, onValueChange: onValueChangeProp, orientation = "horizontal", render, value: valueProp, style, ...elementProps } = componentProps;
+	const hasExplicitDefaultValueProp = componentProps.defaultValue !== void 0;
+	const tabPanelRefs = React.useRef([]);
+	const [mountedTabPanels, setMountedTabPanels] = React.useState(() => /* @__PURE__ */ new Map());
+	const [value, setValue] = useControlled({
+		controlled: valueProp,
+		default: defaultValueProp,
+		name: "Tabs",
+		state: "value"
+	});
+	const isControlled = valueProp !== void 0;
+	const [tabMap, setTabMap] = React.useState(() => /* @__PURE__ */ new Map());
+	const lastKnownTabElementRef = React.useRef(void 0);
+	const getTabElementBySelectedValue = React.useCallback((selectedValue) => findTabElement(tabMap, selectedValue), [tabMap]);
+	const [activationDirectionState, setActivationDirectionState] = React.useState(() => ({
+		previousValue: value,
+		tabActivationDirection: "none"
+	}));
+	const { previousValue, tabActivationDirection: committedTabActivationDirection } = activationDirectionState;
+	let tabActivationDirection = committedTabActivationDirection;
+	let directionComputationIncomplete = false;
+	if (previousValue !== value) {
+		tabActivationDirection = computeActivationDirection(previousValue, value, orientation, tabMap);
+		directionComputationIncomplete = previousValue != null && value != null && getTabElementBySelectedValue(value) == null;
+	}
+	const nextPreviousValue = directionComputationIncomplete ? previousValue : value;
+	const shouldSyncActivationDirectionState = previousValue !== nextPreviousValue || committedTabActivationDirection !== tabActivationDirection;
+	useIsoLayoutEffect(() => {
+		if (!shouldSyncActivationDirectionState) return;
+		setActivationDirectionState({
+			previousValue: nextPreviousValue,
+			tabActivationDirection
+		});
+	}, [
+		nextPreviousValue,
+		shouldSyncActivationDirectionState,
+		tabActivationDirection
+	]);
+	const onValueChange = useStableCallback((newValue, eventDetails) => {
+		eventDetails.activationDirection = computeActivationDirection(value, newValue, orientation, tabMap);
+		onValueChangeProp?.(newValue, eventDetails);
+		if (eventDetails.isCanceled) return;
+		setValue(newValue);
+	});
+	const notifyAutomaticValueChange = useStableCallback((nextValue, reason) => {
+		onValueChangeProp?.(nextValue, createChangeEventDetails(reason, void 0, void 0, { activationDirection: "none" }));
+	});
+	const registerMountedTabPanel = useStableCallback((panelValue, panelId) => {
+		setMountedTabPanels((prev) => {
+			const next = new Map(prev);
+			next.set(panelValue, panelId);
+			return next;
+		});
+		return () => {
+			setMountedTabPanels((prev) => {
+				if (prev.get(panelValue) !== panelId) return prev;
+				const next = new Map(prev);
+				next.delete(panelValue);
+				return next;
+			});
+		};
+	});
+	const getTabPanelIdByValue = React.useCallback((tabValue) => {
+		return mountedTabPanels.get(tabValue);
+	}, [mountedTabPanels]);
+	const getTabIdByPanelValue = React.useCallback((tabPanelValue) => {
+		for (const tabMetadata of tabMap.values()) if (tabPanelValue === tabMetadata.value) return tabMetadata.id;
+	}, [tabMap]);
+	const tabsContextValue = React.useMemo(() => ({
+		getTabElementBySelectedValue,
+		getTabIdByPanelValue,
+		getTabPanelIdByValue,
+		onValueChange,
+		orientation,
+		registerMountedTabPanel,
+		setTabMap,
+		tabActivationDirection,
+		value
+	}), [
+		getTabElementBySelectedValue,
+		getTabIdByPanelValue,
+		getTabPanelIdByValue,
+		onValueChange,
+		orientation,
+		registerMountedTabPanel,
+		setTabMap,
+		tabActivationDirection,
+		value
+	]);
+	const selectedTabMetadata = React.useMemo(() => {
+		for (const tabMetadata of tabMap.values()) if (tabMetadata.value === value) return tabMetadata;
+	}, [tabMap, value]);
+	const firstEnabledTabValue = React.useMemo(() => {
+		for (const tabMetadata of tabMap.values()) if (!tabMetadata.disabled) return tabMetadata.value;
+	}, [tabMap]);
+	const shouldNotifyInitialValueChangeRef = React.useRef(!hasExplicitDefaultValueProp);
+	const initialDefaultValueRef = React.useRef(defaultValueProp);
+	const shouldHonorDisabledDefaultValueRef = React.useRef(hasExplicitDefaultValueProp);
+	const didRegisterTabsRef = React.useRef(false);
+	useIsoLayoutEffect(() => {
+		if (isControlled) return;
+		function commitAutomaticValueChange(fallbackValue, fallbackReason) {
+			setValue(fallbackValue);
+			setActivationDirectionState({
+				previousValue: fallbackValue,
+				tabActivationDirection: "none"
+			});
+			notifyAutomaticValueChange(fallbackValue, fallbackReason);
+			shouldNotifyInitialValueChangeRef.current = false;
+		}
+		if (tabMap.size === 0) {
+			if (didRegisterTabsRef.current && value !== null && !lastKnownTabElementRef.current?.isConnected) commitAutomaticValueChange(null, missing);
+			return;
+		}
+		didRegisterTabsRef.current = true;
+		lastKnownTabElementRef.current = tabMap.keys().next().value;
+		const selectionIsDisabled = selectedTabMetadata?.disabled;
+		const selectionIsMissing = selectedTabMetadata == null && value !== null;
+		if (!selectionIsDisabled && value === initialDefaultValueRef.current) shouldHonorDisabledDefaultValueRef.current = false;
+		if (shouldHonorDisabledDefaultValueRef.current && selectionIsDisabled && value === initialDefaultValueRef.current) return;
+		const shouldNotifyInitialValueChange = shouldNotifyInitialValueChangeRef.current;
+		if (selectionIsDisabled || selectionIsMissing) {
+			const fallbackValue = firstEnabledTabValue ?? null;
+			if (value === fallbackValue) {
+				shouldNotifyInitialValueChangeRef.current = false;
+				return;
+			}
+			let fallbackReason = missing;
+			if (shouldNotifyInitialValueChange) fallbackReason = initial;
+			else if (selectionIsDisabled) fallbackReason = disabled;
+			commitAutomaticValueChange(fallbackValue, fallbackReason);
+			return;
+		}
+		if (shouldNotifyInitialValueChange && selectedTabMetadata != null) {
+			notifyAutomaticValueChange(value, initial);
+			shouldNotifyInitialValueChangeRef.current = false;
+		}
+	}, [
+		firstEnabledTabValue,
+		isControlled,
+		notifyAutomaticValueChange,
+		selectedTabMetadata,
+		setValue,
+		tabMap,
+		value
+	]);
+	const element = useRenderElement("div", componentProps, {
+		state: {
+			orientation,
+			tabActivationDirection
+		},
+		ref: forwardedRef,
+		props: elementProps,
+		stateAttributesMapping: tabsStateAttributesMapping
+	});
+	return /*#__PURE__*/ jsx(TabsRootContext.Provider, {
+		value: tabsContextValue,
+		children: /*#__PURE__*/ jsx(CompositeList, {
+			elementsRef: tabPanelRefs,
+			children: element
+		})
+	});
+});
+if (process.env.NODE_ENV !== "production") TabsRoot.displayName = "TabsRoot";
+function findTabElement(tabMap, value) {
+	for (const [tabElement, tabMetadata] of tabMap.entries()) if (value === tabMetadata.value) return tabElement;
+	return null;
+}
+function computeActivationDirection(oldValue, newValue, orientation, tabMap) {
+	if (oldValue == null || newValue == null) return "none";
+	const [positionProp, backward, forward] = orientation === "horizontal" ? [
+		"left",
+		"left",
+		"right"
+	] : [
+		"top",
+		"up",
+		"down"
+	];
+	const oldTab = findTabElement(tabMap, oldValue);
+	const newTab = findTabElement(tabMap, newValue);
+	if (oldTab == null || newTab == null) {
+		if (oldTab !== newTab && (typeof oldValue === "number" || typeof oldValue === "string") && typeof oldValue === typeof newValue) return newValue > oldValue ? forward : backward;
+		return "none";
+	}
+	const oldPosition = oldTab.getBoundingClientRect()[positionProp];
+	const newPosition = newTab.getBoundingClientRect()[positionProp];
+	if (newPosition < oldPosition) return backward;
+	if (newPosition > oldPosition) return forward;
+	return "none";
+}
+//#endregion
+export { TabsRoot };

package/dist/vendor/@base-ui/react/tabs/root/TabsRootContext.js

@@ -0,0 +1,16 @@
+"use client";
+import formatErrorMessage from "../../../utils/formatErrorMessage.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/tabs/root/TabsRootContext.mjs
+/**
+* @internal
+*/
+const TabsRootContext = /*#__PURE__*/ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TabsRootContext.displayName = "TabsRootContext";
+function useTabsRootContext() {
+	const context = React.useContext(TabsRootContext);
+	if (context === void 0) throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsRootContext is missing. Tabs parts must be placed within <Tabs.Root>." : formatErrorMessage(64));
+	return context;
+}
+//#endregion
+export { TabsRootContext, useTabsRootContext };

package/dist/vendor/@base-ui/react/tabs/root/TabsRootDataAttributes.js

@@ -0,0 +1,8 @@
+//#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/tabs/root/TabsRootDataAttributes.mjs
+/**
+* Indicates the direction of the activation (based on the previous active tab).
+* @type {'left' | 'right' | 'up' | 'down' | 'none'}
+*/
+const activationDirection = "data-activation-direction";
+//#endregion
+export { activationDirection };

package/dist/vendor/@base-ui/react/tabs/root/stateAttributesMapping.js

@@ -0,0 +1,5 @@
+import { activationDirection } from "./TabsRootDataAttributes.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/tabs/root/stateAttributesMapping.mjs
+const tabsStateAttributesMapping = { tabActivationDirection: (dir) => ({ [activationDirection]: dir }) };
+//#endregion
+export { tabsStateAttributesMapping };

package/dist/vendor/@base-ui/react/tabs/tab/TabsTab.js

@@ -0,0 +1,137 @@
+"use client";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useStableCallback } from "../../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { useCompositeRootContext } from "../../internals/composite/root/CompositeRootContext.js";
+import { ownerDocument } from "../../../utils/owner.js";
+import { useButton } from "../../internals/use-button/useButton.js";
+import { none } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { useBaseUiId } from "../../internals/useBaseUiId.js";
+import { activeElement, contains } from "../../../utils/shadowDom.js";
+import { useTabsRootContext } from "../root/TabsRootContext.js";
+import { tabsStateAttributesMapping } from "../root/stateAttributesMapping.js";
+import { ACTIVE_COMPOSITE_ITEM } from "../../internals/composite/constants.js";
+import { useCompositeItem } from "../../internals/composite/item/useCompositeItem.js";
+import { useTabsListContext } from "../list/TabsListContext.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/tabs/tab/TabsTab.mjs
+/**
+* An individual interactive tab button that toggles the corresponding panel.
+* Renders a `<button>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+const TabsTab = /*#__PURE__*/ React.forwardRef(function TabsTab(componentProps, forwardedRef) {
+	const { className, disabled = false, render, value, id: idProp, nativeButton = true, style, ...elementProps } = componentProps;
+	const { value: activeTabValue, getTabPanelIdByValue, onValueChange, orientation, tabActivationDirection } = useTabsRootContext();
+	const { activateOnFocus, registerTabResizeObserverElement, tabsListElement } = useTabsListContext();
+	const { highlightedIndex, onHighlightedIndexChange } = useCompositeRootContext();
+	const id = useBaseUiId(idProp);
+	const tabMetadata = React.useMemo(() => ({
+		disabled,
+		id,
+		value
+	}), [
+		disabled,
+		id,
+		value
+	]);
+	const { compositeProps, compositeRef, index } = useCompositeItem({ metadata: tabMetadata });
+	const active = value === activeTabValue;
+	const isNavigatingRef = React.useRef(false);
+	const unobserveTabElementRef = React.useRef(null);
+	const observeTabElement = useStableCallback((element) => {
+		unobserveTabElementRef.current?.();
+		unobserveTabElementRef.current = element ? registerTabResizeObserverElement(element) : null;
+	});
+	useIsoLayoutEffect(() => {
+		if (isNavigatingRef.current) {
+			isNavigatingRef.current = false;
+			return;
+		}
+		if (!(active && index > -1 && highlightedIndex !== index)) return;
+		const listElement = tabsListElement;
+		if (listElement != null) {
+			const activeEl = activeElement(ownerDocument(listElement));
+			if (activeEl && contains(listElement, activeEl)) return;
+		}
+		if (!disabled) onHighlightedIndexChange(index);
+	}, [
+		active,
+		index,
+		highlightedIndex,
+		onHighlightedIndexChange,
+		disabled,
+		tabsListElement
+	]);
+	const { getButtonProps, buttonRef } = useButton({
+		disabled,
+		native: nativeButton,
+		focusableWhenDisabled: true
+	});
+	const tabPanelId = getTabPanelIdByValue(value);
+	const isPressingRef = React.useRef(false);
+	const isMainButtonRef = React.useRef(false);
+	function activate(event) {
+		onValueChange(value, createChangeEventDetails(none, event.nativeEvent, void 0, { activationDirection: "none" }));
+	}
+	function onClick(event) {
+		if (active || disabled) return;
+		activate(event);
+	}
+	function onFocus(event) {
+		if (active || disabled) return;
+		if (activateOnFocus && (!isPressingRef.current || isMainButtonRef.current)) activate(event);
+	}
+	function onPointerDown(event) {
+		if (active || disabled) return;
+		isPressingRef.current = true;
+		isMainButtonRef.current = event.button === 0;
+		const doc = ownerDocument(event.currentTarget);
+		function handlePointerEnd() {
+			isPressingRef.current = false;
+			isMainButtonRef.current = false;
+			doc.removeEventListener("pointerup", handlePointerEnd);
+			doc.removeEventListener("pointercancel", handlePointerEnd);
+		}
+		doc.addEventListener("pointerup", handlePointerEnd);
+		doc.addEventListener("pointercancel", handlePointerEnd);
+	}
+	return useRenderElement("button", componentProps, {
+		state: {
+			disabled,
+			active,
+			orientation,
+			tabActivationDirection
+		},
+		ref: [
+			forwardedRef,
+			buttonRef,
+			compositeRef,
+			observeTabElement
+		],
+		props: [
+			compositeProps,
+			{
+				role: "tab",
+				"aria-controls": tabPanelId,
+				"aria-selected": active,
+				id,
+				onClick,
+				onFocus,
+				onPointerDown,
+				[ACTIVE_COMPOSITE_ITEM]: active ? "" : void 0,
+				onKeyDownCapture() {
+					isNavigatingRef.current = true;
+				}
+			},
+			elementProps,
+			getButtonProps
+		],
+		stateAttributesMapping: tabsStateAttributesMapping
+	});
+});
+if (process.env.NODE_ENV !== "production") TabsTab.displayName = "TabsTab";
+//#endregion
+export { TabsTab };

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

@@ -0,0 +1,24 @@
+import { endingStyle as endingStyle$1, startingStyle as startingStyle$1 } from "../internals/TransitionStatusDataAttributes.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/CommonPopupDataAttributes.mjs
+/**
+* Present when the popup is open.
+*/
+const open = "data-open";
+/**
+* Present when the popup is closed.
+*/
+const closed = "data-closed";
+/**
+* Present when the popup begins animating in.
+*/
+const startingStyle = startingStyle$1;
+/**
+* Present when the popup is animating out.
+*/
+const endingStyle = endingStyle$1;
+/**
+* Present when the anchor is hidden.
+*/
+const anchorHidden = "data-anchor-hidden";
+//#endregion
+export { anchorHidden, closed, endingStyle, open, startingStyle };

package/dist/vendor/@base-ui/react/utils/CommonTriggerDataAttributes.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/CommonTriggerDataAttributes.mjs
+/**
+* Present when the popup is open.
+*/
+const popupOpen = "data-popup-open";
+/**
+* Present when a pressable trigger is pressed.
+*/
+const pressed = "data-pressed";
+//#endregion
+export { popupOpen, pressed };

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

@@ -0,0 +1,32 @@
+"use client";
+import { useIsoLayoutEffect } from "../../utils/useIsoLayoutEffect.js";
+import { webkit } from "../../utils/platform/engine.js";
+import { voiceOver } from "../../utils/platform/screen-reader.js";
+import { visuallyHidden } from "../../utils/visuallyHidden.js";
+import * as React from "react";
+import { jsx } from "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/utils/FocusGuard.mjs
+/**
+* @internal
+*/
+const FocusGuard = /*#__PURE__*/ React.forwardRef(function FocusGuard(props, ref) {
+	const [role, setRole] = React.useState();
+	useIsoLayoutEffect(() => {
+		if (voiceOver && webkit) setRole("button");
+	}, []);
+	const restProps = {
+		tabIndex: 0,
+		role
+	};
+	return /*#__PURE__*/ jsx("span", {
+		...props,
+		ref,
+		style: visuallyHidden,
+		"aria-hidden": role ? void 0 : true,
+		...restProps,
+		"data-base-ui-focus-guard": ""
+	});
+});
+if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
+//#endregion
+export { FocusGuard };

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

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { jsx } from "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/utils/InternalBackdrop.mjs
+/**
+* @internal
+*/
+const InternalBackdrop = /*#__PURE__*/ React.forwardRef(function InternalBackdrop(props, ref) {
+	const { cutout, ...otherProps } = props;
+	let clipPath;
+	if (cutout) {
+		const rect = cutout.getBoundingClientRect();
+		clipPath = `polygon(0% 0%,100% 0%,100% 100%,0% 100%,0% 0%,${rect.left}px ${rect.top}px,${rect.left}px ${rect.bottom}px,${rect.right}px ${rect.bottom}px,${rect.right}px ${rect.top}px,${rect.left}px ${rect.top}px)`;
+	}
+	return /*#__PURE__*/ jsx("div", {
+		ref,
+		role: "presentation",
+		"data-base-ui-inert": "",
+		...otherProps,
+		style: {
+			position: "fixed",
+			inset: 0,
+			userSelect: "none",
+			WebkitUserSelect: "none",
+			clipPath
+		}
+	});
+});
+if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
+//#endregion
+export { InternalBackdrop };

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

@@ -0,0 +1,25 @@
+import { getWindow } 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/utils/dispatchClickWithModifiers.mjs
+/**
+* Dispatches a constructed click on the target so it carries the source event's
+* modifier state, which `click()` always reports as unpressed. Like `click()`,
+* the untrusted click still runs native activation behavior (form submission,
+* link navigation).
+* `detail` defaults to 0 (the native convention for keyboard-generated clicks);
+* pass `detail: 1` when the click represents a mouse gesture so consumers keying
+* off `detail === 0` don't classify it as a keyboard activation.
+*/
+function dispatchClickWithModifiers(target, sourceEvent, { detail = 0 } = {}) {
+	target.dispatchEvent(new (getWindow(target)).PointerEvent("click", {
+		bubbles: true,
+		cancelable: true,
+		composed: true,
+		detail,
+		shiftKey: sourceEvent.shiftKey,
+		ctrlKey: sourceEvent.ctrlKey,
+		altKey: sourceEvent.altKey,
+		metaKey: sourceEvent.metaKey
+	}));
+}
+//#endregion
+export { dispatchClickWithModifiers };