@selvajs/selva 4.20.0-beta.10 → 4.20.0-beta.11

package/build/server/chunks/chunks/popper-layer-force-mount.js-w6fkZ5aq.js

@@ -0,0 +1,1922 @@
+import { ai as spread_props, ae as derived } from './server.js-eNE8c09e.js';
+import { s as simpleBox, b as boxWith, a as boxFrom, c as attachRef, d as cssToStyleObj, f as styleToString, m as mergeProps } from './create-id.js-DQq_g2YK.js';
+import { I as Icon } from './utils2.js-C1oP9gJ9.js';
+import { C as Context, u as useId, E as ElementSize, i as isNotNull, w as watch, g as getWindow$1, S as Scroll_lock, F as Focus_scope, a as Escape_layer, D as Dismissible_layer, T as Text_selection_layer } from './scroll-lock.js-2WQOe0ze.js';
+
+//#region ../../node_modules/.pnpm/@lucide+svelte@1.48.0_svelte@5.57.1_@typescript-eslint+types@8.70.1_/node_modules/@lucide/svelte/dist/icons/check.svelte
+function Check($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Icon($$renderer, spread_props([props, { icon: {
+		"name": "check",
+		"size": 24,
+		"node": [["path", { "d": "M20 6 9 17l-5-5" }]]
+	} }]));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/node_modules/bits-ui/dist/bits/utilities/floating-layer/floating-root.svelte.js
+var FloatingRootContext = new Context("Floating.Root");
+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 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;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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/@floating-ui+utils@0.2.12/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) {
+	var _padding$top, _padding$right, _padding$bottom, _padding$left;
+	return {
+		top: (_padding$top = padding.top) != null ? _padding$top : 0,
+		right: (_padding$right = padding.right) != null ? _padding$right : 0,
+		bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
+		left: (_padding$left = padding.left) != null ? _padding$left : 0
+	};
+}
+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.8.0/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
+		};
+	}
+	const alignment = getAlignment(placement);
+	if (alignment) coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
+	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
+	};
+	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 max = clientSize - arrowDimensions[length] - maxPadding;
+		const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+		const offset = clamp(minPadding, center, max);
+		const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < minPadding ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+		const alignmentOffset = shouldAddOffset ? center < minPadding ? center - minPadding : 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;
+				}
+				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(placement);
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			const clampCoord = (axis, coord) => clamp(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
+			if (checkMainAxis) mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
+			if (checkCrossAxis) crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
+			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) {
+			var _rawOffset$mainAxis, _rawOffset$crossAxis;
+			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: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
+				crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
+			};
+			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) {
+			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 shiftData = state.middlewareData.shift;
+			const noShift = !shiftData;
+			let availableHeight = overflowAvailableHeight;
+			let availableWidth = overflowAvailableWidth;
+			if (shiftData != null && shiftData.enabled.x) availableWidth = maximumClippingWidth;
+			if (shiftData != null && shiftData.enabled.y) availableHeight = maximumClippingHeight;
+			if (noShift && !alignment) {
+				if (isYAxis) availableWidth = width - 2 * max(overflow.left, overflow.right);
+				else availableHeight = height - 2 * 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.12/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).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.8.0/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;
+	return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
+}
+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 && offsetParent) {
+		const win = getWindow(domElement);
+		const offsetWin = isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		let currentWin = win;
+		let currentIFrame = getFrameElement(currentWin);
+		while (currentIFrame && 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 || !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 element.getClientRects ? Array.from(element.getClientRects()) : [];
+}
+function getDocumentRect(html) {
+	const scroll = getNodeScroll(html);
+	const body = html.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(html);
+	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, rootBoundary) {
+	if (rootBoundary === void 0) rootBoundary = "viewport";
+	const isLayoutViewport = rootBoundary === "layoutViewport";
+	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) {
+		const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
+		if (isLayoutViewport) {
+			if (!layoutRelativeClientCoords) {
+				x = -visualViewport.offsetLeft;
+				y = -visualViewport.offsetTop;
+			}
+		} else {
+			width = visualViewport.width;
+			height = visualViewport.height;
+			if (layoutRelativeClientCoords) {
+				x = visualViewport.offsetLeft;
+				y = visualViewport.offsetTop;
+			}
+		}
+	}
+	if (getWindowScrollBarX(html) <= 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 reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+		const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
+		if (gutter <= SCROLLBAR_MAX) width -= gutter;
+	}
+	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 = getScale(element);
+	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" || clippingAncestor === "layoutViewport") rect = getViewportRect(element, strategy, clippingAncestor);
+	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 getClippingElementAncestors(element, cache) {
+	const cachedResult = cache.get(element);
+	if (cachedResult) return cachedResult;
+	let result = getOverflowAncestors(element, []).filter((el) => isElement(el) && getNodeName(el) !== "body");
+	let lastKeptComputedStyle = 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);
+		const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
+		if (!currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static")) result = result.filter((ancestor) => ancestor !== currentNode);
+		else lastKeptComputedStyle = 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);
+	if (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;
+		}
+	}
+	if (!isOffsetParentAnElement && documentElement) offsets.x = getWindowScrollBarX(documentElement);
+	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 = options != null ? options : {};
+	const platformWithCache = {
+		...platform,
+		...mergedOptions.platform,
+		_c: cache
+	};
+	return computePosition$1(reference, floating, {
+		...mergedOptions,
+		platform: platformWithCache
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/bits-ui@2.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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 FloatingContentContext = new Context("Floating.Content");
+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);
+			};
+		});
+	}
+};
+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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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, {
+														id,
+														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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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.19.3_@internationalized+date@3.12.4_@sveltejs+kit@2.70.3_@opentelemetry+api@1_30b4406f5b6bd5e3091453cbf522c8c6/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 }
+	]));
+}
+
+export { Check as C, Floating_layer as F, Popper_layer_force_mount as P, Floating_layer_anchor as a, Popper_layer as b, getFloatingContentCSSVars as g };
+//# sourceMappingURL=popper-layer-force-mount.js-w6fkZ5aq.js.map