@manafishrov/ui 1.4.4 → 1.4.6

package/dist/node_modules/.bun/@floating-ui_core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -1,533 +1,361 @@
-import { evaluate as L, getSide as j, getSideAxis as T, getOppositePlacement as Z, getExpandedPlacements as ee, getOppositeAxisPlacements as te, getAlignmentSides as ne, clamp as $, getPaddingObject as U, getAlignmentAxis as q, getAlignment as _, min as Y, max as B, getOppositeAxis as G, getAxisLength as J, sides as ie, rectToClientRect as z } from "../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
-function X(t, e, d) {
-  let {
-    reference: a,
-    floating: m
-  } = t;
-  const n = T(e), i = q(e), l = J(i), g = j(e), p = n === "y", r = a.x + a.width / 2 - m.width / 2, o = a.y + a.height / 2 - m.height / 2, f = a[l] / 2 - m[l] / 2;
-  let s;
-  switch (g) {
-    case "top":
-      s = {
-        x: r,
-        y: a.y - m.height
-      };
-      break;
-    case "bottom":
-      s = {
-        x: r,
-        y: a.y + a.height
-      };
-      break;
-    case "right":
-      s = {
-        x: a.x + a.width,
-        y: o
-      };
-      break;
-    case "left":
-      s = {
-        x: a.x - m.width,
-        y: o
-      };
-      break;
-    default:
-      s = {
-        x: a.x,
-        y: a.y
-      };
-  }
-  switch (_(e)) {
-    case "start":
-      s[i] -= f * (d && p ? -1 : 1);
-      break;
-    case "end":
-      s[i] += f * (d && p ? -1 : 1);
-      break;
-  }
-  return s;
+import { clamp as e, evaluate as t, getAlignment as n, getAlignmentAxis as r, getAlignmentSides as i, getAxisLength as a, getExpandedPlacements as o, getOppositeAxis as s, getOppositeAxisPlacements as c, getOppositePlacement as l, getPaddingObject as u, getSide as d, getSideAxis as f, max as p, min as m, rectToClientRect as h, sides as g } from "../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+//#region ../../node_modules/.bun/@floating-ui+core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function _(e, t, i) {
+	let { reference: o, floating: s } = e, c = f(t), l = r(t), u = a(l), p = d(t), m = c === "y", h = o.x + o.width / 2 - s.width / 2, g = o.y + o.height / 2 - s.height / 2, _ = o[u] / 2 - s[u] / 2, v;
+	switch (p) {
+		case "top":
+			v = {
+				x: h,
+				y: o.y - s.height
+			};
+			break;
+		case "bottom":
+			v = {
+				x: h,
+				y: o.y + o.height
+			};
+			break;
+		case "right":
+			v = {
+				x: o.x + o.width,
+				y: g
+			};
+			break;
+		case "left":
+			v = {
+				x: o.x - s.width,
+				y: g
+			};
+			break;
+		default: v = {
+			x: o.x,
+			y: o.y
+		};
+	}
+	switch (n(t)) {
+		case "start":
+			v[l] -= _ * (i && m ? -1 : 1);
+			break;
+		case "end":
+			v[l] += _ * (i && m ? -1 : 1);
+			break;
+	}
+	return v;
 }
-async function se(t, e) {
-  var d;
-  e === void 0 && (e = {});
-  const {
-    x: a,
-    y: m,
-    platform: n,
-    rects: i,
-    elements: l,
-    strategy: g
-  } = t, {
-    boundary: p = "clippingAncestors",
-    rootBoundary: r = "viewport",
-    elementContext: o = "floating",
-    altBoundary: f = !1,
-    padding: s = 0
-  } = L(e, t), c = U(s), h = l[f ? o === "floating" ? "reference" : "floating" : o], v = z(await n.getClippingRect({
-    element: (d = await (n.isElement == null ? void 0 : n.isElement(h))) == null || d ? h : h.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(l.floating)),
-    boundary: p,
-    rootBoundary: r,
-    strategy: g
-  })), A = o === "floating" ? {
-    x: a,
-    y: m,
-    width: i.floating.width,
-    height: i.floating.height
-  } : i.reference, u = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(l.floating)), w = await (n.isElement == null ? void 0 : n.isElement(u)) ? await (n.getScale == null ? void 0 : n.getScale(u)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, y = z(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: l,
-    rect: A,
-    offsetParent: u,
-    strategy: g
-  }) : A);
-  return {
-    top: (v.top - y.top + c.top) / w.y,
-    bottom: (y.bottom - v.bottom + c.bottom) / w.y,
-    left: (v.left - y.left + c.left) / w.x,
-    right: (y.right - v.right + c.right) / w.x
-  };
+async function v(e, n) {
+	n === void 0 && (n = {});
+	let { x: r, y: i, platform: a, rects: o, elements: s, strategy: c } = e, { boundary: l = "clippingAncestors", rootBoundary: d = "viewport", elementContext: f = "floating", altBoundary: p = !1, padding: m = 0 } = t(n, e), g = u(m), _ = s[p ? f === "floating" ? "reference" : "floating" : f], v = h(await a.getClippingRect({
+		element: await (a.isElement == null ? void 0 : a.isElement(_)) ?? !0 ? _ : _.contextElement || await (a.getDocumentElement == null ? void 0 : a.getDocumentElement(s.floating)),
+		boundary: l,
+		rootBoundary: d,
+		strategy: c
+	})), y = f === "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 = h(a.convertOffsetParentRelativeRectToViewportRelativeRect ? await a.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements: s,
+		rect: y,
+		offsetParent: b,
+		strategy: c
+	}) : y);
+	return {
+		top: (v.top - S.top + g.top) / x.y,
+		bottom: (S.bottom - v.bottom + g.bottom) / x.y,
+		left: (v.left - S.left + g.left) / x.x,
+		right: (S.right - v.right + g.right) / x.x
+	};
 }
-const oe = 50, le = async (t, e, d) => {
-  const {
-    placement: a = "bottom",
-    strategy: m = "absolute",
-    middleware: n = [],
-    platform: i
-  } = d, l = i.detectOverflow ? i : {
-    ...i,
-    detectOverflow: se
-  }, g = await (i.isRTL == null ? void 0 : i.isRTL(e));
-  let p = await i.getElementRects({
-    reference: t,
-    floating: e,
-    strategy: m
-  }), {
-    x: r,
-    y: o
-  } = X(p, a, g), f = a, s = 0;
-  const c = {};
-  for (let x = 0; x < n.length; x++) {
-    const h = n[x];
-    if (!h)
-      continue;
-    const {
-      name: v,
-      fn: A
-    } = h, {
-      x: u,
-      y: w,
-      data: y,
-      reset: b
-    } = await A({
-      x: r,
-      y: o,
-      initialPlacement: a,
-      placement: f,
-      strategy: m,
-      middlewareData: c,
-      rects: p,
-      platform: l,
-      elements: {
-        reference: t,
-        floating: e
-      }
-    });
-    r = u ?? r, o = w ?? o, c[v] = {
-      ...c[v],
-      ...y
-    }, b && s < oe && (s++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (p = b.rects === !0 ? await i.getElementRects({
-      reference: t,
-      floating: e,
-      strategy: m
-    }) : b.rects), {
-      x: r,
-      y: o
-    } = X(p, f, g)), x = -1);
-  }
-  return {
-    x: r,
-    y: o,
-    placement: f,
-    strategy: m,
-    middlewareData: c
-  };
-}, re = (t) => ({
-  name: "arrow",
-  options: t,
-  async fn(e) {
-    const {
-      x: d,
-      y: a,
-      placement: m,
-      rects: n,
-      platform: i,
-      elements: l,
-      middlewareData: g
-    } = e, {
-      element: p,
-      padding: r = 0
-    } = L(t, e) || {};
-    if (p == null)
-      return {};
-    const o = U(r), f = {
-      x: d,
-      y: a
-    }, s = q(m), c = J(s), x = await i.getDimensions(p), h = s === "y", v = h ? "top" : "left", A = h ? "bottom" : "right", u = h ? "clientHeight" : "clientWidth", w = n.reference[c] + n.reference[s] - f[s] - n.floating[c], y = f[s] - n.reference[s], b = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(p));
-    let C = b ? b[u] : 0;
-    (!C || !await (i.isElement == null ? void 0 : i.isElement(b))) && (C = l.floating[u] || n.floating[c]);
-    const E = w / 2 - y / 2, D = C / 2 - x[c] / 2 - 1, P = Y(o[v], D), H = Y(o[A], D), k = P, F = C - x[c] - H, O = C / 2 - x[c] / 2 + E, W = $(k, O, F), M = !g.arrow && _(m) != null && O !== W && n.reference[c] / 2 - (O < k ? P : H) - x[c] / 2 < 0, S = M ? O < k ? O - k : O - F : 0;
-    return {
-      [s]: f[s] + S,
-      data: {
-        [s]: W,
-        centerOffset: O - W - S,
-        ...M && {
-          alignmentOffset: S
-        }
-      },
-      reset: M
-    };
-  }
-}), fe = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "flip",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        placement: m,
-        middlewareData: n,
-        rects: i,
-        initialPlacement: l,
-        platform: g,
-        elements: p
-      } = e, {
-        mainAxis: r = !0,
-        crossAxis: o = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: s = "bestFit",
-        fallbackAxisSideDirection: c = "none",
-        flipAlignment: x = !0,
-        ...h
-      } = L(t, e);
-      if ((d = n.arrow) != null && d.alignmentOffset)
-        return {};
-      const v = j(m), A = T(l), u = j(l) === l, w = await (g.isRTL == null ? void 0 : g.isRTL(p.floating)), y = f || (u || !x ? [Z(l)] : ee(l)), b = c !== "none";
-      !f && b && y.push(...te(l, x, c, w));
-      const C = [l, ...y], E = await g.detectOverflow(e, h), D = [];
-      let P = ((a = n.flip) == null ? void 0 : a.overflows) || [];
-      if (r && D.push(E[v]), o) {
-        const O = ne(m, i, w);
-        D.push(E[O[0]], E[O[1]]);
-      }
-      if (P = [...P, {
-        placement: m,
-        overflows: D
-      }], !D.every((O) => O <= 0)) {
-        var H, k;
-        const O = (((H = n.flip) == null ? void 0 : H.index) || 0) + 1, W = C[O];
-        if (W && (!(o === "alignment" ? A !== T(W) : !1) || // We leave the current main axis only if every placement on that axis
-        // overflows the main axis.
-        P.every((R) => T(R.placement) === A ? R.overflows[0] > 0 : !0)))
-          return {
-            data: {
-              index: O,
-              overflows: P
-            },
-            reset: {
-              placement: W
-            }
-          };
-        let M = (k = P.filter((S) => S.overflows[0] <= 0).sort((S, R) => S.overflows[1] - R.overflows[1])[0]) == null ? void 0 : k.placement;
-        if (!M)
-          switch (s) {
-            case "bestFit": {
-              var F;
-              const S = (F = P.filter((R) => {
-                if (b) {
-                  const V = T(R.placement);
-                  return V === A || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  V === "y";
-                }
-                return !0;
-              }).map((R) => [R.placement, R.overflows.filter((V) => V > 0).reduce((V, Q) => V + Q, 0)]).sort((R, V) => R[1] - V[1])[0]) == null ? void 0 : F[0];
-              S && (M = S);
-              break;
-            }
-            case "initialPlacement":
-              M = l;
-              break;
-          }
-        if (m !== M)
-          return {
-            reset: {
-              placement: M
-            }
-          };
-      }
-      return {};
-    }
-  };
+var y = 50, b = async (e, t, n) => {
+	let { placement: r = "bottom", strategy: i = "absolute", middleware: a = [], platform: o } = n, s = o.detectOverflow ? o : {
+		...o,
+		detectOverflow: v
+	}, c = await (o.isRTL == null ? void 0 : o.isRTL(t)), l = await o.getElementRects({
+		reference: e,
+		floating: t,
+		strategy: i
+	}), { x: u, y: d } = _(l, r, c), f = r, p = 0, m = {};
+	for (let n = 0; n < a.length; n++) {
+		let h = a[n];
+		if (!h) continue;
+		let { name: g, fn: v } = h, { x: b, y: x, data: S, reset: C } = await v({
+			x: u,
+			y: d,
+			initialPlacement: r,
+			placement: f,
+			strategy: i,
+			middlewareData: m,
+			rects: l,
+			platform: s,
+			elements: {
+				reference: e,
+				floating: t
+			}
+		});
+		u = b ?? u, d = x ?? d, m[g] = {
+			...m[g],
+			...S
+		}, C && p < y && (p++, typeof C == "object" && (C.placement && (f = C.placement), C.rects && (l = C.rects === !0 ? await o.getElementRects({
+			reference: e,
+			floating: t,
+			strategy: i
+		}) : C.rects), {x: u, y: d} = _(l, f, c)), n = -1);
+	}
+	return {
+		x: u,
+		y: d,
+		placement: f,
+		strategy: i,
+		middlewareData: m
+	};
+}, x = (i) => ({
+	name: "arrow",
+	options: i,
+	async fn(o) {
+		let { x: s, y: c, placement: l, rects: d, platform: f, elements: p, middlewareData: h } = o, { element: g, padding: _ = 0 } = t(i, o) || {};
+		if (g == null) return {};
+		let v = u(_), y = {
+			x: s,
+			y: c
+		}, b = r(l), x = a(b), S = await f.getDimensions(g), C = b === "y", w = C ? "top" : "left", T = C ? "bottom" : "right", E = C ? "clientHeight" : "clientWidth", D = d.reference[x] + d.reference[b] - y[b] - d.floating[x], O = y[b] - d.reference[b], k = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(g)), A = k ? k[E] : 0;
+		(!A || !await (f.isElement == null ? void 0 : f.isElement(k))) && (A = p.floating[E] || d.floating[x]);
+		let j = D / 2 - O / 2, M = A / 2 - S[x] / 2 - 1, N = m(v[w], M), P = m(v[T], M), F = N, I = A - S[x] - P, L = A / 2 - S[x] / 2 + j, R = e(F, L, I), z = !h.arrow && n(l) != null && L !== R && d.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
+		};
+	}
+}), S = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "flip",
+		options: e,
+		async fn(n) {
+			var r;
+			let { placement: a, middlewareData: s, rects: u, initialPlacement: p, platform: m, elements: h } = n, { mainAxis: g = !0, crossAxis: _ = !0, fallbackPlacements: v, fallbackStrategy: y = "bestFit", fallbackAxisSideDirection: b = "none", flipAlignment: x = !0, ...S } = t(e, n);
+			if ((r = s.arrow) != null && r.alignmentOffset) return {};
+			let C = d(a), w = f(p), T = d(p) === p, E = await (m.isRTL == null ? void 0 : m.isRTL(h.floating)), D = v || (T || !x ? [l(p)] : o(p)), O = b !== "none";
+			!v && O && D.push(...c(p, x, b, E));
+			let k = [p, ...D], A = await m.detectOverflow(n, S), j = [], M = s.flip?.overflows || [];
+			if (g && j.push(A[C]), _) {
+				let e = i(a, u, E);
+				j.push(A[e[0]], A[e[1]]);
+			}
+			if (M = [...M, {
+				placement: a,
+				overflows: j
+			}], !j.every((e) => e <= 0)) {
+				let e = (s.flip?.index || 0) + 1, t = k[e];
+				if (t && (!(_ === "alignment" && w !== f(t)) || M.every((e) => f(e.placement) === w ? e.overflows[0] > 0 : !0))) return {
+					data: {
+						index: e,
+						overflows: M
+					},
+					reset: { placement: t }
+				};
+				let n = M.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 = M.filter((e) => {
+							if (O) {
+								let t = f(e.placement);
+								return t === w || 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 = p;
+						break;
+				}
+				if (a !== n) return { reset: { placement: n } };
+			}
+			return {};
+		}
+	};
 };
-function I(t, e) {
-  return {
-    top: t.top - e.height,
-    right: t.right - e.width,
-    bottom: t.bottom - e.height,
-    left: t.left - e.width
-  };
+function C(e, t) {
+	return {
+		top: e.top - t.height,
+		right: e.right - t.width,
+		bottom: e.bottom - t.height,
+		left: e.left - t.width
+	};
 }
-function N(t) {
-  return ie.some((e) => t[e] >= 0);
+function w(e) {
+	return g.some((t) => e[t] >= 0);
 }
-const me = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "hide",
-    options: t,
-    async fn(e) {
-      const {
-        rects: d,
-        platform: a
-      } = e, {
-        strategy: m = "referenceHidden",
-        ...n
-      } = L(t, e);
-      switch (m) {
-        case "referenceHidden": {
-          const i = await a.detectOverflow(e, {
-            ...n,
-            elementContext: "reference"
-          }), l = I(i, d.reference);
-          return {
-            data: {
-              referenceHiddenOffsets: l,
-              referenceHidden: N(l)
-            }
-          };
-        }
-        case "escaped": {
-          const i = await a.detectOverflow(e, {
-            ...n,
-            altBoundary: !0
-          }), l = I(i, d.floating);
-          return {
-            data: {
-              escapedOffsets: l,
-              escaped: N(l)
-            }
-          };
-        }
-        default:
-          return {};
-      }
-    }
-  };
-}, K = /* @__PURE__ */ new Set(["left", "top"]);
-async function ce(t, e) {
-  const {
-    placement: d,
-    platform: a,
-    elements: m
-  } = t, n = await (a.isRTL == null ? void 0 : a.isRTL(m.floating)), i = j(d), l = _(d), g = T(d) === "y", p = K.has(i) ? -1 : 1, r = n && g ? -1 : 1, o = L(e, t);
-  let {
-    mainAxis: f,
-    crossAxis: s,
-    alignmentAxis: c
-  } = typeof o == "number" ? {
-    mainAxis: o,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: o.mainAxis || 0,
-    crossAxis: o.crossAxis || 0,
-    alignmentAxis: o.alignmentAxis
-  };
-  return l && typeof c == "number" && (s = l === "end" ? c * -1 : c), g ? {
-    x: s * r,
-    y: f * p
-  } : {
-    x: f * p,
-    y: s * r
-  };
+var T = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "hide",
+		options: e,
+		async fn(n) {
+			let { rects: r, platform: i } = n, { strategy: a = "referenceHidden", ...o } = t(e, n);
+			switch (a) {
+				case "referenceHidden": {
+					let e = C(await i.detectOverflow(n, {
+						...o,
+						elementContext: "reference"
+					}), r.reference);
+					return { data: {
+						referenceHiddenOffsets: e,
+						referenceHidden: w(e)
+					} };
+				}
+				case "escaped": {
+					let e = C(await i.detectOverflow(n, {
+						...o,
+						altBoundary: !0
+					}), r.floating);
+					return { data: {
+						escapedOffsets: e,
+						escaped: w(e)
+					} };
+				}
+				default: return {};
+			}
+		}
+	};
+}, E = /* @__PURE__ */ new Set(["left", "top"]);
+async function D(e, r) {
+	let { placement: i, platform: a, elements: o } = e, s = await (a.isRTL == null ? void 0 : a.isRTL(o.floating)), c = d(i), l = n(i), u = f(i) === "y", p = E.has(c) ? -1 : 1, m = s && u ? -1 : 1, h = t(r, 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: _ * m,
+		y: g * p
+	} : {
+		x: g * p,
+		y: _ * m
+	};
 }
-const de = function(t) {
-  return t === void 0 && (t = 0), {
-    name: "offset",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        x: m,
-        y: n,
-        placement: i,
-        middlewareData: l
-      } = e, g = await ce(e, t);
-      return i === ((d = l.offset) == null ? void 0 : d.placement) && (a = l.arrow) != null && a.alignmentOffset ? {} : {
-        x: m + g.x,
-        y: n + g.y,
-        data: {
-          ...g,
-          placement: i
-        }
-      };
-    }
-  };
-}, xe = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "shift",
-    options: t,
-    async fn(e) {
-      const {
-        x: d,
-        y: a,
-        placement: m,
-        platform: n
-      } = e, {
-        mainAxis: i = !0,
-        crossAxis: l = !1,
-        limiter: g = {
-          fn: (v) => {
-            let {
-              x: A,
-              y: u
-            } = v;
-            return {
-              x: A,
-              y: u
-            };
-          }
-        },
-        ...p
-      } = L(t, e), r = {
-        x: d,
-        y: a
-      }, o = await n.detectOverflow(e, p), f = T(j(m)), s = G(f);
-      let c = r[s], x = r[f];
-      if (i) {
-        const v = s === "y" ? "top" : "left", A = s === "y" ? "bottom" : "right", u = c + o[v], w = c - o[A];
-        c = $(u, c, w);
-      }
-      if (l) {
-        const v = f === "y" ? "top" : "left", A = f === "y" ? "bottom" : "right", u = x + o[v], w = x - o[A];
-        x = $(u, x, w);
-      }
-      const h = g.fn({
-        ...e,
-        [s]: c,
-        [f]: x
-      });
-      return {
-        ...h,
-        data: {
-          x: h.x - d,
-          y: h.y - a,
-          enabled: {
-            [s]: i,
-            [f]: l
-          }
-        }
-      };
-    }
-  };
-}, ge = function(t) {
-  return t === void 0 && (t = {}), {
-    options: t,
-    fn(e) {
-      const {
-        x: d,
-        y: a,
-        placement: m,
-        rects: n,
-        middlewareData: i
-      } = e, {
-        offset: l = 0,
-        mainAxis: g = !0,
-        crossAxis: p = !0
-      } = L(t, e), r = {
-        x: d,
-        y: a
-      }, o = T(m), f = G(o);
-      let s = r[f], c = r[o];
-      const x = L(l, e), h = typeof x == "number" ? {
-        mainAxis: x,
-        crossAxis: 0
-      } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        ...x
-      };
-      if (g) {
-        const u = f === "y" ? "height" : "width", w = n.reference[f] - n.floating[u] + h.mainAxis, y = n.reference[f] + n.reference[u] - h.mainAxis;
-        s < w ? s = w : s > y && (s = y);
-      }
-      if (p) {
-        var v, A;
-        const u = f === "y" ? "width" : "height", w = K.has(j(m)), y = n.reference[o] - n.floating[u] + (w && ((v = i.offset) == null ? void 0 : v[o]) || 0) + (w ? 0 : h.crossAxis), b = n.reference[o] + n.reference[u] + (w ? 0 : ((A = i.offset) == null ? void 0 : A[o]) || 0) - (w ? h.crossAxis : 0);
-        c < y ? c = y : c > b && (c = b);
-      }
-      return {
-        [f]: s,
-        [o]: c
-      };
-    }
-  };
-}, ue = function(t) {
-  return t === void 0 && (t = {}), {
-    name: "size",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        placement: m,
-        rects: n,
-        platform: i,
-        elements: l
-      } = e, {
-        apply: g = () => {
-        },
-        ...p
-      } = L(t, e), r = await i.detectOverflow(e, p), o = j(m), f = _(m), s = T(m) === "y", {
-        width: c,
-        height: x
-      } = n.floating;
-      let h, v;
-      o === "top" || o === "bottom" ? (h = o, v = f === (await (i.isRTL == null ? void 0 : i.isRTL(l.floating)) ? "start" : "end") ? "left" : "right") : (v = o, h = f === "end" ? "top" : "bottom");
-      const A = x - r.top - r.bottom, u = c - r.left - r.right, w = Y(x - r[h], A), y = Y(c - r[v], u), b = !e.middlewareData.shift;
-      let C = w, E = y;
-      if ((d = e.middlewareData.shift) != null && d.enabled.x && (E = u), (a = e.middlewareData.shift) != null && a.enabled.y && (C = A), b && !f) {
-        const P = B(r.left, 0), H = B(r.right, 0), k = B(r.top, 0), F = B(r.bottom, 0);
-        s ? E = c - 2 * (P !== 0 || H !== 0 ? P + H : B(r.left, r.right)) : C = x - 2 * (k !== 0 || F !== 0 ? k + F : B(r.top, r.bottom));
-      }
-      await g({
-        ...e,
-        availableWidth: E,
-        availableHeight: C
-      });
-      const D = await i.getDimensions(l.floating);
-      return c !== D.width || x !== D.height ? {
-        reset: {
-          rects: !0
-        }
-      } : {};
-    }
-  };
+var O = 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 D(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
+				}
+			};
+		}
+	};
+}, k = function(n) {
+	return n === void 0 && (n = {}), {
+		name: "shift",
+		options: n,
+		async fn(r) {
+			let { x: i, y: a, placement: o, platform: c } = r, { mainAxis: l = !0, crossAxis: u = !1, limiter: p = { fn: (e) => {
+				let { x: t, y: n } = e;
+				return {
+					x: t,
+					y: n
+				};
+			} }, ...m } = t(n, r), h = {
+				x: i,
+				y: a
+			}, g = await c.detectOverflow(r, m), _ = f(d(o)), v = s(_), y = h[v], b = h[_];
+			if (l) {
+				let t = v === "y" ? "top" : "left", n = v === "y" ? "bottom" : "right", r = y + g[t], i = y - g[n];
+				y = e(r, y, i);
+			}
+			if (u) {
+				let t = _ === "y" ? "top" : "left", n = _ === "y" ? "bottom" : "right", r = b + g[t], i = b - g[n];
+				b = e(r, b, i);
+			}
+			let x = p.fn({
+				...r,
+				[v]: y,
+				[_]: b
+			});
+			return {
+				...x,
+				data: {
+					x: x.x - i,
+					y: x.y - a,
+					enabled: {
+						[v]: l,
+						[_]: u
+					}
+				}
+			};
+		}
+	};
+}, A = function(e) {
+	return e === void 0 && (e = {}), {
+		options: e,
+		fn(n) {
+			let { x: r, y: i, placement: a, rects: o, middlewareData: c } = n, { offset: l = 0, mainAxis: u = !0, crossAxis: p = !0 } = t(e, n), m = {
+				x: r,
+				y: i
+			}, h = f(a), g = s(h), _ = m[g], v = m[h], y = t(l, n), 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 (p) {
+				let e = g === "y" ? "width" : "height", t = E.has(d(a)), n = o.reference[h] - o.floating[e] + (t && c.offset?.[h] || 0) + (t ? 0 : b.crossAxis), r = o.reference[h] + o.reference[e] + (t ? 0 : c.offset?.[h] || 0) - (t ? b.crossAxis : 0);
+				v < n ? v = n : v > r && (v = r);
+			}
+			return {
+				[g]: _,
+				[h]: v
+			};
+		}
+	};
+}, j = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "size",
+		options: e,
+		async fn(r) {
+			var i, a;
+			let { placement: o, rects: s, platform: c, elements: l } = r, { apply: u = () => {}, ...h } = t(e, r), g = await c.detectOverflow(r, h), _ = d(o), v = n(o), y = f(o) === "y", { width: b, height: x } = s.floating, S, C;
+			_ === "top" || _ === "bottom" ? (S = _, C = v === (await (c.isRTL == null ? void 0 : c.isRTL(l.floating)) ? "start" : "end") ? "left" : "right") : (C = _, S = v === "end" ? "top" : "bottom");
+			let w = x - g.top - g.bottom, T = b - g.left - g.right, E = m(x - g[S], w), D = m(b - g[C], T), O = !r.middlewareData.shift, k = E, A = D;
+			if ((i = r.middlewareData.shift) != null && i.enabled.x && (A = T), (a = r.middlewareData.shift) != null && a.enabled.y && (k = w), O && !v) {
+				let e = p(g.left, 0), t = p(g.right, 0), n = p(g.top, 0), r = p(g.bottom, 0);
+				y ? A = b - 2 * (e !== 0 || t !== 0 ? e + t : p(g.left, g.right)) : k = x - 2 * (n !== 0 || r !== 0 ? n + r : p(g.top, g.bottom));
+			}
+			await u({
+				...r,
+				availableWidth: A,
+				availableHeight: k
+			});
+			let j = await c.getDimensions(l.floating);
+			return b !== j.width || x !== j.height ? { reset: { rects: !0 } } : {};
+		}
+	};
 };
-export {
-  re as arrow,
-  le as computePosition,
-  se as detectOverflow,
-  fe as flip,
-  me as hide,
-  ge as limitShift,
-  de as offset,
-  z as rectToClientRect,
-  xe as shift,
-  ue as size
-};
-//# sourceMappingURL=floating-ui.core.js.map
+//#endregion
+export { x as arrow, b as computePosition, S as flip, T as hide, A as limitShift, O as offset, k as shift, j as size };
+
+//# sourceMappingURL=floating-ui.core.js.map