@selvajs/selva 4.7.0-beta.4 → 4.7.0-beta.6

package/build/server/chunks/select-C1aC27lp.js

@@ -0,0 +1,3656 @@
+import { o as bind_props, e as ensure_array_like, j as derived, s as spread_props, c as attributes, v as props_id, w as on, m as escape_html } from './index.js-NH2Q8xBT.js';
+import { r as styleToString, c as createBitsAttrs, b as boxWith, s as simpleBox, u as boolToTrueOrUndef, m as mergeProps, a as createId, d as attachRef, e as boolToEmptyStrOrUndef, g as getDataOpenClosed, f as boolToStr, h as getDataTransitionAttrs, j as boxFrom, v as boolToStrTrueOrUndef, w as cssToStyleObj } from './create-id-BeZr-sz1.js';
+import { c as cn } from './utils3-DxMdQNFZ.js';
+import { C as Check } from './check-DSmSEGza.js';
+import { C as Chevron_down } from './chevron-down-40ILRRFy.js';
+import { C as Chevron_up } from './chevron-up-DFBN0p3A.js';
+import { n as noop, w as watch, C as Context, A as ARROW_DOWN, P as PAGE_UP, H as HOME, e as ARROW_UP, f as PAGE_DOWN, k as ElementSize, l as isNotNull, m as Previous, b as isIOS } from './noop-BAtAcwOB.js';
+import { a as afterTick, c as DOMContext, P as PresenceManager, b as Portal, d as DOMTypeahead, n as next, p as prev, f as forward, e as backward, g as boxAutoReset, h as getNextMatch, i as afterSleep, u as useId, j as getWindow$1, S as Scroll_lock, F as Focus_scope, E as Escape_layer, D as Dismissible_layer, T as Text_selection_layer } from './scroll-lock-CW0vmTSk.js';
+
+//#region ../../node_modules/.pnpm/svelte-toolbelt@0.10.6_@sve_50aa02660b796e911ea3ca1ac6beddfe/node_modules/svelte-toolbelt/dist/utils/sr-only-styles.js
+var srOnlyStyles = {
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	padding: "0",
+	margin: "-1px",
+	overflow: "hidden",
+	clip: "rect(0, 0, 0, 0)",
+	whiteSpace: "nowrap",
+	borderWidth: "0",
+	transform: "translateX(-100%)"
+};
+styleToString(srOnlyStyles);
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/hidden-input.svelte
+function Hidden_input($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { value = void 0, $$slots, $$events, ...restProps } = $$props;
+		const mergedProps = derived(() => mergeProps(restProps, {
+			"aria-hidden": "true",
+			tabindex: -1,
+			style: {
+				...srOnlyStyles,
+				position: "absolute",
+				top: "0",
+				left: "0"
+			}
+		}));
+		if (mergedProps().type === "checkbox") {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<input${attributes({
+				...mergedProps(),
+				value
+			}, void 0, void 0, void 0, 4)}/>`);
+		} else {
+			$$renderer.push("<!--[-1-->");
+			$$renderer.push(`<input${attributes({
+				value,
+				...mergedProps()
+			}, void 0, void 0, void 0, 4)}/>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { value });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+* Custom positioning reference element.
+* @see https://floating-ui.com/docs/virtual-elements
+*/
+var sides = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var createCoords = (v) => ({
+	x: v,
+	y: v
+});
+var oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+function clamp(start, value, end) {
+	return max(start, min(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+	const firstChar = placement[0];
+	return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+	if (rtl === void 0) rtl = false;
+	const alignment = getAlignment(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const length = getAxisLength(alignmentAxis);
+	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+	const oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeAlignmentPlacement(placement),
+		oppositePlacement,
+		getOppositeAlignmentPlacement(oppositePlacement)
+	];
+}
+function getOppositeAlignmentPlacement(placement) {
+	return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+var lrPlacement = ["left", "right"];
+var rlPlacement = ["right", "left"];
+var tbPlacement = ["top", "bottom"];
+var btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+	switch (side) {
+		case "top":
+		case "bottom":
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return isStart ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+	const alignment = getAlignment(placement);
+	let list = getSideList(getSide(placement), direction === "start", rtl);
+	if (alignment) {
+		list = list.map((side) => side + "-" + alignment);
+		if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+	}
+	return list;
+}
+function getOppositePlacement(placement) {
+	const side = getSide(placement);
+	return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+	let { reference, floating } = _ref;
+	const sideAxis = getSideAxis(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const alignLength = getAxisLength(alignmentAxis);
+	const side = getSide(placement);
+	const isVertical = sideAxis === "y";
+	const commonX = reference.x + reference.width / 2 - floating.width / 2;
+	const commonY = reference.y + reference.height / 2 - floating.height / 2;
+	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+	let coords;
+	switch (side) {
+		case "top":
+			coords = {
+				x: commonX,
+				y: reference.y - floating.height
+			};
+			break;
+		case "bottom":
+			coords = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case "right":
+			coords = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case "left":
+			coords = {
+				x: reference.x - floating.width,
+				y: commonY
+			};
+			break;
+		default: coords = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	switch (getAlignment(placement)) {
+		case "start":
+			coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+		case "end":
+			coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+	}
+	return coords;
+}
+/**
+* Resolves with an object of overflow side offsets that determine how much the
+* element is overflowing a given clipping boundary on each side.
+* - positive = overflowing the boundary by that number of pixels
+* - negative = how many pixels left before it will overflow
+* - 0 = lies flush with the boundary
+* @see https://floating-ui.com/docs/detectOverflow
+*/
+async function detectOverflow(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform, rects, elements, strategy } = state;
+	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
+	const paddingObject = getPaddingObject(padding);
+	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
+	const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+		element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
+		boundary,
+		rootBoundary,
+		strategy
+	}));
+	const rect = elementContext === "floating" ? {
+		x,
+		y,
+		width: rects.floating.width,
+		height: rects.floating.height
+	} : rects.reference;
+	const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+	const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
+		x: 1,
+		y: 1
+	} : {
+		x: 1,
+		y: 1
+	};
+	const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements,
+		rect,
+		offsetParent,
+		strategy
+	}) : rect);
+	return {
+		top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+		bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+		left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+		right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+	};
+}
+var MAX_RESET_COUNT = 50;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*
+* This export does not have any `platform` interface logic. You will need to
+* write one for the platform you are using Floating UI with.
+*/
+var computePosition$1 = async (reference, floating, config) => {
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
+	const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+		...platform,
+		detectOverflow
+	};
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+	let rects = await platform.getElementRects({
+		reference,
+		floating,
+		strategy
+	});
+	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+	let statefulPlacement = placement;
+	let resetCount = 0;
+	const middlewareData = {};
+	for (let i = 0; i < middleware.length; i++) {
+		const currentMiddleware = middleware[i];
+		if (!currentMiddleware) continue;
+		const { name, fn } = currentMiddleware;
+		const { x: nextX, y: nextY, data, reset } = await fn({
+			x,
+			y,
+			initialPlacement: placement,
+			placement: statefulPlacement,
+			strategy,
+			middlewareData,
+			rects,
+			platform: platformWithDetectOverflow,
+			elements: {
+				reference,
+				floating
+			}
+		});
+		x = nextX != null ? nextX : x;
+		y = nextY != null ? nextY : y;
+		middlewareData[name] = {
+			...middlewareData[name],
+			...data
+		};
+		if (reset && resetCount < MAX_RESET_COUNT) {
+			resetCount++;
+			if (typeof reset === "object") {
+				if (reset.placement) statefulPlacement = reset.placement;
+				if (reset.rects) rects = reset.rects === true ? await platform.getElementRects({
+					reference,
+					floating,
+					strategy
+				}) : reset.rects;
+				({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+			}
+			i = -1;
+		}
+	}
+	return {
+		x,
+		y,
+		placement: statefulPlacement,
+		strategy,
+		middlewareData
+	};
+};
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow$1 = (options) => ({
+	name: "arrow",
+	options,
+	async fn(state) {
+		const { x, y, placement, rects, platform, elements, middlewareData } = state;
+		const { element, padding = 0 } = evaluate(options, state) || {};
+		if (element == null) return {};
+		const paddingObject = getPaddingObject(padding);
+		const coords = {
+			x,
+			y
+		};
+		const axis = getAlignmentAxis(placement);
+		const length = getAxisLength(axis);
+		const arrowDimensions = await platform.getDimensions(element);
+		const isYAxis = axis === "y";
+		const minProp = isYAxis ? "top" : "left";
+		const maxProp = isYAxis ? "bottom" : "right";
+		const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+		const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+		const startDiff = coords[axis] - rects.reference[axis];
+		const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
+		let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+		if (!clientSize || !await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent))) clientSize = elements.floating[clientProp] || rects.floating[length];
+		const centerToReference = endDiff / 2 - startDiff / 2;
+		const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+		const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+		const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+		const min$1 = minPadding;
+		const max = clientSize - arrowDimensions[length] - maxPadding;
+		const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+		const offset = clamp(min$1, center, max);
+		const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+		const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+		return {
+			[axis]: coords[axis] + alignmentOffset,
+			data: {
+				[axis]: offset,
+				centerOffset: center - offset - alignmentOffset,
+				...shouldAddOffset && { alignmentOffset }
+			},
+			reset: shouldAddOffset
+		};
+	}
+});
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+var flip$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "flip",
+		options,
+		async fn(state) {
+			var _middlewareData$arrow, _middlewareData$flip;
+			const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
+			if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			const side = getSide(placement);
+			const initialSideAxis = getSideAxis(initialPlacement);
+			const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+			const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+			const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+			const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+			if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+			const placements = [initialPlacement, ...fallbackPlacements];
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const overflows = [];
+			let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+			if (checkMainAxis) overflows.push(overflow[side]);
+			if (checkCrossAxis) {
+				const sides = getAlignmentSides(placement, rects, rtl);
+				overflows.push(overflow[sides[0]], overflow[sides[1]]);
+			}
+			overflowsData = [...overflowsData, {
+				placement,
+				overflows
+			}];
+			if (!overflows.every((side) => side <= 0)) {
+				var _middlewareData$flip2, _overflowsData$filter;
+				const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+				const nextPlacement = placements[nextIndex];
+				if (nextPlacement) {
+					if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) || overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
+						data: {
+							index: nextIndex,
+							overflows: overflowsData
+						},
+						reset: { placement: nextPlacement }
+					};
+				}
+				let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+				if (!resetPlacement) switch (fallbackStrategy) {
+					case "bestFit": {
+						var _overflowsData$filter2;
+						const placement = (_overflowsData$filter2 = overflowsData.filter((d) => {
+							if (hasFallbackAxisSideDirection) {
+								const currentSideAxis = getSideAxis(d.placement);
+								return currentSideAxis === initialSideAxis || currentSideAxis === "y";
+							}
+							return true;
+						}).map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+						if (placement) resetPlacement = placement;
+						break;
+					}
+					case "initialPlacement":
+						resetPlacement = initialPlacement;
+						break;
+				}
+				if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
+			}
+			return {};
+		}
+	};
+};
+function getSideOffsets(overflow, rect) {
+	return {
+		top: overflow.top - rect.height,
+		right: overflow.right - rect.width,
+		bottom: overflow.bottom - rect.height,
+		left: overflow.left - rect.width
+	};
+}
+function isAnySideFullyClipped(overflow) {
+	return sides.some((side) => overflow[side] >= 0);
+}
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
+var hide$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "hide",
+		options,
+		async fn(state) {
+			const { rects, platform } = state;
+			const { strategy = "referenceHidden", ...detectOverflowOptions } = evaluate(options, state);
+			switch (strategy) {
+				case "referenceHidden": {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
+						...detectOverflowOptions,
+						elementContext: "reference"
+					}), rects.reference);
+					return { data: {
+						referenceHiddenOffsets: offsets,
+						referenceHidden: isAnySideFullyClipped(offsets)
+					} };
+				}
+				case "escaped": {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
+						...detectOverflowOptions,
+						altBoundary: true
+					}), rects.floating);
+					return { data: {
+						escapedOffsets: offsets,
+						escaped: isAnySideFullyClipped(offsets)
+					} };
+				}
+				default: return {};
+			}
+		}
+	};
+};
+var originSides = /*#__PURE__*/ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+	const { placement, platform, elements } = state;
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+	const side = getSide(placement);
+	const alignment = getAlignment(placement);
+	const isVertical = getSideAxis(placement) === "y";
+	const mainAxisMulti = originSides.has(side) ? -1 : 1;
+	const crossAxisMulti = rtl && isVertical ? -1 : 1;
+	const rawValue = evaluate(options, state);
+	let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number" ? {
+		mainAxis: rawValue,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: rawValue.mainAxis || 0,
+		crossAxis: rawValue.crossAxis || 0,
+		alignmentAxis: rawValue.alignmentAxis
+	};
+	if (alignment && typeof alignmentAxis === "number") crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+	return isVertical ? {
+		x: crossAxis * crossAxisMulti,
+		y: mainAxis * mainAxisMulti
+	} : {
+		x: mainAxis * mainAxisMulti,
+		y: crossAxis * crossAxisMulti
+	};
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset$1 = function(options) {
+	if (options === void 0) options = 0;
+	return {
+		name: "offset",
+		options,
+		async fn(state) {
+			var _middlewareData$offse, _middlewareData$arrow;
+			const { x, y, placement, middlewareData } = state;
+			const diffCoords = await convertValueToCoords(state, options);
+			if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			return {
+				x: x + diffCoords.x,
+				y: y + diffCoords.y,
+				data: {
+					...diffCoords,
+					placement
+				}
+			};
+		}
+	};
+};
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+var shift$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "shift",
+		options,
+		async fn(state) {
+			const { x, y, placement, platform } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
+				let { x, y } = _ref;
+				return {
+					x,
+					y
+				};
+			} }, ...detectOverflowOptions } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const crossAxis = getSideAxis(getSide(placement));
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			if (checkMainAxis) {
+				const minSide = mainAxis === "y" ? "top" : "left";
+				const maxSide = mainAxis === "y" ? "bottom" : "right";
+				const min = mainAxisCoord + overflow[minSide];
+				const max = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min, mainAxisCoord, max);
+			}
+			if (checkCrossAxis) {
+				const minSide = crossAxis === "y" ? "top" : "left";
+				const maxSide = crossAxis === "y" ? "bottom" : "right";
+				const min = crossAxisCoord + overflow[minSide];
+				const max = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min, crossAxisCoord, max);
+			}
+			const limitedCoords = limiter.fn({
+				...state,
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			});
+			return {
+				...limitedCoords,
+				data: {
+					x: limitedCoords.x - x,
+					y: limitedCoords.y - y,
+					enabled: {
+						[mainAxis]: checkMainAxis,
+						[crossAxis]: checkCrossAxis
+					}
+				}
+			};
+		}
+	};
+};
+/**
+* Built-in `limiter` that will stop `shift()` at a certain point.
+*/
+var limitShift$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		options,
+		fn(state) {
+			const { x, y, placement, rects, middlewareData } = state;
+			const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const crossAxis = getSideAxis(placement);
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			const rawOffset = evaluate(offset, state);
+			const computedOffset = typeof rawOffset === "number" ? {
+				mainAxis: rawOffset,
+				crossAxis: 0
+			} : {
+				mainAxis: 0,
+				crossAxis: 0,
+				...rawOffset
+			};
+			if (checkMainAxis) {
+				const len = mainAxis === "y" ? "height" : "width";
+				const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+				const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+				if (mainAxisCoord < limitMin) mainAxisCoord = limitMin;
+				else if (mainAxisCoord > limitMax) mainAxisCoord = limitMax;
+			}
+			if (checkCrossAxis) {
+				var _middlewareData$offse, _middlewareData$offse2;
+				const len = mainAxis === "y" ? "width" : "height";
+				const isOriginSide = originSides.has(getSide(placement));
+				const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+				const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+				if (crossAxisCoord < limitMin) crossAxisCoord = limitMin;
+				else if (crossAxisCoord > limitMax) crossAxisCoord = limitMax;
+			}
+			return {
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			};
+		}
+	};
+};
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+var size$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "size",
+		options,
+		async fn(state) {
+			var _state$middlewareData, _state$middlewareData2;
+			const { placement, rects, platform, elements } = state;
+			const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const side = getSide(placement);
+			const alignment = getAlignment(placement);
+			const isYAxis = getSideAxis(placement) === "y";
+			const { width, height } = rects.floating;
+			let heightSide;
+			let widthSide;
+			if (side === "top" || side === "bottom") {
+				heightSide = side;
+				widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+			} else {
+				widthSide = side;
+				heightSide = alignment === "end" ? "top" : "bottom";
+			}
+			const maximumClippingHeight = height - overflow.top - overflow.bottom;
+			const maximumClippingWidth = width - overflow.left - overflow.right;
+			const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+			const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+			const noShift = !state.middlewareData.shift;
+			let availableHeight = overflowAvailableHeight;
+			let availableWidth = overflowAvailableWidth;
+			if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
+			if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
+			if (noShift && !alignment) {
+				const xMin = max(overflow.left, 0);
+				const xMax = max(overflow.right, 0);
+				const yMin = max(overflow.top, 0);
+				const yMax = max(overflow.bottom, 0);
+				if (isYAxis) availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+				else availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+			}
+			await apply({
+				...state,
+				availableWidth,
+				availableHeight
+			});
+			const nextDimensions = await platform.getDimensions(elements.floating);
+			if (width !== nextDimensions.width || height !== nextDimensions.height) return { reset: { rects: true } };
+			return {};
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+	return typeof window !== "undefined";
+}
+function getNodeName(node) {
+	if (isNode(node)) return (node.nodeName || "").toLowerCase();
+	return "#document";
+}
+function getWindow(node) {
+	var _node$ownerDocument;
+	return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+	var _ref;
+	return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
+	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+	return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+	try {
+		if (element.matches(":popover-open")) return true;
+	} catch (_e) {}
+	try {
+		return element.matches(":modal");
+	} catch (_e) {
+		return false;
+	}
+}
+var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+var containRe = /paint|layout|strict|content/;
+var isNotNone = (value) => !!value && value !== "none";
+var isWebKitValue;
+function isContainingBlock(elementOrCss) {
+	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+	return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
+}
+function getContainingBlock(element) {
+	let currentNode = getParentNode(element);
+	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		if (isContainingBlock(currentNode)) return currentNode;
+		else if (isTopLayer(currentNode)) return null;
+		currentNode = getParentNode(currentNode);
+	}
+	return null;
+}
+function isWebKit() {
+	if (isWebKitValue == null) isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+	return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+	return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+	if (isElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+	const parentNode = getParentNode(node);
+	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+	var _node$ownerDocument2;
+	if (list === void 0) list = [];
+	const scrollableAncestor = getNearestOverflowAncestor(node);
+	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+	const win = getWindow(scrollableAncestor);
+	if (isBody) {
+		getFrameElement(win);
+		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], []);
+	} else return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, []));
+}
+function getFrameElement(win) {
+	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+dom@1.7.6/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(element) {
+	const css = getComputedStyle$1(element);
+	let width = parseFloat(css.width) || 0;
+	let height = parseFloat(css.height) || 0;
+	const hasOffset = isHTMLElement(element);
+	const offsetWidth = hasOffset ? element.offsetWidth : width;
+	const offsetHeight = hasOffset ? element.offsetHeight : height;
+	const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+	if (shouldFallback) {
+		width = offsetWidth;
+		height = offsetHeight;
+	}
+	return {
+		width,
+		height,
+		$: shouldFallback
+	};
+}
+function unwrapElement(element) {
+	return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+	const domElement = unwrapElement(element);
+	if (!isHTMLElement(domElement)) return createCoords(1);
+	const rect = domElement.getBoundingClientRect();
+	const { width, height, $ } = getCssDimensions(domElement);
+	let x = ($ ? round(rect.width) : rect.width) / width;
+	let y = ($ ? round(rect.height) : rect.height) / height;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+var noOffsets = /*#__PURE__*/ createCoords(0);
+function getVisualOffsets(element) {
+	const win = getWindow(element);
+	if (!isWebKit() || !win.visualViewport) return noOffsets;
+	return {
+		x: win.visualViewport.offsetLeft,
+		y: win.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+	if (isFixed === void 0) isFixed = false;
+	if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
+	return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+	if (includeScale === void 0) includeScale = false;
+	if (isFixedStrategy === void 0) isFixedStrategy = false;
+	const clientRect = element.getBoundingClientRect();
+	const domElement = unwrapElement(element);
+	let scale = createCoords(1);
+	if (includeScale) if (offsetParent) {
+		if (isElement(offsetParent)) scale = getScale(offsetParent);
+	} else scale = getScale(element);
+	const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+	let x = (clientRect.left + visualOffsets.x) / scale.x;
+	let y = (clientRect.top + visualOffsets.y) / scale.y;
+	let width = clientRect.width / scale.x;
+	let height = clientRect.height / scale.y;
+	if (domElement) {
+		const win = getWindow(domElement);
+		const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		let currentWin = win;
+		let currentIFrame = getFrameElement(currentWin);
+		while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+			const iframeScale = getScale(currentIFrame);
+			const iframeRect = currentIFrame.getBoundingClientRect();
+			const css = getComputedStyle$1(currentIFrame);
+			const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+			const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+			x *= iframeScale.x;
+			y *= iframeScale.y;
+			width *= iframeScale.x;
+			height *= iframeScale.y;
+			x += left;
+			y += top;
+			currentWin = getWindow(currentIFrame);
+			currentIFrame = getFrameElement(currentWin);
+		}
+	}
+	return rectToClientRect({
+		width,
+		height,
+		x,
+		y
+	});
+}
+function getWindowScrollBarX(element, rect) {
+	const leftScroll = getNodeScroll(element).scrollLeft;
+	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+	return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+	const htmlRect = documentElement.getBoundingClientRect();
+	return {
+		x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
+		y: htmlRect.top + scroll.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+	let { elements, rect, offsetParent, strategy } = _ref;
+	const isFixed = strategy === "fixed";
+	const documentElement = getDocumentElement(offsetParent);
+	const topLayer = elements ? isTopLayer(elements.floating) : false;
+	if (offsetParent === documentElement || topLayer && isFixed) return rect;
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	let scale = createCoords(1);
+	const offsets = createCoords(0);
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent);
+			scale = getScale(offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		}
+	}
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		width: rect.width * scale.x,
+		height: rect.height * scale.y,
+		x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+		y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+	};
+}
+function getClientRects(element) {
+	return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+	const html = getDocumentElement(element);
+	const scroll = getNodeScroll(element);
+	const body = element.ownerDocument.body;
+	const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+	const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+	let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+	const y = -scroll.scrollTop;
+	if (getComputedStyle$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+var SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+	const win = getWindow(element);
+	const html = getDocumentElement(element);
+	const visualViewport = win.visualViewport;
+	let width = html.clientWidth;
+	let height = html.clientHeight;
+	let x = 0;
+	let y = 0;
+	if (visualViewport) {
+		width = visualViewport.width;
+		height = visualViewport.height;
+		const visualViewportBased = isWebKit();
+		if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+			x = visualViewport.offsetLeft;
+			y = visualViewport.offsetTop;
+		}
+	}
+	const windowScrollbarX = getWindowScrollBarX(html);
+	if (windowScrollbarX <= 0) {
+		const doc = html.ownerDocument;
+		const body = doc.body;
+		const bodyStyles = getComputedStyle(body);
+		const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+		const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+		if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
+	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+function getInnerBoundingClientRect(element, strategy) {
+	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+	const top = clientRect.top + element.clientTop;
+	const left = clientRect.left + element.clientLeft;
+	const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+	return {
+		width: element.clientWidth * scale.x,
+		height: element.clientHeight * scale.y,
+		x: left * scale.x,
+		y: top * scale.y
+	};
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+	let rect;
+	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
+	else if (clippingAncestor === "document") rect = getDocumentRect(getDocumentElement(element));
+	else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+	else {
+		const visualOffsets = getVisualOffsets(element);
+		rect = {
+			x: clippingAncestor.x - visualOffsets.x,
+			y: clippingAncestor.y - visualOffsets.y,
+			width: clippingAncestor.width,
+			height: clippingAncestor.height
+		};
+	}
+	return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+	const parentNode = getParentNode(element);
+	if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
+	return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+	const cachedResult = cache.get(element);
+	if (cachedResult) return cachedResult;
+	let result = getOverflowAncestors(element, []).filter((el) => isElement(el) && getNodeName(el) !== "body");
+	let currentContainingBlockComputedStyle = null;
+	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+	let currentNode = elementIsFixed ? getParentNode(element) : element;
+	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		const computedStyle = getComputedStyle$1(currentNode);
+		const currentNodeIsContaining = isContainingBlock(currentNode);
+		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
+		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
+		else currentContainingBlockComputedStyle = computedStyle;
+		currentNode = getParentNode(currentNode);
+	}
+	cache.set(element, result);
+	return result;
+}
+function getClippingRect(_ref) {
+	let { element, boundary, rootBoundary, strategy } = _ref;
+	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
+	const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+	let top = firstRect.top;
+	let right = firstRect.right;
+	let bottom = firstRect.bottom;
+	let left = firstRect.left;
+	for (let i = 1; i < clippingAncestors.length; i++) {
+		const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
+		top = max(rect.top, top);
+		right = min(rect.right, right);
+		bottom = min(rect.bottom, bottom);
+		left = max(rect.left, left);
+	}
+	return {
+		width: right - left,
+		height: bottom - top,
+		x: left,
+		y: top
+	};
+}
+function getDimensions(element) {
+	const { width, height } = getCssDimensions(element);
+	return {
+		width,
+		height
+	};
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	const documentElement = getDocumentElement(offsetParent);
+	const isFixed = strategy === "fixed";
+	const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	const offsets = createCoords(0);
+	function setLeftRTLScrollbarOffset() {
+		offsets.x = getWindowScrollBarX(documentElement);
+	}
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		} else if (documentElement) setLeftRTLScrollbarOffset();
+	}
+	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
+		y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
+		width: rect.width,
+		height: rect.height
+	};
+}
+function isStaticPositioned(element) {
+	return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+	if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") return null;
+	if (polyfill) return polyfill(element);
+	let rawOffsetParent = element.offsetParent;
+	if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
+	return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+	const win = getWindow(element);
+	if (isTopLayer(element)) return win;
+	if (!isHTMLElement(element)) {
+		let svgOffsetParent = getParentNode(element);
+		while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+			if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
+			svgOffsetParent = getParentNode(svgOffsetParent);
+		}
+		return win;
+	}
+	let offsetParent = getTrueOffsetParent(element, polyfill);
+	while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+	if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
+	return offsetParent || getContainingBlock(element) || win;
+}
+var getElementRects = async function(data) {
+	const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+	const getDimensionsFn = this.getDimensions;
+	const floatingDimensions = await getDimensionsFn(data.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: floatingDimensions.width,
+			height: floatingDimensions.height
+		}
+	};
+};
+function isRTL(element) {
+	return getComputedStyle$1(element).direction === "rtl";
+}
+var platform = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement,
+	isRTL
+};
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset = offset$1;
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+var shift = shift$1;
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+var flip = flip$1;
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+var size = size$1;
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
+var hide = hide$1;
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow = arrow$1;
+/**
+* Built-in `limiter` that will stop `shift()` at a certain point.
+*/
+var limitShift = limitShift$1;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*/
+var computePosition = (reference, floating, options) => {
+	const cache = /* @__PURE__ */ new Map();
+	const mergedOptions = {
+		platform,
+		...options
+	};
+	const platformWithCache = {
+		...mergedOptions.platform,
+		_c: cache
+	};
+	return computePosition$1(reference, floating, {
+		...mergedOptions,
+		platform: platformWithCache
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/internal/floating-svelte/floating-utils.svelte.js
+function get(valueOrGetValue) {
+	return typeof valueOrGetValue === "function" ? valueOrGetValue() : valueOrGetValue;
+}
+function getDPR(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+	const dpr = getDPR(element);
+	return Math.round(value * dpr) / dpr;
+}
+function getFloatingContentCSSVars(name) {
+	return {
+		[`--bits-${name}-content-transform-origin`]: `var(--bits-floating-transform-origin)`,
+		[`--bits-${name}-content-available-width`]: `var(--bits-floating-available-width)`,
+		[`--bits-${name}-content-available-height`]: `var(--bits-floating-available-height)`,
+		[`--bits-${name}-anchor-width`]: `var(--bits-floating-anchor-width)`,
+		[`--bits-${name}-anchor-height`]: `var(--bits-floating-anchor-height)`
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/internal/floating-svelte/use-floating.svelte.js
+function useFloating(options) {
+	const openOption = derived(() => get(options.open) ?? true);
+	const middlewareOption = derived(() => get(options.middleware));
+	const transformOption = derived(() => get(options.transform) ?? true);
+	const placementOption = derived(() => get(options.placement) ?? "bottom");
+	const strategyOption = derived(() => get(options.strategy) ?? "absolute");
+	const sideOffsetOption = derived(() => get(options.sideOffset) ?? 0);
+	const alignOffsetOption = derived(() => get(options.alignOffset) ?? 0);
+	const reference = options.reference;
+	/** State */
+	let x = 0;
+	let y = 0;
+	const floating = simpleBox(null);
+	let strategy = strategyOption();
+	let placement = placementOption();
+	let middlewareData = {};
+	let isPositioned = false;
+	let updateRequestId = 0;
+	const floatingStyles = derived(() => {
+		const xVal = floating.current ? roundByDPR(floating.current, x) : x;
+		const yVal = floating.current ? roundByDPR(floating.current, y) : y;
+		if (transformOption()) return {
+			position: strategy,
+			left: "0",
+			top: "0",
+			transform: `translate(${xVal}px, ${yVal}px)`,
+			...floating.current && getDPR(floating.current) >= 1.5 && { willChange: "transform" }
+		};
+		return {
+			position: strategy,
+			left: `${xVal}px`,
+			top: `${yVal}px`
+		};
+	});
+	function update() {
+		if (reference.current === null || floating.current === null) return;
+		const referenceNode = reference.current;
+		const floatingNode = floating.current;
+		const requestId = ++updateRequestId;
+		computePosition(referenceNode, floatingNode, {
+			middleware: middlewareOption(),
+			placement: placementOption(),
+			strategy: strategyOption()
+		}).then((position) => {
+			if (requestId !== updateRequestId) return;
+			if (reference.current !== referenceNode || floating.current !== floatingNode) return;
+			if (isReferenceHidden(referenceNode)) {
+				middlewareData = {
+					...middlewareData,
+					hide: {
+						...middlewareData.hide,
+						referenceHidden: true
+					}
+				};
+				return;
+			}
+			if (!openOption() && x !== 0 && y !== 0) {
+				const maxExpectedOffset = Math.max(Math.abs(sideOffsetOption()), Math.abs(alignOffsetOption()), 15);
+				if (position.x <= maxExpectedOffset && position.y <= maxExpectedOffset) return;
+			}
+			x = position.x;
+			y = position.y;
+			strategy = position.strategy;
+			placement = position.placement;
+			middlewareData = position.middlewareData;
+			isPositioned = true;
+		});
+	}
+	return {
+		floating,
+		reference,
+		get strategy() {
+			return strategy;
+		},
+		get placement() {
+			return placement;
+		},
+		get middlewareData() {
+			return middlewareData;
+		},
+		get isPositioned() {
+			return isPositioned;
+		},
+		get floatingStyles() {
+			return floatingStyles();
+		},
+		get update() {
+			return update;
+		}
+	};
+}
+function isReferenceHidden(node) {
+	if (!(node instanceof Element)) return false;
+	if (!node.isConnected) return true;
+	if (node instanceof HTMLElement && node.hidden) return true;
+	return node.getClientRects().length === 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/floating-layer/use-floating-layer.svelte.js
+var OPPOSITE_SIDE = {
+	top: "bottom",
+	right: "left",
+	bottom: "top",
+	left: "right"
+};
+var FloatingRootContext = new Context("Floating.Root");
+var FloatingContentContext = new Context("Floating.Content");
+var FloatingTooltipRootContext = new Context("Floating.Root");
+var FloatingRootState = class FloatingRootState {
+	static create(tooltip = false) {
+		return tooltip ? FloatingTooltipRootContext.set(new FloatingRootState()) : FloatingRootContext.set(new FloatingRootState());
+	}
+	anchorNode = simpleBox(null);
+	customAnchorNode = simpleBox(null);
+	triggerNode = simpleBox(null);
+	constructor() {}
+};
+var FloatingContentState = class FloatingContentState {
+	static create(opts, tooltip = false) {
+		return tooltip ? FloatingContentContext.set(new FloatingContentState(opts, FloatingTooltipRootContext.get())) : FloatingContentContext.set(new FloatingContentState(opts, FloatingRootContext.get()));
+	}
+	opts;
+	root;
+	contentRef = simpleBox(null);
+	wrapperRef = simpleBox(null);
+	arrowRef = simpleBox(null);
+	contentAttachment = attachRef(this.contentRef);
+	wrapperAttachment = attachRef(this.wrapperRef);
+	arrowAttachment = attachRef(this.arrowRef);
+	arrowId = simpleBox(useId());
+	#transformedStyle = derived(() => {
+		if (typeof this.opts.style === "string") return cssToStyleObj(this.opts.style);
+		if (!this.opts.style) return {};
+	});
+	#updatePositionStrategy = void 0;
+	#arrowSize = new ElementSize(() => this.arrowRef.current ?? void 0);
+	#arrowWidth = derived(() => this.#arrowSize?.width ?? 0);
+	#arrowHeight = derived(() => this.#arrowSize?.height ?? 0);
+	#desiredPlacement = derived(() => this.opts.side?.current + (this.opts.align.current !== "center" ? `-${this.opts.align.current}` : ""));
+	#boundary = derived(() => Array.isArray(this.opts.collisionBoundary.current) ? this.opts.collisionBoundary.current : [this.opts.collisionBoundary.current]);
+	#hasExplicitBoundaries = derived(() => this.#boundary().length > 0);
+	get hasExplicitBoundaries() {
+		return this.#hasExplicitBoundaries();
+	}
+	set hasExplicitBoundaries($$value) {
+		return this.#hasExplicitBoundaries($$value);
+	}
+	#detectOverflowOptions = derived(() => ({
+		padding: this.opts.collisionPadding.current,
+		boundary: this.#boundary().filter(isNotNull),
+		altBoundary: this.hasExplicitBoundaries
+	}));
+	get detectOverflowOptions() {
+		return this.#detectOverflowOptions();
+	}
+	set detectOverflowOptions($$value) {
+		return this.#detectOverflowOptions($$value);
+	}
+	#availableWidth = void 0;
+	#availableHeight = void 0;
+	#anchorWidth = void 0;
+	#anchorHeight = void 0;
+	#middleware = derived(() => [
+		offset({
+			mainAxis: this.opts.sideOffset.current + this.#arrowHeight(),
+			alignmentAxis: this.opts.alignOffset.current
+		}),
+		this.opts.avoidCollisions.current && shift({
+			mainAxis: true,
+			crossAxis: false,
+			limiter: this.opts.sticky.current === "partial" ? limitShift() : void 0,
+			...this.detectOverflowOptions
+		}),
+		this.opts.avoidCollisions.current && flip({ ...this.detectOverflowOptions }),
+		size({
+			...this.detectOverflowOptions,
+			apply: ({ rects, availableWidth, availableHeight }) => {
+				const { width: anchorWidth, height: anchorHeight } = rects.reference;
+				this.#availableWidth = availableWidth;
+				this.#availableHeight = availableHeight;
+				this.#anchorWidth = anchorWidth;
+				this.#anchorHeight = anchorHeight;
+			}
+		}),
+		this.arrowRef.current && arrow({
+			element: this.arrowRef.current,
+			padding: this.opts.arrowPadding.current
+		}),
+		transformOrigin({
+			arrowWidth: this.#arrowWidth(),
+			arrowHeight: this.#arrowHeight()
+		}),
+		this.opts.hideWhenDetached.current && hide({
+			strategy: "referenceHidden",
+			...this.detectOverflowOptions
+		})
+	].filter(Boolean));
+	get middleware() {
+		return this.#middleware();
+	}
+	set middleware($$value) {
+		return this.#middleware($$value);
+	}
+	floating;
+	#placedSide = derived(() => getSideFromPlacement(this.floating.placement));
+	get placedSide() {
+		return this.#placedSide();
+	}
+	set placedSide($$value) {
+		return this.#placedSide($$value);
+	}
+	#placedAlign = derived(() => getAlignFromPlacement(this.floating.placement));
+	get placedAlign() {
+		return this.#placedAlign();
+	}
+	set placedAlign($$value) {
+		return this.#placedAlign($$value);
+	}
+	#arrowX = derived(() => this.floating.middlewareData.arrow?.x ?? 0);
+	get arrowX() {
+		return this.#arrowX();
+	}
+	set arrowX($$value) {
+		return this.#arrowX($$value);
+	}
+	#arrowY = derived(() => this.floating.middlewareData.arrow?.y ?? 0);
+	get arrowY() {
+		return this.#arrowY();
+	}
+	set arrowY($$value) {
+		return this.#arrowY($$value);
+	}
+	#cannotCenterArrow = derived(() => this.floating.middlewareData.arrow?.centerOffset !== 0);
+	get cannotCenterArrow() {
+		return this.#cannotCenterArrow();
+	}
+	set cannotCenterArrow($$value) {
+		return this.#cannotCenterArrow($$value);
+	}
+	contentZIndex;
+	#arrowBaseSide = derived(() => OPPOSITE_SIDE[this.placedSide]);
+	get arrowBaseSide() {
+		return this.#arrowBaseSide();
+	}
+	set arrowBaseSide($$value) {
+		return this.#arrowBaseSide($$value);
+	}
+	#wrapperProps = derived(() => ({
+		id: this.opts.wrapperId.current,
+		"data-bits-floating-content-wrapper": "",
+		style: {
+			...this.floating.floatingStyles,
+			transform: this.floating.isPositioned ? this.floating.floatingStyles.transform : "translate(0, -200%)",
+			minWidth: "max-content",
+			zIndex: this.contentZIndex,
+			"--bits-floating-transform-origin": `${this.floating.middlewareData.transformOrigin?.x} ${this.floating.middlewareData.transformOrigin?.y}`,
+			"--bits-floating-available-width": `${this.#availableWidth}px`,
+			"--bits-floating-available-height": `${this.#availableHeight}px`,
+			"--bits-floating-anchor-width": `${this.#anchorWidth}px`,
+			"--bits-floating-anchor-height": `${this.#anchorHeight}px`,
+			...this.floating.middlewareData.hide?.referenceHidden && {
+				visibility: "hidden",
+				"pointer-events": "none"
+			},
+			...this.#transformedStyle()
+		},
+		dir: this.opts.dir.current,
+		...this.wrapperAttachment
+	}));
+	get wrapperProps() {
+		return this.#wrapperProps();
+	}
+	set wrapperProps($$value) {
+		return this.#wrapperProps($$value);
+	}
+	#props = derived(() => ({
+		"data-side": this.placedSide,
+		"data-align": this.placedAlign,
+		style: styleToString({ ...this.#transformedStyle() }),
+		...this.contentAttachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+	#arrowStyle = derived(() => ({
+		position: "absolute",
+		left: this.arrowX ? `${this.arrowX}px` : void 0,
+		top: this.arrowY ? `${this.arrowY}px` : void 0,
+		[this.arrowBaseSide]: 0,
+		"transform-origin": {
+			top: "",
+			right: "0 0",
+			bottom: "center 0",
+			left: "100% 0"
+		}[this.placedSide],
+		transform: {
+			top: "translateY(100%)",
+			right: "translateY(50%) rotate(90deg) translateX(-50%)",
+			bottom: "rotate(180deg)",
+			left: "translateY(50%) rotate(-90deg) translateX(50%)"
+		}[this.placedSide],
+		visibility: this.cannotCenterArrow ? "hidden" : void 0
+	}));
+	get arrowStyle() {
+		return this.#arrowStyle();
+	}
+	set arrowStyle($$value) {
+		return this.#arrowStyle($$value);
+	}
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.#updatePositionStrategy = opts.updatePositionStrategy;
+		if (opts.customAnchor) this.root.customAnchorNode.current = opts.customAnchor.current;
+		watch(() => opts.customAnchor.current, (customAnchor) => {
+			this.root.customAnchorNode.current = customAnchor;
+		});
+		this.floating = useFloating({
+			strategy: () => this.opts.strategy.current,
+			placement: () => this.#desiredPlacement(),
+			middleware: () => this.middleware,
+			reference: this.root.anchorNode,
+			open: () => this.opts.enabled.current,
+			sideOffset: () => this.opts.sideOffset.current,
+			alignOffset: () => this.opts.alignOffset.current
+		});
+		watch(() => this.contentRef.current, (contentNode) => {
+			if (!contentNode || !this.opts.enabled.current) return;
+			const win = getWindow$1(contentNode);
+			const rafId = win.requestAnimationFrame(() => {
+				if (this.contentRef.current !== contentNode || !this.opts.enabled.current) return;
+				const zIndex = win.getComputedStyle(contentNode).zIndex;
+				if (zIndex !== this.contentZIndex) this.contentZIndex = zIndex;
+			});
+			return () => {
+				win.cancelAnimationFrame(rafId);
+			};
+		});
+	}
+};
+var FloatingAnchorState = class FloatingAnchorState {
+	static create(opts, tooltip = false) {
+		return tooltip ? new FloatingAnchorState(opts, FloatingTooltipRootContext.get()) : new FloatingAnchorState(opts, FloatingRootContext.get());
+	}
+	opts;
+	root;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		if (opts.virtualEl && opts.virtualEl.current) root.triggerNode = boxFrom(opts.virtualEl.current);
+		else root.triggerNode = opts.ref;
+	}
+};
+function transformOrigin(options) {
+	return {
+		name: "transformOrigin",
+		options,
+		fn(data) {
+			const { placement, rects, middlewareData } = data;
+			const isArrowHidden = middlewareData.arrow?.centerOffset !== 0;
+			const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
+			const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
+			const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
+			const noArrowAlign = {
+				start: "0%",
+				center: "50%",
+				end: "100%"
+			}[placedAlign];
+			const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;
+			const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;
+			let x = "";
+			let y = "";
+			if (placedSide === "bottom") {
+				x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+				y = `${-arrowHeight}px`;
+			} else if (placedSide === "top") {
+				x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+				y = `${rects.floating.height + arrowHeight}px`;
+			} else if (placedSide === "right") {
+				x = `${-arrowHeight}px`;
+				y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+			} else if (placedSide === "left") {
+				x = `${rects.floating.width + arrowHeight}px`;
+				y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+			}
+			return { data: {
+				x,
+				y
+			} };
+		}
+	};
+}
+function getSideAndAlignFromPlacement(placement) {
+	const [side, align = "center"] = placement.split("-");
+	return [side, align];
+}
+function getSideFromPlacement(placement) {
+	return getSideAndAlignFromPlacement(placement)[0];
+}
+function getAlignFromPlacement(placement) {
+	return getSideAndAlignFromPlacement(placement)[1];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/floating-layer/components/floating-layer.svelte
+function Floating_layer($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { children, tooltip = false } = $$props;
+		FloatingRootState.create(tooltip);
+		children?.($$renderer);
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/internal/data-typeahead.svelte.js
+var DataTypeahead = class {
+	#opts;
+	#candidateValues = derived(() => this.#opts.candidateValues());
+	#search;
+	constructor(opts) {
+		this.#opts = opts;
+		this.#search = boxAutoReset("", {
+			afterMs: 1e3,
+			getWindow: this.#opts.getWindow
+		});
+		this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
+		this.resetTypeahead = this.resetTypeahead.bind(this);
+	}
+	handleTypeaheadSearch(key) {
+		if (!this.#opts.enabled() || !this.#candidateValues().length) return;
+		this.#search.current = this.#search.current + key;
+		const currentItem = this.#opts.getCurrentItem();
+		const currentMatch = this.#candidateValues().find((item) => item === currentItem) ?? "";
+		const nextMatch = getNextMatch(this.#candidateValues().map((item) => item ?? ""), this.#search.current, currentMatch);
+		const newItem = this.#candidateValues().find((item) => item === nextMatch);
+		if (newItem) this.#opts.onMatch(newItem);
+		return newItem;
+	}
+	resetTypeahead() {
+		this.#search.current = "";
+	}
+};
+var FIRST_KEYS = [
+	ARROW_DOWN,
+	PAGE_UP,
+	HOME
+];
+var LAST_KEYS = [
+	ARROW_UP,
+	PAGE_DOWN,
+	"End"
+];
+var FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
+var selectAttrs = createBitsAttrs({
+	component: "select",
+	parts: [
+		"trigger",
+		"content",
+		"item",
+		"viewport",
+		"scroll-up-button",
+		"scroll-down-button",
+		"group",
+		"group-label",
+		"separator",
+		"arrow",
+		"input",
+		"content-wrapper",
+		"item-text",
+		"value"
+	]
+});
+var SelectRootContext = new Context("Select.Root | Combobox.Root");
+var SelectContentContext = new Context("Select.Content | Combobox.Content");
+var SelectBaseRootState = class {
+	opts;
+	touchedInput = false;
+	inputNode = null;
+	contentNode = null;
+	contentPresence;
+	viewportNode = null;
+	triggerNode = null;
+	valueNode = null;
+	valueId = "";
+	highlightedNode = null;
+	#highlightedValue = derived(() => {
+		if (!this.highlightedNode) return null;
+		return this.highlightedNode.getAttribute("data-value");
+	});
+	get highlightedValue() {
+		return this.#highlightedValue();
+	}
+	set highlightedValue($$value) {
+		return this.#highlightedValue($$value);
+	}
+	#highlightedId = derived(() => {
+		if (!this.highlightedNode) return void 0;
+		return this.highlightedNode.id;
+	});
+	get highlightedId() {
+		return this.#highlightedId();
+	}
+	set highlightedId($$value) {
+		return this.#highlightedId($$value);
+	}
+	#highlightedLabel = derived(() => {
+		if (!this.highlightedNode) return null;
+		return this.highlightedNode.getAttribute("data-label");
+	});
+	get highlightedLabel() {
+		return this.#highlightedLabel();
+	}
+	set highlightedLabel($$value) {
+		return this.#highlightedLabel($$value);
+	}
+	contentIsPositioned = false;
+	isUsingKeyboard = false;
+	isCombobox = false;
+	domContext = new DOMContext(() => null);
+	constructor(opts) {
+		this.opts = opts;
+		this.isCombobox = opts.isCombobox;
+		this.contentPresence = new PresenceManager({
+			ref: boxWith(() => this.contentNode),
+			open: this.opts.open,
+			onComplete: () => {
+				this.opts.onOpenChangeComplete.current(this.opts.open.current);
+			}
+		});
+	}
+	setHighlightedNode(node, initial = false) {
+		this.highlightedNode = node;
+		if (node && (this.isUsingKeyboard || initial)) this.scrollHighlightedNodeIntoView(node);
+	}
+	scrollHighlightedNodeIntoView(node) {
+		if (!this.viewportNode || !this.contentIsPositioned) return;
+		node.scrollIntoView({ block: this.opts.scrollAlignment.current });
+	}
+	getCandidateNodes() {
+		const node = this.contentNode;
+		if (!node) return [];
+		return Array.from(node.querySelectorAll(`[${this.getBitsAttr("item")}]:not([data-disabled])`));
+	}
+	setHighlightedToFirstCandidate(initial = false) {
+		this.setHighlightedNode(null);
+		let nodes = this.getCandidateNodes();
+		if (!nodes.length) return;
+		if (this.viewportNode) {
+			const viewportRect = this.viewportNode.getBoundingClientRect();
+			nodes = nodes.filter((node) => {
+				if (!this.viewportNode) return false;
+				const nodeRect = node.getBoundingClientRect();
+				return nodeRect.right <= viewportRect.right && nodeRect.left >= viewportRect.left && nodeRect.bottom <= viewportRect.bottom && nodeRect.top >= viewportRect.top;
+			});
+		}
+		this.setHighlightedNode(nodes[0], initial);
+	}
+	getNodeByValue(value) {
+		return this.getCandidateNodes().find((node) => node.dataset.value === value) ?? null;
+	}
+	/**
+	* Resolves the display label for a value: `items` entry when present, otherwise the
+	* mounted item's `data-label` or its text content.
+	*/
+	getLabelForValue(value) {
+		if (value === "") return "";
+		const fromItems = this.opts.items.current.find((item) => item.value === value)?.label;
+		if (fromItems !== void 0) return fromItems;
+		const node = this.getNodeByValue(value);
+		if (node) {
+			const dataLabel = node.getAttribute("data-label");
+			if (dataLabel !== null && dataLabel !== "") return dataLabel;
+			return node.textContent?.trim() ?? value;
+		}
+		return value;
+	}
+	setOpen(open) {
+		this.opts.open.current = open;
+	}
+	toggleOpen() {
+		this.opts.open.current = !this.opts.open.current;
+	}
+	handleOpen() {
+		this.setOpen(true);
+	}
+	handleClose() {
+		this.setHighlightedNode(null);
+		this.setOpen(false);
+	}
+	toggleMenu() {
+		this.toggleOpen();
+	}
+	getBitsAttr = (part) => {
+		return selectAttrs.getAttr(part, this.isCombobox ? "combobox" : void 0);
+	};
+};
+var SelectSingleRootState = class extends SelectBaseRootState {
+	opts;
+	isMulti = false;
+	#hasValue = derived(() => this.opts.value.current !== "");
+	get hasValue() {
+		return this.#hasValue();
+	}
+	set hasValue($$value) {
+		return this.#hasValue($$value);
+	}
+	#currentLabel = derived(() => {
+		if (!this.opts.items.current.length) return "";
+		return this.opts.items.current.find((item) => item.value === this.opts.value.current)?.label ?? "";
+	});
+	get currentLabel() {
+		return this.#currentLabel();
+	}
+	set currentLabel($$value) {
+		return this.#currentLabel($$value);
+	}
+	#candidateLabels = derived(() => {
+		if (!this.opts.items.current.length) return [];
+		return this.opts.items.current.filter((item) => !item.disabled).map((item) => item.label);
+	});
+	get candidateLabels() {
+		return this.#candidateLabels();
+	}
+	set candidateLabels($$value) {
+		return this.#candidateLabels($$value);
+	}
+	#dataTypeaheadEnabled = derived(() => {
+		if (this.isMulti) return false;
+		if (this.opts.items.current.length === 0) return false;
+		return true;
+	});
+	get dataTypeaheadEnabled() {
+		return this.#dataTypeaheadEnabled();
+	}
+	set dataTypeaheadEnabled($$value) {
+		return this.#dataTypeaheadEnabled($$value);
+	}
+	constructor(opts) {
+		super(opts);
+		this.opts = opts;
+		watch(() => this.opts.open.current, () => {
+			if (!this.opts.open.current) return;
+			this.setInitialHighlightedNode();
+		});
+	}
+	includesItem(itemValue) {
+		return this.opts.value.current === itemValue;
+	}
+	toggleItem(itemValue, itemLabel = itemValue) {
+		const newValue = this.includesItem(itemValue) ? "" : itemValue;
+		this.opts.value.current = newValue;
+		if (newValue !== "") this.opts.inputValue.current = itemLabel;
+	}
+	setInitialHighlightedNode() {
+		afterTick(() => {
+			if (this.highlightedNode && this.domContext.getDocument().contains(this.highlightedNode)) return;
+			if (this.opts.value.current !== "") {
+				const node = this.getNodeByValue(this.opts.value.current);
+				if (node) {
+					this.setHighlightedNode(node, true);
+					return;
+				}
+			}
+			this.setHighlightedToFirstCandidate(true);
+		});
+	}
+};
+var SelectMultipleRootState = class extends SelectBaseRootState {
+	opts;
+	isMulti = true;
+	#hasValue = derived(() => this.opts.value.current.length > 0);
+	get hasValue() {
+		return this.#hasValue();
+	}
+	set hasValue($$value) {
+		return this.#hasValue($$value);
+	}
+	constructor(opts) {
+		super(opts);
+		this.opts = opts;
+		watch(() => this.opts.open.current, () => {
+			if (!this.opts.open.current) return;
+			this.setInitialHighlightedNode();
+		});
+	}
+	includesItem(itemValue) {
+		return this.opts.value.current.includes(itemValue);
+	}
+	toggleItem(itemValue, itemLabel = itemValue) {
+		if (this.includesItem(itemValue)) this.opts.value.current = this.opts.value.current.filter((v) => v !== itemValue);
+		else this.opts.value.current = [...this.opts.value.current, itemValue];
+		this.opts.inputValue.current = itemLabel;
+	}
+	setInitialHighlightedNode() {
+		afterTick(() => {
+			if (!this.domContext) return;
+			if (this.highlightedNode && this.domContext.getDocument().contains(this.highlightedNode)) return;
+			if (this.opts.value.current.length && this.opts.value.current[0] !== "") {
+				const node = this.getNodeByValue(this.opts.value.current[0]);
+				if (node) {
+					this.setHighlightedNode(node, true);
+					return;
+				}
+			}
+			this.setHighlightedToFirstCandidate(true);
+		});
+	}
+};
+var SelectRootState = class {
+	static create(props) {
+		const { type, ...rest } = props;
+		const rootState = type === "single" ? new SelectSingleRootState(rest) : new SelectMultipleRootState(rest);
+		return SelectRootContext.set(rootState);
+	}
+};
+var SelectTriggerState = class SelectTriggerState {
+	static create(opts) {
+		return new SelectTriggerState(opts, SelectRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	#domTypeahead;
+	#dataTypeahead;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(opts.ref, (v) => this.root.triggerNode = v);
+		this.root.domContext = new DOMContext(opts.ref);
+		this.#domTypeahead = new DOMTypeahead({
+			getCurrentItem: () => this.root.highlightedNode,
+			onMatch: (node) => {
+				this.root.setHighlightedNode(node);
+			},
+			getActiveElement: () => this.root.domContext.getActiveElement(),
+			getWindow: () => this.root.domContext.getWindow()
+		});
+		this.#dataTypeahead = new DataTypeahead({
+			getCurrentItem: () => {
+				if (this.root.isMulti) return "";
+				return this.root.currentLabel;
+			},
+			onMatch: (label) => {
+				if (this.root.isMulti) return;
+				if (!this.root.opts.items.current) return;
+				const matchedItem = this.root.opts.items.current.find((item) => item.label === label);
+				if (!matchedItem) return;
+				this.root.opts.value.current = matchedItem.value;
+			},
+			enabled: () => !this.root.isMulti && this.root.dataTypeaheadEnabled,
+			candidateValues: () => this.root.isMulti ? [] : this.root.candidateLabels,
+			getWindow: () => this.root.domContext.getWindow()
+		});
+		this.onkeydown = this.onkeydown.bind(this);
+		this.onpointerdown = this.onpointerdown.bind(this);
+		this.onpointerup = this.onpointerup.bind(this);
+		this.onclick = this.onclick.bind(this);
+	}
+	#handleOpen() {
+		this.root.opts.open.current = true;
+		this.#dataTypeahead.resetTypeahead();
+		this.#domTypeahead.resetTypeahead();
+	}
+	#handlePointerOpen(_) {
+		this.#handleOpen();
+	}
+	/**
+	* Logic used to handle keyboard selection/deselection.
+	*
+	* If it returns true, it means the item was selected and whatever is calling
+	* this function should return early
+	*
+	*/
+	#handleKeyboardSelection() {
+		const isCurrentSelectedValue = this.root.highlightedValue === this.root.opts.value.current;
+		if (!this.root.opts.allowDeselect.current && isCurrentSelectedValue && !this.root.isMulti) {
+			this.root.handleClose();
+			return true;
+		}
+		if (this.root.highlightedValue !== null) this.root.toggleItem(this.root.highlightedValue, this.root.highlightedLabel ?? void 0);
+		if (!this.root.isMulti && !isCurrentSelectedValue) {
+			this.root.handleClose();
+			return true;
+		}
+		return false;
+	}
+	onkeydown(e) {
+		this.root.isUsingKeyboard = true;
+		if (e.key === "ArrowUp" || e.key === "ArrowDown") e.preventDefault();
+		if (!this.root.opts.open.current) {
+			if (e.key === "Enter" || e.key === " " || e.key === "ArrowDown" || e.key === "ArrowUp") {
+				e.preventDefault();
+				this.root.handleOpen();
+			} else if (!this.root.isMulti && this.root.dataTypeaheadEnabled) {
+				this.#dataTypeahead.handleTypeaheadSearch(e.key);
+				return;
+			}
+			if (this.root.hasValue) return;
+			const candidateNodes = this.root.getCandidateNodes();
+			if (!candidateNodes.length) return;
+			if (e.key === "ArrowDown") {
+				const firstCandidate = candidateNodes[0];
+				this.root.setHighlightedNode(firstCandidate);
+			} else if (e.key === "ArrowUp") {
+				const lastCandidate = candidateNodes[candidateNodes.length - 1];
+				this.root.setHighlightedNode(lastCandidate);
+			}
+			return;
+		}
+		if (e.key === "Tab") {
+			this.root.handleClose();
+			return;
+		}
+		if ((e.key === "Enter" || e.key === " " && this.#domTypeahead.search === "") && !e.isComposing) {
+			e.preventDefault();
+			if (this.#handleKeyboardSelection()) return;
+		}
+		if (e.key === "ArrowUp" && e.altKey) this.root.handleClose();
+		if (FIRST_LAST_KEYS.includes(e.key)) {
+			e.preventDefault();
+			const candidateNodes = this.root.getCandidateNodes();
+			const currHighlightedNode = this.root.highlightedNode;
+			const currIndex = currHighlightedNode ? candidateNodes.indexOf(currHighlightedNode) : -1;
+			const loop = this.root.opts.loop.current;
+			let nextItem;
+			if (e.key === "ArrowDown") nextItem = next(candidateNodes, currIndex, loop);
+			else if (e.key === "ArrowUp") nextItem = prev(candidateNodes, currIndex, loop);
+			else if (e.key === "PageDown") nextItem = forward(candidateNodes, currIndex, 10, loop);
+			else if (e.key === "PageUp") nextItem = backward(candidateNodes, currIndex, 10, loop);
+			else if (e.key === "Home") nextItem = candidateNodes[0];
+			else if (e.key === "End") nextItem = candidateNodes[candidateNodes.length - 1];
+			if (!nextItem) return;
+			this.root.setHighlightedNode(nextItem);
+			return;
+		}
+		const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
+		const isCharacterKey = e.key.length === 1;
+		const isSpaceKey = e.key === " ";
+		const candidateNodes = this.root.getCandidateNodes();
+		if (e.key === "Tab") return;
+		if (!isModifierKey && (isCharacterKey || isSpaceKey)) {
+			if (!this.#domTypeahead.handleTypeaheadSearch(e.key, candidateNodes) && isSpaceKey) {
+				e.preventDefault();
+				this.#handleKeyboardSelection();
+			}
+			return;
+		}
+		if (!this.root.highlightedNode) this.root.setHighlightedToFirstCandidate();
+	}
+	onclick(e) {
+		e.currentTarget.focus();
+	}
+	onpointerdown(e) {
+		if (this.root.opts.disabled.current) return;
+		if (e.pointerType === "touch") return e.preventDefault();
+		const target = e.target;
+		if (target?.hasPointerCapture(e.pointerId)) target?.releasePointerCapture(e.pointerId);
+		if (e.button === 0 && e.ctrlKey === false) if (this.root.opts.open.current === false) this.#handlePointerOpen(e);
+		else this.root.handleClose();
+	}
+	onpointerup(e) {
+		if (this.root.opts.disabled.current) return;
+		e.preventDefault();
+		if (e.pointerType === "touch") if (this.root.opts.open.current === false) this.#handlePointerOpen(e);
+		else this.root.handleClose();
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		disabled: this.root.opts.disabled.current ? true : void 0,
+		"aria-haspopup": "listbox",
+		"aria-expanded": boolToStr(this.root.opts.open.current),
+		"aria-activedescendant": this.root.highlightedId,
+		"data-state": getDataOpenClosed(this.root.opts.open.current),
+		"data-disabled": boolToEmptyStrOrUndef(this.root.opts.disabled.current),
+		"data-placeholder": this.root.hasValue ? void 0 : "",
+		[this.root.getBitsAttr("trigger")]: "",
+		onpointerdown: this.onpointerdown,
+		onkeydown: this.onkeydown,
+		onclick: this.onclick,
+		onpointerup: this.onpointerup,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectContentState = class SelectContentState {
+	static create(opts) {
+		return SelectContentContext.set(new SelectContentState(opts, SelectRootContext.get()));
+	}
+	opts;
+	root;
+	attachment;
+	isPositioned = false;
+	domContext;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(opts.ref, (v) => this.root.contentNode = v);
+		this.domContext = new DOMContext(this.opts.ref);
+		if (this.root.domContext === null) this.root.domContext = this.domContext;
+		watch(() => this.root.opts.open.current, () => {
+			if (this.root.opts.open.current) return;
+			this.root.contentIsPositioned = false;
+			this.isPositioned = false;
+		});
+		watch([() => this.isPositioned, () => this.root.highlightedNode], () => {
+			if (!this.isPositioned || !this.root.highlightedNode) return;
+			this.root.scrollHighlightedNodeIntoView(this.root.highlightedNode);
+		});
+		this.onpointermove = this.onpointermove.bind(this);
+	}
+	onpointermove(_) {
+		this.root.isUsingKeyboard = false;
+	}
+	#styles = derived(() => {
+		return getFloatingContentCSSVars(this.root.isCombobox ? "combobox" : "select");
+	});
+	onInteractOutside = (e) => {
+		if (e.target === this.root.triggerNode || e.target === this.root.inputNode) {
+			e.preventDefault();
+			return;
+		}
+		this.opts.onInteractOutside.current(e);
+		if (e.defaultPrevented) return;
+		this.root.handleClose();
+	};
+	onEscapeKeydown = (e) => {
+		this.opts.onEscapeKeydown.current(e);
+		if (e.defaultPrevented) return;
+		this.root.handleClose();
+	};
+	onOpenAutoFocus = (e) => {
+		e.preventDefault();
+	};
+	onCloseAutoFocus = (e) => {
+		e.preventDefault();
+	};
+	get shouldRender() {
+		return this.root.contentPresence.shouldRender;
+	}
+	#snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+	get snippetProps() {
+		return this.#snippetProps();
+	}
+	set snippetProps($$value) {
+		return this.#snippetProps($$value);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "listbox",
+		"aria-multiselectable": this.root.isMulti ? "true" : void 0,
+		"data-state": getDataOpenClosed(this.root.opts.open.current),
+		...getDataTransitionAttrs(this.root.contentPresence.transitionStatus),
+		[this.root.getBitsAttr("content")]: "",
+		style: {
+			display: "flex",
+			flexDirection: "column",
+			outline: "none",
+			boxSizing: "border-box",
+			pointerEvents: "auto",
+			...this.#styles()
+		},
+		onpointermove: this.onpointermove,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+	popperProps = {
+		onInteractOutside: this.onInteractOutside,
+		onEscapeKeydown: this.onEscapeKeydown,
+		onOpenAutoFocus: this.onOpenAutoFocus,
+		onCloseAutoFocus: this.onCloseAutoFocus,
+		trapFocus: false,
+		loop: false,
+		onPlaced: () => {
+			if (this.root.opts.open.current) {
+				this.root.contentIsPositioned = true;
+				this.isPositioned = true;
+			}
+		}
+	};
+};
+var SelectItemState = class SelectItemState {
+	static create(opts) {
+		return new SelectItemState(opts, SelectRootContext.get());
+	}
+	opts;
+	root;
+	attachment;
+	#isSelected = derived(() => this.root.includesItem(this.opts.value.current));
+	get isSelected() {
+		return this.#isSelected();
+	}
+	set isSelected($$value) {
+		return this.#isSelected($$value);
+	}
+	#isHighlighted = derived(() => this.root.highlightedValue === this.opts.value.current);
+	get isHighlighted() {
+		return this.#isHighlighted();
+	}
+	set isHighlighted($$value) {
+		return this.#isHighlighted($$value);
+	}
+	prevHighlighted = new Previous(() => this.isHighlighted);
+	mounted = false;
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.attachment = attachRef(opts.ref);
+		watch([() => this.isHighlighted, () => this.prevHighlighted.current], () => {
+			if (this.isHighlighted) this.opts.onHighlight.current();
+			else if (this.prevHighlighted.current) this.opts.onUnhighlight.current();
+		});
+		watch(() => this.mounted, () => {
+			if (!this.mounted) return;
+			this.root.setInitialHighlightedNode();
+		});
+		this.onpointerdown = this.onpointerdown.bind(this);
+		this.onpointerup = this.onpointerup.bind(this);
+		this.onpointermove = this.onpointermove.bind(this);
+	}
+	handleSelect() {
+		if (this.opts.disabled.current) return;
+		const isCurrentSelectedValue = this.opts.value.current === this.root.opts.value.current;
+		if (!this.root.opts.allowDeselect.current && isCurrentSelectedValue && !this.root.isMulti) {
+			this.root.handleClose();
+			return;
+		}
+		this.root.toggleItem(this.opts.value.current, this.opts.label.current);
+		if (!this.root.isMulti && !isCurrentSelectedValue) this.root.handleClose();
+	}
+	#snippetProps = derived(() => ({
+		selected: this.isSelected,
+		highlighted: this.isHighlighted
+	}));
+	get snippetProps() {
+		return this.#snippetProps();
+	}
+	set snippetProps($$value) {
+		return this.#snippetProps($$value);
+	}
+	onpointerdown(e) {
+		e.preventDefault();
+	}
+	/**
+	* Using `pointerup` instead of `click` allows power users to pointerdown
+	* the trigger, then release pointerup on an item to select it vs having to do
+	* multiple clicks.
+	*/
+	onpointerup(e) {
+		if (e.defaultPrevented || !this.opts.ref.current) return;
+		/**
+		* For one reason or another, when it's a touch pointer and _not_ on IOS,
+		* we need to listen for the immediate click event to handle the selection,
+		* otherwise a click event will fire on the element _behind_ the item.
+		*/
+		if (e.pointerType === "touch" && !isIOS) {
+			on(this.opts.ref.current, "click", () => {
+				this.handleSelect();
+				this.root.setHighlightedNode(this.opts.ref.current);
+			}, { once: true });
+			return;
+		}
+		e.preventDefault();
+		this.handleSelect();
+		if (e.pointerType === "touch") this.root.setHighlightedNode(this.opts.ref.current);
+	}
+	onpointermove(e) {
+		/**
+		* We don't want to highlight items on touch devices when scrolling,
+		* as this is confusing behavior, so we return here and instead handle
+		* the highlighting on the `pointerup` (or following `click`) event for
+		* touch devices only.
+		*/
+		if (e.pointerType === "touch") return;
+		if (this.root.highlightedNode !== this.opts.ref.current) this.root.setHighlightedNode(this.opts.ref.current);
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "option",
+		"aria-selected": this.root.includesItem(this.opts.value.current) ? "true" : void 0,
+		"data-value": this.opts.value.current,
+		"data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
+		"data-highlighted": this.root.highlightedValue === this.opts.value.current && !this.opts.disabled.current ? "" : void 0,
+		"data-selected": this.root.includesItem(this.opts.value.current) ? "" : void 0,
+		"data-label": this.opts.label.current,
+		[this.root.getBitsAttr("item")]: "",
+		onpointermove: this.onpointermove,
+		onpointerdown: this.onpointerdown,
+		onpointerup: this.onpointerup,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectHiddenInputState = class SelectHiddenInputState {
+	static create(opts) {
+		return new SelectHiddenInputState(opts, SelectRootContext.get());
+	}
+	opts;
+	root;
+	#shouldRender = derived(() => this.root.opts.name.current !== "");
+	get shouldRender() {
+		return this.#shouldRender();
+	}
+	set shouldRender($$value) {
+		return this.#shouldRender($$value);
+	}
+	constructor(opts, root) {
+		this.opts = opts;
+		this.root = root;
+		this.onfocus = this.onfocus.bind(this);
+	}
+	onfocus(e) {
+		e.preventDefault();
+		if (!this.root.isCombobox) this.root.triggerNode?.focus();
+		else this.root.inputNode?.focus();
+	}
+	#props = derived(() => ({
+		disabled: boolToTrueOrUndef(this.root.opts.disabled.current),
+		required: boolToTrueOrUndef(this.root.opts.required.current),
+		name: this.root.opts.name.current,
+		value: this.opts.value.current,
+		onfocus: this.onfocus
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectViewportState = class SelectViewportState {
+	static create(opts) {
+		return new SelectViewportState(opts, SelectContentContext.get());
+	}
+	opts;
+	content;
+	root;
+	attachment;
+	prevScrollTop = 0;
+	constructor(opts, content) {
+		this.opts = opts;
+		this.content = content;
+		this.root = content.root;
+		this.attachment = attachRef(opts.ref, (v) => {
+			this.root.viewportNode = v;
+		});
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		role: "presentation",
+		[this.root.getBitsAttr("viewport")]: "",
+		style: {
+			position: "relative",
+			flex: 1,
+			overflow: "auto"
+		},
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectScrollButtonImplState = class {
+	opts;
+	content;
+	root;
+	attachment;
+	autoScrollTimer = null;
+	userScrollTimer = -1;
+	isUserScrolling = false;
+	onAutoScroll = noop;
+	mounted = false;
+	constructor(opts, content) {
+		this.opts = opts;
+		this.content = content;
+		this.root = content.root;
+		this.attachment = attachRef(opts.ref);
+		watch([() => this.mounted], () => {
+			if (!this.mounted) {
+				this.isUserScrolling = false;
+				return;
+			}
+			if (this.isUserScrolling) return;
+		});
+		this.onpointerdown = this.onpointerdown.bind(this);
+		this.onpointermove = this.onpointermove.bind(this);
+		this.onpointerleave = this.onpointerleave.bind(this);
+	}
+	handleUserScroll() {
+		this.content.domContext.clearTimeout(this.userScrollTimer);
+		this.isUserScrolling = true;
+		this.userScrollTimer = this.content.domContext.setTimeout(() => {
+			this.isUserScrolling = false;
+		}, 200);
+	}
+	clearAutoScrollInterval() {
+		if (this.autoScrollTimer === null) return;
+		this.content.domContext.clearTimeout(this.autoScrollTimer);
+		this.autoScrollTimer = null;
+	}
+	onpointerdown(_) {
+		if (this.autoScrollTimer !== null) return;
+		const autoScroll = (tick) => {
+			this.onAutoScroll();
+			this.autoScrollTimer = this.content.domContext.setTimeout(() => autoScroll(tick + 1), this.opts.delay.current(tick));
+		};
+		this.autoScrollTimer = this.content.domContext.setTimeout(() => autoScroll(1), this.opts.delay.current(0));
+	}
+	onpointermove(e) {
+		this.onpointerdown(e);
+	}
+	onpointerleave(_) {
+		this.clearAutoScrollInterval();
+	}
+	#props = derived(() => ({
+		id: this.opts.id.current,
+		"aria-hidden": boolToStrTrueOrUndef(true),
+		style: { flexShrink: 0 },
+		onpointerdown: this.onpointerdown,
+		onpointermove: this.onpointermove,
+		onpointerleave: this.onpointerleave,
+		...this.attachment
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectScrollDownButtonState = class SelectScrollDownButtonState {
+	static create(opts) {
+		return new SelectScrollDownButtonState(new SelectScrollButtonImplState(opts, SelectContentContext.get()));
+	}
+	scrollButtonState;
+	content;
+	root;
+	canScrollDown = false;
+	scrollIntoViewTimer = null;
+	constructor(scrollButtonState) {
+		this.scrollButtonState = scrollButtonState;
+		this.content = scrollButtonState.content;
+		this.root = scrollButtonState.root;
+		this.scrollButtonState.onAutoScroll = this.handleAutoScroll;
+		watch([() => this.root.viewportNode, () => this.content.isPositioned], () => {
+			if (!this.root.viewportNode || !this.content.isPositioned) return;
+			this.handleScroll(true);
+			return on(this.root.viewportNode, "scroll", () => this.handleScroll());
+		});
+		/**
+		* If the input value changes, this means that the filtered items may have changed,
+		* so we need to re-evaluate the scroll-ability of the list.
+		*/
+		watch([
+			() => this.root.opts.inputValue.current,
+			() => this.root.viewportNode,
+			() => this.content.isPositioned
+		], () => {
+			if (!this.root.viewportNode || !this.content.isPositioned) return;
+			this.handleScroll(true);
+		});
+		watch(() => this.scrollButtonState.mounted, () => {
+			if (!this.scrollButtonState.mounted) return;
+			if (this.scrollIntoViewTimer) clearTimeout(this.scrollIntoViewTimer);
+			this.scrollIntoViewTimer = afterSleep(5, () => {
+				const activeItem = this.root.highlightedNode;
+				if (!activeItem) return;
+				this.root.scrollHighlightedNodeIntoView(activeItem);
+			});
+		});
+	}
+	/**
+	* @param manual - if true, it means the function was invoked manually outside of an event
+	* listener, so we don't call `handleUserScroll` to prevent the auto scroll from kicking in.
+	*/
+	handleScroll = (manual = false) => {
+		if (!manual) this.scrollButtonState.handleUserScroll();
+		if (!this.root.viewportNode) return;
+		const maxScroll = this.root.viewportNode.scrollHeight - this.root.viewportNode.clientHeight;
+		const paddingTop = Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop, 10);
+		this.canScrollDown = Math.ceil(this.root.viewportNode.scrollTop) < maxScroll - paddingTop;
+	};
+	handleAutoScroll = () => {
+		const viewport = this.root.viewportNode;
+		const selectedItem = this.root.highlightedNode;
+		if (!viewport || !selectedItem) return;
+		viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
+	};
+	#props = derived(() => ({
+		...this.scrollButtonState.props,
+		[this.root.getBitsAttr("scroll-down-button")]: ""
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+var SelectScrollUpButtonState = class SelectScrollUpButtonState {
+	static create(opts) {
+		return new SelectScrollUpButtonState(new SelectScrollButtonImplState(opts, SelectContentContext.get()));
+	}
+	scrollButtonState;
+	content;
+	root;
+	canScrollUp = false;
+	constructor(scrollButtonState) {
+		this.scrollButtonState = scrollButtonState;
+		this.content = scrollButtonState.content;
+		this.root = scrollButtonState.root;
+		this.scrollButtonState.onAutoScroll = this.handleAutoScroll;
+		watch([() => this.root.viewportNode, () => this.content.isPositioned], () => {
+			if (!this.root.viewportNode || !this.content.isPositioned) return;
+			this.handleScroll(true);
+			return on(this.root.viewportNode, "scroll", () => this.handleScroll());
+		});
+	}
+	/**
+	* @param manual - if true, it means the function was invoked manually outside of an event
+	* listener, so we don't call `handleUserScroll` to prevent the auto scroll from kicking in.
+	*/
+	handleScroll = (manual = false) => {
+		if (!manual) this.scrollButtonState.handleUserScroll();
+		if (!this.root.viewportNode) return;
+		const paddingTop = Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop, 10);
+		this.canScrollUp = this.root.viewportNode.scrollTop - paddingTop > .1;
+	};
+	handleAutoScroll = () => {
+		if (!this.root.viewportNode || !this.root.highlightedNode) return;
+		this.root.viewportNode.scrollTop = this.root.viewportNode.scrollTop - this.root.highlightedNode.offsetHeight;
+	};
+	#props = derived(() => ({
+		...this.scrollButtonState.props,
+		[this.root.getBitsAttr("scroll-up-button")]: ""
+	}));
+	get props() {
+		return this.#props();
+	}
+	set props($$value) {
+		return this.#props($$value);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-hidden-input.svelte
+function Select_hidden_input($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { value = void 0, autocomplete } = $$props;
+		const hiddenInputState = SelectHiddenInputState.create({ value: boxWith(() => value) });
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (hiddenInputState.shouldRender) {
+				$$renderer.push("<!--[0-->");
+				Hidden_input($$renderer, spread_props([hiddenInputState.props, {
+					autocomplete,
+					get value() {
+						return value;
+					},
+					set value($$value) {
+						value = $$value;
+						$$settled = false;
+					}
+				}]));
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { value });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/floating-layer/components/floating-layer-anchor.svelte
+function Floating_layer_anchor($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { id, children, virtualEl, ref, tooltip = false } = $$props;
+		FloatingAnchorState.create({
+			id: boxWith(() => id),
+			virtualEl: boxWith(() => virtualEl),
+			ref
+		}, tooltip);
+		children?.($$renderer);
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/floating-layer/components/floating-layer-content.svelte
+function Floating_layer_content($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { content, side = "bottom", sideOffset = 0, align = "center", alignOffset = 0, id, arrowPadding = 0, avoidCollisions = true, collisionBoundary = [], collisionPadding = 0, hideWhenDetached = false, onPlaced = () => {}, sticky = "partial", updatePositionStrategy = "optimized", strategy = "fixed", dir = "ltr", style = {}, wrapperId = useId(), customAnchor = null, enabled, tooltip = false } = $$props;
+		const contentState = FloatingContentState.create({
+			side: boxWith(() => side),
+			sideOffset: boxWith(() => sideOffset),
+			align: boxWith(() => align),
+			alignOffset: boxWith(() => alignOffset),
+			id: boxWith(() => id),
+			arrowPadding: boxWith(() => arrowPadding),
+			avoidCollisions: boxWith(() => avoidCollisions),
+			collisionBoundary: boxWith(() => collisionBoundary),
+			collisionPadding: boxWith(() => collisionPadding),
+			hideWhenDetached: boxWith(() => hideWhenDetached),
+			onPlaced: boxWith(() => onPlaced),
+			sticky: boxWith(() => sticky),
+			updatePositionStrategy: boxWith(() => updatePositionStrategy),
+			strategy: boxWith(() => strategy),
+			dir: boxWith(() => dir),
+			style: boxWith(() => style),
+			enabled: boxWith(() => enabled),
+			wrapperId: boxWith(() => wrapperId),
+			customAnchor: boxWith(() => customAnchor)
+		}, tooltip);
+		const mergedProps = derived(() => mergeProps(contentState.wrapperProps, { style: { pointerEvents: "auto" } }));
+		content?.($$renderer, {
+			props: contentState.props,
+			wrapperProps: mergedProps()
+		});
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/floating-layer/components/floating-layer-content-static.svelte
+function Floating_layer_content_static($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { content} = $$props;
+		content?.($$renderer, {
+			props: {},
+			wrapperProps: {}
+		});
+		$$renderer.push(`<!---->`);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/popper-layer/popper-content.svelte
+function Popper_content($$renderer, $$props) {
+	let { content, isStatic = false, onPlaced, $$slots, $$events, ...restProps } = $$props;
+	if (isStatic) {
+		$$renderer.push("<!--[0-->");
+		Floating_layer_content_static($$renderer, {
+			content});
+	} else {
+		$$renderer.push("<!--[-1-->");
+		Floating_layer_content($$renderer, spread_props([{
+			content,
+			onPlaced
+		}, restProps]));
+	}
+	$$renderer.push(`<!--]-->`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/popper-layer/popper-layer-inner.svelte
+function Popper_layer_inner($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { popper, onEscapeKeydown, escapeKeydownBehavior, preventOverflowTextSelection, id, onPointerDown, onPointerUp, side, sideOffset, align, alignOffset, arrowPadding, avoidCollisions, collisionBoundary, collisionPadding, sticky, hideWhenDetached, updatePositionStrategy, strategy, dir, preventScroll, wrapperId, style, onPlaced, onInteractOutside, onCloseAutoFocus, onOpenAutoFocus, onFocusOutside, interactOutsideBehavior = "close", loop, trapFocus = true, isValidEvent = () => false, customAnchor = null, isStatic = false, enabled, ref, tooltip = false, contentPointerEvents = "auto", $$slots, $$events, ...restProps } = $$props;
+		const resolvedPreventScroll = derived(() => preventScroll ?? true);
+		const effectiveStrategy = derived(() => strategy ?? (resolvedPreventScroll() ? "fixed" : "absolute"));
+		{
+			function content($$renderer, { props: floatingProps, wrapperProps }) {
+				if (restProps.forceMount && enabled) {
+					$$renderer.push("<!--[0-->");
+					Scroll_lock($$renderer, { preventScroll: resolvedPreventScroll() });
+				} else if (!restProps.forceMount) {
+					$$renderer.push("<!--[1-->");
+					Scroll_lock($$renderer, { preventScroll: resolvedPreventScroll() });
+				} else $$renderer.push("<!--[-1-->");
+				$$renderer.push(`<!--]--> `);
+				{
+					function focusScope($$renderer, { props: focusScopeProps }) {
+						Escape_layer($$renderer, {
+							onEscapeKeydown,
+							escapeKeydownBehavior,
+							enabled,
+							ref,
+							children: ($$renderer) => {
+								{
+									function children($$renderer, { props: dismissibleProps }) {
+										Text_selection_layer($$renderer, {
+											id,
+											preventOverflowTextSelection,
+											onPointerDown,
+											onPointerUp,
+											enabled,
+											ref,
+											children: ($$renderer) => {
+												popper?.($$renderer, {
+													props: mergeProps(restProps, floatingProps, dismissibleProps, focusScopeProps, { style: { pointerEvents: contentPointerEvents } }),
+													wrapperProps
+												});
+												$$renderer.push(`<!---->`);
+											}});
+									}
+									Dismissible_layer($$renderer, {
+										id,
+										onInteractOutside,
+										onFocusOutside,
+										interactOutsideBehavior,
+										isValidEvent,
+										enabled,
+										ref,
+										children});
+								}
+							}});
+					}
+					Focus_scope($$renderer, {
+						onOpenAutoFocus,
+						onCloseAutoFocus,
+						loop,
+						enabled,
+						trapFocus,
+						forceMount: restProps.forceMount,
+						ref,
+						focusScope});
+				}
+				$$renderer.push(`<!---->`);
+			}
+			Popper_content($$renderer, {
+				isStatic,
+				id,
+				side,
+				sideOffset,
+				align,
+				alignOffset,
+				arrowPadding,
+				avoidCollisions,
+				collisionBoundary,
+				collisionPadding,
+				sticky,
+				hideWhenDetached,
+				updatePositionStrategy,
+				strategy: effectiveStrategy(),
+				dir,
+				wrapperId,
+				style,
+				onPlaced,
+				customAnchor,
+				enabled,
+				tooltip,
+				content,
+				$$slots: { content: true }
+			});
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/popper-layer/popper-layer.svelte
+function Popper_layer($$renderer, $$props) {
+	let { popper, open, onEscapeKeydown, escapeKeydownBehavior, preventOverflowTextSelection, id, onPointerDown, onPointerUp, side, sideOffset, align, alignOffset, arrowPadding, avoidCollisions, collisionBoundary, collisionPadding, sticky, hideWhenDetached, updatePositionStrategy, strategy, dir, preventScroll, wrapperId, style, onPlaced, onInteractOutside, onCloseAutoFocus, onOpenAutoFocus, onFocusOutside, interactOutsideBehavior = "close", loop, trapFocus = true, isValidEvent = () => false, customAnchor = null, isStatic = false, ref, shouldRender, $$slots, $$events, ...restProps } = $$props;
+	if (shouldRender) {
+		$$renderer.push("<!--[0-->");
+		Popper_layer_inner($$renderer, spread_props([{
+			popper,
+			onEscapeKeydown,
+			escapeKeydownBehavior,
+			preventOverflowTextSelection,
+			id,
+			onPointerDown,
+			onPointerUp,
+			side,
+			sideOffset,
+			align,
+			alignOffset,
+			arrowPadding,
+			avoidCollisions,
+			collisionBoundary,
+			collisionPadding,
+			sticky,
+			hideWhenDetached,
+			updatePositionStrategy,
+			strategy,
+			dir,
+			preventScroll,
+			wrapperId,
+			style,
+			onPlaced,
+			customAnchor,
+			isStatic,
+			enabled: open,
+			onInteractOutside,
+			onCloseAutoFocus,
+			onOpenAutoFocus,
+			interactOutsideBehavior,
+			loop,
+			trapFocus,
+			isValidEvent,
+			onFocusOutside,
+			forceMount: false,
+			ref
+		}, restProps]));
+	} else $$renderer.push("<!--[-1-->");
+	$$renderer.push(`<!--]-->`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/popper-layer/popper-layer-force-mount.svelte
+function Popper_layer_force_mount($$renderer, $$props) {
+	let { popper, onEscapeKeydown, escapeKeydownBehavior, preventOverflowTextSelection, id, onPointerDown, onPointerUp, side, sideOffset, align, alignOffset, arrowPadding, avoidCollisions, collisionBoundary, collisionPadding, sticky, hideWhenDetached, updatePositionStrategy, strategy, dir, preventScroll, wrapperId, style, onPlaced, onInteractOutside, onCloseAutoFocus, onOpenAutoFocus, onFocusOutside, interactOutsideBehavior = "close", loop, trapFocus = true, isValidEvent = () => false, customAnchor = null, isStatic = false, enabled, $$slots, $$events, ...restProps } = $$props;
+	Popper_layer_inner($$renderer, spread_props([
+		{
+			popper,
+			onEscapeKeydown,
+			escapeKeydownBehavior,
+			preventOverflowTextSelection,
+			id,
+			onPointerDown,
+			onPointerUp,
+			side,
+			sideOffset,
+			align,
+			alignOffset,
+			arrowPadding,
+			avoidCollisions,
+			collisionBoundary,
+			collisionPadding,
+			sticky,
+			hideWhenDetached,
+			updatePositionStrategy,
+			strategy,
+			dir,
+			preventScroll,
+			wrapperId,
+			style,
+			onPlaced,
+			customAnchor,
+			isStatic,
+			enabled,
+			onInteractOutside,
+			onCloseAutoFocus,
+			onOpenAutoFocus,
+			interactOutsideBehavior,
+			loop,
+			trapFocus,
+			isValidEvent,
+			onFocusOutside
+		},
+		restProps,
+		{ forceMount: true }
+	]));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-content.svelte
+function Select_content$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, forceMount = false, side = "bottom", onInteractOutside = noop, onEscapeKeydown = noop, children, child, preventScroll = false, style, $$slots, $$events, ...restProps } = $$props;
+		const contentState = SelectContentState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			onInteractOutside: boxWith(() => onInteractOutside),
+			onEscapeKeydown: boxWith(() => onEscapeKeydown)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, contentState.props));
+		if (forceMount) {
+			$$renderer.push("<!--[0-->");
+			{
+				function popper($$renderer, { props, wrapperProps }) {
+					const finalProps = mergeProps(props, { style: contentState.props.style }, { style });
+					if (child) {
+						$$renderer.push("<!--[0-->");
+						child($$renderer, {
+							props: finalProps,
+							wrapperProps,
+							...contentState.snippetProps
+						});
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push("<!--[-1-->");
+						$$renderer.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+						children?.($$renderer);
+						$$renderer.push(`<!----></div></div>`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				Popper_layer_force_mount($$renderer, spread_props([
+					mergedProps(),
+					contentState.popperProps,
+					{
+						ref: contentState.opts.ref,
+						side,
+						enabled: contentState.root.opts.open.current,
+						id,
+						preventScroll,
+						forceMount: true,
+						shouldRender: contentState.shouldRender,
+						popper,
+						$$slots: { popper: true }
+					}
+				]));
+			}
+		} else if (!forceMount) {
+			$$renderer.push("<!--[1-->");
+			{
+				function popper($$renderer, { props, wrapperProps }) {
+					const finalProps = mergeProps(props, { style: contentState.props.style }, { style });
+					if (child) {
+						$$renderer.push("<!--[0-->");
+						child($$renderer, {
+							props: finalProps,
+							wrapperProps,
+							...contentState.snippetProps
+						});
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push("<!--[-1-->");
+						$$renderer.push(`<div${attributes({ ...wrapperProps })}><div${attributes({ ...finalProps })}>`);
+						children?.($$renderer);
+						$$renderer.push(`<!----></div></div>`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				Popper_layer($$renderer, spread_props([
+					mergedProps(),
+					contentState.popperProps,
+					{
+						ref: contentState.opts.ref,
+						side,
+						open: contentState.root.opts.open.current,
+						id,
+						preventScroll,
+						forceMount: false,
+						shouldRender: contentState.shouldRender,
+						popper,
+						$$slots: { popper: true }
+					}
+				]));
+			}
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/utilities/mounted.svelte
+function Mounted($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { mounted = false, onMountedChange = noop } = $$props;
+		bind_props($$props, { mounted });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-item.svelte
+function Select_item$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, value, label = value, disabled = false, children, child, onHighlight = noop, onUnhighlight = noop, $$slots, $$events, ...restProps } = $$props;
+		const itemState = SelectItemState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			value: boxWith(() => value),
+			disabled: boxWith(() => disabled),
+			label: boxWith(() => label),
+			onHighlight: boxWith(() => onHighlight),
+			onUnhighlight: boxWith(() => onUnhighlight)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, itemState.props));
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (child) {
+				$$renderer.push("<!--[0-->");
+				child($$renderer, {
+					props: mergedProps(),
+					...itemState.snippetProps
+				});
+				$$renderer.push(`<!---->`);
+			} else {
+				$$renderer.push("<!--[-1-->");
+				$$renderer.push(`<div${attributes({ ...mergedProps() })}>`);
+				children?.($$renderer, itemState.snippetProps);
+				$$renderer.push(`<!----></div>`);
+			}
+			$$renderer.push(`<!--]--> `);
+			Mounted($$renderer, {
+				get mounted() {
+					return itemState.mounted;
+				},
+				set mounted($$value) {
+					itemState.mounted = $$value;
+					$$settled = false;
+				}
+			});
+			$$renderer.push(`<!---->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-viewport.svelte
+function Select_viewport($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, children, child, $$slots, $$events, ...restProps } = $$props;
+		const viewportState = SelectViewportState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, viewportState.props));
+		if (child) {
+			$$renderer.push("<!--[0-->");
+			child($$renderer, { props: mergedProps() });
+			$$renderer.push(`<!---->`);
+		} else {
+			$$renderer.push("<!--[-1-->");
+			$$renderer.push(`<div${attributes({ ...mergedProps() })}>`);
+			children?.($$renderer);
+			$$renderer.push(`<!----></div>`);
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-scroll-down-button.svelte
+function Select_scroll_down_button$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, delay = () => 50, child, children, $$slots, $$events, ...restProps } = $$props;
+		const scrollButtonState = SelectScrollDownButtonState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			delay: boxWith(() => delay)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, scrollButtonState.props));
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (scrollButtonState.canScrollDown) {
+				$$renderer.push("<!--[0-->");
+				Mounted($$renderer, {
+					get mounted() {
+						return scrollButtonState.scrollButtonState.mounted;
+					},
+					set mounted($$value) {
+						scrollButtonState.scrollButtonState.mounted = $$value;
+						$$settled = false;
+					}
+				});
+				$$renderer.push(`<!----> `);
+				if (child) {
+					$$renderer.push("<!--[0-->");
+					child($$renderer, { props: restProps });
+					$$renderer.push(`<!---->`);
+				} else {
+					$$renderer.push("<!--[-1-->");
+					$$renderer.push(`<div${attributes({ ...mergedProps() })}>`);
+					children?.($$renderer);
+					$$renderer.push(`<!----></div>`);
+				}
+				$$renderer.push(`<!--]-->`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-scroll-up-button.svelte
+function Select_scroll_up_button$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, delay = () => 50, child, children, $$slots, $$events, ...restProps } = $$props;
+		const scrollButtonState = SelectScrollUpButtonState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v),
+			delay: boxWith(() => delay)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, scrollButtonState.props));
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (scrollButtonState.canScrollUp) {
+				$$renderer.push("<!--[0-->");
+				Mounted($$renderer, {
+					get mounted() {
+						return scrollButtonState.scrollButtonState.mounted;
+					},
+					set mounted($$value) {
+						scrollButtonState.scrollButtonState.mounted = $$value;
+						$$settled = false;
+					}
+				});
+				$$renderer.push(`<!----> `);
+				if (child) {
+					$$renderer.push("<!--[0-->");
+					child($$renderer, { props: restProps });
+					$$renderer.push(`<!---->`);
+				} else {
+					$$renderer.push("<!--[-1-->");
+					$$renderer.push(`<div${attributes({ ...mergedProps() })}>`);
+					children?.($$renderer);
+					$$renderer.push(`<!----></div>`);
+				}
+				$$renderer.push(`<!--]-->`);
+			} else $$renderer.push("<!--[-1-->");
+			$$renderer.push(`<!--]-->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select.svelte
+function Select($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { value = void 0, onValueChange = noop, name = "", disabled = false, type, open = false, onOpenChange = noop, onOpenChangeComplete = noop, loop = false, scrollAlignment = "nearest", required = false, items = [], allowDeselect = false, autocomplete, children } = $$props;
+		function handleDefaultValue() {
+			if (value !== void 0) return;
+			value = type === "single" ? "" : [];
+		}
+		handleDefaultValue();
+		watch.pre(() => value, () => {
+			handleDefaultValue();
+		});
+		let inputValue = "";
+		const rootState = SelectRootState.create({
+			type,
+			value: boxWith(() => value, (v) => {
+				value = v;
+				onValueChange(v);
+			}),
+			disabled: boxWith(() => disabled),
+			required: boxWith(() => required),
+			open: boxWith(() => open, (v) => {
+				open = v;
+				onOpenChange(v);
+			}),
+			loop: boxWith(() => loop),
+			scrollAlignment: boxWith(() => scrollAlignment),
+			name: boxWith(() => name),
+			isCombobox: false,
+			items: boxWith(() => items),
+			allowDeselect: boxWith(() => allowDeselect),
+			inputValue: boxWith(() => inputValue, (v) => inputValue = v),
+			onOpenChangeComplete: boxWith(() => onOpenChangeComplete)
+		});
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			Floating_layer($$renderer, {
+				children: ($$renderer) => {
+					children?.($$renderer);
+					$$renderer.push(`<!---->`);
+				}});
+			$$renderer.push(`<!----> `);
+			if (Array.isArray(rootState.opts.value.current)) {
+				$$renderer.push("<!--[0-->");
+				if (rootState.opts.value.current.length === 0) {
+					$$renderer.push("<!--[0-->");
+					Select_hidden_input($$renderer, { autocomplete });
+				} else {
+					$$renderer.push("<!--[-1-->");
+					$$renderer.push(`<!--[-->`);
+					const each_array = ensure_array_like(rootState.opts.value.current);
+					for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+						let item = each_array[$$index];
+						Select_hidden_input($$renderer, {
+							value: item,
+							autocomplete
+						});
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				$$renderer.push(`<!--]-->`);
+			} else {
+				$$renderer.push("<!--[-1-->");
+				Select_hidden_input($$renderer, {
+					autocomplete,
+					get value() {
+						return rootState.opts.value.current;
+					},
+					set value($$value) {
+						rootState.opts.value.current = $$value;
+						$$settled = false;
+					}
+				});
+			}
+			$$renderer.push(`<!--]-->`);
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, {
+			value,
+			open
+		});
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.18.1_@internation_cf9efa5a0e2445160199ecbd5e48fd57/node_modules/bits-ui/dist/bits/select/components/select-trigger.svelte
+function Select_trigger$1($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { id = createId(uid), ref = null, child, children, type = "button", $$slots, $$events, ...restProps } = $$props;
+		const triggerState = SelectTriggerState.create({
+			id: boxWith(() => id),
+			ref: boxWith(() => ref, (v) => ref = v)
+		});
+		const mergedProps = derived(() => mergeProps(restProps, triggerState.props, { type }));
+		if (Floating_layer_anchor) {
+			$$renderer.push("<!--[-->");
+			Floating_layer_anchor($$renderer, {
+				id,
+				ref: triggerState.opts.ref,
+				children: ($$renderer) => {
+					if (child) {
+						$$renderer.push("<!--[0-->");
+						child($$renderer, { props: mergedProps() });
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push("<!--[-1-->");
+						$$renderer.push(`<button${attributes({ ...mergedProps() })}>`);
+						children?.($$renderer);
+						$$renderer.push(`<!----></button>`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}});
+			$$renderer.push("<!--]-->");
+		} else {
+			$$renderer.push("<!--[!-->");
+			$$renderer.push("<!--]-->");
+		}
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/select-item.svelte
+function Select_item($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, value, label, children: childrenProp, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			{
+				function children($$renderer, { selected, highlighted }) {
+					$$renderer.push(`<span class="right-2 size-3.5 absolute flex items-center justify-center">`);
+					if (selected) {
+						$$renderer.push("<!--[0-->");
+						Check($$renderer, { class: "size-4" });
+					} else $$renderer.push("<!--[-1-->");
+					$$renderer.push(`<!--]--></span> `);
+					if (childrenProp) {
+						$$renderer.push("<!--[0-->");
+						childrenProp($$renderer, {
+							selected,
+							highlighted
+						});
+						$$renderer.push(`<!---->`);
+					} else {
+						$$renderer.push("<!--[-1-->");
+						$$renderer.push(`${escape_html(label || value)}`);
+					}
+					$$renderer.push(`<!--]-->`);
+				}
+				if (Select_item$1) {
+					$$renderer.push("<!--[-->");
+					Select_item$1($$renderer, spread_props([
+						{
+							value,
+							"data-slot": "select-item",
+							class: cn("gap-2 py-1.5 pr-8 pl-2 text-sm [&_svg:not([class*='size-'])]:size-4 *:[span]:last:gap-2 relative flex w-full cursor-default items-center rounded-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[highlighted]:bg-accent data-[highlighted]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='text-'])]:text-muted-foreground *:[span]:last:flex *:[span]:last:items-center", className)
+						},
+						restProps,
+						{
+							get ref() {
+								return ref;
+							},
+							set ref($$value) {
+								ref = $$value;
+								$$settled = false;
+							},
+							children,
+							$$slots: { default: true }
+						}
+					]));
+					$$renderer.push("<!--]-->");
+				} else {
+					$$renderer.push("<!--[!-->");
+					$$renderer.push("<!--]-->");
+				}
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/select-scroll-up-button.svelte
+function Select_scroll_up_button($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Select_scroll_up_button$1) {
+				$$renderer.push("<!--[-->");
+				Select_scroll_up_button$1($$renderer, spread_props([
+					{
+						"data-slot": "select-scroll-up-button",
+						class: cn("py-1 flex cursor-default items-center justify-center", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						},
+						children: ($$renderer) => {
+							Chevron_up($$renderer, { class: "size-4" });
+						},
+						$$slots: { default: true }
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/select-scroll-down-button.svelte
+function Select_scroll_down_button($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Select_scroll_down_button$1) {
+				$$renderer.push("<!--[-->");
+				Select_scroll_down_button$1($$renderer, spread_props([
+					{
+						"data-slot": "select-scroll-down-button",
+						class: cn("py-1 flex cursor-default items-center justify-center", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						},
+						children: ($$renderer) => {
+							Chevron_down($$renderer, { class: "size-4" });
+						},
+						$$slots: { default: true }
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/select-content.svelte
+function Select_content($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, sideOffset = 4, portalProps, children, $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Portal) {
+				$$renderer.push("<!--[-->");
+				Portal($$renderer, spread_props([portalProps, {
+					children: ($$renderer) => {
+						if (Select_content$1) {
+							$$renderer.push("<!--[-->");
+							Select_content$1($$renderer, spread_props([
+								{
+									sideOffset,
+									"data-slot": "select-content",
+									class: cn("shadow-md data-[side=bottom]:translate-y-1 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:-translate-x-1 data-[side=left]:slide-in-from-right-2 data-[side=right]:translate-x-1 data-[side=right]:slide-in-from-left-2 data-[side=top]:-translate-y-1 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95 relative z-50 max-h-(--bits-select-content-available-height) min-w-[8rem] origin-(--bits-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border bg-popover text-popover-foreground", className)
+								},
+								restProps,
+								{
+									get ref() {
+										return ref;
+									},
+									set ref($$value) {
+										ref = $$value;
+										$$settled = false;
+									},
+									children: ($$renderer) => {
+										Select_scroll_up_button($$renderer, {});
+										$$renderer.push(`<!----> `);
+										if (Select_viewport) {
+											$$renderer.push("<!--[-->");
+											Select_viewport($$renderer, {
+												class: cn("scroll-my-1 p-1 h-(--bits-select-anchor-height) w-full min-w-(--bits-select-anchor-width)"),
+												children: ($$renderer) => {
+													children?.($$renderer);
+													$$renderer.push(`<!---->`);
+												},
+												$$slots: { default: true }
+											});
+											$$renderer.push("<!--]-->");
+										} else {
+											$$renderer.push("<!--[!-->");
+											$$renderer.push("<!--]-->");
+										}
+										$$renderer.push(` `);
+										Select_scroll_down_button($$renderer, {});
+										$$renderer.push(`<!---->`);
+									},
+									$$slots: { default: true }
+								}
+							]));
+							$$renderer.push("<!--]-->");
+						} else {
+							$$renderer.push("<!--[!-->");
+							$$renderer.push("<!--]-->");
+						}
+					},
+					$$slots: { default: true }
+				}]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/select-trigger.svelte
+function Select_trigger($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { ref = null, class: className, children, size = "default", $$slots, $$events, ...restProps } = $$props;
+		let $$settled = true;
+		let $$inner_renderer;
+		function $$render_inner($$renderer) {
+			if (Select_trigger$1) {
+				$$renderer.push("<!--[-->");
+				Select_trigger$1($$renderer, spread_props([
+					{
+						"data-slot": "select-trigger",
+						"data-size": size,
+						class: cn("gap-2 px-3 py-2 text-sm shadow-xs data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:gap-2 [&_svg:not([class*='size-'])]:size-4 flex w-fit items-center justify-between rounded-md border border-input bg-transparent whitespace-nowrap transition-[color,box-shadow] outline-none select-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 data-[placeholder]:text-muted-foreground *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='text-'])]:text-muted-foreground", className)
+					},
+					restProps,
+					{
+						get ref() {
+							return ref;
+						},
+						set ref($$value) {
+							ref = $$value;
+							$$settled = false;
+						},
+						children: ($$renderer) => {
+							children?.($$renderer);
+							$$renderer.push(`<!----> `);
+							Chevron_down($$renderer, { class: "size-4 opacity-50" });
+							$$renderer.push(`<!---->`);
+						},
+						$$slots: { default: true }
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		do {
+			$$settled = true;
+			$$inner_renderer = $$renderer.copy();
+			$$render_inner($$inner_renderer);
+		} while (!$$settled);
+		$$renderer.subsume($$inner_renderer);
+		bind_props($$props, { ref });
+	});
+}
+//#endregion
+//#region ../ui/dist/components/primitives/select/index.js
+var Root = Select;
+
+export { Floating_layer as F, Hidden_input as H, Popper_layer_force_mount as P, Root as R, Select_trigger as S, Select_content as a, Select_item as b, Floating_layer_anchor as c, Popper_layer as d, getFloatingContentCSSVars as g };
+//# sourceMappingURL=select-C1aC27lp.js.map