@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.js

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