solid-baseui 0.1.0-alpha.0

package/dist/lib/server/select/index.js

@@ -0,0 +1,2630 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { getStateAttributesProps } from "../internals/getStateAttributesProps.js";
+import { F as windowResize, S as listNavigation, t as cancelOpen, w as none, y as itemPress } from "../internals/reasons.js";
+import { n as resolveClass, t as resolveStyle } from "../resolveStyle-XCSFDHAL.js";
+import { createChangeEventDetails } from "../internals/createBaseUIEventDetails.js";
+import { transitionStatusMapping } from "../internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "../internals/composeEventHandlers.js";
+import { t as runOnceAnimationsFinish } from "../runOnceAnimationsFinish-DCHzXWZU.js";
+import { m as ownerWindow, n as contains, p as ownerDocument } from "../dom-Crg_2R-j.js";
+import { t as createAnchorPositioning } from "../createAnchorPositioning-C-cVOPwz.js";
+import { t as InternalBackdrop } from "../InternalBackdrop-C_iDPVR-.js";
+import { t as createAnchoredPopupScrollLock } from "../createAnchoredPopupScrollLock-DFuUrykR.js";
+import { t as createClickInteraction } from "../createClickInteraction-BYsMgvup.js";
+import { c as useFloatingTree, i as createFloatingNode, n as FloatingTreeContext, r as FloatingTreeStore, s as useFloatingParentNodeId, t as FloatingParentNodeContext } from "../FloatingTree-z1JPD1dR.js";
+import { a as createPopupPresence, n as createTriggerRegistration, o as createDismiss, t as PopupStore } from "../PopupStore-DEs3FAEe.js";
+import { t as createTransitionStatus } from "../createTransitionStatus-BTlrerSS.js";
+import { a as triggerOpenStateMapping, i as pressableTriggerOpenStateMapping, n as popupStateMapping, o as PopupPortal, r as popupTransitionStateMapping } from "../popupStateMapping-nKoUwoke.js";
+import { t as FocusManager } from "../FocusManager-BrbZVWME.js";
+import { t as TriggerFocusGuards } from "../TriggerFocusGuards-sbGwf45f.js";
+import { a as stopButtonInteraction, i as preventDisabledButtonKeyDown, n as handleNonNativeButtonKeyUp, r as preventButtonInteraction, t as handleNonNativeButtonKeyDown } from "../buttonSemantics-BSwDxJhh.js";
+import { t as setRef } from "../setRef-Bt70sW7c.js";
+import { n as useDirection } from "../DirectionContext-YORWLF08.js";
+import { fieldStateAttributesMapping } from "../internals/field-constants.js";
+import { n as useFieldRootContext } from "../FieldRootContext-IC-LWzVp.js";
+import { n as useFormContext } from "../FormContext-pvESt85v.js";
+import { a as defaultItemEquality, c as removeItem, i as compareItemEquality, n as isSolidAccessor, o as findItemIndex, r as areItemArraysEqual, t as mergeStyleValue } from "../mergeStyleValue-Db8bRCM4.js";
+import { r as useLabelableContext } from "../LabelableContext-DZP3rgAY.js";
+import { n as useToolbarRootContext } from "../ToolbarRootContext-DD-qe7s8.js";
+import { Dynamic, escape, memo, mergeProps, scope, ssr, ssrAttribute, ssrElement, ssrGroup, ssrHydrationKey, ssrStyle } from "@solidjs/web";
+import { For, Show, createContext, createEffect, createMemo, createSignal, createUniqueId, flush, merge, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/select/utils/value.ts
+function serializeValue(value, itemToStringValue) {
+	if (value == null) return "";
+	if (itemToStringValue) return itemToStringValue(value) ?? "";
+	if (typeof value === "object" && hasOwn(value, "value") && hasOwn(value, "label")) return serializeUnknown(value.value);
+	return serializeUnknown(value);
+}
+function stringifyAsLabel(value, itemToStringLabel) {
+	if (value == null) return "";
+	if (itemToStringLabel) return itemToStringLabel(value) ?? "";
+	if (typeof value === "object") {
+		if (hasOwn(value, "label") && value.label != null) return String(value.label);
+		if (hasOwn(value, "value") && value.value != null) return String(value.value);
+	}
+	return serializeUnknown(value);
+}
+function resolveSelectedLabel(value, items, itemToStringLabel) {
+	if (value != null && itemToStringLabel) return itemToStringLabel(value);
+	if (value != null && typeof value === "object" && hasOwn(value, "label") && value.label != null) return value.label;
+	const resolved = findItemLabel(value, items);
+	return resolved.found ? resolved.label : stringifyAsLabel(value, itemToStringLabel);
+}
+function resolveMultipleLabels(values, items, itemToStringLabel) {
+	return values.map((value) => resolveSelectedLabel(value, items, itemToStringLabel)).flatMap((label, index) => index === 0 ? [label] : [", ", label]);
+}
+function hasNullItemLabel(items) {
+	return findItemLabel(null, items).found && findItemLabel(null, items).label != null;
+}
+function findItemLabel(value, items) {
+	if (!items) return {
+		found: false,
+		label: void 0
+	};
+	if (!Array.isArray(items)) {
+		const key = String(value);
+		return Object.prototype.hasOwnProperty.call(items, key) ? {
+			found: true,
+			label: items[key]
+		} : {
+			found: false,
+			label: void 0
+		};
+	}
+	const definitions = flattenItems(items);
+	for (const item of definitions) if (Object.is(item.value, value) || value != null && typeof value === "object" && hasOwn(value, "value") && Object.is(item.value, value.value)) return {
+		found: true,
+		label: item.label
+	};
+	return {
+		found: false,
+		label: void 0
+	};
+}
+function flattenItems(items) {
+	const first = items[0];
+	if (first && typeof first === "object" && "items" in first) return items.flatMap((group) => group.items);
+	return items;
+}
+function serializeUnknown(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function getMaxScrollOffset(scrollSize, clientSize) {
+	return Math.max(0, scrollSize - clientSize);
+}
+function normalizeScrollOffset(offset, maximum) {
+	if (offset <= 1) return 0;
+	if (maximum - offset <= 1) return maximum;
+	return Math.max(0, Math.min(maximum, offset));
+}
+//#endregion
+//#region src/select/store/SelectCollection.ts
+var SelectCollection = class {
+	registrations = /* @__PURE__ */ new Map();
+	revision;
+	setRevision;
+	order = 0;
+	constructor() {
+		const [revision, setRevision] = createSignal(0, { ownedWrite: true });
+		this.revision = revision;
+		this.setRevision = setRevision;
+	}
+	register(item) {
+		const registration = {
+			...item,
+			order: this.order
+		};
+		this.order += 1;
+		this.registrations.set(item.token, registration);
+		this.touch();
+		return () => {
+			if (this.registrations.delete(item.token)) this.touch();
+		};
+	}
+	touch() {
+		this.setRevision((value) => value + 1);
+	}
+	items() {
+		this.revision();
+		return Array.from(this.registrations.values()).sort(compareItems);
+	}
+	indexOf(token) {
+		return this.items().findIndex((item) => item.token === token);
+	}
+	elements() {
+		return this.items().map((item) => item.element());
+	}
+	labels() {
+		return this.items().map((item) => {
+			const explicit = item.label();
+			if (explicit !== void 0) return explicit;
+			return item.textElement()?.textContent ?? item.element()?.textContent ?? null;
+		});
+	}
+	values() {
+		return this.items().map((item) => item.value());
+	}
+	disabledIndices() {
+		return this.items().flatMap((item, index) => item.disabled() ? [index] : []);
+	}
+};
+function compareItems(first, second) {
+	const firstElement = first.element();
+	const secondElement = second.element();
+	if (firstElement && secondElement && firstElement !== secondElement) {
+		const position = firstElement.compareDocumentPosition(secondElement);
+		if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+		if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+	}
+	return first.order - second.order;
+}
+//#endregion
+//#region src/select/store/SelectStore.ts
+var SelectStore = class extends PopupStore {
+	collection = new SelectCollection();
+	selection = {
+		allowSelectedMouseUp: false,
+		allowUnselectedMouseUp: false,
+		dragY: 0
+	};
+	activeElementAccessor;
+	setActiveElementSignal;
+	activeElementValue = null;
+	openMethodAccessor;
+	setOpenMethodSignal;
+	openReasonAccessor;
+	setOpenReasonSignal;
+	forceMountAccessor;
+	setForceMountSignal;
+	labelIdAccessor;
+	setLabelIdSignal;
+	listElementAccessor;
+	setListElementSignal;
+	popupSideAccessor;
+	setPopupSideSignal;
+	scrollUpVisibleAccessor;
+	setScrollUpVisibleSignal;
+	scrollDownVisibleAccessor;
+	setScrollDownVisibleSignal;
+	hasScrollArrowsAccessor;
+	setHasScrollArrowsSignal;
+	alignItemAccessor;
+	setAlignItemSignal;
+	typingAccessor;
+	setTypingSignal;
+	forceMountAllowed = true;
+	focusSequence = 0;
+	scrollFrame;
+	pointerX = null;
+	pointerY = null;
+	pointerHoverBlocked = false;
+	pointerMovements = /* @__PURE__ */ new WeakMap();
+	pointerHoverFrame;
+	constructor(options) {
+		super(options);
+		const [activeElement, setActiveElement] = createSignal(null, { ownedWrite: true });
+		this.activeElementAccessor = activeElement;
+		this.setActiveElementSignal = setActiveElement;
+		const [openMethod, setOpenMethod] = createSignal(null, { ownedWrite: true });
+		this.openMethodAccessor = openMethod;
+		this.setOpenMethodSignal = setOpenMethod;
+		const [openReason, setOpenReason] = createSignal(null, { ownedWrite: true });
+		this.openReasonAccessor = openReason;
+		this.setOpenReasonSignal = setOpenReason;
+		const [forceMount, setForceMount] = createSignal(false, { ownedWrite: true });
+		this.forceMountAccessor = forceMount;
+		this.setForceMountSignal = setForceMount;
+		const [labelId, setLabelId] = createSignal();
+		this.labelIdAccessor = labelId;
+		this.setLabelIdSignal = setLabelId;
+		const [listElement, setListElement] = createSignal(null, { ownedWrite: true });
+		this.listElementAccessor = listElement;
+		this.setListElementSignal = setListElement;
+		const [popupSide, setPopupSide] = createSignal(null, { ownedWrite: true });
+		this.popupSideAccessor = popupSide;
+		this.setPopupSideSignal = setPopupSide;
+		const [scrollUpVisible, setScrollUpVisible] = createSignal(false, { ownedWrite: true });
+		this.scrollUpVisibleAccessor = scrollUpVisible;
+		this.setScrollUpVisibleSignal = setScrollUpVisible;
+		const [scrollDownVisible, setScrollDownVisible] = createSignal(false, { ownedWrite: true });
+		this.scrollDownVisibleAccessor = scrollDownVisible;
+		this.setScrollDownVisibleSignal = setScrollDownVisible;
+		const [hasScrollArrows, setHasScrollArrows] = createSignal(false, { ownedWrite: true });
+		this.hasScrollArrowsAccessor = hasScrollArrows;
+		this.setHasScrollArrowsSignal = setHasScrollArrows;
+		const [alignItem, setAlignItem] = createSignal(false, { ownedWrite: true });
+		this.alignItemAccessor = alignItem;
+		this.setAlignItemSignal = setAlignItem;
+		const [typing, setTyping] = createSignal(false, { ownedWrite: true });
+		this.typingAccessor = typing;
+		this.setTypingSignal = setTyping;
+	}
+	activeIndex() {
+		this.activeElementAccessor();
+		const element = this.activeElementValue;
+		if (!element) return null;
+		const index = this.collection.elements().indexOf(element);
+		return index === -1 ? null : index;
+	}
+	activeElement() {
+		this.activeElementAccessor();
+		return this.activeElementValue;
+	}
+	setActiveIndex(index, focus = false) {
+		const element = index === null ? null : this.collection.elements()[index] ?? null;
+		const sequence = ++this.focusSequence;
+		this.activeElementValue = element;
+		this.setActiveElementSignal(element);
+		if (this.scrollFrame) {
+			this.scrollFrame.window.cancelAnimationFrame(this.scrollFrame.id);
+			this.scrollFrame = void 0;
+		}
+		if (focus && element) {
+			flush();
+			element.focus({ preventScroll: true });
+			const windowNode = element.ownerDocument.defaultView;
+			if (windowNode) {
+				const id = windowNode.requestAnimationFrame(() => {
+					if (sequence === this.focusSequence && this.activeElementValue === element && element.isConnected) element.scrollIntoView?.({
+						block: "nearest",
+						inline: "nearest"
+					});
+				});
+				this.scrollFrame = {
+					window: windowNode,
+					id
+				};
+			}
+		}
+	}
+	setActiveElement(element) {
+		this.activeElementValue = element;
+		this.setActiveElementSignal(element);
+		flush();
+	}
+	trackPointer(event) {
+		if ("pointerType" in event && event.pointerType !== "mouse") return;
+		const moved = this.pointerX !== null && this.pointerY !== null ? event.clientX !== this.pointerX || event.clientY !== this.pointerY : !this.pointerHoverBlocked;
+		this.pointerX = event.clientX;
+		this.pointerY = event.clientY;
+		this.pointerMovements.set(event, moved);
+	}
+	pointerMoved(event) {
+		if (!this.pointerMovements.has(event)) this.trackPointer(event);
+		const moved = this.pointerMovements.get(event) ?? false;
+		if (this.pointerHoverBlocked && !moved) return false;
+		if (moved) this.pointerHoverBlocked = false;
+		return moved;
+	}
+	blockPointerHover(windowNode) {
+		this.pointerHoverBlocked = true;
+		if (this.pointerHoverFrame) {
+			this.pointerHoverFrame.window.cancelAnimationFrame(this.pointerHoverFrame.id);
+			this.pointerHoverFrame = void 0;
+		}
+		if (this.pointerX !== null || !windowNode) return;
+		const firstFrame = windowNode.requestAnimationFrame(() => {
+			const secondFrame = windowNode.requestAnimationFrame(() => {
+				this.pointerHoverFrame = void 0;
+				if (this.pointerX === null) this.pointerHoverBlocked = false;
+			});
+			this.pointerHoverFrame = {
+				window: windowNode,
+				id: secondFrame
+			};
+		});
+		this.pointerHoverFrame = {
+			window: windowNode,
+			id: firstFrame
+		};
+	}
+	openMethod() {
+		return this.openMethodAccessor();
+	}
+	setOpenMethod(method) {
+		this.setOpenMethodSignal(method);
+	}
+	openChangeReason() {
+		return this.openReasonAccessor();
+	}
+	forceMount() {
+		return this.forceMountAccessor();
+	}
+	setForceMount(value) {
+		if (!value || this.forceMountAllowed) this.setForceMountSignal(value);
+	}
+	suppressForceMount() {
+		this.forceMountAllowed = false;
+		this.setForceMountSignal(false);
+	}
+	labelId() {
+		return this.labelIdAccessor();
+	}
+	setLabelId(value) {
+		this.setLabelIdSignal(value);
+	}
+	listElement() {
+		return this.listElementAccessor();
+	}
+	setListElement(value) {
+		this.setListElementSignal(value);
+	}
+	popupSide() {
+		return this.popupSideAccessor();
+	}
+	setPopupSide(value) {
+		this.setPopupSideSignal(value);
+	}
+	scrollUpVisible() {
+		return this.scrollUpVisibleAccessor();
+	}
+	setScrollUpVisible(value) {
+		this.setScrollUpVisibleSignal(value);
+	}
+	scrollDownVisible() {
+		return this.scrollDownVisibleAccessor();
+	}
+	setScrollDownVisible(value) {
+		this.setScrollDownVisibleSignal(value);
+	}
+	hasScrollArrows() {
+		return this.hasScrollArrowsAccessor();
+	}
+	setHasScrollArrows(value) {
+		this.setHasScrollArrowsSignal(value);
+	}
+	alignItemWithTrigger() {
+		return this.alignItemAccessor();
+	}
+	setAlignItemWithTrigger(value) {
+		this.setAlignItemSignal(value);
+	}
+	typing() {
+		return this.typingAccessor();
+	}
+	setTyping(value) {
+		this.setTypingSignal(value);
+	}
+	resetAfterClose() {
+		this.setActiveIndex(null);
+		this.setOpenMethod(null);
+		this.setScrollUpVisible(false);
+		this.setScrollDownVisible(false);
+		this.setTyping(false);
+		this.selection.allowSelectedMouseUp = false;
+		this.selection.allowUnselectedMouseUp = false;
+		this.selection.dragY = 0;
+	}
+	dispose() {
+		this.focusSequence += 1;
+		if (this.scrollFrame) {
+			this.scrollFrame.window.cancelAnimationFrame(this.scrollFrame.id);
+			this.scrollFrame = void 0;
+		}
+		if (this.pointerHoverFrame) {
+			this.pointerHoverFrame.window.cancelAnimationFrame(this.pointerHoverFrame.id);
+			this.pointerHoverFrame = void 0;
+		}
+	}
+	setOpen(open, details) {
+		const accepted = super.setOpen(open, details);
+		if (accepted) {
+			if (open) this.forceMountAllowed = true;
+			this.setOpenReasonSignal(details.reason);
+		}
+		return accepted;
+	}
+};
+//#endregion
+//#region src/select/root/SelectRootContext.ts
+var MISSING_CONTEXT$4 = Symbol("SelectRootContext");
+var SelectRootContext = createContext(MISSING_CONTEXT$4);
+function useSelectRootContext() {
+	const context = useContext(SelectRootContext);
+	if (context === MISSING_CONTEXT$4) throw new Error("Base UI: SelectRootContext is missing. Select parts must be placed within <Select.Root>.");
+	return context;
+}
+//#endregion
+//#region src/select/root/SelectRoot.tsx
+var _tmpl$ = [
+	"<input",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	" tabindex=\"-1\" style=\"",
+	"\" aria-hidden=\"true\"",
+	"",
+	">"
+];
+var _tmpl$2 = [
+	"<input",
+	" type=\"hidden\"",
+	"",
+	"",
+	"",
+	">"
+];
+var HIDDEN_INPUT_STYLE = {
+	"clip-path": "inset(50%)",
+	overflow: "hidden",
+	"white-space": "nowrap",
+	border: "0",
+	padding: "0",
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	position: "fixed",
+	top: "0",
+	left: "0"
+};
+var HIDDEN_NAMED_INPUT_STYLE = {
+	...HIDDEN_INPUT_STYLE,
+	position: "absolute"
+};
+/** Groups all parts of the select without rendering a wrapper element. */
+function SelectRoot(props) {
+	var _v$, _g$2, _g$, _v$6;
+	const field = useFieldRootContext(true);
+	const formContext = useFormContext();
+	const labelable = useLabelableContext();
+	const inheritedTree = useFloatingTree();
+	const inheritedParentNodeId = useFloatingParentNodeId();
+	const tree = inheritedTree ?? new FloatingTreeStore();
+	const fieldControlSource = Symbol("Select");
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const floatingId = `base-ui-${createUniqueId()}`;
+	const nodeId = createUniqueId();
+	const controlledValue = untrack(() => props.value !== void 0);
+	const controlledOpen = untrack(() => props.open !== void 0);
+	const multiple = createMemo(() => props.multiple ?? false);
+	const initialValue = untrack(() => {
+		const defaultValue = props.defaultValue;
+		if (defaultValue != null) return cloneValue(defaultValue);
+		return props.multiple ? [] : null;
+	});
+	const [uncontrolledValue, setUncontrolledValue] = createSignal(() => initialValue);
+	const [triggerElement, setTriggerElement] = createSignal(null, { ownedWrite: true });
+	const [inputElement, setInputElement] = createSignal(null, { ownedWrite: true });
+	const [valueElement, setValueElement] = createSignal(null, { ownedWrite: true });
+	const [firstItemText, setFirstItemText] = createSignal(null, { ownedWrite: true });
+	const [selectedItemText, setSelectedItemText] = createSignal(null, { ownedWrite: true });
+	const [backdropElement, setBackdropElement] = createSignal(null, { ownedWrite: true });
+	const [internalBackdropElement, setInternalBackdropElement] = createSignal(null, { ownedWrite: true });
+	const [beforeContentGuard, setBeforeContentGuard] = createSignal(null, { ownedWrite: true });
+	const [afterTriggerGuard, setAfterTriggerGuard] = createSignal(null, { ownedWrite: true });
+	const id = createMemo(() => props.id ?? generatedId);
+	const value = createMemo(() => controlledValue ? props.value : uncontrolledValue());
+	const comparator = createMemo(() => props.isItemEqualToValue ?? defaultItemEquality);
+	const disabled = createMemo(() => field.disabled() || (props.disabled ?? false));
+	const readOnly = createMemo(() => props.readOnly ?? false);
+	const required = createMemo(() => props.required ?? false);
+	const modal = createMemo(() => props.modal ?? true);
+	const highlightItemOnHover = createMemo(() => props.highlightItemOnHover ?? true);
+	const name = createMemo(() => field.name() ?? props.name);
+	const serializedValue = createMemo(() => multiple() ? "" : serializeValue(value(), props.itemToStringValue));
+	const serializedFieldValue = createMemo(() => {
+		const current = value();
+		return multiple() && Array.isArray(current) ? current.map((item) => serializeValue(item, props.itemToStringValue)) : serializeValue(current, props.itemToStringValue);
+	});
+	const hasSelectedValue = createMemo(() => {
+		const current = value();
+		return multiple() ? Array.isArray(current) && current.length > 0 : current != null && serializedValue() !== "";
+	});
+	let previousValue = cloneValue(untrack(value));
+	let previousOpen = Boolean(untrack(() => props.open ?? props.defaultOpen));
+	let selectionTimer;
+	let typeaheadTimer;
+	let typed = "";
+	let typeaheadMatch = -1;
+	let pendingInitialFocus = null;
+	let initializedOpen = false;
+	let focusEpoch = 0;
+	let previousElements = [];
+	const scrollHandler = { current: null };
+	const store = new SelectStore({
+		controlledOpen: () => controlledOpen ? props.open : void 0,
+		floatingId,
+		nodeId,
+		onOpenChange: () => (open, details) => {
+			if (!open && props.actionsRef) details.preventUnmountOnClose();
+			props.onOpenChange?.(open, details);
+			if (!details.isCanceled && !open && (details.reason === "focus-out" || details.reason === "outside-press")) {
+				field.setTouched(true);
+				field.setFocused(false);
+				if (field.validationMode() === "onBlur") field.validation.commit(untrack(value));
+			}
+		},
+		onOpenChangeComplete: () => props.onOpenChangeComplete
+	});
+	store.update({ open: previousOpen });
+	store.configureTriggerUnmount({ closeOnActiveTriggerUnmount: false });
+	const node = createFloatingNode({
+		tree,
+		id: nodeId,
+		parentId: inheritedParentNodeId,
+		context: () => store.context.floatingRoot
+	});
+	const presence = createPopupPresence(store, () => store.track().popupElement, { onUnmount: () => store.resetAfterClose() });
+	const selectedIndex = createMemo(() => {
+		const values = store.collection.values();
+		const current = value();
+		if (multiple()) {
+			if (!Array.isArray(current) || current.length === 0) return null;
+			const index = findItemIndex(values, current[current.length - 1], comparator());
+			return index === -1 ? null : index;
+		}
+		const index = findItemIndex(values, current, comparator());
+		return index === -1 ? null : index;
+	});
+	function setValue(nextValue, details) {
+		props.onValueChange?.(nextValue, details);
+		if (details.isCanceled) return false;
+		if (!controlledValue) setUncontrolledValue(() => nextValue);
+		return true;
+	}
+	function setOpen(open, details) {
+		return store.setOpen(open, details);
+	}
+	const dismiss = createDismiss({
+		context: store.context.floatingRoot,
+		tree: () => tree,
+		outsidePressEvent: () => ({
+			mouse: "sloppy",
+			touch: "sloppy"
+		})
+	});
+	function handleKeyDown(event) {
+		store.blockPointerHover(event.currentTarget?.ownerDocument.defaultView ?? null);
+		dismiss.onKeyDown(event);
+		if (event.baseUIHandlerPrevented || event.key === "Escape" && event.defaultPrevented) return;
+		handleTypeahead(event);
+		handleNavigation(event);
+	}
+	function handleNavigation(event) {
+		if (disabled() || readOnly() || ![
+			"ArrowDown",
+			"ArrowUp",
+			"Home",
+			"End"
+		].includes(event.key)) return;
+		event.preventDefault();
+		event.stopPropagation();
+		if (!store.open()) {
+			if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+			pendingInitialFocus = event.key === "ArrowDown" ? "first" : "last";
+			store.setOpenMethod("keyboard");
+			setOpen(true, createChangeEventDetails(listNavigation, event, triggerElement() ?? void 0));
+			return;
+		}
+		const elements = store.collection.elements();
+		if (elements.length === 0) return;
+		const current = store.activeIndex() ?? selectedIndex() ?? -1;
+		const next = event.key === "Home" ? 0 : event.key === "End" ? elements.length - 1 : Math.max(0, Math.min(elements.length - 1, current + (event.key === "ArrowDown" ? 1 : -1)));
+		store.setActiveIndex(next, true);
+	}
+	function resetTypeahead() {
+		clearTimeout(typeaheadTimer);
+		typed = "";
+		typeaheadMatch = -1;
+		store.setTyping(false);
+	}
+	function handleTypeahead(event) {
+		if (disabled() || readOnly() || !store.open() && multiple() || event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return;
+		if (typed && event.key === " ") {
+			event.preventDefault();
+			event.stopPropagation();
+		}
+		typed = typed.length > 0 && [...typed].every((character) => character.toLocaleLowerCase() === event.key.toLocaleLowerCase()) ? event.key : typed + event.key;
+		store.setTyping(true);
+		clearTimeout(typeaheadTimer);
+		typeaheadTimer = setTimeout(resetTypeahead, 750);
+		const labels = store.collection.labels();
+		const disabledItems = new Set(store.collection.disabledIndices());
+		const start = (typeaheadMatch >= 0 ? typeaheadMatch : store.activeIndex() ?? selectedIndex() ?? -1) + 1;
+		const query = typed.toLocaleLowerCase();
+		for (let offset = 0; offset < labels.length; offset += 1) {
+			const index = (start + offset) % labels.length;
+			if (!disabledItems.has(index) && labels[index]?.toLocaleLowerCase().startsWith(query)) {
+				typeaheadMatch = index;
+				if (store.open()) {
+					event.preventDefault();
+					event.stopPropagation();
+					store.setActiveIndex(index, true);
+				} else {
+					const nextValue = store.collection.values()[index];
+					if (nextValue !== void 0) setValue(nextValue, createChangeEventDetails(none, event));
+				}
+				return;
+			}
+		}
+	}
+	function handleTypeaheadBlur(event) {
+		untrack(() => {
+			const next = event.relatedTarget;
+			const positioner = store.track().positionerElement;
+			if (!triggerElement()?.contains(next) && !positioner?.contains(next)) resetTypeahead();
+		});
+	}
+	function handleScroll(scroller) {
+		if (scrollHandler.current) {
+			scrollHandler.current(scroller);
+			return;
+		}
+		updateScrollArrowVisibility(scroller);
+	}
+	function updateScrollArrowVisibility(scroller) {
+		const maximum = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+		const offset = normalizeScrollOffset(scroller.scrollTop, maximum);
+		if (offset !== scroller.scrollTop) scroller.scrollTop = offset;
+		store.setScrollUpVisible(offset > 0);
+		store.setScrollDownVisible(offset < maximum);
+	}
+	const context = {
+		store,
+		tree,
+		node,
+		presence,
+		id,
+		value,
+		items: () => props.items,
+		multiple,
+		disabled,
+		readOnly,
+		required,
+		modal,
+		highlightItemOnHover,
+		itemToStringLabel: () => props.itemToStringLabel,
+		itemToStringValue: () => props.itemToStringValue,
+		comparator,
+		hasSelectedValue,
+		selectedIndex,
+		setValue,
+		setOpen,
+		triggerElement,
+		setTriggerElement,
+		valueElement,
+		setValueElement,
+		firstItemText,
+		selectedItemText,
+		setFirstItemText,
+		setSelectedItemText,
+		handleKeyDown,
+		handleTypeaheadBlur,
+		handleScroll,
+		updateScrollArrowVisibility,
+		scrollHandler,
+		scrollArrowsMounted: { count: 0 },
+		field,
+		formContext,
+		backdropElement,
+		setBackdropElement,
+		internalBackdropElement,
+		setInternalBackdropElement,
+		beforeContentGuard,
+		setBeforeContentGuard,
+		afterTriggerGuard,
+		setAfterTriggerGuard,
+		initialValue
+	};
+	const registration = {
+		id: generatedId,
+		name: void 0,
+		value,
+		getValue: serializedFieldValue,
+		getControl: () => triggerElement()
+	};
+	const actions = { unmount() {
+		store.suppressForceMount();
+		presence.forceUnmount();
+	} };
+	store.context.floatingRoot.context.data.insideElements = () => [backdropElement(), internalBackdropElement()];
+	store.setInteractionProps({
+		activeTriggerProps: { onKeyDown: handleKeyDown },
+		inactiveTriggerProps: { onKeyDown: handleKeyDown },
+		popupProps: { onKeyDown: handleKeyDown }
+	});
+	createEffect(() => ({
+		open: store.open(),
+		activeTriggerId: store.activeTriggerId()
+	}), () => untrack(() => store.reconcileTriggers()));
+	createEffect(() => triggerElement()?.ownerDocument, (documentNode) => {
+		if (!documentNode) return;
+		const trackPointer = (event) => store.trackPointer(event);
+		documentNode.addEventListener("pointermove", trackPointer, true);
+		documentNode.addEventListener("mousemove", trackPointer, true);
+		return () => {
+			documentNode.removeEventListener("pointermove", trackPointer, true);
+			documentNode.removeEventListener("mousemove", trackPointer, true);
+		};
+	});
+	createEffect(() => store.open(), (open) => {
+		clearTimeout(selectionTimer);
+		if (open) selectionTimer = setTimeout(() => {
+			store.selection.allowSelectedMouseUp = true;
+			store.selection.allowUnselectedMouseUp = true;
+		}, 400);
+		else if (previousOpen) {
+			store.selection.allowSelectedMouseUp = false;
+			store.selection.allowUnselectedMouseUp = false;
+			store.selection.dragY = 0;
+		}
+		previousOpen = open;
+	});
+	createEffect(() => ({
+		open: store.open(),
+		reason: store.openChangeReason(),
+		trigger: triggerElement()
+	}), (current, previous) => {
+		if (previous?.open && !current.open && current.trigger && (current.reason === "item-press" || current.reason === "escape-key")) queueMicrotask(() => current.trigger?.focus({ preventScroll: true }));
+	});
+	createEffect(() => ({
+		open: store.open(),
+		mounted: presence.mounted(),
+		itemCount: store.collection.items().length
+	}), ({ open, mounted, itemCount }) => {
+		if (!open) {
+			initializedOpen = false;
+			focusEpoch += 1;
+			return;
+		}
+		if (!mounted || itemCount === 0 || initializedOpen) return;
+		initializedOpen = true;
+		const epoch = ++focusEpoch;
+		queueMicrotask(() => {
+			untrack(() => {
+				if (epoch !== focusEpoch || !store.open()) return;
+				const selected = selectedIndex();
+				const available = store.collection.items().flatMap((item, index) => item.disabled() ? [] : [index]);
+				const index = selected ?? (pendingInitialFocus === "last" ? available[available.length - 1] : available[0]) ?? null;
+				pendingInitialFocus = null;
+				store.setActiveIndex(index, true);
+			});
+		});
+	});
+	createEffect(() => store.collection.elements(), (elements) => {
+		const previous = previousElements;
+		previousElements = elements;
+		untrack(() => {
+			const active = store.activeElement();
+			if (!store.open() || !presence.mounted() || !active || elements.includes(active)) return;
+			const previousIndex = previous.indexOf(active);
+			const available = store.collection.items().flatMap((item, index) => item.disabled() ? [] : [index]);
+			const next = available.find((index) => index >= Math.max(0, previousIndex)) ?? available[available.length - 1] ?? null;
+			store.setActiveIndex(next, next !== null);
+		});
+	});
+	createEffect(() => ({
+		current: value(),
+		filled: hasSelectedValue(),
+		comparator: comparator()
+	}), ({ current, filled, comparator: currentComparator }) => {
+		field.setFilled(filled);
+		if (sameValue(current, previousValue, currentComparator)) return;
+		previousValue = cloneValue(current);
+		untrack(() => {
+			formContext.clearError(name());
+			field.setDirty(!sameDirtyValue(current, field.validityData().initialValue, currentComparator));
+			field.validation.change(current);
+		});
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		id: id(),
+		name: props.name,
+		trigger: triggerElement()
+	}), (current) => {
+		registration.id = current.id;
+		registration.name = current.name;
+		field.registerFieldControl(fieldControlSource, current.disabled || !current.trigger ? void 0 : registration);
+	});
+	createEffect(inputElement, (input) => {
+		if (!input) return;
+		return field.validation.registerInput(fieldControlSource, input, () => triggerElement());
+	});
+	createEffect(() => props.actionsRef, (actionsRef) => {
+		actionsRef?.(actions);
+	});
+	onCleanup(() => {
+		clearTimeout(selectionTimer);
+		clearTimeout(typeaheadTimer);
+		field.registerFieldControl(fieldControlSource, void 0);
+		store.dispose();
+		store.clearInteractionProps();
+		delete store.context.floatingRoot.context.data.insideElements;
+	});
+	return SelectRootContext({
+		value: context,
+		get children() {
+			return FloatingTreeContext({
+				value: tree,
+				get children() {
+					return FloatingParentNodeContext({
+						get value() {
+							return node.id ?? null;
+						},
+						get children() {
+							return [
+								memo(() => {
+									return escape(props.children);
+								}),
+								(_v$ = ssrHydrationKey(), props.inputRef, _g$2 = ssrGroup(() => {
+									return [
+										ssrAttribute("id", name() == null ? `${escape(id(), true)}-hidden-input` : escape(void 0, true)),
+										ssrAttribute("form", escape(props.form, true)),
+										ssrAttribute("name", multiple() ? escape(void 0, true) : escape(name(), true)),
+										ssrAttribute("autocomplete", escape(props.autoComplete, true))
+									];
+								}, 4), _g$ = ssrGroup(() => {
+									return [
+										ssrAttribute("disabled", escape(disabled(), true)),
+										ssrAttribute("required", required() && !(multiple() && hasSelectedValue())),
+										ssrAttribute("readonly", escape(readOnly(), true)),
+										ssrStyle(name() ? HIDDEN_NAMED_INPUT_STYLE : HIDDEN_INPUT_STYLE),
+										ssrAttribute("aria-describedby", escape(labelable.getAriaDescribedBy(void 0), true)),
+										ssrAttribute("aria-invalid", field.state().valid === false && !disabled() ? "true" : escape(void 0, true))
+									];
+								}, 6), _v$6 = () => {
+									return ssrAttribute("value", escape(serializedValue(), true));
+								}, ssr(_tmpl$, _v$, _g$2, _g$2, _g$2, _g$2, _v$6, _g$, _g$, _g$, _g$, _g$, _g$)),
+								For({
+									get each() {
+										return memo(() => {
+											return !!(multiple() && Array.isArray(value()));
+										})() ? value() : [];
+									},
+									children: (item) => {
+										var _v$13, _g$3, _v$17, _v$16;
+										return _v$13 = ssrHydrationKey(), _g$3 = ssrGroup(() => {
+											return [ssrAttribute("form", escape(props.form, true)), ssrAttribute("name", escape(name(), true))];
+										}, 2), _v$17 = () => {
+											return ssrAttribute("disabled", escape(disabled(), true));
+										}, _v$16 = () => {
+											return ssrAttribute("value", escape(serializeValue(item, props.itemToStringValue), true));
+										}, ssr(_tmpl$2, _v$13, _g$3, _g$3, _v$16, _v$17);
+									}
+								})
+							];
+						}
+					});
+				}
+			});
+		}
+	});
+}
+function cloneValue(value) {
+	return Array.isArray(value) ? value.slice() : value;
+}
+function sameValue(first, second, comparator) {
+	if (Array.isArray(first) && Array.isArray(second)) return areItemArraysEqual(first, second, comparator);
+	return Object.is(first, second);
+}
+function sameDirtyValue(current, initial, comparator) {
+	if (Array.isArray(current) && Array.isArray(initial)) return areItemArraysEqual(current, initial, comparator);
+	return current === initial;
+}
+//#endregion
+//#region src/select/label/SelectLabel.tsx
+/** An accessible label automatically associated with the select trigger. */
+function SelectLabel(props) {
+	const context = useSelectRootContext();
+	const labelable = useLabelableContext();
+	const internalProps = props;
+	const allProps = props;
+	const id = createMemo(() => `${context.id()}-label`);
+	const state = createMemo(() => context.field.state());
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), fieldStateAttributesMapping));
+	const others = omit(allProps, "as", "class", "id", "onClick", "onPointerDown", "ref", "style");
+	function focusTrigger(event) {
+		const target = event.composedPath()[0];
+		if (target instanceof Element && target.closest("button,input,select,textarea,a[href]")) return;
+		if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+		context.triggerElement()?.focus({ focusVisible: true });
+	}
+	function preventPointerFocus(event) {
+		event.preventDefault();
+	}
+	const onClick = composeEventHandlers(() => internalProps.onClick, () => focusTrigger);
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => preventPointerFocus);
+	createEffect(id, (currentId) => {
+		context.store.setLabelId(currentId);
+		const unregister = labelable.registerLabelId(currentId);
+		return () => {
+			unregister();
+			if (untrack(() => context.store.labelId()) === currentId) context.store.setLabelId(void 0);
+		};
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		get id() {
+			return id();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onClick,
+		onPointerDown
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/select/utils/stateAttributesMapping.ts
+var selectTriggerStateMapping = {
+	...pressableTriggerOpenStateMapping,
+	...fieldStateAttributesMapping,
+	popupSide: (value) => value ? { "data-popup-side": value } : null,
+	value: () => null
+};
+var selectPositionerStateMapping = { ...popupStateMapping };
+var selectPopupStateMapping = { ...popupTransitionStateMapping };
+//#endregion
+//#region src/select/trigger/SelectTrigger.tsx
+/** A button that opens the select popup. */
+function SelectTrigger(props) {
+	const context = useSelectRootContext();
+	const labelable = useLabelableContext();
+	const internalProps = props;
+	const allProps = props;
+	const labelSource = Symbol("SelectTrigger");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const id = createMemo(() => internalProps.id ?? context.id());
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const disabled = createMemo(() => context.disabled() || (internalProps.disabled ?? false));
+	const open = createMemo(() => context.store.open());
+	const popupSide = createMemo(() => context.presence.mounted() && context.store.track().positionerElement ? context.store.popupSide() : null);
+	const state = createMemo(() => ({
+		...context.field.state(),
+		open: open(),
+		disabled: disabled(),
+		readOnly: context.readOnly(),
+		popupSide: popupSide(),
+		value: context.value(),
+		placeholder: !context.hasSelectedValue()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), selectTriggerStateMapping));
+	const ariaLabelledBy = createMemo(() => internalProps["aria-labelledby"] ?? labelable.labelId() ?? context.store.labelId());
+	const ariaDescribedBy = createMemo(() => labelable.getAriaDescribedBy(internalProps["aria-describedby"]));
+	const others = omit(allProps, "aria-describedby", "aria-labelledby", "as", "class", "disabled", "id", "nativeButton", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseDown", "onPointerDown", "ref", "style");
+	const click = createClickInteraction({
+		context: context.store.context.floatingRoot,
+		enabled: () => !disabled() && !context.readOnly(),
+		event: () => "mousedown"
+	});
+	let pointerType = "";
+	let mouseUpTimer;
+	let removeMouseUp;
+	createTriggerRegistration(() => context.store, id, element);
+	function handlePointerDown(event) {
+		pointerType = event.pointerType || "";
+		click.onPointerDown(event);
+	}
+	function handleMouseDown(event) {
+		if (!open()) {
+			context.store.setOpenMethod(pointerType || (isIOS() ? "touch" : "mouse"));
+			installReleaseListener(event.currentTarget);
+		}
+		click.onMouseDown(event);
+	}
+	function installReleaseListener(trigger) {
+		clearTimeout(mouseUpTimer);
+		removeMouseUp?.();
+		mouseUpTimer = setTimeout(() => {
+			const onMouseUp = (event) => {
+				const target = event.target;
+				const positioner = context.store.track().positionerElement;
+				if (contains(trigger, target) || contains(positioner, target)) return;
+				const rect = trigger.getBoundingClientRect();
+				if (!(event.clientX >= rect.left - 5 && event.clientX <= rect.right + 5 && event.clientY >= rect.top - 5 && event.clientY <= rect.bottom + 5)) context.setOpen(false, createChangeEventDetails(cancelOpen, event));
+			};
+			trigger.ownerDocument.addEventListener("mouseup", onMouseUp, { once: true });
+			removeMouseUp = () => trigger.ownerDocument.removeEventListener("mouseup", onMouseUp);
+		});
+	}
+	function handleClick(event) {
+		if (event.detail === 0) context.store.setOpenMethod("keyboard");
+		click.onClick(event);
+	}
+	function handleFocus() {
+		context.field.setFocused(true);
+		if (open() && context.store.alignItemWithTrigger()) context.setOpen(false, createChangeEventDetails(none));
+		queueMicrotask(() => context.store.setForceMount(true));
+	}
+	function handleBlur(event) {
+		untrack(() => {
+			if (contains(context.store.track().positionerElement, event.relatedTarget)) return;
+			context.field.setTouched(true);
+			context.field.setFocused(false);
+			if (context.field.validationMode() === "onBlur") context.field.validation.commit(context.value());
+			context.handleTypeaheadBlur(event);
+		});
+	}
+	function handleKeyDown(event) {
+		if (event.target !== event.currentTarget) return;
+		pointerType = "keyboard";
+		context.handleKeyDown(event);
+	}
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => handleBlur);
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => handleFocus);
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledButtonKeyDown : void 0), () => internalProps.onKeyDown, () => handleKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeButtonKeyUp));
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onMouseDown, () => handleMouseDown);
+	const onPointerDown = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onPointerDown, () => handlePointerDown);
+	createEffect(() => ({
+		id: id(),
+		element: element()
+	}), (current) => {
+		context.setTriggerElement(current.element);
+		labelable.registerControlId(labelSource, current.id);
+		return () => {
+			if (context.triggerElement() === current.element) context.setTriggerElement(null);
+		};
+	});
+	onCleanup(() => {
+		clearTimeout(mouseUpTimer);
+		removeMouseUp?.();
+		labelable.registerControlId(labelSource, void 0);
+	});
+	const trigger = Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "button";
+		},
+		ref: [((value) => setElement(value)), internalProps.ref],
+		get id() {
+			return id();
+		},
+		get type() {
+			return nativeButton() ? "button" : void 0;
+		},
+		role: "combobox",
+		get tabindex() {
+			return disabled() ? -1 : 0;
+		},
+		get disabled() {
+			return nativeButton() && disabled() ? true : void 0;
+		},
+		get ["aria-disabled"]() {
+			return !nativeButton() && disabled() ? "true" : void 0;
+		},
+		get ["aria-expanded"]() {
+			return open() ? "true" : "false";
+		},
+		"aria-haspopup": "listbox",
+		get ["aria-controls"]() {
+			return memo(() => {
+				return !!open();
+			})() ? context.store.listElement()?.id || context.store.popupId() : void 0;
+		},
+		get ["aria-labelledby"]() {
+			return ariaLabelledBy();
+		},
+		get ["aria-describedby"]() {
+			return ariaDescribedBy();
+		},
+		get ["aria-readonly"]() {
+			return context.readOnly() ? "true" : void 0;
+		},
+		get ["aria-required"]() {
+			return context.required() ? "true" : void 0;
+		},
+		get ["aria-invalid"]() {
+			return state().valid === false && !disabled() ? "true" : void 0;
+		},
+		"data-base-ui-click-trigger": "",
+		get ["data-trigger-disabled"]() {
+			return disabled() ? "" : void 0;
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onBlur,
+		onClick,
+		onFocus,
+		onKeyDown,
+		onKeyUp,
+		onMouseDown,
+		onPointerDown
+	}, stateAttributes, others));
+	return TriggerFocusGuards({
+		get context() {
+			return context.store.context.floatingRoot;
+		},
+		get enabled() {
+			return context.presence.mounted();
+		},
+		trigger: element,
+		positioner: () => context.store.track().positionerElement,
+		get beforeContentGuard() {
+			return context.beforeContentGuard;
+		},
+		get afterGuardRef() {
+			return context.setAfterTriggerGuard;
+		},
+		children: trigger
+	});
+}
+function isIOS() {
+	if (typeof navigator === "undefined") return false;
+	const platform = navigator.platform.toLowerCase();
+	return /^i(os$|p)/.test(platform) || platform === "macintel" && navigator.maxTouchPoints > 1;
+}
+//#endregion
+//#region src/select/value/SelectValue.tsx
+/** Displays the selected value or a placeholder. */
+function SelectValue(props) {
+	const context = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		value: context.value(),
+		placeholder: !context.hasSelectedValue()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), { value: () => null }));
+	const others = omit(allProps, "as", "children", "class", "placeholder", "ref", "style");
+	const content = createMemo(() => {
+		const child = props.children;
+		if (typeof child === "function") return isSolidAccessor(child) ? untrack(() => child()) : child(context.value());
+		if (child != null) return child;
+		if (!context.hasSelectedValue() && props.placeholder != null && !hasNullItemLabel(context.items())) return props.placeholder;
+		const current = context.value();
+		if (Array.isArray(current)) return resolveMultipleLabels(current, context.items(), context.itemToStringLabel());
+		return resolveSelectedLabel(current, context.items(), context.itemToStringLabel());
+	});
+	const ref = [((element) => context.setValueElement(element)), internalProps.ref];
+	return Show({
+		get when() {
+			return props.as;
+		},
+		get fallback() {
+			return ssrElement("span", () => {
+				return mergeProps({
+					get ["class"]() {
+						return classValue();
+					},
+					get style() {
+						return styleValue();
+					}
+				}, stateAttributes, others);
+			}, () => {
+				return scope(() => {
+					return escape(content());
+				});
+			}, true);
+		},
+		children: (component) => Dynamic(mergeProps({
+			get component() {
+				return component();
+			},
+			ref,
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others, { get children() {
+			return content();
+		} }))
+	});
+}
+//#endregion
+//#region src/select/icon/SelectIcon.tsx
+/** Displays a decorative select indicator. */
+function SelectIcon(props) {
+	const context = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({ open: context.store.open() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), triggerOpenStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return Show({
+		get when() {
+			return props.as;
+		},
+		get fallback() {
+			return ssrElement("span", () => {
+				return mergeProps({
+					"aria-hidden": "true",
+					get ["class"]() {
+						return classValue();
+					},
+					get style() {
+						return styleValue();
+					}
+				}, stateAttributes, others);
+			}, () => {
+				return () => {
+					return escape(props.children ?? "▼");
+				};
+			}, true);
+		},
+		children: (component) => Dynamic(mergeProps({
+			get component() {
+				return component();
+			},
+			ref: [internalProps.ref],
+			"aria-hidden": "true",
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			}
+		}, stateAttributes, others, { get children() {
+			return props.children ?? "▼";
+		} }))
+	});
+}
+//#endregion
+//#region src/select/portal/SelectPortalContext.ts
+var MISSING_CONTEXT$3 = Symbol("SelectPortalContext");
+var SelectPortalContext = createContext(MISSING_CONTEXT$3);
+function useSelectPortalContext() {
+	if (useContext(SelectPortalContext) === MISSING_CONTEXT$3) throw new Error("Base UI: SelectPositioner must be placed within <Select.Portal>.");
+}
+//#endregion
+//#region src/select/portal/SelectPortal.tsx
+/** Moves the select layer into a portal appended to the document body by default. */
+function SelectPortal(props) {
+	const context = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const shouldRender = createMemo(() => context.presence.mounted() || context.store.forceMount());
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "container", "ref", "style");
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return SelectPortalContext({
+				value: true,
+				get children() {
+					return PopupPortal(mergeProps({
+						get as() {
+							return props.as;
+						},
+						get container() {
+							return internalProps.container;
+						},
+						ref: (element) => setRef(internalProps.ref, element),
+						get ["class"]() {
+							return classValue();
+						},
+						get style() {
+							return styleValue();
+						}
+					}, others, { get children() {
+						return props.children;
+					} }));
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/select/backdrop/SelectBackdrop.tsx
+/** A presentational overlay displayed beneath the select popup. */
+function SelectBackdrop(props) {
+	const context = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		transitionStatus: context.store.track().transitionStatus
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({
+		"user-select": "none",
+		"-webkit-user-select": "none"
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupTransitionStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let backdrop = null;
+	onCleanup(() => {
+		if (context.backdropElement() === backdrop) context.setBackdropElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			backdrop = element;
+			context.setBackdropElement(element);
+		}), internalProps.ref],
+		role: "presentation",
+		get hidden() {
+			return !context.presence.mounted();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/select/positioner/SelectPositionerContext.ts
+var MISSING_CONTEXT$2 = Symbol("SelectPositionerContext");
+var SelectPositionerContext = createContext(MISSING_CONTEXT$2);
+function useSelectPositionerContext() {
+	const context = useContext(SelectPositionerContext);
+	if (context === MISSING_CONTEXT$2) throw new Error("Base UI: SelectPositionerContext is missing. Select popup parts must be placed within <Select.Positioner>.");
+	return context;
+}
+//#endregion
+//#region src/select/positioner/SelectPositioner.tsx
+/** Positions the select popup against its trigger or a custom anchor. */
+function SelectPositioner(props) {
+	useSelectPortalContext();
+	const context = useSelectRootContext();
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const [controlledAlign, setControlledAlign] = createSignal(untrack(() => internalProps.alignItemWithTrigger ?? true));
+	const [scrollUpArrow, setScrollUpArrow] = createSignal(null, { ownedWrite: true });
+	const [scrollDownArrow, setScrollDownArrow] = createSignal(null, { ownedWrite: true });
+	const reference = createMemo(() => resolveAnchor(internalProps.anchor) ?? context.store.context.floatingRoot.referenceElement());
+	const alignItemWithTriggerActive = createMemo(() => context.presence.mounted() && controlledAlign() && context.store.openMethod() !== "touch");
+	const positioning = createAnchorPositioning({
+		reference,
+		floating: element,
+		mounted: context.presence.mounted,
+		direction,
+		positionMethod: () => internalProps.positionMethod ?? "absolute",
+		side: () => internalProps.side ?? "bottom",
+		sideOffset: () => internalProps.sideOffset ?? 0,
+		align: () => internalProps.align ?? "center",
+		alignOffset: () => internalProps.alignOffset ?? 0,
+		collisionBoundary: () => internalProps.collisionBoundary ?? "clipping-ancestors",
+		collisionPadding: () => internalProps.collisionPadding ?? 5,
+		arrowPadding: () => internalProps.arrowPadding ?? 5,
+		sticky: () => internalProps.sticky ?? false,
+		disableAnchorTracking: () => internalProps.disableAnchorTracking ?? alignItemWithTriggerActive(),
+		collisionAvoidance: () => internalProps.collisionAvoidance ?? {
+			side: "flip",
+			align: "flip",
+			fallbackAxisSide: "none"
+		}
+	});
+	const renderedSide = createMemo(() => alignItemWithTriggerActive() ? "none" : positioning.renderedSide());
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: renderedSide(),
+		align: positioning.renderedAlign(),
+		anchorHidden: positioning.anchorHidden()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({
+		...positioning.styles(),
+		position: alignItemWithTriggerActive() ? "fixed" : positioning.styles().position,
+		"pointer-events": context.store.open() ? void 0 : "none",
+		transition: context.store.track().transitionStatus === "starting" ? "none" : void 0
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), selectPositionerStateMapping));
+	const others = omit(allProps, "align", "alignItemWithTrigger", "alignOffset", "anchor", "arrowPadding", "as", "class", "collisionAvoidance", "collisionBoundary", "collisionPadding", "disableAnchorTracking", "positionMethod", "ref", "side", "sideOffset", "sticky", "style");
+	let previousSize = 0;
+	createAnchoredPopupScrollLock({
+		enabled: () => context.store.open() && (alignItemWithTriggerActive() || context.modal()),
+		touchOpen: () => context.store.openMethod() === "touch",
+		positioner: element,
+		reference: context.triggerElement
+	});
+	createEffect(() => ({
+		mounted: context.presence.mounted(),
+		requested: internalProps.alignItemWithTrigger
+	}), (current) => {
+		if (!current.mounted) setControlledAlign(current.requested ?? true);
+	});
+	createEffect(alignItemWithTriggerActive, (active) => context.store.setAlignItemWithTrigger(active));
+	createEffect(positioning.renderedSide, (side) => context.store.setPopupSide(side));
+	createEffect(() => ({
+		size: context.store.collection.items().length,
+		values: context.store.collection.values()
+	}), ({ size, values }) => {
+		const oldSize = previousSize;
+		previousSize = size;
+		if (oldSize === 0 || size === oldSize || values.length === 0) return;
+		untrack(() => {
+			const current = context.value();
+			if (context.multiple()) {
+				if (!Array.isArray(current)) return;
+				const next = current.filter((selected) => findItemIndex(values, selected, context.comparator()) !== -1);
+				if (next.length !== current.length) {
+					context.setValue(next, createChangeEventDetails(none));
+					if (next.length === 0) context.setSelectedItemText(null);
+				}
+			} else if (current !== null && findItemIndex(values, current, context.comparator()) === -1) {
+				const initial = context.initialValue;
+				const next = initial != null && !Array.isArray(initial) && findItemIndex(values, initial, context.comparator()) !== -1 ? initial : null;
+				context.setValue(next, createChangeEventDetails(none));
+				if (next === null) context.setSelectedItemText(null);
+			}
+			if (context.store.open() && alignItemWithTriggerActive()) {
+				context.store.setScrollUpVisible(false);
+				context.store.setScrollDownVisible(false);
+				element()?.style.removeProperty("height");
+				context.store.track().popupElement?.style.removeProperty("height");
+			}
+		});
+	});
+	onCleanup(() => {
+		context.store.setAlignItemWithTrigger(false);
+		if (context.store.state.positionerElement === untrack(element)) context.store.setPositionerElement(null);
+	});
+	const positionerContext = {
+		...positioning,
+		side: renderedSide,
+		align: positioning.renderedAlign,
+		alignItemWithTriggerActive,
+		setControlledAlignItemWithTrigger: setControlledAlign,
+		scrollUpArrow,
+		setScrollUpArrow,
+		scrollDownArrow,
+		setScrollDownArrow
+	};
+	function ModalBackdrop() {
+		let backdrop = null;
+		onCleanup(() => {
+			if (context.internalBackdropElement() === backdrop) context.setInternalBackdropElement(null);
+		});
+		return InternalBackdrop({
+			ref: (element) => {
+				backdrop = element;
+				context.setInternalBackdropElement(element);
+			},
+			get cutout() {
+				return context.triggerElement();
+			},
+			get open() {
+				return context.store.open();
+			}
+		});
+	}
+	return SelectPositionerContext({
+		value: positionerContext,
+		get children() {
+			return [Show({
+				get when() {
+					return memo(() => {
+						return !!context.presence.mounted();
+					})() ? context.modal() : context.presence.mounted();
+				},
+				get children() {
+					return ModalBackdrop({});
+				}
+			}), Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					setElement(value);
+					context.store.setPositionerElement(value);
+				}), internalProps.ref],
+				role: "presentation",
+				get hidden() {
+					return !context.presence.mounted();
+				},
+				get inert() {
+					return !context.store.open() || void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others))];
+		}
+	});
+}
+function resolveAnchor(anchor) {
+	if (typeof anchor === "function") return anchor();
+	if (anchor && "current" in anchor) return anchor.current;
+	return anchor;
+}
+//#endregion
+//#region src/select/popup/SelectPopup.tsx
+var COMPOSITE_KEYS = /* @__PURE__ */ new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End"
+]);
+var SELECT_LIST_FUNCTIONAL_STYLES = {
+	position: "relative",
+	"max-height": "100%",
+	"overflow-x": "hidden",
+	"overflow-y": "auto"
+};
+/** A container for the select list. */
+function SelectPopup(props) {
+	const context = useSelectRootContext();
+	const positioner = useSelectPositionerContext();
+	const insideToolbar = useToolbarRootContext(true) !== void 0;
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		side: positioner.side(),
+		align: positioner.align(),
+		open: context.store.open(),
+		transitionStatus: context.store.track().transitionStatus
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({
+		...positioner.alignItemWithTriggerActive() ? context.store.listElement() ? { height: "100%" } : {
+			...SELECT_LIST_FUNCTIONAL_STYLES,
+			"scrollbar-width": context.store.openMethod() === "touch" ? void 0 : "none"
+		} : {},
+		transition: state().transitionStatus === "starting" ? "none" : void 0
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), selectPopupStateMapping));
+	const id = createMemo(() => internalProps.id ?? `${context.id()}-list`);
+	const others = omit(allProps, "as", "class", "finalFocus", "id", "onBlur", "onKeyDown", "onScroll", "ref", "style");
+	let popupElement = null;
+	let initialPlaced = false;
+	let reachedMaxHeight = false;
+	let originalPositionerStyles;
+	let originalPopupStyles;
+	function setArrowVisibility(scroller) {
+		const maximum = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+		const offset = normalizeScrollOffset(scroller.scrollTop, maximum);
+		if (offset !== scroller.scrollTop) scroller.scrollTop = offset;
+		context.store.setScrollUpVisible(offset > 0);
+		context.store.setScrollDownVisible(offset < maximum);
+	}
+	function handleScroll(scroller) {
+		const positionerElement = context.store.track().positionerElement;
+		if (!positionerElement || !popupElement || !initialPlaced) return;
+		const topAnchored = positionerElement.style.top === "0px";
+		const bottomAnchored = positionerElement.style.bottom === "0px";
+		if (reachedMaxHeight || !positioner.alignItemWithTriggerActive() || !topAnchored && !bottomAnchored) {
+			setArrowVisibility(scroller);
+			return;
+		}
+		const scale = getScale(positionerElement);
+		const currentHeight = positionerElement.getBoundingClientRect().height / scale.y;
+		const styles = ownerWindow(positionerElement).getComputedStyle(positionerElement);
+		const marginTop = parseFloat(styles.marginTop) || 0;
+		const marginBottom = parseFloat(styles.marginBottom) || 0;
+		const maximumHeight = Math.min(ownerDocument(positionerElement).documentElement.clientHeight - marginTop - marginBottom, getMaxPopupHeight(ownerWindow(popupElement).getComputedStyle(popupElement)));
+		const scrollTop = scroller.scrollTop;
+		const maximumScroll = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+		const difference = topAnchored ? maximumScroll - scrollTop : scrollTop;
+		const nextHeight = Math.min(currentHeight + difference, maximumHeight);
+		let nextScrollTop = null;
+		if (difference <= 1) {
+			const delta = clamp(difference, 0, maximumHeight - currentHeight);
+			if (delta > 0) positionerElement.style.height = `${currentHeight + delta}px`;
+			scroller.scrollTop = topAnchored ? maximumScroll : 0;
+			reachedMaxHeight = maximumHeight - (currentHeight + delta) <= 1;
+			setArrowVisibility(scroller);
+			return;
+		}
+		const roundedHeight = Math.ceil(nextHeight);
+		if (roundedHeight > 0) positionerElement.style.height = `${roundedHeight}px`;
+		if (maximumHeight - nextHeight > 1) nextScrollTop = topAnchored ? Infinity : 0;
+		else if (bottomAnchored && scrollTop < maximumScroll) nextScrollTop = scrollTop - (difference - (currentHeight + difference - maximumHeight));
+		if (nextScrollTop !== null) {
+			const target = clamp(nextScrollTop, 0, getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight));
+			if (Math.abs(scroller.scrollTop - target) > 1) scroller.scrollTop = target;
+		}
+		reachedMaxHeight = roundedHeight >= maximumHeight - 1;
+		setArrowVisibility(scroller);
+	}
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => context.handleTypeaheadBlur);
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => (event) => {
+		const handler = context.store.state.popupProps.onKeyDown;
+		if (typeof handler === "function") Reflect.apply(handler, event.currentTarget, [event]);
+	}, () => (event) => {
+		if (insideToolbar && COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+	});
+	const onScroll = composeEventHandlers(() => internalProps.onScroll, () => (event) => {
+		if (!context.store.listElement()) handleScroll(event.currentTarget);
+	});
+	createEffect(() => id(), (currentId) => context.store.setPopupId(currentId));
+	createEffect(() => ({
+		open: context.store.open(),
+		positioned: positioner.state().isPositioned,
+		active: positioner.alignItemWithTriggerActive(),
+		trigger: context.triggerElement(),
+		positioner: context.store.track().positionerElement,
+		popup: popupElement,
+		list: context.store.listElement(),
+		selectedText: context.selectedItemText(),
+		firstText: context.firstItemText(),
+		valueElement: context.valueElement(),
+		transitionStatus: context.store.track().transitionStatus,
+		hasSelectedValue: context.hasSelectedValue(),
+		direction: direction()
+	}), (current) => {
+		if (!current.open || !current.trigger || !current.positioner || !current.popup || current.active && !current.positioned || current.transitionStatus === "ending") return;
+		initialPlaced = true;
+		current.popup.style.removeProperty("--transform-origin");
+		const scroller = current.list ?? current.popup;
+		if (!current.active) {
+			requestAnimationFrame(() => setArrowVisibility(scroller));
+			return;
+		}
+		applyItemAlignment({
+			trigger: current.trigger,
+			positioner: current.positioner,
+			popup: current.popup,
+			scroller,
+			text: current.selectedText?.isConnected ? current.selectedText : !current.hasSelectedValue && current.firstText?.isConnected ? current.firstText : null,
+			valueElement: current.valueElement,
+			direction: current.direction
+		});
+	});
+	createEffect(() => ({
+		open: context.store.open(),
+		active: positioner.alignItemWithTriggerActive(),
+		positionerElement: context.store.track().positionerElement
+	}), (current) => {
+		if (!current.open && !current.active) {
+			initialPlaced = false;
+			reachedMaxHeight = false;
+			restoreItemAlignment(current.positionerElement);
+		}
+	});
+	createEffect(() => ({
+		open: context.store.open(),
+		active: positioner.alignItemWithTriggerActive(),
+		positioner: context.store.track().positionerElement
+	}), (current) => {
+		if (!current.open || !current.active || !current.positioner) return;
+		const windowNode = ownerWindow(current.positioner);
+		const resize = (event) => context.setOpen(false, createChangeEventDetails(windowResize, event));
+		windowNode.addEventListener("resize", resize);
+		return () => windowNode.removeEventListener("resize", resize);
+	});
+	createEffect(() => context.store.track().popupElement, (element) => {
+		if (!element || typeof MutationObserver === "undefined") return;
+		const observer = new MutationObserver(() => context.store.collection.touch());
+		observer.observe(element, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+		return () => observer.disconnect();
+	});
+	context.scrollHandler.current = handleScroll;
+	onCleanup(() => {
+		untrack(() => {
+			restoreItemAlignment(context.store.track().positionerElement);
+			if (context.scrollHandler.current === handleScroll) context.scrollHandler.current = null;
+			if (context.store.state.popupElement === popupElement) context.store.setPopupElement(null);
+		});
+	});
+	function applyItemAlignment(options) {
+		const { trigger, positioner: positionerElement, popup, scroller, text, valueElement: valueNode } = options;
+		snapshotStyles(positionerElement, popup);
+		const restoreTransforms = unsetTransformStyles(popup);
+		try {
+			positionerElement.style.transform = "none";
+			positionerElement.style.right = "";
+			const scale = getScale(trigger);
+			const triggerRect = normalizeRect(trigger.getBoundingClientRect(), scale);
+			const positionerRect = normalizeRect(positionerElement.getBoundingClientRect(), scale);
+			const popupStyles = ownerWindow(popup).getComputedStyle(popup);
+			const positionerStyles = ownerWindow(positionerElement).getComputedStyle(positionerElement);
+			const documentNode = ownerDocument(trigger);
+			const marginTop = parseFloat(positionerStyles.marginTop) || 10;
+			const marginBottom = parseFloat(positionerStyles.marginBottom) || 10;
+			const minimumHeight = parseFloat(positionerStyles.minHeight) || 100;
+			const viewportHeight = documentNode.documentElement.clientHeight - marginTop - marginBottom;
+			const viewportWidth = documentNode.documentElement.clientWidth;
+			const availableBelow = viewportHeight - triggerRect.bottom + triggerRect.height;
+			let alignedLeft = options.direction === "rtl" ? triggerRect.right - positionerRect.width : triggerRect.left;
+			let offsetY = 0;
+			let textRect;
+			if (text && valueNode) {
+				textRect = normalizeRect(text.getBoundingClientRect(), scale);
+				const valueRect = normalizeRect(valueNode.getBoundingClientRect(), scale);
+				alignedLeft = positionerRect.left + (options.direction === "rtl" ? valueRect.right - textRect.right : valueRect.left - textRect.left);
+				offsetY = textRect.top - positionerRect.top + textRect.height / 2 - (valueRect.top - triggerRect.top + valueRect.height / 2);
+			}
+			const idealHeight = availableBelow + offsetY + marginBottom + (parseFloat(popupStyles.borderBottomWidth) || 0);
+			let height = Math.min(viewportHeight, idealHeight);
+			const initialScrollTop = idealHeight - height;
+			positionerElement.style.left = `${clamp(alignedLeft, 5, viewportWidth - 5 - positionerRect.width)}px`;
+			if (text && valueNode) {
+				const nextTextRect = normalizeRect(text.getBoundingClientRect(), scale);
+				const nextValueRect = normalizeRect(valueNode.getBoundingClientRect(), scale);
+				const correction = options.direction === "rtl" ? nextValueRect.right - nextTextRect.right : nextValueRect.left - nextTextRect.left;
+				const positionedLeft = parseFloat(positionerElement.style.left) || 0;
+				positionerElement.style.left = `${clamp(positionedLeft + correction, 5, viewportWidth - 5 - positionerRect.width)}px`;
+				requestAnimationFrame(() => {
+					if (!text.isConnected || !valueNode.isConnected || !positionerElement.isConnected) return;
+					const finalTextRect = text.getBoundingClientRect();
+					const finalValueRect = valueNode.getBoundingClientRect();
+					const finalCorrection = options.direction === "rtl" ? finalValueRect.right - finalTextRect.right : finalValueRect.left - finalTextRect.left;
+					const finalLeft = parseFloat(positionerElement.style.left) || 0;
+					positionerElement.style.left = `${clamp(finalLeft + finalCorrection, 5, viewportWidth - 5 - positionerRect.width)}px`;
+				});
+			}
+			positionerElement.style.height = `${height}px`;
+			positionerElement.style.maxHeight = "none";
+			positionerElement.style.marginTop = `${marginTop}px`;
+			positionerElement.style.marginBottom = `${marginBottom}px`;
+			popup.style.height = "100%";
+			const maximumScroll = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+			const topPositioned = initialScrollTop >= maximumScroll - 1;
+			if (topPositioned) height = Math.min(viewportHeight, positionerRect.height) - (initialScrollTop - maximumScroll);
+			if (triggerRect.top < 20 || triggerRect.bottom > viewportHeight - 20 || Math.ceil(height) + 1 < Math.min(scroller.scrollHeight, minimumHeight) || (ownerWindow(positionerElement).visualViewport?.scale ?? 1) !== 1 && isWebKit()) {
+				restoreItemAlignment(positionerElement);
+				positioner.setControlledAlignItemWithTrigger(false);
+				return;
+			}
+			if (topPositioned) {
+				const topOffset = Math.max(0, viewportHeight - idealHeight);
+				positionerElement.style.top = positionerRect.height >= viewportHeight ? "0px" : `${topOffset}px`;
+				positionerElement.style.bottom = "";
+				positionerElement.style.height = `${height}px`;
+				scroller.scrollTop = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+			} else {
+				positionerElement.style.top = "";
+				positionerElement.style.bottom = "0px";
+				scroller.scrollTop = initialScrollTop;
+			}
+			if (textRect) {
+				const center = positionerRect.height > 0 ? clamp((textRect.top + textRect.height / 2 - positionerRect.top) / positionerRect.height * 100, 0, 100) : 50;
+				popup.style.setProperty("--transform-origin", `50% ${center}%`);
+			}
+			reachedMaxHeight = height >= getMaxPopupHeight(popupStyles) || height >= viewportHeight;
+			setArrowVisibility(scroller);
+		} finally {
+			restoreTransforms();
+		}
+	}
+	function snapshotStyles(positionerElement, popup) {
+		originalPositionerStyles ??= captureStyles(positionerElement, [
+			"top",
+			"left",
+			"right",
+			"bottom",
+			"height",
+			"min-height",
+			"max-height",
+			"margin-top",
+			"margin-bottom",
+			"transform"
+		]);
+		originalPopupStyles ??= captureStyles(popup, ["height", "--transform-origin"]);
+	}
+	function restoreItemAlignment(positionerElement) {
+		if (positionerElement && originalPositionerStyles) restoreStyles(positionerElement, originalPositionerStyles);
+		if (popupElement && originalPopupStyles) restoreStyles(popupElement, originalPopupStyles);
+		originalPositionerStyles = void 0;
+		originalPopupStyles = void 0;
+	}
+	function PopupElement() {
+		const list = () => context.store.listElement();
+		return Dynamic(mergeProps({
+			get component() {
+				return props.as ?? "div";
+			},
+			ref: [((element) => {
+				popupElement = element;
+				context.store.setPopupElement(element);
+			}), internalProps.ref],
+			get id() {
+				return memo(() => {
+					return !!list();
+				})() ? internalProps.id : id();
+			},
+			get role() {
+				return list() ? "presentation" : "listbox";
+			},
+			tabindex: -1,
+			"data-base-ui-focusable": "",
+			get ["data-rootownerid"]() {
+				return context.node.id;
+			},
+			get ["aria-orientation"]() {
+				return list() ? void 0 : "vertical";
+			},
+			get ["aria-multiselectable"]() {
+				return !list() && context.multiple() ? "true" : void 0;
+			},
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			},
+			onBlur,
+			onKeyDown,
+			onScroll
+		}, stateAttributes, others));
+	}
+	return FocusManager({
+		get context() {
+			return context.store.context.floatingRoot;
+		},
+		get tree() {
+			return context.tree;
+		},
+		get disabled() {
+			return !context.presence.mounted();
+		},
+		initialFocus: () => untrack(() => context.store.activeElement()) ?? true,
+		get returnFocus() {
+			return internalProps.finalFocus ?? true;
+		},
+		restoreFocus: true,
+		modal: false,
+		get openInteractionType() {
+			return context.store.openMethod();
+		},
+		get previousFocusableElement() {
+			return context.triggerElement;
+		},
+		get beforeContentGuardRef() {
+			return context.setBeforeContentGuard;
+		},
+		get children() {
+			return PopupElement({});
+		}
+	});
+}
+function getScale(element) {
+	const rect = element.getBoundingClientRect();
+	return {
+		x: element.offsetWidth ? rect.width / element.offsetWidth : 1,
+		y: element.offsetHeight ? rect.height / element.offsetHeight : 1
+	};
+}
+function normalizeRect(rect, scale) {
+	const x = rect.x / scale.x;
+	const y = rect.y / scale.y;
+	const width = rect.width / scale.x;
+	const height = rect.height / scale.y;
+	return {
+		x,
+		y,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		width,
+		height
+	};
+}
+function getMaxPopupHeight(styles) {
+	return styles.maxHeight.endsWith("px") ? parseFloat(styles.maxHeight) || Infinity : Infinity;
+}
+function clamp(value, minimum, maximum) {
+	return Math.max(minimum, Math.min(maximum, value));
+}
+function captureStyles(element, properties) {
+	return Object.fromEntries(properties.map((property) => [property, element.style.getPropertyValue(property)]));
+}
+function restoreStyles(element, styles) {
+	for (const [property, value] of Object.entries(styles)) if (value) element.style.setProperty(property, value);
+	else element.style.removeProperty(property);
+}
+function unsetTransformStyles(element) {
+	const original = captureStyles(element, [
+		"transform",
+		"scale",
+		"translate"
+	]);
+	element.style.setProperty("transform", "none", "important");
+	element.style.setProperty("scale", "1", "important");
+	element.style.setProperty("translate", "0 0", "important");
+	return () => restoreStyles(element, original);
+}
+function isWebKit() {
+	return typeof navigator !== "undefined" && /AppleWebKit/.test(navigator.userAgent) && !/Chrome|Chromium/.test(navigator.userAgent);
+}
+//#endregion
+//#region src/select/list/SelectList.tsx
+/** A scrolling container for select items. */
+function SelectList(props) {
+	const context = useSelectRootContext();
+	const positioner = useSelectPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => mergeStyleValue({
+		...positioner.alignItemWithTriggerActive() ? SELECT_LIST_FUNCTIONAL_STYLES : {},
+		"scrollbar-width": context.store.hasScrollArrows() && context.store.openMethod() !== "touch" ? "none" : void 0
+	}, resolveStyle(props.style, state)));
+	const others = omit(allProps, "as", "class", "id", "onScroll", "ref", "style");
+	const onScroll = composeEventHandlers(() => internalProps.onScroll, () => (event) => context.handleScroll(event.currentTarget));
+	let listElement = null;
+	onCleanup(() => {
+		if (context.store.listElement() === listElement) context.store.setListElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			listElement = element;
+			context.store.setListElement(element);
+		}), internalProps.ref],
+		get id() {
+			return internalProps.id ?? `${context.id()}-list`;
+		},
+		role: "listbox",
+		get ["aria-multiselectable"]() {
+			return context.multiple() ? "true" : void 0;
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onScroll
+	}, others));
+}
+//#endregion
+//#region src/select/item/SelectItemContext.ts
+var MISSING_CONTEXT$1 = Symbol("SelectItemContext");
+var SelectItemContext = createContext(MISSING_CONTEXT$1);
+function useSelectItemContext() {
+	const context = useContext(SelectItemContext);
+	if (context === MISSING_CONTEXT$1) throw new Error("Base UI: SelectItemContext is missing. SelectItem parts must be placed within <Select.Item>.");
+	return context;
+}
+//#endregion
+//#region src/select/item/SelectItem.tsx
+/** An individual option in the select popup. */
+function SelectItem(props) {
+	const context = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const token = Symbol("SelectItem");
+	const itemValue = createMemo(() => internalProps.value ?? null);
+	const disabled = createMemo(() => context.disabled() || (internalProps.disabled ?? false));
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const [textElement, setTextElement] = createSignal(null, { ownedWrite: true });
+	const unregister = context.store.collection.register({
+		token,
+		element,
+		textElement,
+		value: itemValue,
+		label: () => internalProps.label,
+		disabled
+	});
+	const index = createMemo(() => context.store.collection.indexOf(token));
+	const selected = createMemo(() => {
+		const current = context.value();
+		if (context.multiple()) return Array.isArray(current) && current.some((value) => compareItemEquality(itemValue(), value, context.comparator()));
+		return compareItemEquality(itemValue(), current, context.comparator());
+	});
+	const highlighted = createMemo(() => context.store.activeElement() === element());
+	const selectedByFocus = createMemo(() => context.selectedIndex() === index());
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		selected: selected(),
+		highlighted: highlighted()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "disabled", "id", "label", "nativeButton", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseMove", "onMouseUp", "onPointerDown", "onPointerEnter", "onPointerMove", "ref", "style", "value");
+	let pointerType = "mouse";
+	let allowMouseSelection = false;
+	let dispatchedClickHandled = false;
+	function commitSelection(event) {
+		if (context.disabled() || context.readOnly()) return;
+		const current = context.value();
+		if (context.multiple()) {
+			const values = Array.isArray(current) ? current : [];
+			const next = selected() ? removeItem(values, itemValue(), context.comparator()) : [...values, itemValue()];
+			context.setValue(next, createChangeEventDetails(itemPress, event));
+		} else {
+			context.setValue(itemValue(), createChangeEventDetails(itemPress, event));
+			context.setOpen(false, createChangeEventDetails(itemPress, event));
+		}
+	}
+	function handleClick(event) {
+		dispatchedClickHandled = true;
+		const clickPointerType = event.pointerType;
+		const virtual = event.detail === 0 && (clickPointerType !== void 0 || highlighted() || element()?.ownerDocument.activeElement === element());
+		const invalidMouseClick = pointerType !== "touch" && !virtual && !allowMouseSelection;
+		allowMouseSelection = false;
+		if (!disabled() && !invalidMouseClick) commitSelection(event);
+	}
+	function handleFocus(event) {
+		context.store.setActiveElement(event.currentTarget);
+		context.field.setFocused(true);
+	}
+	function handleBlur(event) {
+		untrack(() => {
+			if (context.store.activeElement() === event.currentTarget && event.relatedTarget !== event.currentTarget) context.store.setActiveElement(null);
+			context.handleTypeaheadBlur(event);
+		});
+	}
+	function handleKeyDown(event) {
+		context.store.setActiveElement(event.currentTarget);
+		if (event.key === " " && context.store.typing()) {
+			event.preventDefault();
+			event.preventBaseUIHandler();
+			return;
+		}
+		context.handleKeyDown(event);
+		if (event.defaultPrevented) {
+			event.preventBaseUIHandler();
+			return;
+		}
+		if (event.target !== event.currentTarget || event.key !== "Enter" && event.key !== " ") return;
+		const current = event.currentTarget;
+		if (nativeButton() && current.tagName === "BUTTON") return;
+		event.preventDefault();
+		event.preventBaseUIHandler();
+		dispatchedClickHandled = false;
+		const clickEvent = dispatchClick(current, event);
+		if (!dispatchedClickHandled && !clickEvent.baseUIHandlerPrevented) commitSelection(event);
+	}
+	function handleKeyUp(event) {
+		if (nativeButton() && event.key === " ") event.preventDefault();
+	}
+	function handlePointerMove(event) {
+		pointerType = event.pointerType;
+		if (event.pointerType === "mouse" && event.buttons === 1) {
+			context.store.selection.dragY += event.movementY;
+			if (context.store.selection.dragY ** 2 >= 64) context.store.selection.allowUnselectedMouseUp = true;
+		}
+		if (event.pointerType === "mouse" && context.store.pointerMoved(event)) highlightHoveredItem(event.currentTarget);
+	}
+	function handleMouseMove(event) {
+		if (context.store.pointerMoved(event)) highlightHoveredItem(event.currentTarget);
+	}
+	function highlightHoveredItem(current) {
+		if (!context.highlightItemOnHover()) return;
+		context.store.setActiveElement(current);
+		flush();
+		current.focus({ preventScroll: true });
+	}
+	function handlePointerDown(event) {
+		pointerType = event.pointerType;
+		allowMouseSelection = true;
+		context.store.selection.dragY = 0;
+	}
+	function handleMouseUp() {
+		context.store.selection.dragY = 0;
+		if (disabled() || pointerType === "touch" || allowMouseSelection) return;
+		if (selected() ? !context.store.selection.allowSelectedMouseUp : !context.store.selection.allowUnselectedMouseUp) return;
+		allowMouseSelection = true;
+		element()?.click();
+		allowMouseSelection = false;
+	}
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => handleBlur);
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => handleClick);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => handleFocus);
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown);
+	const onKeyUp = composeEventHandlers(() => internalProps.onKeyUp, () => handleKeyUp);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => handleMouseUp);
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => handleMouseMove);
+	const onPointerDown = composeEventHandlers(() => internalProps.onPointerDown, () => handlePointerDown);
+	const onPointerEnter = composeEventHandlers(() => internalProps.onPointerEnter, () => (event) => {
+		pointerType = event.pointerType;
+	});
+	const onPointerMove = composeEventHandlers(() => internalProps.onPointerMove, () => handlePointerMove);
+	createEffect(() => ({
+		index: index(),
+		selectedByFocus: selectedByFocus(),
+		text: textElement()
+	}), (current) => {
+		if (current.index === 0) context.setFirstItemText(current.text);
+		if (current.selectedByFocus && current.text) context.setSelectedItemText(current.text);
+	});
+	onCleanup(() => {
+		unregister();
+		if (context.firstItemText() === untrack(textElement)) context.setFirstItemText(null);
+		if (context.selectedItemText() === untrack(textElement)) context.setSelectedItemText(null);
+	});
+	return SelectItemContext({
+		value: {
+			selected,
+			selectedByFocus,
+			index,
+			textElement,
+			setTextElement
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					setElement(value);
+					context.store.collection.touch();
+				}), internalProps.ref],
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				role: "option",
+				get tabindex() {
+					return context.store.open() && highlighted() ? 0 : -1;
+				},
+				get ["aria-selected"]() {
+					return selected() ? "true" : "false";
+				},
+				get ["aria-disabled"]() {
+					return disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onBlur,
+				onClick,
+				onFocus,
+				onKeyDown,
+				onKeyUp,
+				onMouseMove,
+				onMouseUp,
+				onPointerDown,
+				onPointerEnter,
+				onPointerMove
+			}, stateAttributes, others));
+		}
+	});
+}
+function dispatchClick(target, source) {
+	const event = new ((target.ownerDocument.defaultView?.MouseEvent) ?? MouseEvent)("click", {
+		bubbles: true,
+		cancelable: true,
+		composed: true,
+		detail: 0,
+		shiftKey: source.shiftKey,
+		ctrlKey: source.ctrlKey,
+		altKey: source.altKey,
+		metaKey: source.metaKey
+	});
+	target.dispatchEvent(event);
+	return event;
+}
+//#endregion
+//#region src/select/item-indicator/SelectItemIndicator.tsx
+/** Indicates whether the enclosing select item is selected. */
+function SelectItemIndicator(props) {
+	const item = useSelectItemContext();
+	const internalProps = props;
+	const allProps = props;
+	const transition = createTransitionStatus(item.selected);
+	const shouldRender = createMemo(() => (internalProps.keepMounted ?? false) || transition.mounted());
+	const state = createMemo(() => ({
+		selected: item.selected(),
+		transitionStatus: transition.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), transitionStatusMapping));
+	const others = omit(allProps, "as", "class", "keepMounted", "ref", "style");
+	let element;
+	createEffect(() => ({
+		selected: item.selected(),
+		status: transition.transitionStatus(),
+		element
+	}), (current) => {
+		if (current.selected || current.status !== "ending" || !current.element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (!untrack(item.selected)) transition.setMounted(false);
+		}, controller.signal);
+		return () => controller.abort();
+	});
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "span";
+				},
+				ref: [((value) => element = value), internalProps.ref],
+				"aria-hidden": "true",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others, { get children() {
+				return props.children ?? "✔️";
+			} }));
+		}
+	});
+}
+//#endregion
+//#region src/select/item-text/SelectItemText.tsx
+/** The primary text of a select item. */
+function SelectItemText(props) {
+	const item = useSelectItemContext();
+	const root = useSelectRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	createEffect(() => ({
+		index: item.index(),
+		selected: item.selectedByFocus(),
+		text: item.textElement()
+	}), (current) => {
+		root.store.collection.touch();
+		if (current.index === 0) root.setFirstItemText(current.text);
+		if (current.selected && current.text) root.setSelectedItemText(current.text);
+	});
+	onCleanup(() => {
+		untrack(() => {
+			const text = item.textElement();
+			if (root.firstItemText() === text) root.setFirstItemText(null);
+			if (root.selectedItemText() === text) root.setSelectedItemText(null);
+		});
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => item.setTextElement(element)), internalProps.ref],
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/select/arrow/SelectArrow.tsx
+/** Displays an arrow positioned against the select anchor. */
+function SelectArrow(props) {
+	const root = useSelectRootContext();
+	const positioner = useSelectPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: root.store.open(),
+		side: positioner.side(),
+		align: positioner.align(),
+		uncentered: positioner.arrowUncentered()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue(positioner.arrowStyles(), resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let arrow = null;
+	onCleanup(() => {
+		if (arrow) positioner.setArrowElement(null);
+	});
+	return Show({
+		get when() {
+			return !positioner.alignItemWithTriggerActive();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((element) => {
+					arrow = element;
+					positioner.setArrowElement(element);
+				}), internalProps.ref],
+				"aria-hidden": "true",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/select/scroll-arrow/SelectScrollArrow.tsx
+/** @internal */
+function SelectScrollArrow(props) {
+	const root = useSelectRootContext();
+	const positioner = useSelectPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const isUp = createMemo(() => internalProps.direction === "up");
+	const stateVisible = createMemo(() => isUp() ? root.store.scrollUpVisible() : root.store.scrollDownVisible());
+	const visible = createMemo(() => stateVisible() && root.store.openMethod() !== "touch");
+	const transition = createTransitionStatus(visible);
+	const shouldRender = createMemo(() => (internalProps.keepMounted ?? false) || transition.mounted());
+	const state = createMemo(() => ({
+		direction: internalProps.direction,
+		visible: visible(),
+		side: positioner.side(),
+		transitionStatus: transition.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeStyleValue({ position: "absolute" }, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), transitionStatusMapping));
+	const others = omit(allProps, "as", "class", "direction", "keepMounted", "onMouseLeave", "onMouseMove", "ref", "style");
+	let element = null;
+	let timer;
+	function stop() {
+		clearTimeout(timer);
+		timer = void 0;
+	}
+	function start(event) {
+		if (event.movementX === 0 && event.movementY === 0 || timer !== void 0) return;
+		root.store.setActiveIndex(null);
+		timer = setTimeout(scrollNext, 40);
+	}
+	function scrollNext() {
+		timer = void 0;
+		const scroller = root.store.listElement() ?? root.store.track().popupElement;
+		if (!scroller) return;
+		root.store.setActiveIndex(null);
+		root.updateScrollArrowVisibility(scroller);
+		const maximum = getMaxScrollOffset(scroller.scrollHeight, scroller.clientHeight);
+		const offset = normalizeScrollOffset(scroller.scrollTop, maximum);
+		if (offset !== scroller.scrollTop) scroller.scrollTop = offset;
+		if (offset === (isUp() ? 0 : maximum)) return;
+		const items = root.store.collection.elements();
+		if (items.length > 0) scroller.scrollTop = getTargetScrollTop(items, isUp(), offset, scroller.clientHeight, element?.offsetHeight ?? 0, maximum);
+		timer = setTimeout(scrollNext, 40);
+	}
+	const onMouseLeave = composeEventHandlers(() => internalProps.onMouseLeave, () => stop);
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => start);
+	root.scrollArrowsMounted.count += 1;
+	root.store.setHasScrollArrows(true);
+	createEffect(() => ({
+		visible: visible(),
+		status: transition.transitionStatus(),
+		element
+	}), (current) => {
+		if (current.visible || current.status !== "ending" || !current.element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (!untrack(visible)) transition.setMounted(false);
+		}, controller.signal);
+		return () => controller.abort();
+	});
+	onCleanup(() => {
+		stop();
+		root.scrollArrowsMounted.count = Math.max(0, root.scrollArrowsMounted.count - 1);
+		if (root.scrollArrowsMounted.count === 0) root.store.setHasScrollArrows(false);
+		if (isUp()) positioner.setScrollUpArrow(null);
+		else positioner.setScrollDownArrow(null);
+	});
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					element = value;
+					if (isUp()) positioner.setScrollUpArrow(value);
+					else positioner.setScrollDownArrow(value);
+				}), internalProps.ref],
+				"aria-hidden": "true",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onMouseLeave,
+				onMouseMove
+			}, stateAttributes, others, { get children() {
+				return props.children ?? (isUp() ? "▲" : "▼");
+			} }));
+		}
+	});
+}
+function getTargetScrollTop(items, isUp, scrollTop, clientHeight, arrowHeight, maximum) {
+	if (isUp) {
+		let firstVisible = 0;
+		const visibleTop = scrollTop + arrowHeight - 1;
+		for (let index = 0; index < items.length; index += 1) if (items[index] && items[index].offsetTop >= visibleTop) {
+			firstVisible = index;
+			break;
+		}
+		const targetIndex = Math.max(0, firstVisible - 1);
+		const target = items[targetIndex];
+		return targetIndex < firstVisible && target ? normalizeScrollOffset(target.offsetTop - arrowHeight, maximum) : 0;
+	}
+	let lastVisible = items.length - 1;
+	const visibleBottom = scrollTop + clientHeight - arrowHeight + 1;
+	for (let index = 0; index < items.length; index += 1) {
+		const item = items[index];
+		if (item && item.offsetTop + item.offsetHeight > visibleBottom) {
+			lastVisible = Math.max(0, index - 1);
+			break;
+		}
+	}
+	const targetIndex = Math.min(items.length - 1, lastVisible + 1);
+	const target = items[targetIndex];
+	return targetIndex > lastVisible && target ? normalizeScrollOffset(target.offsetTop + target.offsetHeight - clientHeight + arrowHeight, maximum) : maximum;
+}
+//#endregion
+//#region src/select/scroll-down-arrow/SelectScrollDownArrow.tsx
+/** An element that scrolls the select popup down when hovered. */
+function SelectScrollDownArrow(props) {
+	return SelectScrollArrow(merge(props, { direction: "down" }));
+}
+//#endregion
+//#region src/select/scroll-up-arrow/SelectScrollUpArrow.tsx
+/** An element that scrolls the select popup up when hovered. */
+function SelectScrollUpArrow(props) {
+	return SelectScrollArrow(merge(props, { direction: "up" }));
+}
+//#endregion
+//#region src/select/group/SelectGroupContext.ts
+var MISSING_CONTEXT = Symbol("SelectGroupContext");
+var SelectGroupContext = createContext(MISSING_CONTEXT);
+function useSelectGroupContext() {
+	const context = useContext(SelectGroupContext);
+	if (context === MISSING_CONTEXT) throw new Error("Base UI: SelectGroupContext is missing. SelectGroup parts must be placed within <Select.Group>.");
+	return context;
+}
+//#endregion
+//#region src/select/group/SelectGroup.tsx
+/** Groups related select items. */
+function SelectGroup(props) {
+	const internalProps = props;
+	const allProps = props;
+	const [labelId, setLabelId] = createSignal();
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return SelectGroupContext({
+		value: {
+			labelId,
+			setLabelId
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [internalProps.ref],
+				role: "group",
+				get ["aria-labelledby"]() {
+					return labelId();
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, others));
+		}
+	});
+}
+//#endregion
+//#region src/select/group-label/SelectGroupLabel.tsx
+/** An accessible label for a select group. */
+function SelectGroupLabel(props) {
+	const context = useSelectGroupContext();
+	const internalProps = props;
+	const allProps = props;
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const id = createMemo(() => internalProps.id ?? generatedId);
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "id", "ref", "style");
+	createEffect(id, (currentId) => {
+		context.setLabelId(currentId);
+		return () => {
+			if (context.labelId() === currentId) context.setLabelId(void 0);
+		};
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		get id() {
+			return id();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/select/separator/SelectSeparator.tsx
+/** A presentational divider between select items or groups. */
+function SelectSeparator(props) {
+	const internalProps = props;
+	const allProps = props;
+	const orientation = createMemo(() => internalProps.orientation ?? "horizontal");
+	const state = createMemo(() => ({ orientation: orientation() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "orientation", "ref", "style");
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		role: "presentation",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/select/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Arrow: () => SelectArrow,
+	Backdrop: () => SelectBackdrop,
+	Group: () => SelectGroup,
+	GroupLabel: () => SelectGroupLabel,
+	Icon: () => SelectIcon,
+	Item: () => SelectItem,
+	ItemIndicator: () => SelectItemIndicator,
+	ItemText: () => SelectItemText,
+	Label: () => SelectLabel,
+	List: () => SelectList,
+	Popup: () => SelectPopup,
+	Portal: () => SelectPortal,
+	Positioner: () => SelectPositioner,
+	Root: () => SelectRoot,
+	ScrollDownArrow: () => SelectScrollDownArrow,
+	ScrollUpArrow: () => SelectScrollUpArrow,
+	Separator: () => SelectSeparator,
+	Trigger: () => SelectTrigger,
+	Value: () => SelectValue
+});
+//#endregion
+export { index_parts_exports as Select };