@youcan/celeste 0.9.3 → 0.10.1

package/dist/cjs/chunks/PopperContent.cjs

@@ -1,4 +1,4 @@
-const require_chunk = require("./chunk.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime.cjs");
 const require_createContext = require("./createContext.cjs");
 const require_Primitive = require("./Primitive.cjs");
 const require_useDirection = require("./useDirection.cjs");
@@ -6,8 +6,8 @@ const require_useForwardExpose = require("./useForwardExpose.cjs");
 const require_useSize = require("./useSize.cjs");
 const require_PopperRoot = require("./PopperRoot.cjs");
 let vue = require("vue");
-vue = require_chunk.__toESM(vue, 1);
-//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/utils.js
+vue = require_rolldown_runtime.__toESM(vue, 1);
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/utils.js
 function isNotNull(value) {
 	return value !== null;
 }
@@ -60,7 +60,7 @@ function getSideAndAlignFromPlacement(placement) {
 	return [side, align];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+//#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
@@ -72,7 +72,7 @@ var sides = [
 	"left"
 ];
 var alignments = ["start", "end"];
-var placements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+var placements = /*#__PURE__*/ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
 var min = Math.min;
 var max = Math.max;
 var round = Math.round;
@@ -87,10 +87,6 @@ var oppositeSideMap = {
 	bottom: "top",
 	top: "bottom"
 };
-var oppositeAlignmentMap = {
-	start: "end",
-	end: "start"
-};
 function clamp(start, value, end) {
 	return max(start, min(value, end));
 }
@@ -110,7 +106,8 @@ function getAxisLength(axis) {
 	return axis === "y" ? "height" : "width";
 }
 function getSideAxis(placement) {
-	return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+	const firstChar = placement[0];
+	return firstChar === "t" || firstChar === "b" ? "y" : "x";
 }
 function getAlignmentAxis(placement) {
 	return getOppositeAxis(getSideAxis(placement));
@@ -133,20 +130,20 @@ function getExpandedPlacements(placement) {
 	];
 }
 function getOppositeAlignmentPlacement(placement) {
-	return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+	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) {
-	const lr = ["left", "right"];
-	const rl = ["right", "left"];
-	const tb = ["top", "bottom"];
-	const bt = ["bottom", "top"];
 	switch (side) {
 		case "top":
 		case "bottom":
-			if (rtl) return isStart ? rl : lr;
-			return isStart ? lr : rl;
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
 		case "left":
-		case "right": return isStart ? tb : bt;
+		case "right": return isStart ? tbPlacement : btPlacement;
 		default: return [];
 	}
 }
@@ -160,15 +157,16 @@ function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
 	return list;
 }
 function getOppositePlacement(placement) {
-	return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+	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: 0,
-		right: 0,
-		bottom: 0,
-		left: 0,
-		...padding
+		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) {
@@ -193,7 +191,7 @@ function rectToClientRect(rect) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+core@1.6.9/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+//#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);
@@ -235,17 +233,57 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
 			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;
-	}
+	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.
 *
@@ -254,7 +292,10 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
 */
 var computePosition$1 = async (reference, floating, config) => {
 	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
-	const validMiddleware = middleware.filter(Boolean);
+	const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+		...platform,
+		detectOverflow
+	};
 	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
 	let rects = await platform.getElementRects({
 		reference,
@@ -263,10 +304,12 @@ var computePosition$1 = async (reference, floating, config) => {
 	});
 	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
 	let statefulPlacement = placement;
-	let middlewareData = {};
 	let resetCount = 0;
-	for (let i = 0; i < validMiddleware.length; i++) {
-		const { name, fn } = validMiddleware[i];
+	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,
@@ -275,7 +318,7 @@ var computePosition$1 = async (reference, floating, config) => {
 			strategy,
 			middlewareData,
 			rects,
-			platform,
+			platform: platformWithDetectOverflow,
 			elements: {
 				reference,
 				floating
@@ -283,14 +326,11 @@ var computePosition$1 = async (reference, floating, config) => {
 		});
 		x = nextX != null ? nextX : x;
 		y = nextY != null ? nextY : y;
-		middlewareData = {
-			...middlewareData,
-			[name]: {
-				...middlewareData[name],
-				...data
-			}
+		middlewareData[name] = {
+			...middlewareData[name],
+			...data
 		};
-		if (reset && resetCount <= 50) {
+		if (reset && resetCount < MAX_RESET_COUNT) {
 			resetCount++;
 			if (typeof reset === "object") {
 				if (reset.placement) statefulPlacement = reset.placement;
@@ -313,54 +353,6 @@ var computePosition$1 = async (reference, floating, config) => {
 	};
 };
 /**
-* 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
-	};
-}
-/**
 * 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
@@ -393,12 +385,11 @@ var arrow$2 = (options) => ({
 		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;
+		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: {
@@ -432,12 +423,12 @@ var autoPlacement$1 = function(options) {
 			const { rects, middlewareData, placement, platform, elements } = state;
 			const { crossAxis = false, alignment, allowedPlacements = placements, autoAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
 			const placements$1 = alignment !== void 0 || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
-			const overflow = await detectOverflow(state, detectOverflowOptions);
 			const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
 			const currentPlacement = placements$1[currentIndex];
 			if (currentPlacement == null) return {};
-			const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
 			if (placement !== currentPlacement) return { reset: { placement: placements$1[0] } };
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
 			const currentOverflows = [
 				overflow[getSide(currentPlacement)],
 				overflow[alignmentSides[0]],
@@ -499,7 +490,7 @@ var flip$1 = function(options) {
 			const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
 			if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
 			const placements = [initialPlacement, ...fallbackPlacements];
-			const overflow = await detectOverflow(state, detectOverflowOptions);
+			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]);
@@ -515,13 +506,15 @@ var flip$1 = function(options) {
 				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) return {
-					data: {
-						index: nextIndex,
-						overflows: overflowsData
-					},
-					reset: { placement: nextPlacement }
-				};
+				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": {
@@ -536,9 +529,7 @@ var flip$1 = function(options) {
 						if (placement) resetPlacement = placement;
 						break;
 					}
-					case "initialPlacement":
-						resetPlacement = initialPlacement;
-						break;
+					case "initialPlacement": resetPlacement = initialPlacement;
 				}
 				if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
 			}
@@ -568,11 +559,11 @@ var hide$1 = function(options) {
 		name: "hide",
 		options,
 		async fn(state) {
-			const { rects } = state;
+			const { rects, platform } = state;
 			const { strategy = "referenceHidden", ...detectOverflowOptions } = evaluate(options, state);
 			switch (strategy) {
 				case "referenceHidden": {
-					const offsets = getSideOffsets(await detectOverflow(state, {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
 						...detectOverflowOptions,
 						elementContext: "reference"
 					}), rects.reference);
@@ -582,7 +573,7 @@ var hide$1 = function(options) {
 					} };
 				}
 				case "escaped": {
-					const offsets = getSideOffsets(await detectOverflow(state, {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
 						...detectOverflowOptions,
 						altBoundary: true
 					}), rects.floating);
@@ -634,11 +625,12 @@ var inline$1 = function(options) {
 			const { placement, elements, rects, platform, strategy } = state;
 			const { padding = 2, x, y } = evaluate(options, state);
 			const nativeClientRects = Array.from(await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference)) || []);
+			if (!nativeClientRects.length) return {};
 			const clientRects = getRectsByLine(nativeClientRects);
 			const fallback = rectToClientRect(getBoundingRect(nativeClientRects));
 			const paddingObject = getPaddingObject(padding);
 			function getBoundingClientRect() {
-				if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) return clientRects.find((rect) => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
+				if (clientRects.length === 2 && (clientRects[0].left > clientRects[1].right || clientRects[1].left > clientRects[0].right) && x != null && y != null) return clientRects.find((rect) => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
 				if (clientRects.length >= 2) {
 					if (getSideAxis(placement) === "y") {
 						const firstRect = clientRects[0];
@@ -647,17 +639,12 @@ var inline$1 = function(options) {
 						const top = firstRect.top;
 						const bottom = lastRect.bottom;
 						const left = isTop ? firstRect.left : lastRect.left;
-						const right = isTop ? firstRect.right : lastRect.right;
-						return {
-							top,
-							bottom,
-							left,
-							right,
-							width: right - left,
-							height: bottom - top,
+						return rectToClientRect({
 							x: left,
-							y: top
-						};
+							y: top,
+							width: (isTop ? firstRect.right : lastRect.right) - left,
+							height: bottom - top
+						});
 					}
 					const isLeftSide = getSide(placement) === "left";
 					const maxRight = max(...clientRects.map((rect) => rect.right));
@@ -665,18 +652,12 @@ var inline$1 = function(options) {
 					const measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
 					const top = measureRects[0].top;
 					const bottom = measureRects[measureRects.length - 1].bottom;
-					const left = minLeft;
-					const right = maxRight;
-					return {
-						top,
-						bottom,
-						left,
-						right,
-						width: right - left,
-						height: bottom - top,
-						x: left,
-						y: top
-					};
+					return rectToClientRect({
+						x: minLeft,
+						y: top,
+						width: maxRight - minLeft,
+						height: bottom - top
+					});
 				}
 				return fallback;
 			}
@@ -690,13 +671,14 @@ var inline$1 = function(options) {
 		}
 	};
 };
+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 = ["left", "top"].includes(side) ? -1 : 1;
+	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" ? {
@@ -756,7 +738,7 @@ var shift$1 = function(options) {
 		name: "shift",
 		options,
 		async fn(state) {
-			const { x, y, placement } = state;
+			const { x, y, placement, platform } = state;
 			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
 				let { x, y } = _ref;
 				return {
@@ -768,25 +750,14 @@ var shift$1 = function(options) {
 				x,
 				y
 			};
-			const overflow = await detectOverflow(state, detectOverflowOptions);
-			const crossAxis = getSideAxis(getSide(placement));
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const crossAxis = getSideAxis(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 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,
@@ -814,6 +785,7 @@ var limitShift$1 = function(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 = {
@@ -829,9 +801,8 @@ var limitShift$1 = function(options) {
 				mainAxis: rawOffset,
 				crossAxis: 0
 			} : {
-				mainAxis: 0,
-				crossAxis: 0,
-				...rawOffset
+				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";
@@ -843,7 +814,7 @@ var limitShift$1 = function(options) {
 			if (checkCrossAxis) {
 				var _middlewareData$offse, _middlewareData$offse2;
 				const len = mainAxis === "y" ? "width" : "height";
-				const isOriginSide = ["top", "left"].includes(getSide(placement));
+				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;
@@ -868,10 +839,9 @@ var size$1 = function(options) {
 		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 detectOverflow(state, detectOverflowOptions);
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
 			const side = getSide(placement);
 			const alignment = getAlignment(placement);
 			const isYAxis = getSideAxis(placement) === "y";
@@ -889,18 +859,15 @@ var size$1 = function(options) {
 			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;
+			const shiftData = state.middlewareData.shift;
+			const noShift = !shiftData;
 			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 (shiftData != null && shiftData.enabled.x) availableWidth = maximumClippingWidth;
+			if (shiftData != null && shiftData.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));
+				if (isYAxis) availableWidth = width - 2 * max(overflow.left, overflow.right);
+				else availableHeight = height - 2 * max(overflow.top, overflow.bottom);
 			}
 			await apply({
 				...state,
@@ -914,7 +881,7 @@ var size$1 = function(options) {
 	};
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+//#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";
 }
@@ -947,47 +914,29 @@ function isShadowRoot(value) {
 	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
 function isOverflowElement(element) {
-	const { overflow, overflowX, overflowY, display } = getComputedStyle(element);
-	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+	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"
-	].includes(getNodeName(element));
+	return /^(table|td|th)$/.test(getNodeName(element));
 }
 function isTopLayer(element) {
-	return [":popover-open", ":modal"].some((selector) => {
-		try {
-			return element.matches(selector);
-		} catch (e) {
-			return false;
-		}
-	});
+	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 webkit = isWebKit();
-	const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
-	return [
-		"transform",
-		"translate",
-		"scale",
-		"rotate",
-		"perspective"
-	].some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || [
-		"transform",
-		"translate",
-		"scale",
-		"rotate",
-		"perspective",
-		"filter"
-	].some((value) => (css.willChange || "").includes(value)) || [
-		"paint",
-		"layout",
-		"strict",
-		"content"
-	].some((value) => (css.contain || "").includes(value));
+	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);
@@ -999,17 +948,13 @@ function getContainingBlock(element) {
 	return null;
 }
 function isWebKit() {
-	if (typeof CSS === "undefined" || !CSS.supports) return false;
-	return CSS.supports("-webkit-backdrop-filter", "none");
+	if (isWebKitValue == null) isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+	return isWebKitValue;
 }
 function isLastTraversableNode(node) {
-	return [
-		"html",
-		"body",
-		"#document"
-	].includes(getNodeName(node));
+	return /^(html|body|#document)$/.test(getNodeName(node));
 }
-function getComputedStyle(element) {
+function getComputedStyle$1(element) {
 	return getWindow(element).getComputedStyle(element);
 }
 function getNodeScroll(element) {
@@ -1029,7 +974,7 @@ function getParentNode(node) {
 }
 function getNearestOverflowAncestor(node) {
 	const parentNode = getParentNode(node);
-	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isLastTraversableNode(parentNode)) return (node.ownerDocument || node).body;
 	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
 	return getNearestOverflowAncestor(parentNode);
 }
@@ -1043,16 +988,15 @@ function getOverflowAncestors(node, list, traverseIframes) {
 	if (isBody) {
 		const frameElement = getFrameElement(win);
 		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-	}
-	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+	} else return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
 }
 function getFrameElement(win) {
 	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+dom@1.6.13/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+//#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(element);
+	const css = getComputedStyle$1(element);
 	let width = parseFloat(css.width) || 0;
 	let height = parseFloat(css.height) || 0;
 	const hasOffset = isHTMLElement(element);
@@ -1086,7 +1030,7 @@ function getScale(element) {
 		y
 	};
 }
-var noOffsets = /* @__PURE__ */ createCoords(0);
+var noOffsets = /*#__PURE__*/ createCoords(0);
 function getVisualOffsets(element) {
 	const win = getWindow(element);
 	if (!isWebKit() || !win.visualViewport) return noOffsets;
@@ -1097,8 +1041,7 @@ function getVisualOffsets(element) {
 }
 function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
 	if (isFixed === void 0) isFixed = false;
-	if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
-	return isFixed;
+	return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
 }
 function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
 	if (includeScale === void 0) includeScale = false;
@@ -1106,23 +1049,25 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
 	const clientRect = element.getBoundingClientRect();
 	const domElement = unwrapElement$1(element);
 	let scale = createCoords(1);
-	if (includeScale) if (offsetParent) {
-		if (isElement(offsetParent)) scale = getScale(offsetParent);
-	} else scale = getScale(element);
+	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) {
+	if (domElement && offsetParent) {
 		const win = getWindow(domElement);
-		const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		const offsetWin = isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
 		let currentWin = win;
 		let currentIFrame = getFrameElement(currentWin);
-		while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+		while (currentIFrame && offsetWin !== currentWin) {
 			const iframeScale = getScale(currentIFrame);
 			const iframeRect = currentIFrame.getBoundingClientRect();
-			const css = getComputedStyle(currentIFrame);
+			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;
@@ -1147,11 +1092,10 @@ function getWindowScrollBarX(element, rect) {
 	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
 	return rect.left + leftScroll;
 }
-function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
-	if (ignoreScrollbarX === void 0) ignoreScrollbarX = false;
+function getHTMLOffset(documentElement, scroll) {
 	const htmlRect = documentElement.getBoundingClientRect();
 	return {
-		x: htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 : getWindowScrollBarX(documentElement, htmlRect)),
+		x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
 		y: htmlRect.top + scroll.scrollTop
 	};
 }
@@ -1168,16 +1112,16 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
 	let scale = createCoords(1);
 	const offsets = createCoords(0);
 	const isOffsetParentAnElement = isHTMLElement(offsetParent);
-	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+	if (isOffsetParentAnElement || !isFixed) {
 		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
-		if (isHTMLElement(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, true) : createCoords(0);
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
 	return {
 		width: rect.width * scale.x,
 		height: rect.height * scale.y,
@@ -1186,17 +1130,16 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
 	};
 }
 function getClientRects(element) {
-	return Array.from(element.getClientRects());
+	return element.getClientRects ? Array.from(element.getClientRects()) : [];
 }
-function getDocumentRect(element) {
-	const html = getDocumentElement(element);
-	const scroll = getNodeScroll(element);
-	const body = element.ownerDocument.body;
+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(element);
+	let x = -scroll.scrollLeft + getWindowScrollBarX(html);
 	const y = -scroll.scrollTop;
-	if (getComputedStyle(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
+	if (getComputedStyle$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
 	return {
 		width,
 		height,
@@ -1204,7 +1147,10 @@ function getDocumentRect(element) {
 		y
 	};
 }
-function getViewportRect(element, strategy) {
+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;
@@ -1213,14 +1159,30 @@ function getViewportRect(element, strategy) {
 	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 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,
@@ -1232,7 +1194,7 @@ 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);
+	const scale = getScale(element);
 	return {
 		width: element.clientWidth * scale.x,
 		height: element.clientHeight * scale.y,
@@ -1242,7 +1204,7 @@ function getInnerBoundingClientRect(element, strategy) {
 }
 function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
 	let rect;
-	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
+	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 {
@@ -1256,24 +1218,19 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
 	}
 	return rectToClientRect(rect);
 }
-function hasFixedPositionAncestor(element, stopNode) {
-	const parentNode = getParentNode(element);
-	if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
-	return getComputedStyle(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
-}
 function getClippingElementAncestors(element, cache) {
 	const cachedResult = cache.get(element);
 	if (cachedResult) return cachedResult;
 	let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
-	let currentContainingBlockComputedStyle = null;
-	const elementIsFixed = getComputedStyle(element).position === "fixed";
+	let lastKeptComputedStyle = null;
+	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
 	let currentNode = elementIsFixed ? getParentNode(element) : element;
 	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-		const computedStyle = getComputedStyle(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 && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
-		else currentContainingBlockComputedStyle = computedStyle;
+		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);
@@ -1282,20 +1239,23 @@ function getClippingElementAncestors(element, cache) {
 function getClippingRect(_ref) {
 	let { element, boundary, rootBoundary, strategy } = _ref;
 	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
-	const firstClippingAncestor = clippingAncestors[0];
-	const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-		const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-		accRect.top = max(rect.top, accRect.top);
-		accRect.right = min(rect.right, accRect.right);
-		accRect.bottom = min(rect.bottom, accRect.bottom);
-		accRect.left = max(rect.left, accRect.left);
-		return accRect;
-	}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+	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: clippingRect.right - clippingRect.left,
-		height: clippingRect.bottom - clippingRect.top,
-		x: clippingRect.left,
-		y: clippingRect.top
+		width: right - left,
+		height: bottom - top,
+		x: left,
+		y: top
 	};
 }
 function getDimensions(element) {
@@ -1315,14 +1275,15 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 		scrollTop: 0
 	};
 	const offsets = createCoords(0);
-	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+	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;
-		} else if (documentElement) offsets.x = getWindowScrollBarX(documentElement);
+		}
 	}
+	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,
@@ -1332,10 +1293,10 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 	};
 }
 function isStaticPositioned(element) {
-	return getComputedStyle(element).position === "static";
+	return getComputedStyle$1(element).position === "static";
 }
 function getTrueOffsetParent(element, polyfill) {
-	if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") return null;
+	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;
@@ -1372,7 +1333,7 @@ var getElementRects = async function(data) {
 	};
 };
 function isRTL(element) {
-	return getComputedStyle(element).direction === "rtl";
+	return getComputedStyle$1(element).direction === "rtl";
 }
 var platform = {
 	convertOffsetParentRelativeRectToViewportRelativeRect,
@@ -1389,7 +1350,7 @@ var platform = {
 function rectsAreEqual(a, b) {
 	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
-function observeMove(element, onMove) {
+function observeMove(element, onMove, ancestorResize) {
 	let io = null;
 	let timeoutId;
 	const root = getDocumentElement(element);
@@ -1418,6 +1379,7 @@ function observeMove(element, onMove) {
 		let isFirstUpdate = true;
 		function handleObserve(entries) {
 			const ratio = entries[0].intersectionRatio;
+			if (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) return refresh();
 			if (ratio !== threshold) {
 				if (!isFirstUpdate) return refresh();
 				if (!ratio) timeoutId = setTimeout(() => {
@@ -1425,7 +1387,6 @@ function observeMove(element, onMove) {
 				}, 1e3);
 				else refresh(false, ratio);
 			}
-			if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
 			isFirstUpdate = false;
 		}
 		try {
@@ -1433,13 +1394,19 @@ function observeMove(element, onMove) {
 				...options,
 				root: root.ownerDocument
 			});
-		} catch (e) {
+		} catch (_e) {
 			io = new IntersectionObserver(handleObserve, options);
 		}
 		io.observe(element);
 	}
+	const win = getWindow(element);
+	const handleResize = () => refresh(ancestorResize);
+	win.addEventListener("resize", handleResize);
 	refresh(true);
-	return cleanup;
+	return () => {
+		win.removeEventListener("resize", handleResize);
+		cleanup();
+	};
 }
 /**
 * Automatically updates the position of the floating element when necessary.
@@ -1453,18 +1420,18 @@ function autoUpdate(reference, floating, update, options) {
 	if (options === void 0) options = {};
 	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
 	const referenceEl = unwrapElement$1(reference);
-	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
 	ancestors.forEach((ancestor) => {
-		ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
+		ancestorScroll && ancestor.addEventListener("scroll", update);
 		ancestorResize && ancestor.addEventListener("resize", update);
 	});
-	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update, ancestorResize) : null;
 	let reobserveFrame = -1;
 	let resizeObserver = null;
 	if (elementResize) {
 		resizeObserver = new ResizeObserver((_ref) => {
 			let [firstEntry] = _ref;
-			if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+			if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
 				resizeObserver.unobserve(floating);
 				cancelAnimationFrame(reobserveFrame);
 				reobserveFrame = requestAnimationFrame(() => {
@@ -1475,7 +1442,7 @@ function autoUpdate(reference, floating, update, options) {
 			update();
 		});
 		if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
-		resizeObserver.observe(floating);
+		if (floating) resizeObserver.observe(floating);
 	}
 	let frameId;
 	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
@@ -1562,11 +1529,9 @@ var limitShift = limitShift$1;
 */
 var computePosition = (reference, floating, options) => {
 	const cache = /* @__PURE__ */ new Map();
-	const mergedOptions = {
-		platform,
-		...options
-	};
+	const mergedOptions = options != null ? options : {};
 	const platformWithCache = {
+		...platform,
 		...mergedOptions.platform,
 		_c: cache
 	};
@@ -1576,8 +1541,8 @@ var computePosition = (reference, floating, options) => {
 	});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/vue-demi@0.14.10_vue@3.5.13_typescript@6.0.3_/node_modules/vue-demi/lib/index.mjs
-var lib_exports = /* @__PURE__ */ require_chunk.__exportAll({
+//#region ../../node_modules/.pnpm/vue-demi@0.14.10_vue@3.5.41_typescript@6.0.3_/node_modules/vue-demi/lib/index.mjs
+var lib_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	Vue: () => vue,
 	Vue2: () => void 0,
 	del: () => del,
@@ -1586,7 +1551,7 @@ var lib_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	isVue3: () => true,
 	set: () => set
 });
-require_chunk.__reExport(lib_exports, require("vue"));
+require_rolldown_runtime.__reExport(lib_exports, require("vue"));
 function install() {}
 function set(target, key, val) {
 	if (Array.isArray(target)) {
@@ -1605,7 +1570,7 @@ function del(target, key) {
 	delete target[key];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+vue@1.1.6_vue@3.5.13_typescript@6.0.3_/node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs
+//#region ../../node_modules/.pnpm/@floating-ui+vue@1.1.11_vue@3.5.41_typescript@6.0.3_/node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs
 function isComponentPublicInstance(target) {
 	return target != null && typeof target === "object" && "$el" in target;
 }
@@ -1765,7 +1730,7 @@ function useFloating(reference, floating, options) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/PopperContent.js
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/PopperContent.js
 var _hoisted_1 = ["dir"];
 var PopperContentPropsDefaultValue = {
 	side: "bottom",
@@ -1785,7 +1750,7 @@ var PopperContentPropsDefaultValue = {
 	updatePositionStrategy: "optimized",
 	prioritizePosition: false
 };
-var [injectPopperContentContext, providePopperContentContext] = /* @__PURE__ */ require_createContext.createContext("PopperContent");
+var [injectPopperContentContext, providePopperContentContext] = /*#__PURE__*/ require_createContext.createContext("PopperContent");
 var PopperContent_default = /* @__PURE__ */ (0, vue.defineComponent)({
 	inheritAttrs: false,
 	__name: "PopperContent",