@oomol-lab/open-flow 0.1.0-beta.57 → 0.1.0-beta.59

package/dist/browser/ui.js

@@ -641,7 +641,7 @@ function warn(...messages) {
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+utils@0.2.8+b87d06724be9db7a/node_modules/@base-ui/utils/esm/empty.js
 function NOOP() {}
-Object.freeze([]);
+var EMPTY_ARRAY$1 = Object.freeze([]);
 var EMPTY_OBJECT = Object.freeze({});
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/getStateAttributesProps.js
@@ -4390,7 +4390,7 @@ var popupStateMapping = {
 };
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/dialog/backdrop/DialogBackdrop.js
-var stateAttributesMapping$2 = {
+var stateAttributesMapping$3 = {
 	...popupStateMapping,
 	...transitionStatusMapping
 };
@@ -4412,7 +4412,7 @@ var DialogBackdrop = /*#__PURE__*/ React.forwardRef(function DialogBackdrop(comp
 			transitionStatus: store.useState("transitionStatus")
 		},
 		ref: [store.context.backdropRef, forwardedRef],
-		stateAttributesMapping: stateAttributesMapping$2,
+		stateAttributesMapping: stateAttributesMapping$3,
 		props: [{
 			role: "presentation",
 			hidden: !mounted,
@@ -5179,6 +5179,250 @@ function rectToClientRect(rect) {
 }
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/floating-ui-react/utils/composite.js
+function isDifferentGridRow(index, cols, prevRow) {
+	return Math.floor(index / cols) !== prevRow;
+}
+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 getGridNavigatedIndex(list, { event, orientation, loopFocus, onLoop, rtl, cols, disabledIndices, minIndex, maxIndex, prevIndex, stopEvent: stop = false }) {
+	let nextIndex = prevIndex;
+	let verticalDirection;
+	if (event.key === "ArrowUp") verticalDirection = "up";
+	else if (event.key === "ArrowDown") verticalDirection = "down";
+	if (verticalDirection) {
+		const rows = [];
+		const rowIndexMap = [];
+		let hasRoleRow = false;
+		let visibleItemCount = 0;
+		{
+			let currentRowEl = null;
+			let currentRowIndex = -1;
+			list.forEach((el, idx) => {
+				if (el == null) return;
+				visibleItemCount += 1;
+				const rowEl = el.closest("[role=\"row\"]");
+				if (rowEl) hasRoleRow = true;
+				if (rowEl !== currentRowEl || currentRowIndex === -1) {
+					currentRowEl = rowEl;
+					currentRowIndex += 1;
+					rows[currentRowIndex] = [];
+				}
+				rows[currentRowIndex].push(idx);
+				rowIndexMap[idx] = currentRowIndex;
+			});
+		}
+		let hasDomRows = false;
+		let inferredDomCols = 0;
+		if (hasRoleRow) for (const row of rows) {
+			const rowLength = row.length;
+			if (rowLength > inferredDomCols) inferredDomCols = rowLength;
+			if (rowLength !== cols) hasDomRows = true;
+		}
+		const hasVirtualizedGaps = hasDomRows && visibleItemCount < list.length;
+		const verticalCols = inferredDomCols || cols;
+		const navigateVertically = (direction) => {
+			if (!hasDomRows || prevIndex === -1) return;
+			const currentRow = rowIndexMap[prevIndex];
+			if (currentRow == null) return;
+			const colInRow = rows[currentRow].indexOf(prevIndex);
+			const step = direction === "up" ? -1 : 1;
+			for (let nextRow = currentRow + step, i = 0; i < rows.length; i += 1, nextRow += step) {
+				if (nextRow < 0 || nextRow >= rows.length) {
+					if (!loopFocus || hasVirtualizedGaps) return;
+					nextRow = nextRow < 0 ? rows.length - 1 : 0;
+					if (onLoop) {
+						const clampedCol = Math.min(colInRow, rows[nextRow].length - 1);
+						const returnedItemIndex = onLoop(event, prevIndex, rows[nextRow][clampedCol] ?? rows[nextRow][0]);
+						nextRow = rowIndexMap[returnedItemIndex] ?? nextRow;
+					}
+				}
+				const targetRow = rows[nextRow];
+				for (let col = Math.min(colInRow, targetRow.length - 1); col >= 0; col -= 1) {
+					const candidate = targetRow[col];
+					if (!isListIndexDisabled(list, candidate, disabledIndices)) return candidate;
+				}
+			}
+		};
+		const navigateVerticallyWithInferredRows = (direction) => {
+			if (!hasVirtualizedGaps || prevIndex === -1) return;
+			const colInRow = prevIndex % verticalCols;
+			const rowStep = direction === "up" ? -verticalCols : verticalCols;
+			const lastRowStart = maxIndex - maxIndex % verticalCols;
+			const rowCount = floor(maxIndex / verticalCols) + 1;
+			for (let rowStart = prevIndex - colInRow + rowStep, i = 0; i < rowCount; i += 1, rowStart += rowStep) {
+				if (rowStart < 0 || rowStart > maxIndex) {
+					if (!loopFocus) return;
+					rowStart = rowStart < 0 ? lastRowStart : 0;
+				}
+				const rowEnd = Math.min(rowStart + verticalCols - 1, maxIndex);
+				for (let candidate = Math.min(rowStart + colInRow, rowEnd); candidate >= rowStart; candidate -= 1) if (!isListIndexDisabled(list, candidate, disabledIndices)) return candidate;
+			}
+		};
+		if (stop) stopEvent(event);
+		const verticalCandidate = navigateVertically(verticalDirection) ?? navigateVerticallyWithInferredRows(verticalDirection);
+		if (verticalCandidate !== void 0) nextIndex = verticalCandidate;
+		else if (prevIndex === -1) nextIndex = verticalDirection === "up" ? maxIndex : minIndex;
+		else {
+			nextIndex = findNonDisabledListIndex(list, {
+				startingIndex: prevIndex,
+				amount: verticalCols,
+				decrement: verticalDirection === "up",
+				disabledIndices
+			});
+			if (loopFocus) {
+				if (verticalDirection === "up" && (prevIndex - verticalCols < minIndex || nextIndex < 0)) {
+					const col = prevIndex % verticalCols;
+					const maxCol = maxIndex % verticalCols;
+					const offset = maxIndex - (maxCol - col);
+					if (maxCol === col) nextIndex = maxIndex;
+					else nextIndex = maxCol > col ? offset : offset - verticalCols;
+					if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+				}
+				if (verticalDirection === "down" && prevIndex + verticalCols > maxIndex) {
+					nextIndex = findNonDisabledListIndex(list, {
+						startingIndex: prevIndex % verticalCols - verticalCols,
+						amount: verticalCols,
+						disabledIndices
+					});
+					if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+				}
+			}
+		}
+		if (isIndexOutOfListBounds(list, nextIndex)) nextIndex = prevIndex;
+	}
+	if (orientation === "both") {
+		const prevRow = floor(prevIndex / cols);
+		if (event.key === (rtl ? "ArrowLeft" : "ArrowRight")) {
+			if (stop) stopEvent(event);
+			if (prevIndex % cols !== cols - 1) {
+				nextIndex = findNonDisabledListIndex(list, {
+					startingIndex: prevIndex,
+					disabledIndices
+				});
+				if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+					nextIndex = findNonDisabledListIndex(list, {
+						startingIndex: prevIndex - prevIndex % cols - 1,
+						disabledIndices
+					});
+					if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+				}
+			} else if (loopFocus) {
+				nextIndex = findNonDisabledListIndex(list, {
+					startingIndex: prevIndex - prevIndex % cols - 1,
+					disabledIndices
+				});
+				if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+			}
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		if (event.key === (rtl ? "ArrowRight" : "ArrowLeft")) {
+			if (stop) stopEvent(event);
+			if (prevIndex % cols !== 0) {
+				nextIndex = findNonDisabledListIndex(list, {
+					startingIndex: prevIndex,
+					decrement: true,
+					disabledIndices
+				});
+				if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+					nextIndex = findNonDisabledListIndex(list, {
+						startingIndex: prevIndex + (cols - prevIndex % cols),
+						decrement: true,
+						disabledIndices
+					});
+					if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+				}
+			} else if (loopFocus) {
+				nextIndex = findNonDisabledListIndex(list, {
+					startingIndex: prevIndex + (cols - prevIndex % cols),
+					decrement: true,
+					disabledIndices
+				});
+				if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+			}
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		const lastRow = floor(maxIndex / cols) === prevRow;
+		if (isIndexOutOfListBounds(list, nextIndex)) {
+			if (loopFocus && lastRow) {
+				nextIndex = event.key === (rtl ? "ArrowRight" : "ArrowLeft") ? maxIndex : findNonDisabledListIndex(list, {
+					startingIndex: prevIndex - prevIndex % cols - 1,
+					disabledIndices
+				});
+				if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+			} else nextIndex = prevIndex;
+		}
+	}
+	return nextIndex;
+}
+/** For each cell index, gets the item index that occupies that cell */
+function createGridCellMap(sizes, cols, dense) {
+	const cellMap = [];
+	let startIndex = 0;
+	sizes.forEach(({ width, height }, index) => {
+		if (width > cols) {
+			if (process.env.NODE_ENV !== "production") throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
+		}
+		let itemPlaced = false;
+		if (dense) startIndex = 0;
+		while (!itemPlaced) {
+			const targetCells = [];
+			for (let i = 0; i < width; i += 1) for (let j = 0; j < height; j += 1) targetCells.push(startIndex + i + j * cols);
+			if (startIndex % cols + width <= cols && targetCells.every((cell) => cellMap[cell] == null)) {
+				targetCells.forEach((cell) => {
+					cellMap[cell] = index;
+				});
+				itemPlaced = true;
+			} else startIndex += 1;
+		}
+	});
+	return [...cellMap];
+}
+/** Gets cell index of an item's corner or -1 when index is -1. */
+function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
+	if (index === -1) return -1;
+	const firstCellIndex = cellMap.indexOf(index);
+	const sizeItem = sizes[index];
+	switch (corner) {
+		case "tl": return firstCellIndex;
+		case "tr":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + sizeItem.width - 1;
+		case "bl":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + (sizeItem.height - 1) * cols;
+		case "br": return cellMap.lastIndexOf(index);
+		default: return -1;
+	}
+}
+/** Gets all cell indices that correspond to the specified indices */
+function getGridCellIndices(indices, cellMap) {
+	return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
+}
+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;
+	return !disabledIndices && (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true");
+}
 function isHiddenByStyles(styles) {
 	return styles.visibility === "hidden" || styles.visibility === "collapse";
 }
@@ -10302,8 +10546,25 @@ var ARROW_LEFT = "ArrowLeft";
 var ARROW_RIGHT = "ArrowRight";
 var HOME = "Home";
 var HORIZONTAL_KEYS = /* @__PURE__ */ new Set([ARROW_LEFT, ARROW_RIGHT]);
+var HORIZONTAL_KEYS_WITH_EXTRA_KEYS = /* @__PURE__ */ new Set([
+	ARROW_LEFT,
+	ARROW_RIGHT,
+	HOME,
+	"End"
+]);
 var VERTICAL_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN]);
-[.../* @__PURE__ */ new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS])];
+var VERTICAL_KEYS_WITH_EXTRA_KEYS = /* @__PURE__ */ new Set([
+	ARROW_UP,
+	ARROW_DOWN,
+	HOME,
+	"End"
+]);
+var ARROW_KEYS = /* @__PURE__ */ new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS]);
+var ALL_KEYS = /* @__PURE__ */ new Set([
+	...ARROW_KEYS,
+	HOME,
+	"End"
+]);
 var COMPOSITE_KEYS = /* @__PURE__ */ new Set([
 	ARROW_UP,
 	ARROW_DOWN,
@@ -10312,9 +10573,78 @@ var COMPOSITE_KEYS = /* @__PURE__ */ new Set([
 	HOME,
 	"End"
 ]);
+var MODIFIER_KEYS = /* @__PURE__ */ new Set([
+	"Shift",
+	"Control",
+	"Alt",
+	"Meta"
+]);
+function isInputElement(element) {
+	return isHTMLElement(element) && element.tagName === "INPUT";
+}
+function isNativeInput(element) {
+	if (isInputElement(element) && element.selectionStart != null) return true;
+	if (isHTMLElement(element) && element.tagName === "TEXTAREA") return true;
+	return false;
+}
+function scrollIntoViewIfNeeded(scrollContainer, element, direction, orientation) {
+	if (!scrollContainer || !element || !element.scrollTo) return;
+	let targetX = scrollContainer.scrollLeft;
+	let targetY = scrollContainer.scrollTop;
+	const isOverflowingX = scrollContainer.clientWidth < scrollContainer.scrollWidth;
+	const isOverflowingY = scrollContainer.clientHeight < scrollContainer.scrollHeight;
+	if (isOverflowingX && orientation !== "vertical") {
+		const elementOffsetLeft = getOffset(scrollContainer, element, "left");
+		const containerStyles = getStyles(scrollContainer);
+		const elementStyles = getStyles(element);
+		if (direction === "ltr") {
+			if (elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight) targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight;
+			else if (elementOffsetLeft - elementStyles.scrollMarginLeft < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft) targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft;
+		}
+		if (direction === "rtl") {
+			if (elementOffsetLeft - elementStyles.scrollMarginRight < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft) targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft;
+			else if (elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight) targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight;
+		}
+	}
+	if (isOverflowingY && orientation !== "horizontal") {
+		const elementOffsetTop = getOffset(scrollContainer, element, "top");
+		const containerStyles = getStyles(scrollContainer);
+		const elementStyles = getStyles(element);
+		if (elementOffsetTop - elementStyles.scrollMarginTop < scrollContainer.scrollTop + containerStyles.scrollPaddingTop) targetY = elementOffsetTop - elementStyles.scrollMarginTop - containerStyles.scrollPaddingTop;
+		else if (elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom > scrollContainer.scrollTop + scrollContainer.clientHeight - containerStyles.scrollPaddingBottom) targetY = elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom - scrollContainer.clientHeight + containerStyles.scrollPaddingBottom;
+	}
+	scrollContainer.scrollTo({
+		left: targetX,
+		top: targetY,
+		behavior: "auto"
+	});
+}
+function getOffset(ancestor, element, side) {
+	const propName = side === "left" ? "offsetLeft" : "offsetTop";
+	let result = 0;
+	while (element.offsetParent) {
+		result += element[propName];
+		if (element.offsetParent === ancestor) break;
+		element = element.offsetParent;
+	}
+	return result;
+}
+function getStyles(element) {
+	const styles = getComputedStyle(element);
+	return {
+		scrollMarginTop: parseFloat(styles.scrollMarginTop) || 0,
+		scrollMarginRight: parseFloat(styles.scrollMarginRight) || 0,
+		scrollMarginBottom: parseFloat(styles.scrollMarginBottom) || 0,
+		scrollMarginLeft: parseFloat(styles.scrollMarginLeft) || 0,
+		scrollPaddingTop: parseFloat(styles.scrollPaddingTop) || 0,
+		scrollPaddingRight: parseFloat(styles.scrollPaddingRight) || 0,
+		scrollPaddingBottom: parseFloat(styles.scrollPaddingBottom) || 0,
+		scrollPaddingLeft: parseFloat(styles.scrollPaddingLeft) || 0
+	};
+}
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/dialog/popup/DialogPopup.js
-var stateAttributesMapping$1 = {
+var stateAttributesMapping$2 = {
 	...popupStateMapping,
 	...transitionStatusMapping,
 	nestedDialogOpen(value) {
@@ -10383,7 +10713,7 @@ var DialogPopup = /*#__PURE__*/ React.forwardRef(function DialogPopup(componentP
 			store.context.popupRef,
 			store.useStateSetter("popupElement")
 		],
-		stateAttributesMapping: stateAttributesMapping$1
+		stateAttributesMapping: stateAttributesMapping$2
 	});
 	return /*#__PURE__*/ jsx(FloatingFocusManager, {
 		context: floatingRootContext,
@@ -11991,7 +12321,7 @@ var TooltipPositioner = /*#__PURE__*/ React.forwardRef(function TooltipPositione
 if (process.env.NODE_ENV !== "production") TooltipPositioner.displayName = "TooltipPositioner";
 //#endregion
 //#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tooltip/popup/TooltipPopup.js
-var stateAttributesMapping = {
+var stateAttributesMapping$1 = {
 	...popupStateMapping,
 	...transitionStatusMapping
 };
@@ -12041,7 +12371,7 @@ var TooltipPopup = /*#__PURE__*/ React.forwardRef(function TooltipPopup(componen
 			getDisabledMountTransitionStyles(transitionStatus),
 			elementProps
 		],
-		stateAttributesMapping
+		stateAttributesMapping: stateAttributesMapping$1
 	});
 });
 if (process.env.NODE_ENV !== "production") TooltipPopup.displayName = "TooltipPopup";
@@ -12641,6 +12971,1075 @@ function NativeSelectOption$1({ className, ...props }) {
 	});
 }
 //#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/list/CompositeListContext.js
+var CompositeListContext = /*#__PURE__*/ React.createContext({
+	register: () => {},
+	unregister: () => {},
+	subscribeMapChange: () => {
+		return () => {};
+	},
+	elementsRef: { current: [] },
+	nextIndexRef: { current: 0 }
+});
+if (process.env.NODE_ENV !== "production") CompositeListContext.displayName = "CompositeListContext";
+function useCompositeListContext() {
+	return React.useContext(CompositeListContext);
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/list/CompositeList.js
+/**
+* Provides context for a list of items in a composite component.
+* @internal
+*/
+function CompositeList(props) {
+	const { children, elementsRef, labelsRef, onMapChange: onMapChangeProp } = props;
+	const onMapChange = useStableCallback(onMapChangeProp);
+	const nextIndexRef = React.useRef(0);
+	const listeners = useRefWithInit(createListeners).current;
+	const map = useRefWithInit(createMap).current;
+	const [mapTick, setMapTick] = React.useState(0);
+	const lastTickRef = React.useRef(mapTick);
+	const register = useStableCallback((node, metadata) => {
+		map.set(node, metadata ?? null);
+		lastTickRef.current += 1;
+		setMapTick(lastTickRef.current);
+	});
+	const unregister = useStableCallback((node) => {
+		map.delete(node);
+		lastTickRef.current += 1;
+		setMapTick(lastTickRef.current);
+	});
+	const sortedMap = React.useMemo(() => {
+		const newMap = /* @__PURE__ */ new Map();
+		Array.from(map.keys()).filter((node) => node.isConnected).sort(sortByDocumentPosition).forEach((node, index) => {
+			const metadata = map.get(node) ?? {};
+			newMap.set(node, {
+				...metadata,
+				index
+			});
+		});
+		return newMap;
+	}, [map, mapTick]);
+	useIsoLayoutEffect(() => {
+		if (typeof MutationObserver !== "function" || sortedMap.size === 0) return;
+		const mutationObserver = new MutationObserver((entries) => {
+			const diff = /* @__PURE__ */ new Set();
+			const updateDiff = (node) => diff.has(node) ? diff.delete(node) : diff.add(node);
+			entries.forEach((entry) => {
+				entry.removedNodes.forEach(updateDiff);
+				entry.addedNodes.forEach(updateDiff);
+			});
+			if (diff.size === 0) {
+				lastTickRef.current += 1;
+				setMapTick(lastTickRef.current);
+			}
+		});
+		sortedMap.forEach((_, node) => {
+			if (node.parentElement) mutationObserver.observe(node.parentElement, { childList: true });
+		});
+		return () => {
+			mutationObserver.disconnect();
+		};
+	}, [sortedMap]);
+	useIsoLayoutEffect(() => {
+		if (lastTickRef.current === mapTick) {
+			if (elementsRef.current.length !== sortedMap.size) elementsRef.current.length = sortedMap.size;
+			if (labelsRef && labelsRef.current.length !== sortedMap.size) labelsRef.current.length = sortedMap.size;
+			nextIndexRef.current = sortedMap.size;
+		}
+		onMapChange(sortedMap);
+	}, [
+		onMapChange,
+		sortedMap,
+		elementsRef,
+		labelsRef,
+		mapTick
+	]);
+	useIsoLayoutEffect(() => {
+		return () => {
+			elementsRef.current = [];
+		};
+	}, [elementsRef]);
+	useIsoLayoutEffect(() => {
+		return () => {
+			if (labelsRef) labelsRef.current = [];
+		};
+	}, [labelsRef]);
+	const subscribeMapChange = useStableCallback((fn) => {
+		listeners.add(fn);
+		return () => {
+			listeners.delete(fn);
+		};
+	});
+	useIsoLayoutEffect(() => {
+		listeners.forEach((l) => l(sortedMap));
+	}, [listeners, sortedMap]);
+	const contextValue = React.useMemo(() => ({
+		register,
+		unregister,
+		subscribeMapChange,
+		elementsRef,
+		labelsRef,
+		nextIndexRef
+	}), [
+		register,
+		unregister,
+		subscribeMapChange,
+		elementsRef,
+		labelsRef,
+		nextIndexRef
+	]);
+	return /*#__PURE__*/ jsx(CompositeListContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function createMap() {
+	return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+	return /* @__PURE__ */ new Set();
+}
+function sortByDocumentPosition(a, b) {
+	const position = a.compareDocumentPosition(b);
+	if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) return -1;
+	if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) return 1;
+	return 0;
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/root/TabsRootContext.js
+/**
+* @internal
+*/
+var 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
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/root/TabsRootDataAttributes.js
+var TabsRootDataAttributes = /*#__PURE__*/ function(TabsRootDataAttributes) {
+	/**
+	* Indicates the direction of the activation (based on the previous active tab).
+	* @type {'left' | 'right' | 'up' | 'down' | 'none'}
+	*/
+	TabsRootDataAttributes["activationDirection"] = "data-activation-direction";
+	/**
+	* Indicates the orientation of the tabs.
+	* @type {'horizontal' | 'vertical'}
+	*/
+	TabsRootDataAttributes["orientation"] = "data-orientation";
+	return TabsRootDataAttributes;
+}({});
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/root/stateAttributesMapping.js
+var tabsStateAttributesMapping = { tabActivationDirection: (dir) => ({ [TabsRootDataAttributes.activationDirection]: dir }) };
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/root/TabsRoot.js
+/**
+* Groups the tabs and the corresponding panels.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+var 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 = Object.hasOwn(componentProps, "defaultValue");
+	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 getTabElementBySelectedValue = React.useCallback((selectedValue) => {
+		if (selectedValue === void 0) return null;
+		for (const [tabElement, tabMetadata] of tabMap.entries()) if (tabMetadata != null && selectedValue === (tabMetadata.value ?? tabMetadata.index)) return tabElement;
+		return null;
+	}, [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 registerMountedTabPanel = useStableCallback((panelValue, panelId) => {
+		setMountedTabPanels((prev) => {
+			if (prev.get(panelValue) === panelId) return prev;
+			const next = new Map(prev);
+			next.set(panelValue, panelId);
+			return next;
+		});
+	});
+	const unregisterMountedTabPanel = useStableCallback((panelValue, panelId) => {
+		setMountedTabPanels((prev) => {
+			if (!prev.has(panelValue) || 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,
+		unregisterMountedTabPanel,
+		tabActivationDirection,
+		value
+	}), [
+		getTabElementBySelectedValue,
+		getTabIdByPanelValue,
+		getTabPanelIdByValue,
+		onValueChange,
+		orientation,
+		registerMountedTabPanel,
+		setTabMap,
+		unregisterMountedTabPanel,
+		tabActivationDirection,
+		value
+	]);
+	const selectedTabMetadata = React.useMemo(() => {
+		for (const tabMetadata of tabMap.values()) if (tabMetadata != null && tabMetadata.value === value) return tabMetadata;
+	}, [tabMap, value]);
+	const firstEnabledTabValue = React.useMemo(() => {
+		for (const tabMetadata of tabMap.values()) if (tabMetadata != null && !tabMetadata.disabled) return tabMetadata.value;
+	}, [tabMap]);
+	useIsoLayoutEffect(() => {
+		if (isControlled || tabMap.size === 0) return;
+		const selectionIsDisabled = selectedTabMetadata?.disabled;
+		const selectionIsMissing = selectedTabMetadata == null && value !== null;
+		if (hasExplicitDefaultValueProp && selectionIsDisabled && value === defaultValueProp) return;
+		if (!selectionIsDisabled && !selectionIsMissing) return;
+		const fallbackValue = firstEnabledTabValue ?? null;
+		if (value === fallbackValue) return;
+		setValue(fallbackValue);
+		setActivationDirectionState((prev) => {
+			if (prev.tabActivationDirection === "none") return prev;
+			return {
+				...prev,
+				tabActivationDirection: "none"
+			};
+		});
+	}, [
+		defaultValueProp,
+		firstEnabledTabValue,
+		hasExplicitDefaultValueProp,
+		isControlled,
+		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 computeActivationDirection(oldValue, newValue, orientation, tabMap) {
+	if (oldValue == null || newValue == null) return "none";
+	let oldTab = null;
+	let newTab = null;
+	for (const [tabElement, tabMetadata] of tabMap.entries()) {
+		if (tabMetadata == null) continue;
+		const tabValue = tabMetadata.value ?? tabMetadata.index;
+		if (oldValue === tabValue) oldTab = tabElement;
+		if (newValue === tabValue) newTab = tabElement;
+		if (oldTab != null && newTab != null) break;
+	}
+	if (oldTab == null || newTab == null) {
+		if (oldTab !== newTab && (typeof oldValue === "number" || typeof oldValue === "string") && typeof oldValue === typeof newValue) {
+			if (orientation === "horizontal") return newValue > oldValue ? "right" : "left";
+			return newValue > oldValue ? "down" : "up";
+		}
+		return "none";
+	}
+	const oldRect = oldTab.getBoundingClientRect();
+	const newRect = newTab.getBoundingClientRect();
+	if (orientation === "horizontal") {
+		if (newRect.left < oldRect.left) return "left";
+		if (newRect.left > oldRect.left) return "right";
+	} else {
+		if (newRect.top < oldRect.top) return "up";
+		if (newRect.top > oldRect.top) return "down";
+	}
+	return "none";
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/constants.js
+var ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/list/useCompositeListItem.js
+var IndexGuessBehavior = /*#__PURE__*/ function(IndexGuessBehavior) {
+	IndexGuessBehavior[IndexGuessBehavior["None"] = 0] = "None";
+	IndexGuessBehavior[IndexGuessBehavior["GuessFromOrder"] = 1] = "GuessFromOrder";
+	return IndexGuessBehavior;
+}({});
+/**
+* Used to register a list item and its index (DOM position) in the `CompositeList`.
+*/
+function useCompositeListItem(params = {}) {
+	const { label, metadata, textRef, indexGuessBehavior, index: externalIndex } = params;
+	const { register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef } = useCompositeListContext();
+	const indexRef = React.useRef(-1);
+	const [index, setIndex] = React.useState(externalIndex ?? (indexGuessBehavior === IndexGuessBehavior.GuessFromOrder ? () => {
+		if (indexRef.current === -1) {
+			const newIndex = nextIndexRef.current;
+			nextIndexRef.current += 1;
+			indexRef.current = newIndex;
+		}
+		return indexRef.current;
+	} : -1));
+	const componentRef = React.useRef(null);
+	const ref = React.useCallback((node) => {
+		componentRef.current = node;
+		if (index !== -1 && node !== null) {
+			elementsRef.current[index] = node;
+			if (labelsRef) {
+				const isLabelDefined = label !== void 0;
+				labelsRef.current[index] = isLabelDefined ? label : textRef?.current?.textContent ?? node.textContent;
+			}
+		}
+	}, [
+		index,
+		elementsRef,
+		labelsRef,
+		label,
+		textRef
+	]);
+	useIsoLayoutEffect(() => {
+		if (externalIndex != null) return;
+		const node = componentRef.current;
+		if (node) {
+			register(node, metadata);
+			return () => {
+				unregister(node);
+			};
+		}
+	}, [
+		externalIndex,
+		register,
+		unregister,
+		metadata
+	]);
+	useIsoLayoutEffect(() => {
+		if (externalIndex != null) return;
+		return subscribeMapChange((map) => {
+			const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+			if (i != null) setIndex(i);
+		});
+	}, [
+		externalIndex,
+		subscribeMapChange,
+		setIndex
+	]);
+	return React.useMemo(() => ({
+		ref,
+		index
+	}), [index, ref]);
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/item/useCompositeItem.js
+function useCompositeItem(params = {}) {
+	const { highlightItemOnHover, highlightedIndex, onHighlightedIndexChange } = useCompositeRootContext();
+	const { ref, index } = useCompositeListItem(params);
+	const isHighlighted = highlightedIndex === index;
+	const itemRef = React.useRef(null);
+	const mergedRef = useMergedRefs(ref, itemRef);
+	return {
+		compositeProps: React.useMemo(() => ({
+			tabIndex: isHighlighted ? 0 : -1,
+			onFocus() {
+				onHighlightedIndexChange(index);
+			},
+			onMouseMove() {
+				const item = itemRef.current;
+				if (!highlightItemOnHover || !item) return;
+				const disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+				if (!isHighlighted && !disabled) item.focus();
+			}
+		}), [
+			isHighlighted,
+			onHighlightedIndexChange,
+			index,
+			highlightItemOnHover
+		]),
+		compositeRef: mergedRef,
+		index
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/list/TabsListContext.js
+var 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
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/tab/TabsTab.js
+/**
+* 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)
+*/
+var 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, orientation } = useTabsRootContext();
+	const { activateOnFocus, highlightedTabIndex, onTabActivation, registerTabResizeObserverElement, setHighlightedTabIndex, tabsListElement } = useTabsListContext();
+	const id = useBaseUiId(idProp);
+	const { compositeProps, compositeRef, index } = useCompositeItem({ metadata: React.useMemo(() => ({
+		disabled,
+		id,
+		value
+	}), [
+		disabled,
+		id,
+		value
+	]) });
+	const active = value === activeTabValue;
+	const isNavigatingRef = React.useRef(false);
+	const tabElementRef = React.useRef(null);
+	React.useEffect(() => {
+		const tabElement = tabElementRef.current;
+		if (!tabElement) return;
+		return registerTabResizeObserverElement(tabElement);
+	}, [registerTabResizeObserverElement]);
+	useIsoLayoutEffect(() => {
+		if (isNavigatingRef.current) {
+			isNavigatingRef.current = false;
+			return;
+		}
+		if (!(active && index > -1 && highlightedTabIndex !== index)) return;
+		const listElement = tabsListElement;
+		if (listElement != null) {
+			const activeEl = activeElement(ownerDocument(listElement));
+			if (activeEl && contains(listElement, activeEl)) return;
+		}
+		if (!disabled) setHighlightedTabIndex(index);
+	}, [
+		active,
+		index,
+		highlightedTabIndex,
+		setHighlightedTabIndex,
+		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 onClick(event) {
+		if (active || disabled) return;
+		onTabActivation(value, createChangeEventDetails(none, event.nativeEvent, void 0, { activationDirection: "none" }));
+	}
+	function onFocus(event) {
+		if (active) return;
+		if (index > -1 && !disabled) setHighlightedTabIndex(index);
+		if (disabled) return;
+		if (activateOnFocus && (!isPressingRef.current || isPressingRef.current && isMainButtonRef.current)) onTabActivation(value, createChangeEventDetails(none, event.nativeEvent, void 0, { activationDirection: "none" }));
+	}
+	function onPointerDown(event) {
+		if (active || disabled) return;
+		isPressingRef.current = true;
+		function handlePointerUp() {
+			isPressingRef.current = false;
+			isMainButtonRef.current = false;
+		}
+		if (!event.button || event.button === 0) {
+			isMainButtonRef.current = true;
+			ownerDocument(event.currentTarget).addEventListener("pointerup", handlePointerUp, { once: true });
+		}
+	}
+	return useRenderElement("button", componentProps, {
+		state: {
+			disabled,
+			active,
+			orientation
+		},
+		ref: [
+			forwardedRef,
+			buttonRef,
+			compositeRef,
+			tabElementRef
+		],
+		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
+		]
+	});
+});
+if (process.env.NODE_ENV !== "production") TabsTab.displayName = "TabsTab";
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/panel/TabsPanelDataAttributes.js
+var TabsPanelDataAttributes = function(TabsPanelDataAttributes) {
+	/**
+	* Indicates the index of the tab panel.
+	*/
+	TabsPanelDataAttributes["index"] = "data-index";
+	/**
+	* Indicates the direction of the activation (based on the previous active tab).
+	* @type {'left' | 'right' | 'up' | 'down' | 'none'}
+	*/
+	TabsPanelDataAttributes["activationDirection"] = "data-activation-direction";
+	/**
+	* Indicates the orientation of the tabs.
+	* @type {'horizontal' | 'vertical'}
+	*/
+	TabsPanelDataAttributes["orientation"] = "data-orientation";
+	/**
+	* Present when the panel is hidden.
+	*/
+	TabsPanelDataAttributes["hidden"] = "data-hidden";
+	/**
+	* Present when the panel is animating in.
+	*/
+	TabsPanelDataAttributes[TabsPanelDataAttributes["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
+	/**
+	* Present when the panel is animating out.
+	*/
+	TabsPanelDataAttributes[TabsPanelDataAttributes["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
+	return TabsPanelDataAttributes;
+}({});
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/panel/TabsPanel.js
+var stateAttributesMapping = {
+	...tabsStateAttributesMapping,
+	...transitionStatusMapping
+};
+/**
+* A panel displayed when the corresponding tab is active.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+var TabsPanel = /*#__PURE__*/ React.forwardRef(function TabPanel(componentProps, forwardedRef) {
+	const { className, value, render, keepMounted = false, style, ...elementProps } = componentProps;
+	const { value: selectedValue, getTabIdByPanelValue, orientation, tabActivationDirection, registerMountedTabPanel, unregisterMountedTabPanel } = useTabsRootContext();
+	const id = useBaseUiId();
+	const { ref: listItemRef, index } = useCompositeListItem({ metadata: React.useMemo(() => ({
+		id,
+		value
+	}), [id, value]) });
+	const open = value === selectedValue;
+	const { mounted, transitionStatus, setMounted } = useTransitionStatus(open);
+	const hidden = !mounted;
+	const correspondingTabId = getTabIdByPanelValue(value);
+	const state = {
+		hidden,
+		orientation,
+		tabActivationDirection,
+		transitionStatus
+	};
+	const panelRef = React.useRef(null);
+	const element = useRenderElement("div", componentProps, {
+		state,
+		ref: [
+			forwardedRef,
+			listItemRef,
+			panelRef
+		],
+		props: [{
+			"aria-labelledby": correspondingTabId,
+			hidden,
+			id,
+			role: "tabpanel",
+			tabIndex: open ? 0 : -1,
+			inert: inertValue(!open),
+			[TabsPanelDataAttributes.index]: index
+		}, elementProps],
+		stateAttributesMapping
+	});
+	useOpenChangeComplete({
+		open,
+		ref: panelRef,
+		onComplete() {
+			if (!open) setMounted(false);
+		}
+	});
+	useIsoLayoutEffect(() => {
+		if (hidden && !keepMounted) return;
+		if (id == null) return;
+		registerMountedTabPanel(value, id);
+		return () => {
+			unregisterMountedTabPanel(value, id);
+		};
+	}, [
+		hidden,
+		keepMounted,
+		value,
+		id,
+		registerMountedTabPanel,
+		unregisterMountedTabPanel
+	]);
+	if (!(keepMounted || mounted)) return null;
+	return element;
+});
+if (process.env.NODE_ENV !== "production") TabsPanel.displayName = "TabsPanel";
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+utils@0.2.8+b87d06724be9db7a/node_modules/@base-ui/utils/esm/isElementDisabled.js
+function isElementDisabled(element) {
+	return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/root/useCompositeRoot.js
+var EMPTY_ARRAY = [];
+function useCompositeRoot(params) {
+	const { itemSizes, cols = 1, loopFocus = true, onLoop, dense = false, orientation = "both", direction, highlightedIndex: externalHighlightedIndex, onHighlightedIndexChange: externalSetHighlightedIndex, rootRef: externalRef, enableHomeAndEndKeys = false, stopEventPropagation = false, disabledIndices, modifierKeys = EMPTY_ARRAY } = params;
+	const [internalHighlightedIndex, internalSetHighlightedIndex] = React.useState(0);
+	const isGrid = cols > 1;
+	const rootRef = React.useRef(null);
+	const mergedRef = useMergedRefs(rootRef, externalRef);
+	const elementsRef = React.useRef([]);
+	const hasSetDefaultIndexRef = React.useRef(false);
+	const highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex;
+	const onHighlightedIndexChange = useStableCallback((index, shouldScrollIntoView = false) => {
+		(externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index);
+		if (shouldScrollIntoView) {
+			const newActiveItem = elementsRef.current[index];
+			scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
+		}
+	});
+	const onMapChange = useStableCallback((map) => {
+		if (map.size === 0 || hasSetDefaultIndexRef.current) return;
+		hasSetDefaultIndexRef.current = true;
+		const sortedElements = Array.from(map.keys());
+		const activeItem = sortedElements.find((compositeElement) => compositeElement?.hasAttribute("data-composite-item-active")) ?? null;
+		const activeIndex = activeItem ? sortedElements.indexOf(activeItem) : -1;
+		if (activeIndex !== -1) onHighlightedIndexChange(activeIndex);
+		scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+	});
+	const wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex) => {
+		if (!onLoop) return nextIndex;
+		return onLoop?.(event, prevIndex, nextIndex, elementsRef);
+	});
+	const props = React.useMemo(() => ({
+		"aria-orientation": orientation === "both" ? void 0 : orientation,
+		ref: mergedRef,
+		onFocus(event) {
+			const element = rootRef.current;
+			const target = getTarget(event.nativeEvent);
+			if (!element || target == null || !isNativeInput(target)) return;
+			target.setSelectionRange(0, target.value.length ?? 0);
+		},
+		onKeyDown(event) {
+			const RELEVANT_KEYS = enableHomeAndEndKeys ? ALL_KEYS : ARROW_KEYS;
+			if (!RELEVANT_KEYS.has(event.key)) return;
+			if (isModifierKeySet(event, modifierKeys)) return;
+			if (!rootRef.current) return;
+			const isRtl = direction === "rtl";
+			const horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT;
+			const forwardKey = {
+				horizontal: horizontalForwardKey,
+				vertical: ARROW_DOWN,
+				both: horizontalForwardKey
+			}[orientation];
+			const horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT;
+			const backwardKey = {
+				horizontal: horizontalBackwardKey,
+				vertical: ARROW_UP,
+				both: horizontalBackwardKey
+			}[orientation];
+			const target = getTarget(event.nativeEvent);
+			if (target != null && isNativeInput(target) && !isElementDisabled(target)) {
+				const selectionStart = target.selectionStart;
+				const selectionEnd = target.selectionEnd;
+				const textContent = target.value ?? "";
+				if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd) return;
+				if (event.key !== backwardKey && selectionStart < textContent.length) return;
+				if (event.key !== forwardKey && selectionStart > 0) return;
+			}
+			let nextIndex = highlightedIndex;
+			const minIndex = getMinListIndex(elementsRef, disabledIndices);
+			const maxIndex = getMaxListIndex(elementsRef, disabledIndices);
+			if (isGrid) {
+				const sizes = itemSizes || Array.from({ length: elementsRef.current.length }, () => ({
+					width: 1,
+					height: 1
+				}));
+				const cellMap = createGridCellMap(sizes, cols, dense);
+				const minGridIndex = cellMap.findIndex((index) => index != null && !isListIndexDisabled(elementsRef.current, index, disabledIndices));
+				const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isListIndexDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);
+				nextIndex = cellMap[getGridNavigatedIndex(cellMap.map((itemIndex) => itemIndex != null ? elementsRef.current[itemIndex] : null), {
+					event,
+					orientation,
+					loopFocus,
+					onLoop: wrappedOnLoop,
+					cols,
+					disabledIndices: getGridCellIndices([...disabledIndices || elementsRef.current.map((_, index) => isListIndexDisabled(elementsRef.current, index) ? index : void 0), void 0], cellMap),
+					minIndex: minGridIndex,
+					maxIndex: maxGridIndex,
+					prevIndex: getGridCellIndexOfCorner(highlightedIndex > maxIndex ? minIndex : highlightedIndex, sizes, cellMap, cols, event.key === "ArrowDown" ? "bl" : event.key === "ArrowRight" ? "tr" : "tl"),
+					rtl: isRtl
+				})];
+			}
+			const forwardKeys = {
+				horizontal: [horizontalForwardKey],
+				vertical: [ARROW_DOWN],
+				both: [horizontalForwardKey, ARROW_DOWN]
+			}[orientation];
+			const backwardKeys = {
+				horizontal: [horizontalBackwardKey],
+				vertical: [ARROW_UP],
+				both: [horizontalBackwardKey, ARROW_UP]
+			}[orientation];
+			const preventedKeys = isGrid ? RELEVANT_KEYS : {
+				horizontal: enableHomeAndEndKeys ? HORIZONTAL_KEYS_WITH_EXTRA_KEYS : HORIZONTAL_KEYS,
+				vertical: enableHomeAndEndKeys ? VERTICAL_KEYS_WITH_EXTRA_KEYS : VERTICAL_KEYS,
+				both: RELEVANT_KEYS
+			}[orientation];
+			if (enableHomeAndEndKeys) {
+				if (event.key === "Home") nextIndex = minIndex;
+				else if (event.key === "End") nextIndex = maxIndex;
+			}
+			if (nextIndex === highlightedIndex && (forwardKeys.includes(event.key) || backwardKeys.includes(event.key))) {
+				if (loopFocus && nextIndex === maxIndex && forwardKeys.includes(event.key)) {
+					nextIndex = minIndex;
+					if (onLoop) nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+				} else if (loopFocus && nextIndex === minIndex && backwardKeys.includes(event.key)) {
+					nextIndex = maxIndex;
+					if (onLoop) nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+				} else nextIndex = findNonDisabledListIndex(elementsRef.current, {
+					startingIndex: nextIndex,
+					decrement: backwardKeys.includes(event.key),
+					disabledIndices
+				});
+			}
+			if (nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex)) {
+				if (stopEventPropagation) event.stopPropagation();
+				if (preventedKeys.has(event.key)) event.preventDefault();
+				onHighlightedIndexChange(nextIndex, true);
+				queueMicrotask(() => {
+					elementsRef.current[nextIndex]?.focus();
+				});
+			}
+		}
+	}), [
+		cols,
+		dense,
+		direction,
+		disabledIndices,
+		elementsRef,
+		enableHomeAndEndKeys,
+		highlightedIndex,
+		isGrid,
+		itemSizes,
+		loopFocus,
+		onLoop,
+		wrappedOnLoop,
+		mergedRef,
+		modifierKeys,
+		onHighlightedIndexChange,
+		orientation,
+		stopEventPropagation
+	]);
+	return React.useMemo(() => ({
+		props,
+		highlightedIndex,
+		onHighlightedIndexChange,
+		elementsRef,
+		disabledIndices,
+		onMapChange,
+		relayKeyboardEvent: props.onKeyDown
+	}), [
+		props,
+		highlightedIndex,
+		onHighlightedIndexChange,
+		elementsRef,
+		disabledIndices,
+		onMapChange
+	]);
+}
+function isModifierKeySet(event, ignoredModifierKeys) {
+	for (const key of MODIFIER_KEYS.values()) {
+		if (ignoredModifierKeys.includes(key)) continue;
+		if (event.getModifierState(key)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/internals/composite/root/CompositeRoot.js
+/**
+* @internal
+*/
+function CompositeRoot(componentProps) {
+	const { render, className, style, refs = EMPTY_ARRAY$1, props = EMPTY_ARRAY$1, state = EMPTY_OBJECT, stateAttributesMapping, highlightedIndex: highlightedIndexProp, onHighlightedIndexChange: onHighlightedIndexChangeProp, orientation, dense, itemSizes, loopFocus, onLoop, cols, enableHomeAndEndKeys, onMapChange: onMapChangeProp, stopEventPropagation = true, rootRef, disabledIndices, modifierKeys, highlightItemOnHover = false, tag = "div", ...elementProps } = componentProps;
+	const { props: defaultProps, highlightedIndex, onHighlightedIndexChange, elementsRef, onMapChange: onMapChangeUnwrapped, relayKeyboardEvent } = useCompositeRoot({
+		itemSizes,
+		cols,
+		loopFocus,
+		onLoop,
+		dense,
+		orientation,
+		highlightedIndex: highlightedIndexProp,
+		onHighlightedIndexChange: onHighlightedIndexChangeProp,
+		rootRef,
+		stopEventPropagation,
+		enableHomeAndEndKeys,
+		direction: useDirection(),
+		disabledIndices,
+		modifierKeys
+	});
+	const element = useRenderElement(tag, componentProps, {
+		state,
+		ref: refs,
+		props: [
+			defaultProps,
+			...props,
+			elementProps
+		],
+		stateAttributesMapping
+	});
+	const contextValue = React.useMemo(() => ({
+		highlightedIndex,
+		onHighlightedIndexChange,
+		highlightItemOnHover,
+		relayKeyboardEvent
+	}), [
+		highlightedIndex,
+		onHighlightedIndexChange,
+		highlightItemOnHover,
+		relayKeyboardEvent
+	]);
+	return /*#__PURE__*/ jsx(CompositeRootContext.Provider, {
+		value: contextValue,
+		children: /*#__PURE__*/ jsx(CompositeList, {
+			elementsRef,
+			onMapChange: (newMap) => {
+				onMapChangeProp?.(newMap);
+				onMapChangeUnwrapped(newMap);
+			},
+			children: element
+		})
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@base-ui+react@1.4.1+fa6c2f29eeb10566/node_modules/@base-ui/react/esm/tabs/list/TabsList.js
+/**
+* Groups the individual tab buttons.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Tabs](https://base-ui.com/react/components/tabs)
+*/
+var TabsList$2 = /*#__PURE__*/ React.forwardRef(function TabsList(componentProps, forwardedRef) {
+	const { activateOnFocus = false, className, loopFocus = true, render, style, ...elementProps } = componentProps;
+	const { onValueChange, orientation, value, 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);
+	const notifyIndicatorUpdateListeners = useStableCallback(() => {
+		indicatorUpdateListenersRef.current.forEach((listener) => {
+			listener();
+		});
+	});
+	React.useEffect(() => {
+		if (typeof ResizeObserver === "undefined") return;
+		const resizeObserver = new ResizeObserver(() => {
+			if (!indicatorUpdateListenersRef.current.size) return;
+			notifyIndicatorUpdateListeners();
+		});
+		resizeObserverRef.current = resizeObserver;
+		if (tabsListElement) resizeObserver.observe(tabsListElement);
+		tabResizeObserverElementsRef.current.forEach((element) => {
+			resizeObserver.observe(element);
+		});
+		return () => {
+			resizeObserver.disconnect();
+			resizeObserverRef.current = null;
+		};
+	}, [tabsListElement, notifyIndicatorUpdateListeners]);
+	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 onTabActivation = useStableCallback((newValue, eventDetails) => {
+		if (newValue !== value) onValueChange(newValue, eventDetails);
+	});
+	const state = {
+		orientation,
+		tabActivationDirection
+	};
+	const defaultProps = {
+		"aria-orientation": orientation === "vertical" ? "vertical" : void 0,
+		role: "tablist"
+	};
+	const tabsListContextValue = React.useMemo(() => ({
+		activateOnFocus,
+		highlightedTabIndex,
+		registerIndicatorUpdateListener,
+		registerTabResizeObserverElement,
+		onTabActivation,
+		setHighlightedTabIndex,
+		tabsListElement
+	}), [
+		activateOnFocus,
+		highlightedTabIndex,
+		registerIndicatorUpdateListener,
+		registerTabResizeObserverElement,
+		onTabActivation,
+		setHighlightedTabIndex,
+		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$1
+		})
+	});
+});
+if (process.env.NODE_ENV !== "production") TabsList$2.displayName = "TabsList";
+//#endregion
+//#region src/ui/browser/tabs.tsx
+function Tabs$1({ className, orientation = "horizontal", ...props }) {
+	return /* @__PURE__ */ jsx(TabsRoot, {
+		"data-slot": "tabs",
+		"data-orientation": orientation,
+		className: cn("group/tabs flex gap-2 data-[orientation=horizontal]:flex-col", className),
+		orientation,
+		...props
+	});
+}
+var tabsListVariants = cva("group/tabs-list inline-flex w-fit items-center justify-center rounded-lg text-muted-foreground group-data-[orientation=vertical]/tabs:h-fit group-data-[orientation=vertical]/tabs:flex-col data-[variant=line]:rounded-none", {
+	variants: {
+		size: {
+			default: "p-[3px] group-data-[orientation=horizontal]/tabs:h-8",
+			sm: "rounded-[6px] p-0.5 group-data-[orientation=horizontal]/tabs:h-6"
+		},
+		variant: {
+			default: "bg-muted",
+			line: "gap-1 bg-transparent",
+			navigation: "gap-1 bg-transparent data-[variant=navigation]:p-0 group-data-[orientation=horizontal]/tabs:data-[variant=navigation]:h-auto",
+			flat: "gap-1 bg-[color-mix(in_srgb,var(--ui-foreground)_8%,var(--ui-popover))] dark:bg-[color-mix(in_srgb,black_16%,var(--ui-popover))]"
+		}
+	},
+	defaultVariants: {
+		size: "default",
+		variant: "default"
+	}
+});
+function TabsList$1({ className, variant = "default", size = "default", ...props }) {
+	return /* @__PURE__ */ jsx(TabsList$2, {
+		"data-slot": "tabs-list",
+		"data-variant": variant,
+		"data-size": size,
+		className: cn(tabsListVariants({
+			variant,
+			size
+		}), className),
+		...props
+	});
+}
+function TabsTrigger$1({ className, ...props }) {
+	return /* @__PURE__ */ jsx(TabsTab, {
+		"data-slot": "tabs-trigger",
+		className: cn("relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium whitespace-nowrap text-foreground/60 transition-[color,background-color,border-color,box-shadow,opacity] group-data-[orientation=vertical]/tabs:w-full group-data-[orientation=vertical]/tabs:justify-start hover:text-foreground focus-visible:border-border focus-visible:outline-2 focus-visible:outline-solid focus-visible:ring-0 focus-visible:aria-invalid:ring-0 focus-visible:outline-offset-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 aria-disabled:pointer-events-none aria-disabled:opacity-50 motion-reduce:transition-none dark:text-muted-foreground dark:hover:text-foreground group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", "group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent", "group-data-[variant=navigation]/tabs-list:h-auto group-data-[variant=navigation]/tabs-list:flex-none group-data-[variant=navigation]/tabs-list:rounded-[6px] group-data-[variant=navigation]/tabs-list:border-0 group-data-[variant=navigation]/tabs-list:px-3 group-data-[variant=navigation]/tabs-list:py-2 group-data-[variant=navigation]/tabs-list:text-[13px] group-data-[variant=navigation]/tabs-list:font-normal group-data-[variant=navigation]/tabs-list:text-muted-foreground group-data-[variant=navigation]/tabs-list:hover:bg-muted group-data-[variant=navigation]/tabs-list:hover:text-foreground group-data-[variant=navigation]/tabs-list:data-active:bg-muted group-data-[variant=navigation]/tabs-list:data-active:font-semibold group-data-[variant=navigation]/tabs-list:data-active:text-foreground dark:group-data-[variant=navigation]/tabs-list:data-active:bg-muted dark:group-data-[variant=navigation]/tabs-list:data-active:text-foreground", "group-data-[variant=flat]/tabs-list:h-full group-data-[variant=flat]/tabs-list:border-0 group-data-[variant=flat]/tabs-list:data-active:bg-popover group-data-[variant=flat]/tabs-list:data-active:shadow-[0_1px_2px_rgb(0_0_0/0.08)] dark:group-data-[variant=flat]/tabs-list:data-active:bg-[color-mix(in_srgb,var(--ui-foreground)_8%,var(--ui-popover))]", "data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground", "after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-[orientation=horizontal]/tabs:after:inset-x-0 group-data-[orientation=horizontal]/tabs:after:bottom-[-5px] group-data-[orientation=horizontal]/tabs:after:h-0.5 group-data-[orientation=vertical]/tabs:after:inset-y-0 group-data-[orientation=vertical]/tabs:after:-right-1 group-data-[orientation=vertical]/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100 motion-reduce:after:transition-none", "group-data-[size=sm]/tabs-list:rounded-[4px] group-data-[size=sm]/tabs-list:gap-1 group-data-[size=sm]/tabs-list:py-0 group-data-[size=sm]/tabs-list:text-[11px] group-data-[size=sm]/tabs-list:leading-4 group-data-[orientation=horizontal]/tabs:group-data-[size=sm]/tabs-list:after:bottom-[-4px]", "group-data-[variant=navigation]/tabs-list:group-data-[size=sm]/tabs-list:rounded-[4px] group-data-[variant=navigation]/tabs-list:group-data-[size=sm]/tabs-list:px-2 group-data-[variant=navigation]/tabs-list:group-data-[size=sm]/tabs-list:py-1 group-data-[variant=navigation]/tabs-list:group-data-[size=sm]/tabs-list:text-[12px]", className),
+		...props
+	});
+}
+function TabsContent$1({ className, ...props }) {
+	return /* @__PURE__ */ jsx(TabsPanel, {
+		"data-slot": "tabs-content",
+		className: cn("flex-1 text-sm outline-none", className),
+		...props
+	});
+}
+//#endregion
 //#region src/ui/browser/label.tsx
 function Label({ className, ...props }) {
 	return /* @__PURE__ */ jsx("label", {
@@ -12876,6 +14275,10 @@ var DialogHeader = DialogHeader$1;
 var DialogFooter = DialogFooter$1;
 var DialogTitle = DialogTitle$1;
 var DialogDescription = DialogDescription$1;
+var Tabs = Tabs$1;
+var TabsList = TabsList$1;
+var TabsTrigger = TabsTrigger$1;
+var TabsContent = TabsContent$1;
 var InputGroup = InputGroup$1;
 var InputGroupAddon = InputGroupAddon$1;
 var InputGroupInput = InputGroupInput$1;
@@ -12916,4 +14319,4 @@ function NotificationUndoLabel({ children }) {
 	}), children);
 }
 //#endregion
-export { Button, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, HostNavigationActions, HostTooltip, IdTooltip, Input, InputGroup, InputGroupAddon, InputGroupInput, Label, NativeSelect, NativeSelectOption, NotificationUndoLabel, OpenFlowLogo, Textarea, notificationToasterProps };
+export { Button, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, HostNavigationActions, HostTooltip, IdTooltip, Input, InputGroup, InputGroupAddon, InputGroupInput, Label, NativeSelect, NativeSelectOption, NotificationUndoLabel, OpenFlowLogo, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, notificationToasterProps };