bootstrap-vue-next 0.45.9 → 0.46.0

package/dist/{floating-ui.vue-CH2o_mZU.mjs → floating-ui.dom-C7UZexJK.js}

@@ -1,6 +1,4 @@
-import { n as __reExport, t as __exportAll } from "./chunk-D1SwGrFN.mjs";
-import * as Vue from "vue";
-//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/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
@@ -12,7 +10,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;
@@ -101,12 +99,12 @@ function getOppositePlacement(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) {
@@ -131,7 +129,7 @@ function rectToClientRect(rect) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+core@1.7.5/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);
@@ -173,14 +171,8 @@ 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;
 }
 /**
@@ -211,10 +203,7 @@ async function detectOverflow(state, options) {
 		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 offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) && await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
 		x: 1,
 		y: 1
 	};
@@ -306,7 +295,7 @@ var computePosition$1 = async (reference, floating, config) => {
 * appears centered to the reference element.
 * @see https://floating-ui.com/docs/arrow
 */
-var arrow$2 = (options) => ({
+var arrow$1 = (options) => ({
 	name: "arrow",
 	options,
 	async fn(state) {
@@ -334,12 +323,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: {
@@ -373,12 +361,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 platform.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]],
@@ -479,9 +467,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 } };
 			}
@@ -577,11 +563,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];
@@ -590,17 +577,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));
@@ -608,18 +590,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;
 			}
@@ -633,7 +609,7 @@ var inline$1 = function(options) {
 		}
 	};
 };
-var originSides = /* @__PURE__ */ new Set(["left", "top"]);
+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));
@@ -713,24 +689,13 @@ var shift$1 = function(options) {
 				y
 			};
 			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-			const crossAxis = getSideAxis(getSide(placement));
+			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,
@@ -758,6 +723,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 = {
@@ -773,9 +739,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";
@@ -812,7 +777,6 @@ 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 platform.detectOverflow(state, detectOverflowOptions);
@@ -833,18 +797,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,
@@ -858,7 +819,7 @@ var size$1 = function(options) {
 	};
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/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";
 }
@@ -951,7 +912,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);
 }
@@ -971,7 +932,7 @@ function getFrameElement(win) {
 	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+dom@1.7.6/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+//#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;
@@ -990,11 +951,11 @@ function getCssDimensions(element) {
 		$: shouldFallback
 	};
 }
-function unwrapElement$1(element) {
+function unwrapElement(element) {
 	return !isElement(element) ? element.contextElement : element;
 }
 function getScale(element) {
-	const domElement = unwrapElement$1(element);
+	const domElement = unwrapElement(element);
 	if (!isHTMLElement(domElement)) return createCoords(1);
 	const rect = domElement.getBoundingClientRect();
 	const { width, height, $ } = getCssDimensions(domElement);
@@ -1007,7 +968,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;
@@ -1018,29 +979,30 @@ 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;
 	if (isFixedStrategy === void 0) isFixedStrategy = false;
 	const clientRect = element.getBoundingClientRect();
-	const domElement = unwrapElement$1(element);
+	const domElement = unwrapElement(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$1(currentIFrame);
@@ -1088,7 +1050,7 @@ 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 (isOffsetParentAnElement) {
 			const offsetRect = getBoundingClientRect(offsetParent);
@@ -1106,15 +1068,14 @@ 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$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
 	return {
@@ -1125,7 +1086,9 @@ function getDocumentRect(element) {
 	};
 }
 var SCROLLBAR_MAX = 25;
-function getViewportRect(element, strategy) {
+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;
@@ -1134,23 +1097,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;
+			}
 		}
 	}
-	const windowScrollbarX = getWindowScrollBarX(html);
-	if (windowScrollbarX <= 0) {
+	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 clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-		if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
-	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+		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,
@@ -1162,7 +1132,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,
@@ -1172,7 +1142,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 {
@@ -1186,24 +1156,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$1(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;
+	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);
-		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
-		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
-		else currentContainingBlockComputedStyle = computedStyle;
+		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);
@@ -1248,18 +1213,15 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 		scrollTop: 0
 	};
 	const offsets = createCoords(0);
-	function setLeftRTLScrollbarOffset() {
-		offsets.x = getWindowScrollBarX(documentElement);
-	}
-	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) setLeftRTLScrollbarOffset();
+		}
 	}
-	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+	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,
@@ -1326,7 +1288,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);
@@ -1355,6 +1317,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(() => {
@@ -1362,7 +1325,6 @@ function observeMove(element, onMove) {
 				}, 1e3);
 				else refresh(false, ratio);
 			}
-			if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
 			isFirstUpdate = false;
 		}
 		try {
@@ -1375,8 +1337,14 @@ function observeMove(element, onMove) {
 		}
 		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.
@@ -1389,13 +1357,13 @@ function observeMove(element, onMove) {
 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 referenceEl = unwrapElement(reference);
 	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) {
@@ -1482,7 +1450,7 @@ var hide = hide$1;
 * appears centered to the reference element.
 * @see https://floating-ui.com/docs/arrow
 */
-var arrow$1 = arrow$2;
+var arrow = arrow$1;
 /**
 * Provides improved positioning for inline reference elements that can span
 * over multiple lines, such as hyperlinks or range selections.
@@ -1499,11 +1467,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
 	};
@@ -1513,196 +1479,6 @@ var computePosition = (reference, floating, options) => {
 	});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/vue-demi@0.14.10_vue@3.5.31_typescript@5.9.3_/node_modules/vue-demi/lib/index.mjs
-var lib_exports = /* @__PURE__ */ __exportAll({
-	Vue: () => Vue,
-	Vue2: () => void 0,
-	del: () => del,
-	install: () => install,
-	isVue2: () => false,
-	isVue3: () => true,
-	set: () => set
-});
-import * as import_vue from "vue";
-__reExport(lib_exports, import_vue);
-function install() {}
-function set(target, key, val) {
-	if (Array.isArray(target)) {
-		target.length = Math.max(target.length, key);
-		target.splice(key, 1, val);
-		return val;
-	}
-	target[key] = val;
-	return val;
-}
-function del(target, key) {
-	if (Array.isArray(target)) {
-		target.splice(key, 1);
-		return;
-	}
-	delete target[key];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@floating-ui+vue@1.1.11_vue@3.5.31_typescript@5.9.3_/node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs
-function isComponentPublicInstance(target) {
-	return target != null && typeof target === "object" && "$el" in target;
-}
-function unwrapElement(target) {
-	if (isComponentPublicInstance(target)) {
-		const element = target.$el;
-		return isNode(element) && getNodeName(element) === "#comment" ? null : element;
-	}
-	return target;
-}
-function toValue$1(source) {
-	return typeof source === "function" ? source() : (0, lib_exports.unref)(source);
-}
-/**
-* Positions an inner element of the floating element such that it is centered to the reference element.
-* @param options The arrow options.
-* @see https://floating-ui.com/docs/arrow
-*/
-function arrow(options) {
-	return {
-		name: "arrow",
-		options,
-		fn(args) {
-			const element = unwrapElement(toValue$1(options.element));
-			if (element == null) return {};
-			return arrow$1({
-				element,
-				padding: options.padding
-			}).fn(args);
-		}
-	};
-}
-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;
-}
-/**
-* Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
-* @param reference The reference template ref.
-* @param floating The floating template ref.
-* @param options The floating options.
-* @see https://floating-ui.com/docs/vue
-*/
-function useFloating(reference, floating, options) {
-	if (options === void 0) options = {};
-	const whileElementsMountedOption = options.whileElementsMounted;
-	const openOption = (0, lib_exports.computed)(() => {
-		var _toValue;
-		return (_toValue = toValue$1(options.open)) != null ? _toValue : true;
-	});
-	const middlewareOption = (0, lib_exports.computed)(() => toValue$1(options.middleware));
-	const placementOption = (0, lib_exports.computed)(() => {
-		var _toValue2;
-		return (_toValue2 = toValue$1(options.placement)) != null ? _toValue2 : "bottom";
-	});
-	const strategyOption = (0, lib_exports.computed)(() => {
-		var _toValue3;
-		return (_toValue3 = toValue$1(options.strategy)) != null ? _toValue3 : "absolute";
-	});
-	const transformOption = (0, lib_exports.computed)(() => {
-		var _toValue4;
-		return (_toValue4 = toValue$1(options.transform)) != null ? _toValue4 : true;
-	});
-	const referenceElement = (0, lib_exports.computed)(() => unwrapElement(reference.value));
-	const floatingElement = (0, lib_exports.computed)(() => unwrapElement(floating.value));
-	const x = (0, lib_exports.ref)(0);
-	const y = (0, lib_exports.ref)(0);
-	const strategy = (0, lib_exports.ref)(strategyOption.value);
-	const placement = (0, lib_exports.ref)(placementOption.value);
-	const middlewareData = (0, lib_exports.shallowRef)({});
-	const isPositioned = (0, lib_exports.ref)(false);
-	const floatingStyles = (0, lib_exports.computed)(() => {
-		const initialStyles = {
-			position: strategy.value,
-			left: "0",
-			top: "0"
-		};
-		if (!floatingElement.value) return initialStyles;
-		const xVal = roundByDPR(floatingElement.value, x.value);
-		const yVal = roundByDPR(floatingElement.value, y.value);
-		if (transformOption.value) return {
-			...initialStyles,
-			transform: "translate(" + xVal + "px, " + yVal + "px)",
-			...getDPR(floatingElement.value) >= 1.5 && { willChange: "transform" }
-		};
-		return {
-			position: strategy.value,
-			left: xVal + "px",
-			top: yVal + "px"
-		};
-	});
-	let whileElementsMountedCleanup;
-	function update() {
-		if (referenceElement.value == null || floatingElement.value == null) return;
-		const open = openOption.value;
-		computePosition(referenceElement.value, floatingElement.value, {
-			middleware: middlewareOption.value,
-			placement: placementOption.value,
-			strategy: strategyOption.value
-		}).then((position) => {
-			x.value = position.x;
-			y.value = position.y;
-			strategy.value = position.strategy;
-			placement.value = position.placement;
-			middlewareData.value = position.middlewareData;
-			/**
-			* The floating element's position may be recomputed while it's closed
-			* but still mounted (such as when transitioning out). To ensure
-			* `isPositioned` will be `false` initially on the next open, avoid
-			* setting it to `true` when `open === false` (must be specified).
-			*/
-			isPositioned.value = open !== false;
-		});
-	}
-	function cleanup() {
-		if (typeof whileElementsMountedCleanup === "function") {
-			whileElementsMountedCleanup();
-			whileElementsMountedCleanup = void 0;
-		}
-	}
-	function attach() {
-		cleanup();
-		if (whileElementsMountedOption === void 0) {
-			update();
-			return;
-		}
-		if (referenceElement.value != null && floatingElement.value != null) {
-			whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
-			return;
-		}
-	}
-	function reset() {
-		if (!openOption.value) isPositioned.value = false;
-	}
-	(0, lib_exports.watch)([
-		middlewareOption,
-		placementOption,
-		strategyOption,
-		openOption
-	], update, { flush: "sync" });
-	(0, lib_exports.watch)([referenceElement, floatingElement], attach, { flush: "sync" });
-	(0, lib_exports.watch)(openOption, reset, { flush: "sync" });
-	if ((0, lib_exports.getCurrentScope)()) (0, lib_exports.onScopeDispose)(cleanup);
-	return {
-		x: (0, lib_exports.shallowReadonly)(x),
-		y: (0, lib_exports.shallowReadonly)(y),
-		strategy: (0, lib_exports.shallowReadonly)(strategy),
-		placement: (0, lib_exports.shallowReadonly)(placement),
-		middlewareData: (0, lib_exports.shallowReadonly)(middlewareData),
-		isPositioned: (0, lib_exports.shallowReadonly)(isPositioned),
-		floatingStyles,
-		update
-	};
-}
-//#endregion
-export { flip as a, limitShift as c, size as d, autoUpdate as i, offset as l, useFloating as n, hide as o, autoPlacement as r, inline as s, arrow as t, shift as u };
+export { flip as a, limitShift as c, size as d, getNodeName as f, computePosition as i, offset as l, autoPlacement as n, hide as o, isNode as p, autoUpdate as r, inline as s, arrow as t, shift as u };
 
-//# sourceMappingURL=floating-ui.vue-CH2o_mZU.mjs.map
+//# sourceMappingURL=floating-ui.dom-C7UZexJK.js.map