@pixpilot/shadcn-ui 0.4.0 → 0.4.1

package/dist/node_modules/.pnpm/@floating-ui_core@1.7.3/node_modules/@floating-ui/core/dist/floating-ui.core.cjs

@@ -1 +1,695 @@
-const e=require(`../../../../../../../_virtual/rolldown_runtime.cjs`),t=require(`../../../../../@floating-ui_utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.cjs`);function n(e,n,r){let{reference:i,floating:a}=e,o=t.getSideAxis(n),s=t.getAlignmentAxis(n),c=t.getAxisLength(s),l=t.getSide(n),u=o===`y`,d=i.x+i.width/2-a.width/2,f=i.y+i.height/2-a.height/2,p=i[c]/2-a[c]/2,m;switch(l){case`top`:m={x:d,y:i.y-a.height};break;case`bottom`:m={x:d,y:i.y+i.height};break;case`right`:m={x:i.x+i.width,y:f};break;case`left`:m={x:i.x-a.width,y:f};break;default:m={x:i.x,y:i.y}}switch(t.getAlignment(n)){case`start`:m[s]-=p*(r&&u?-1:1);break;case`end`:m[s]+=p*(r&&u?-1:1);break}return m}async function r(e,n){n===void 0&&(n={});let{x:r,y:i,platform:a,rects:o,elements:s,strategy:c}=e,{boundary:l=`clippingAncestors`,rootBoundary:u=`viewport`,elementContext:d=`floating`,altBoundary:f=!1,padding:p=0}=t.evaluate(n,e),m=t.getPaddingObject(p),h=s[f?d===`floating`?`reference`:`floating`:d],g=t.rectToClientRect(await a.getClippingRect({element:await(a.isElement==null?void 0:a.isElement(h))??!0?h:h.contextElement||await(a.getDocumentElement==null?void 0:a.getDocumentElement(s.floating)),boundary:l,rootBoundary:u,strategy:c})),_=d===`floating`?{x:r,y:i,width:o.floating.width,height:o.floating.height}:o.reference,v=await(a.getOffsetParent==null?void 0:a.getOffsetParent(s.floating)),y=await(a.isElement==null?void 0:a.isElement(v))&&await(a.getScale==null?void 0:a.getScale(v))||{x:1,y:1},b=t.rectToClientRect(a.convertOffsetParentRelativeRectToViewportRelativeRect?await a.convertOffsetParentRelativeRectToViewportRelativeRect({elements:s,rect:_,offsetParent:v,strategy:c}):_);return{top:(g.top-b.top+m.top)/y.y,bottom:(b.bottom-g.bottom+m.bottom)/y.y,left:(g.left-b.left+m.left)/y.x,right:(b.right-g.right+m.right)/y.x}}function i(e,n,r){return(e?[...r.filter(n=>t.getAlignment(n)===e),...r.filter(n=>t.getAlignment(n)!==e)]:r.filter(e=>t.getSide(e)===e)).filter(r=>e?t.getAlignment(r)===e||(n?t.getOppositeAlignmentPlacement(r)!==r:!1):!0)}function a(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function o(e){return t.sides.some(t=>e[t]>=0)}function s(e){let n=t.min(...e.map(e=>e.left)),r=t.min(...e.map(e=>e.top)),i=t.max(...e.map(e=>e.right)),a=t.max(...e.map(e=>e.bottom));return{x:n,y:r,width:i-n,height:a-r}}function c(e){let n=e.slice().sort((e,t)=>e.y-t.y),r=[],i=null;for(let e=0;e<n.length;e++){let t=n[e];!i||t.y-i.y>i.height/2?r.push([t]):r[r.length-1].push(t),i=t}return r.map(e=>t.rectToClientRect(s(e)))}async function l(e,n){let{placement:r,platform:i,elements:a}=e,o=await(i.isRTL==null?void 0:i.isRTL(a.floating)),s=t.getSide(r),c=t.getAlignment(r),l=t.getSideAxis(r)===`y`,u=g.has(s)?-1:1,d=o&&l?-1:1,f=t.evaluate(n,e),{mainAxis:p,crossAxis:m,alignmentAxis:h}=typeof f==`number`?{mainAxis:f,crossAxis:0,alignmentAxis:null}:{mainAxis:f.mainAxis||0,crossAxis:f.crossAxis||0,alignmentAxis:f.alignmentAxis};return c&&typeof h==`number`&&(m=c===`end`?h*-1:h),l?{x:m*d,y:p*u}:{x:p*u,y:m*d}}var u,d,f,p,m,h,g,_,v,y,b,x=e.__esmMin((()=>{t.init_floating_ui_utils(),u=async(e,t,r)=>{let{placement:i=`bottom`,strategy:a=`absolute`,middleware:o=[],platform:s}=r,c=o.filter(Boolean),l=await(s.isRTL==null?void 0:s.isRTL(t)),u=await s.getElementRects({reference:e,floating:t,strategy:a}),{x:d,y:f}=n(u,i,l),p=i,m={},h=0;for(let r=0;r<c.length;r++){let{name:o,fn:g}=c[r],{x:_,y:v,data:y,reset:b}=await g({x:d,y:f,initialPlacement:i,placement:p,strategy:a,middlewareData:m,rects:u,platform:s,elements:{reference:e,floating:t}});d=_??d,f=v??f,m={...m,[o]:{...m[o],...y}},b&&h<=50&&(h++,typeof b==`object`&&(b.placement&&(p=b.placement),b.rects&&(u=b.rects===!0?await s.getElementRects({reference:e,floating:t,strategy:a}):b.rects),{x:d,y:f}=n(u,p,l)),r=-1)}return{x:d,y:f,placement:p,strategy:a,middlewareData:m}},d=e=>({name:`arrow`,options:e,async fn(n){let{x:r,y:i,placement:a,rects:o,platform:s,elements:c,middlewareData:l}=n,{element:u,padding:d=0}=t.evaluate(e,n)||{};if(u==null)return{};let f=t.getPaddingObject(d),p={x:r,y:i},m=t.getAlignmentAxis(a),h=t.getAxisLength(m),g=await s.getDimensions(u),_=m===`y`,v=_?`top`:`left`,y=_?`bottom`:`right`,b=_?`clientHeight`:`clientWidth`,x=o.reference[h]+o.reference[m]-p[m]-o.floating[h],S=p[m]-o.reference[m],C=await(s.getOffsetParent==null?void 0:s.getOffsetParent(u)),w=C?C[b]:0;(!w||!await(s.isElement==null?void 0:s.isElement(C)))&&(w=c.floating[b]||o.floating[h]);let T=x/2-S/2,E=w/2-g[h]/2-1,D=t.min(f[v],E),O=t.min(f[y],E),k=D,A=w-g[h]-O,j=w/2-g[h]/2+T,M=t.clamp(k,j,A),N=!l.arrow&&t.getAlignment(a)!=null&&j!==M&&o.reference[h]/2-(j<k?D:O)-g[h]/2<0,P=N?j<k?j-k:j-A:0;return{[m]:p[m]+P,data:{[m]:M,centerOffset:j-M-P,...N&&{alignmentOffset:P}},reset:N}}}),f=function(e){return e===void 0&&(e={}),{name:`autoPlacement`,options:e,async fn(n){let{rects:a,middlewareData:o,placement:s,platform:c,elements:l}=n,{crossAxis:u=!1,alignment:d,allowedPlacements:f=t.placements,autoAlignment:p=!0,...m}=t.evaluate(e,n),h=d!==void 0||f===t.placements?i(d||null,p,f):f,g=await r(n,m),_=o.autoPlacement?.index||0,v=h[_];if(v==null)return{};let y=t.getAlignmentSides(v,a,await(c.isRTL==null?void 0:c.isRTL(l.floating)));if(s!==v)return{reset:{placement:h[0]}};let b=[g[t.getSide(v)],g[y[0]],g[y[1]]],x=[...o.autoPlacement?.overflows||[],{placement:v,overflows:b}],S=h[_+1];if(S)return{data:{index:_+1,overflows:x},reset:{placement:S}};let C=x.map(e=>{let n=t.getAlignment(e.placement);return[e.placement,n&&u?e.overflows.slice(0,2).reduce((e,t)=>e+t,0):e.overflows[0],e.overflows]}).sort((e,t)=>e[1]-t[1]),w=C.filter(e=>e[2].slice(0,t.getAlignment(e[0])?2:3).every(e=>e<=0))[0]?.[0]||C[0][0];return w===s?{}:{data:{index:_+1,overflows:x},reset:{placement:w}}}}},p=function(e){return e===void 0&&(e={}),{name:`flip`,options:e,async fn(n){var i;let{placement:a,middlewareData:o,rects:s,initialPlacement:c,platform:l,elements:u}=n,{mainAxis:d=!0,crossAxis:f=!0,fallbackPlacements:p,fallbackStrategy:m=`bestFit`,fallbackAxisSideDirection:h=`none`,flipAlignment:g=!0,..._}=t.evaluate(e,n);if((i=o.arrow)!=null&&i.alignmentOffset)return{};let v=t.getSide(a),y=t.getSideAxis(c),b=t.getSide(c)===c,x=await(l.isRTL==null?void 0:l.isRTL(u.floating)),S=p||(b||!g?[t.getOppositePlacement(c)]:t.getExpandedPlacements(c)),C=h!==`none`;!p&&C&&S.push(...t.getOppositeAxisPlacements(c,g,h,x));let w=[c,...S],T=await r(n,_),E=[],D=o.flip?.overflows||[];if(d&&E.push(T[v]),f){let e=t.getAlignmentSides(a,s,x);E.push(T[e[0]],T[e[1]])}if(D=[...D,{placement:a,overflows:E}],!E.every(e=>e<=0)){let e=(o.flip?.index||0)+1,n=w[e];if(n&&(!(f===`alignment`&&y!==t.getSideAxis(n))||D.every(e=>t.getSideAxis(e.placement)===y?e.overflows[0]>0:!0)))return{data:{index:e,overflows:D},reset:{placement:n}};let r=D.filter(e=>e.overflows[0]<=0).sort((e,t)=>e.overflows[1]-t.overflows[1])[0]?.placement;if(!r)switch(m){case`bestFit`:{let e=D.filter(e=>{if(C){let n=t.getSideAxis(e.placement);return n===y||n===`y`}return!0}).map(e=>[e.placement,e.overflows.filter(e=>e>0).reduce((e,t)=>e+t,0)]).sort((e,t)=>e[1]-t[1])[0]?.[0];e&&(r=e);break}case`initialPlacement`:r=c;break}if(a!==r)return{reset:{placement:r}}}return{}}}},m=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(n){let{rects:i}=n,{strategy:s=`referenceHidden`,...c}=t.evaluate(e,n);switch(s){case`referenceHidden`:{let e=a(await r(n,{...c,elementContext:`reference`}),i.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:o(e)}}}case`escaped`:{let e=a(await r(n,{...c,altBoundary:!0}),i.floating);return{data:{escapedOffsets:e,escaped:o(e)}}}default:return{}}}}},h=function(e){return e===void 0&&(e={}),{name:`inline`,options:e,async fn(n){let{placement:r,elements:i,rects:a,platform:o,strategy:l}=n,{padding:u=2,x:d,y:f}=t.evaluate(e,n),p=Array.from(await(o.getClientRects==null?void 0:o.getClientRects(i.reference))||[]),m=c(p),h=t.rectToClientRect(s(p)),g=t.getPaddingObject(u);function _(){if(m.length===2&&m[0].left>m[1].right&&d!=null&&f!=null)return m.find(e=>d>e.left-g.left&&d<e.right+g.right&&f>e.top-g.top&&f<e.bottom+g.bottom)||h;if(m.length>=2){if(t.getSideAxis(r)===`y`){let e=m[0],n=m[m.length-1],i=t.getSide(r)===`top`,a=e.top,o=n.bottom,s=i?e.left:n.left,c=i?e.right:n.right;return{top:a,bottom:o,left:s,right:c,width:c-s,height:o-a,x:s,y:a}}let e=t.getSide(r)===`left`,n=t.max(...m.map(e=>e.right)),i=t.min(...m.map(e=>e.left)),a=m.filter(t=>e?t.left===i:t.right===n),o=a[0].top,s=a[a.length-1].bottom,c=i,l=n;return{top:o,bottom:s,left:c,right:l,width:l-c,height:s-o,x:c,y:o}}return h}let v=await o.getElementRects({reference:{getBoundingClientRect:_},floating:i.floating,strategy:l});return a.reference.x!==v.reference.x||a.reference.y!==v.reference.y||a.reference.width!==v.reference.width||a.reference.height!==v.reference.height?{reset:{rects:v}}:{}}}},g=new Set([`left`,`top`]),_=function(e){return e===void 0&&(e=0),{name:`offset`,options:e,async fn(t){var n;let{x:r,y:i,placement:a,middlewareData:o}=t,s=await l(t,e);return a===o.offset?.placement&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:r+s.x,y:i+s.y,data:{...s,placement:a}}}}},v=function(e){return e===void 0&&(e={}),{name:`shift`,options:e,async fn(n){let{x:i,y:a,placement:o}=n,{mainAxis:s=!0,crossAxis:c=!1,limiter:l={fn:e=>{let{x:t,y:n}=e;return{x:t,y:n}}},...u}=t.evaluate(e,n),d={x:i,y:a},f=await r(n,u),p=t.getSideAxis(t.getSide(o)),m=t.getOppositeAxis(p),h=d[m],g=d[p];if(s){let e=m===`y`?`top`:`left`,n=m===`y`?`bottom`:`right`,r=h+f[e],i=h-f[n];h=t.clamp(r,h,i)}if(c){let e=p===`y`?`top`:`left`,n=p===`y`?`bottom`:`right`,r=g+f[e],i=g-f[n];g=t.clamp(r,g,i)}let _=l.fn({...n,[m]:h,[p]:g});return{..._,data:{x:_.x-i,y:_.y-a,enabled:{[m]:s,[p]:c}}}}}},y=function(e){return e===void 0&&(e={}),{options:e,fn(n){let{x:r,y:i,placement:a,rects:o,middlewareData:s}=n,{offset:c=0,mainAxis:l=!0,crossAxis:u=!0}=t.evaluate(e,n),d={x:r,y:i},f=t.getSideAxis(a),p=t.getOppositeAxis(f),m=d[p],h=d[f],_=t.evaluate(c,n),v=typeof _==`number`?{mainAxis:_,crossAxis:0}:{mainAxis:0,crossAxis:0,..._};if(l){let e=p===`y`?`height`:`width`,t=o.reference[p]-o.floating[e]+v.mainAxis,n=o.reference[p]+o.reference[e]-v.mainAxis;m<t?m=t:m>n&&(m=n)}if(u){let e=p===`y`?`width`:`height`,n=g.has(t.getSide(a)),r=o.reference[f]-o.floating[e]+(n&&s.offset?.[f]||0)+(n?0:v.crossAxis),i=o.reference[f]+o.reference[e]+(n?0:s.offset?.[f]||0)-(n?v.crossAxis:0);h<r?h=r:h>i&&(h=i)}return{[p]:m,[f]:h}}}},b=function(e){return e===void 0&&(e={}),{name:`size`,options:e,async fn(n){var i,a;let{placement:o,rects:s,platform:c,elements:l}=n,{apply:u=()=>{},...d}=t.evaluate(e,n),f=await r(n,d),p=t.getSide(o),m=t.getAlignment(o),h=t.getSideAxis(o)===`y`,{width:g,height:_}=s.floating,v,y;p===`top`||p===`bottom`?(v=p,y=m===(await(c.isRTL==null?void 0:c.isRTL(l.floating))?`start`:`end`)?`left`:`right`):(y=p,v=m===`end`?`top`:`bottom`);let b=_-f.top-f.bottom,x=g-f.left-f.right,S=t.min(_-f[v],b),C=t.min(g-f[y],x),w=!n.middlewareData.shift,T=S,E=C;if((i=n.middlewareData.shift)!=null&&i.enabled.x&&(E=x),(a=n.middlewareData.shift)!=null&&a.enabled.y&&(T=b),w&&!m){let e=t.max(f.left,0),n=t.max(f.right,0),r=t.max(f.top,0),i=t.max(f.bottom,0);h?E=g-2*(e!==0||n!==0?e+n:t.max(f.left,f.right)):T=_-2*(r!==0||i!==0?r+i:t.max(f.top,f.bottom))}await u({...n,availableWidth:E,availableHeight:T});let D=await c.getDimensions(l.floating);return g!==D.width||_!==D.height?{reset:{rects:!0}}:{}}}}}));x(),exports.arrow=d,exports.autoPlacement=f,exports.computePosition=u,exports.detectOverflow=r,exports.flip=p,exports.hide=m,Object.defineProperty(exports,`init_floating_ui_core`,{enumerable:!0,get:function(){return x}}),exports.inline=h,exports.limitShift=y,exports.offset=_,exports.shift=v,exports.size=b;
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
+const require_floating_ui_utils = require('../../../../../@floating-ui_utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.cjs');
+
+//#region ../../node_modules/.pnpm/@floating-ui+core@1.7.3/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+	let { reference, floating } = _ref;
+	const sideAxis = require_floating_ui_utils.getSideAxis(placement);
+	const alignmentAxis = require_floating_ui_utils.getAlignmentAxis(placement);
+	const alignLength = require_floating_ui_utils.getAxisLength(alignmentAxis);
+	const side = require_floating_ui_utils.getSide(placement);
+	const isVertical = sideAxis === "y";
+	const commonX = reference.x + reference.width / 2 - floating.width / 2;
+	const commonY = reference.y + reference.height / 2 - floating.height / 2;
+	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+	let coords;
+	switch (side) {
+		case "top":
+			coords = {
+				x: commonX,
+				y: reference.y - floating.height
+			};
+			break;
+		case "bottom":
+			coords = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case "right":
+			coords = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case "left":
+			coords = {
+				x: reference.x - floating.width,
+				y: commonY
+			};
+			break;
+		default: coords = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	switch (require_floating_ui_utils.getAlignment(placement)) {
+		case "start":
+			coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+		case "end":
+			coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+	}
+	return coords;
+}
+/**
+* Resolves with an object of overflow side offsets that determine how much the
+* element is overflowing a given clipping boundary on each side.
+* - positive = overflowing the boundary by that number of pixels
+* - negative = how many pixels left before it will overflow
+* - 0 = lies flush with the boundary
+* @see https://floating-ui.com/docs/detectOverflow
+*/
+async function detectOverflow(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform, rects, elements, strategy } = state;
+	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = require_floating_ui_utils.evaluate(options, state);
+	const paddingObject = require_floating_ui_utils.getPaddingObject(padding);
+	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
+	const clippingClientRect = require_floating_ui_utils.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 = require_floating_ui_utils.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
+	};
+}
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+	return (alignment ? [...allowedPlacements.filter((placement) => require_floating_ui_utils.getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => require_floating_ui_utils.getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => require_floating_ui_utils.getSide(placement) === placement)).filter((placement) => {
+		if (alignment) return require_floating_ui_utils.getAlignment(placement) === alignment || (autoAlignment ? require_floating_ui_utils.getOppositeAlignmentPlacement(placement) !== placement : false);
+		return true;
+	});
+}
+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 require_floating_ui_utils.sides.some((side) => overflow[side] >= 0);
+}
+function getBoundingRect(rects) {
+	const minX = require_floating_ui_utils.min(...rects.map((rect) => rect.left));
+	const minY = require_floating_ui_utils.min(...rects.map((rect) => rect.top));
+	const maxX = require_floating_ui_utils.max(...rects.map((rect) => rect.right));
+	const maxY = require_floating_ui_utils.max(...rects.map((rect) => rect.bottom));
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function getRectsByLine(rects) {
+	const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
+	const groups = [];
+	let prevRect = null;
+	for (let i = 0; i < sortedRects.length; i++) {
+		const rect = sortedRects[i];
+		if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) groups.push([rect]);
+		else groups[groups.length - 1].push(rect);
+		prevRect = rect;
+	}
+	return groups.map((rect) => require_floating_ui_utils.rectToClientRect(getBoundingRect(rect)));
+}
+async function convertValueToCoords(state, options) {
+	const { placement, platform, elements } = state;
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+	const side = require_floating_ui_utils.getSide(placement);
+	const alignment = require_floating_ui_utils.getAlignment(placement);
+	const isVertical = require_floating_ui_utils.getSideAxis(placement) === "y";
+	const mainAxisMulti = originSides.has(side) ? -1 : 1;
+	const crossAxisMulti = rtl && isVertical ? -1 : 1;
+	const rawValue = require_floating_ui_utils.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
+	};
+}
+var computePosition, arrow, autoPlacement, flip, hide, inline, originSides, offset, shift, limitShift, size;
+var init_floating_ui_core = require_rolldown_runtime.__esm({ "../../node_modules/.pnpm/@floating-ui+core@1.7.3/node_modules/@floating-ui/core/dist/floating-ui.core.mjs": (() => {
+	require_floating_ui_utils.init_floating_ui_utils();
+	computePosition = async (reference, floating, config) => {
+		const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
+		const validMiddleware = middleware.filter(Boolean);
+		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 middlewareData = {};
+		let resetCount = 0;
+		for (let i = 0; i < validMiddleware.length; i++) {
+			const { name, fn } = validMiddleware[i];
+			const { x: nextX, y: nextY, data, reset } = await fn({
+				x,
+				y,
+				initialPlacement: placement,
+				placement: statefulPlacement,
+				strategy,
+				middlewareData,
+				rects,
+				platform,
+				elements: {
+					reference,
+					floating
+				}
+			});
+			x = nextX != null ? nextX : x;
+			y = nextY != null ? nextY : y;
+			middlewareData = {
+				...middlewareData,
+				[name]: {
+					...middlewareData[name],
+					...data
+				}
+			};
+			if (reset && resetCount <= 50) {
+				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
+		};
+	};
+	arrow = (options) => ({
+		name: "arrow",
+		options,
+		async fn(state) {
+			const { x, y, placement, rects, platform, elements, middlewareData } = state;
+			const { element, padding = 0 } = require_floating_ui_utils.evaluate(options, state) || {};
+			if (element == null) return {};
+			const paddingObject = require_floating_ui_utils.getPaddingObject(padding);
+			const coords = {
+				x,
+				y
+			};
+			const axis = require_floating_ui_utils.getAlignmentAxis(placement);
+			const length = require_floating_ui_utils.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 = require_floating_ui_utils.min(paddingObject[minProp], largestPossiblePadding);
+			const maxPadding = require_floating_ui_utils.min(paddingObject[maxProp], largestPossiblePadding);
+			const min$1 = minPadding;
+			const max$1 = clientSize - arrowDimensions[length] - maxPadding;
+			const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+			const offset$1 = require_floating_ui_utils.clamp(min$1, center, max$1);
+			const shouldAddOffset = !middlewareData.arrow && require_floating_ui_utils.getAlignment(placement) != null && center !== offset$1 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+			const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max$1 : 0;
+			return {
+				[axis]: coords[axis] + alignmentOffset,
+				data: {
+					[axis]: offset$1,
+					centerOffset: center - offset$1 - alignmentOffset,
+					...shouldAddOffset && { alignmentOffset }
+				},
+				reset: shouldAddOffset
+			};
+		}
+	});
+	autoPlacement = function(options) {
+		if (options === void 0) options = {};
+		return {
+			name: "autoPlacement",
+			options,
+			async fn(state) {
+				var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+				const { rects, middlewareData, placement, platform, elements } = state;
+				const { crossAxis = false, alignment, allowedPlacements = require_floating_ui_utils.placements, autoAlignment = true,...detectOverflowOptions } = require_floating_ui_utils.evaluate(options, state);
+				const placements$1 = alignment !== void 0 || allowedPlacements === require_floating_ui_utils.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 = require_floating_ui_utils.getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
+				if (placement !== currentPlacement) return { reset: { placement: placements$1[0] } };
+				const currentOverflows = [
+					overflow[require_floating_ui_utils.getSide(currentPlacement)],
+					overflow[alignmentSides[0]],
+					overflow[alignmentSides[1]]
+				];
+				const allOverflows = [...((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || [], {
+					placement: currentPlacement,
+					overflows: currentOverflows
+				}];
+				const nextPlacement = placements$1[currentIndex + 1];
+				if (nextPlacement) return {
+					data: {
+						index: currentIndex + 1,
+						overflows: allOverflows
+					},
+					reset: { placement: nextPlacement }
+				};
+				const placementsSortedByMostSpace = allOverflows.map((d) => {
+					const alignment$1 = require_floating_ui_utils.getAlignment(d.placement);
+					return [
+						d.placement,
+						alignment$1 && crossAxis ? d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) : d.overflows[0],
+						d.overflows
+					];
+				}).sort((a, b) => a[1] - b[1]);
+				const resetPlacement = ((_placementsThatFitOnE = placementsSortedByMostSpace.filter((d) => d[2].slice(0, require_floating_ui_utils.getAlignment(d[0]) ? 2 : 3).every((v) => v <= 0))[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+				if (resetPlacement !== placement) return {
+					data: {
+						index: currentIndex + 1,
+						overflows: allOverflows
+					},
+					reset: { placement: resetPlacement }
+				};
+				return {};
+			}
+		};
+	};
+	flip = 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 } = require_floating_ui_utils.evaluate(options, state);
+				if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+				const side = require_floating_ui_utils.getSide(placement);
+				const initialSideAxis = require_floating_ui_utils.getSideAxis(initialPlacement);
+				const isBasePlacement = require_floating_ui_utils.getSide(initialPlacement) === initialPlacement;
+				const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+				const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [require_floating_ui_utils.getOppositePlacement(initialPlacement)] : require_floating_ui_utils.getExpandedPlacements(initialPlacement));
+				const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+				if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...require_floating_ui_utils.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+				const placements$1 = [initialPlacement, ...fallbackPlacements];
+				const overflow = await 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$1 = require_floating_ui_utils.getAlignmentSides(placement, rects, rtl);
+					overflows.push(overflow[sides$1[0]], overflow[sides$1[1]]);
+				}
+				overflowsData = [...overflowsData, {
+					placement,
+					overflows
+				}];
+				if (!overflows.every((side$1) => side$1 <= 0)) {
+					var _middlewareData$flip2, _overflowsData$filter;
+					const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+					const nextPlacement = placements$1[nextIndex];
+					if (nextPlacement) {
+						if (!(checkCrossAxis === "alignment" ? initialSideAxis !== require_floating_ui_utils.getSideAxis(nextPlacement) : false) || overflowsData.every((d) => require_floating_ui_utils.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$1 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+								if (hasFallbackAxisSideDirection) {
+									const currentSideAxis = require_floating_ui_utils.getSideAxis(d.placement);
+									return currentSideAxis === initialSideAxis || currentSideAxis === "y";
+								}
+								return true;
+							}).map((d) => [d.placement, d.overflows.filter((overflow$1) => overflow$1 > 0).reduce((acc, overflow$1) => acc + overflow$1, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+							if (placement$1) resetPlacement = placement$1;
+							break;
+						}
+						case "initialPlacement":
+							resetPlacement = initialPlacement;
+							break;
+					}
+					if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
+				}
+				return {};
+			}
+		};
+	};
+	hide = function(options) {
+		if (options === void 0) options = {};
+		return {
+			name: "hide",
+			options,
+			async fn(state) {
+				const { rects } = state;
+				const { strategy = "referenceHidden",...detectOverflowOptions } = require_floating_ui_utils.evaluate(options, state);
+				switch (strategy) {
+					case "referenceHidden": {
+						const offsets = getSideOffsets(await detectOverflow(state, {
+							...detectOverflowOptions,
+							elementContext: "reference"
+						}), rects.reference);
+						return { data: {
+							referenceHiddenOffsets: offsets,
+							referenceHidden: isAnySideFullyClipped(offsets)
+						} };
+					}
+					case "escaped": {
+						const offsets = getSideOffsets(await detectOverflow(state, {
+							...detectOverflowOptions,
+							altBoundary: true
+						}), rects.floating);
+						return { data: {
+							escapedOffsets: offsets,
+							escaped: isAnySideFullyClipped(offsets)
+						} };
+					}
+					default: return {};
+				}
+			}
+		};
+	};
+	inline = function(options) {
+		if (options === void 0) options = {};
+		return {
+			name: "inline",
+			options,
+			async fn(state) {
+				const { placement, elements, rects, platform, strategy } = state;
+				const { padding = 2, x, y } = require_floating_ui_utils.evaluate(options, state);
+				const nativeClientRects = Array.from(await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference)) || []);
+				const clientRects = getRectsByLine(nativeClientRects);
+				const fallback = require_floating_ui_utils.rectToClientRect(getBoundingRect(nativeClientRects));
+				const paddingObject = require_floating_ui_utils.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) {
+						if (require_floating_ui_utils.getSideAxis(placement) === "y") {
+							const firstRect = clientRects[0];
+							const lastRect = clientRects[clientRects.length - 1];
+							const isTop = require_floating_ui_utils.getSide(placement) === "top";
+							const top$1 = firstRect.top;
+							const bottom$1 = lastRect.bottom;
+							const left$1 = isTop ? firstRect.left : lastRect.left;
+							const right$1 = isTop ? firstRect.right : lastRect.right;
+							return {
+								top: top$1,
+								bottom: bottom$1,
+								left: left$1,
+								right: right$1,
+								width: right$1 - left$1,
+								height: bottom$1 - top$1,
+								x: left$1,
+								y: top$1
+							};
+						}
+						const isLeftSide = require_floating_ui_utils.getSide(placement) === "left";
+						const maxRight = require_floating_ui_utils.max(...clientRects.map((rect) => rect.right));
+						const minLeft = require_floating_ui_utils.min(...clientRects.map((rect) => rect.left));
+						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 fallback;
+				}
+				const resetRects = await platform.getElementRects({
+					reference: { getBoundingClientRect },
+					floating: elements.floating,
+					strategy
+				});
+				if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) return { reset: { rects: resetRects } };
+				return {};
+			}
+		};
+	};
+	originSides = /* @__PURE__ */ new Set(["left", "top"]);
+	offset = 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
+					}
+				};
+			}
+		};
+	};
+	shift = function(options) {
+		if (options === void 0) options = {};
+		return {
+			name: "shift",
+			options,
+			async fn(state) {
+				const { x, y, placement } = state;
+				const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
+					let { x: x$1, y: y$1 } = _ref;
+					return {
+						x: x$1,
+						y: y$1
+					};
+				} },...detectOverflowOptions } = require_floating_ui_utils.evaluate(options, state);
+				const coords = {
+					x,
+					y
+				};
+				const overflow = await detectOverflow(state, detectOverflowOptions);
+				const crossAxis = require_floating_ui_utils.getSideAxis(require_floating_ui_utils.getSide(placement));
+				const mainAxis = require_floating_ui_utils.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$1 = mainAxisCoord + overflow[minSide];
+					const max$1 = mainAxisCoord - overflow[maxSide];
+					mainAxisCoord = require_floating_ui_utils.clamp(min$1, mainAxisCoord, max$1);
+				}
+				if (checkCrossAxis) {
+					const minSide = crossAxis === "y" ? "top" : "left";
+					const maxSide = crossAxis === "y" ? "bottom" : "right";
+					const min$1 = crossAxisCoord + overflow[minSide];
+					const max$1 = crossAxisCoord - overflow[maxSide];
+					crossAxisCoord = require_floating_ui_utils.clamp(min$1, crossAxisCoord, max$1);
+				}
+				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
+						}
+					}
+				};
+			}
+		};
+	};
+	limitShift = function(options) {
+		if (options === void 0) options = {};
+		return {
+			options,
+			fn(state) {
+				const { x, y, placement, rects, middlewareData } = state;
+				const { offset: offset$1 = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = require_floating_ui_utils.evaluate(options, state);
+				const coords = {
+					x,
+					y
+				};
+				const crossAxis = require_floating_ui_utils.getSideAxis(placement);
+				const mainAxis = require_floating_ui_utils.getOppositeAxis(crossAxis);
+				let mainAxisCoord = coords[mainAxis];
+				let crossAxisCoord = coords[crossAxis];
+				const rawOffset = require_floating_ui_utils.evaluate(offset$1, state);
+				const computedOffset = typeof rawOffset === "number" ? {
+					mainAxis: rawOffset,
+					crossAxis: 0
+				} : {
+					mainAxis: 0,
+					crossAxis: 0,
+					...rawOffset
+				};
+				if (checkMainAxis) {
+					const len = mainAxis === "y" ? "height" : "width";
+					const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+					const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+					if (mainAxisCoord < limitMin) mainAxisCoord = limitMin;
+					else if (mainAxisCoord > limitMax) mainAxisCoord = limitMax;
+				}
+				if (checkCrossAxis) {
+					var _middlewareData$offse, _middlewareData$offse2;
+					const len = mainAxis === "y" ? "width" : "height";
+					const isOriginSide = originSides.has(require_floating_ui_utils.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
+				};
+			}
+		};
+	};
+	size = function(options) {
+		if (options === void 0) options = {};
+		return {
+			name: "size",
+			options,
+			async fn(state) {
+				var _state$middlewareData, _state$middlewareData2;
+				const { placement, rects, platform, elements } = state;
+				const { apply = () => {},...detectOverflowOptions } = require_floating_ui_utils.evaluate(options, state);
+				const overflow = await detectOverflow(state, detectOverflowOptions);
+				const side = require_floating_ui_utils.getSide(placement);
+				const alignment = require_floating_ui_utils.getAlignment(placement);
+				const isYAxis = require_floating_ui_utils.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 = require_floating_ui_utils.min(height - overflow[heightSide], maximumClippingHeight);
+				const overflowAvailableWidth = require_floating_ui_utils.min(width - overflow[widthSide], maximumClippingWidth);
+				const noShift = !state.middlewareData.shift;
+				let availableHeight = overflowAvailableHeight;
+				let availableWidth = overflowAvailableWidth;
+				if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
+				if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
+				if (noShift && !alignment) {
+					const xMin = require_floating_ui_utils.max(overflow.left, 0);
+					const xMax = require_floating_ui_utils.max(overflow.right, 0);
+					const yMin = require_floating_ui_utils.max(overflow.top, 0);
+					const yMax = require_floating_ui_utils.max(overflow.bottom, 0);
+					if (isYAxis) availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : require_floating_ui_utils.max(overflow.left, overflow.right));
+					else availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : require_floating_ui_utils.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
+init_floating_ui_core();
+exports.arrow = arrow;
+exports.autoPlacement = autoPlacement;
+exports.computePosition = computePosition;
+exports.detectOverflow = detectOverflow;
+exports.flip = flip;
+exports.hide = hide;
+Object.defineProperty(exports, 'init_floating_ui_core', {
+  enumerable: true,
+  get: function () {
+    return init_floating_ui_core;
+  }
+});
+exports.inline = inline;
+exports.limitShift = limitShift;
+exports.offset = offset;
+exports.shift = shift;
+exports.size = size;