@indielayer/ui 1.18.1 → 2.1.0

package/lib/node_modules/.pnpm/@floating-ui_core@1.5.3/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -1,497 +1,329 @@
-import { evaluate as V, getPaddingObject as X, getAlignmentAxis as q, clamp as W, getAlignment as M, placements as Y, getAlignmentSides as G, getSide as B, getOppositePlacement as N, getExpandedPlacements as Q, getOppositeAxisPlacements as U, getSideAxis as j, max as $, rectToClientRect as z, getAxisLength as J, min as _, getOppositeAlignmentPlacement as Z, getOppositeAxis as ee } from "../../../../../@floating-ui_utils@0.2.1/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
-function I(e, i, c) {
-  let {
-    reference: o,
-    floating: n
-  } = e;
-  const s = j(i), m = q(i), d = J(m), l = B(i), g = s === "y", u = o.x + o.width / 2 - n.width / 2, r = o.y + o.height / 2 - n.height / 2, f = o[d] / 2 - n[d] / 2;
-  let t;
-  switch (l) {
-    case "top":
-      t = {
-        x: u,
-        y: o.y - n.height
-      };
-      break;
-    case "bottom":
-      t = {
-        x: u,
-        y: o.y + o.height
-      };
-      break;
-    case "right":
-      t = {
-        x: o.x + o.width,
-        y: r
-      };
-      break;
-    case "left":
-      t = {
-        x: o.x - n.width,
-        y: r
-      };
-      break;
-    default:
-      t = {
-        x: o.x,
-        y: o.y
-      };
-  }
-  switch (M(i)) {
-    case "start":
-      t[m] -= f * (c && g ? -1 : 1);
-      break;
-    case "end":
-      t[m] += f * (c && g ? -1 : 1);
-      break;
-  }
-  return t;
+import { clamp as e, evaluate as t, getAlignment as n, getAlignmentAxis as r, getAlignmentSides as i, getAxisLength as a, getExpandedPlacements as o, getOppositeAlignmentPlacement as s, getOppositeAxis as c, getOppositeAxisPlacements as l, getOppositePlacement as u, getPaddingObject as d, getSide as f, getSideAxis as p, max as m, min as h, placements as g, rectToClientRect as _ } from "../../../../../@floating-ui_utils@0.2.1/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+//#region ../../node_modules/.pnpm/@floating-ui+core@1.5.3/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function v(e, t, i) {
+	let { reference: o, floating: s } = e, c = p(t), l = r(t), u = a(l), d = f(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 (d) {
+		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;
 }
-const oe = async (e, i, c) => {
-  const {
-    placement: o = "bottom",
-    strategy: n = "absolute",
-    middleware: s = [],
-    platform: m
-  } = c, d = s.filter(Boolean), l = await (m.isRTL == null ? void 0 : m.isRTL(i));
-  let g = await m.getElementRects({
-    reference: e,
-    floating: i,
-    strategy: n
-  }), {
-    x: u,
-    y: r
-  } = I(g, o, l), f = o, t = {}, a = 0;
-  for (let x = 0; x < d.length; x++) {
-    const {
-      name: w,
-      fn: v
-    } = d[x], {
-      x: p,
-      y: h,
-      data: P,
-      reset: y
-    } = await v({
-      x: u,
-      y: r,
-      initialPlacement: o,
-      placement: f,
-      strategy: n,
-      middlewareData: t,
-      rects: g,
-      platform: m,
-      elements: {
-        reference: e,
-        floating: i
-      }
-    });
-    if (u = p ?? u, r = h ?? r, t = {
-      ...t,
-      [w]: {
-        ...t[w],
-        ...P
-      }
-    }, y && a <= 50) {
-      a++, typeof y == "object" && (y.placement && (f = y.placement), y.rects && (g = y.rects === !0 ? await m.getElementRects({
-        reference: e,
-        floating: i,
-        strategy: n
-      }) : y.rects), {
-        x: u,
-        y: r
-      } = I(g, f, l)), x = -1;
-      continue;
-    }
-  }
-  return {
-    x: u,
-    y: r,
-    placement: f,
-    strategy: n,
-    middlewareData: t
-  };
+var y = 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 } = v(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: y, reset: b } = await h({
+			x: u,
+			y: d,
+			initialPlacement: r,
+			placement: f,
+			strategy: i,
+			middlewareData: p,
+			rects: l,
+			platform: o,
+			elements: {
+				reference: e,
+				floating: t
+			}
+		});
+		if (u = g ?? u, d = _ ?? d, p = {
+			...p,
+			[a]: {
+				...p[a],
+				...y
+			}
+		}, b && m <= 50) {
+			m++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (l = b.rects === !0 ? await o.getElementRects({
+				reference: e,
+				floating: t,
+				strategy: i
+			}) : b.rects), {x: u, y: d} = v(l, f, c)), n = -1;
+			continue;
+		}
+	}
+	return {
+		x: u,
+		y: d,
+		placement: f,
+		strategy: i,
+		middlewareData: p
+	};
 };
-async function H(e, i) {
-  var c;
-  i === void 0 && (i = {});
-  const {
-    x: o,
-    y: n,
-    platform: s,
-    rects: m,
-    elements: d,
-    strategy: l
-  } = e, {
-    boundary: g = "clippingAncestors",
-    rootBoundary: u = "viewport",
-    elementContext: r = "floating",
-    altBoundary: f = !1,
-    padding: t = 0
-  } = V(i, e), a = X(t), w = d[f ? r === "floating" ? "reference" : "floating" : r], v = z(await s.getClippingRect({
-    element: (c = await (s.isElement == null ? void 0 : s.isElement(w))) == null || c ? w : w.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(d.floating)),
-    boundary: g,
-    rootBoundary: u,
-    strategy: l
-  })), p = r === "floating" ? {
-    ...m.floating,
-    x: o,
-    y: n
-  } : m.reference, h = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(d.floating)), P = await (s.isElement == null ? void 0 : s.isElement(h)) ? await (s.getScale == null ? void 0 : s.getScale(h)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, y = z(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
-    rect: p,
-    offsetParent: h,
-    strategy: l
-  }) : p);
-  return {
-    top: (v.top - y.top + a.top) / P.y,
-    bottom: (y.bottom - v.bottom + a.bottom) / P.y,
-    left: (v.left - y.left + a.left) / P.x,
-    right: (y.right - v.right + a.right) / P.x
-  };
+async function b(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: f = "floating", altBoundary: p = !1, padding: m = 0 } = t(n, e), h = d(m), g = s[p ? f === "floating" ? "reference" : "floating" : f], v = _(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
+	})), y = f === "floating" ? {
+		...o.floating,
+		x: r,
+		y: i
+	} : 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 = _(a.convertOffsetParentRelativeRectToViewportRelativeRect ? await a.convertOffsetParentRelativeRectToViewportRelativeRect({
+		rect: y,
+		offsetParent: b,
+		strategy: c
+	}) : y);
+	return {
+		top: (v.top - S.top + h.top) / x.y,
+		bottom: (S.bottom - v.bottom + h.bottom) / x.y,
+		left: (v.left - S.left + h.left) / x.x,
+		right: (S.right - v.right + h.right) / x.x
+	};
 }
-const se = (e) => ({
-  name: "arrow",
-  options: e,
-  async fn(i) {
-    const {
-      x: c,
-      y: o,
-      placement: n,
-      rects: s,
-      platform: m,
-      elements: d,
-      middlewareData: l
-    } = i, {
-      element: g,
-      padding: u = 0
-    } = V(e, i) || {};
-    if (g == null)
-      return {};
-    const r = X(u), f = {
-      x: c,
-      y: o
-    }, t = q(n), a = J(t), x = await m.getDimensions(g), w = t === "y", v = w ? "top" : "left", p = w ? "bottom" : "right", h = w ? "clientHeight" : "clientWidth", P = s.reference[a] + s.reference[t] - f[t] - s.floating[a], y = f[t] - s.reference[t], A = await (m.getOffsetParent == null ? void 0 : m.getOffsetParent(g));
-    let b = A ? A[h] : 0;
-    (!b || !await (m.isElement == null ? void 0 : m.isElement(A))) && (b = d.floating[h] || s.floating[a]);
-    const D = P / 2 - y / 2, C = b / 2 - x[a] / 2 - 1, O = _(r[v], C), T = _(r[p], C), R = O, F = b - x[a] - T, S = b / 2 - x[a] / 2 + D, k = W(R, S, F), E = !l.arrow && M(n) != null && S != k && s.reference[a] / 2 - (S < R ? O : T) - x[a] / 2 < 0, L = E ? S < R ? S - R : S - F : 0;
-    return {
-      [t]: f[t] + L,
-      data: {
-        [t]: k,
-        centerOffset: S - k - L,
-        ...E && {
-          alignmentOffset: L
-        }
-      },
-      reset: E
-    };
-  }
+var x = (i) => ({
+	name: "arrow",
+	options: i,
+	async fn(o) {
+		let { x: s, y: c, placement: l, rects: u, platform: f, elements: p, middlewareData: m } = o, { element: g, padding: _ = 0 } = t(i, o) || {};
+		if (g == null) return {};
+		let v = d(_), 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 = u.reference[x] + u.reference[b] - y[b] - u.floating[x], O = y[b] - u.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] || u.floating[x]);
+		let j = D / 2 - O / 2, M = A / 2 - S[x] / 2 - 1, N = h(v[w], M), P = h(v[T], M), F = N, I = A - S[x] - P, L = A / 2 - S[x] / 2 + j, R = e(F, L, I), z = !m.arrow && n(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
+		};
+	}
 });
-function te(e, i, c) {
-  return (e ? [...c.filter((n) => M(n) === e), ...c.filter((n) => M(n) !== e)] : c.filter((n) => B(n) === n)).filter((n) => e ? M(n) === e || (i ? Z(n) !== n : !1) : !0);
+function S(e, t, r) {
+	return (e ? [...r.filter((t) => n(t) === e), ...r.filter((t) => n(t) !== e)] : r.filter((e) => f(e) === e)).filter((r) => e ? n(r) === e || (t ? s(r) !== r : !1) : !0);
 }
-const le = function(e) {
-  return e === void 0 && (e = {}), {
-    name: "autoPlacement",
-    options: e,
-    async fn(i) {
-      var c, o, n;
-      const {
-        rects: s,
-        middlewareData: m,
-        placement: d,
-        platform: l,
-        elements: g
-      } = i, {
-        crossAxis: u = !1,
-        alignment: r,
-        allowedPlacements: f = Y,
-        autoAlignment: t = !0,
-        ...a
-      } = V(e, i), x = r !== void 0 || f === Y ? te(r || null, t, f) : f, w = await H(i, a), v = ((c = m.autoPlacement) == null ? void 0 : c.index) || 0, p = x[v];
-      if (p == null)
-        return {};
-      const h = G(p, s, await (l.isRTL == null ? void 0 : l.isRTL(g.floating)));
-      if (d !== p)
-        return {
-          reset: {
-            placement: x[0]
-          }
-        };
-      const P = [w[B(p)], w[h[0]], w[h[1]]], y = [...((o = m.autoPlacement) == null ? void 0 : o.overflows) || [], {
-        placement: p,
-        overflows: P
-      }], A = x[v + 1];
-      if (A)
-        return {
-          data: {
-            index: v + 1,
-            overflows: y
-          },
-          reset: {
-            placement: A
-          }
-        };
-      const b = y.map((O) => {
-        const T = M(O.placement);
-        return [O.placement, T && u ? (
-          // Check along the mainAxis and main crossAxis side.
-          O.overflows.slice(0, 2).reduce((R, F) => R + F, 0)
-        ) : (
-          // Check only the mainAxis.
-          O.overflows[0]
-        ), O.overflows];
-      }).sort((O, T) => O[1] - T[1]), C = ((n = b.filter((O) => O[2].slice(
-        0,
-        // Aligned placements should not check their opposite crossAxis
-        // side.
-        M(O[0]) ? 2 : 3
-      ).every((T) => T <= 0))[0]) == null ? void 0 : n[0]) || b[0][0];
-      return C !== d ? {
-        data: {
-          index: v + 1,
-          overflows: y
-        },
-        reset: {
-          placement: C
-        }
-      } : {};
-    }
-  };
-}, ae = function(e) {
-  return e === void 0 && (e = {}), {
-    name: "flip",
-    options: e,
-    async fn(i) {
-      var c, o;
-      const {
-        placement: n,
-        middlewareData: s,
-        rects: m,
-        initialPlacement: d,
-        platform: l,
-        elements: g
-      } = i, {
-        mainAxis: u = !0,
-        crossAxis: r = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: t = "bestFit",
-        fallbackAxisSideDirection: a = "none",
-        flipAlignment: x = !0,
-        ...w
-      } = V(e, i);
-      if ((c = s.arrow) != null && c.alignmentOffset)
-        return {};
-      const v = B(n), p = B(d) === d, h = await (l.isRTL == null ? void 0 : l.isRTL(g.floating)), P = f || (p || !x ? [N(d)] : Q(d));
-      !f && a !== "none" && P.push(...U(d, x, a, h));
-      const y = [d, ...P], A = await H(i, w), b = [];
-      let D = ((o = s.flip) == null ? void 0 : o.overflows) || [];
-      if (u && b.push(A[v]), r) {
-        const R = G(n, m, h);
-        b.push(A[R[0]], A[R[1]]);
-      }
-      if (D = [...D, {
-        placement: n,
-        overflows: b
-      }], !b.every((R) => R <= 0)) {
-        var C, O;
-        const R = (((C = s.flip) == null ? void 0 : C.index) || 0) + 1, F = y[R];
-        if (F)
-          return {
-            data: {
-              index: R,
-              overflows: D
-            },
-            reset: {
-              placement: F
-            }
-          };
-        let S = (O = D.filter((k) => k.overflows[0] <= 0).sort((k, E) => k.overflows[1] - E.overflows[1])[0]) == null ? void 0 : O.placement;
-        if (!S)
-          switch (t) {
-            case "bestFit": {
-              var T;
-              const k = (T = D.map((E) => [E.placement, E.overflows.filter((L) => L > 0).reduce((L, K) => L + K, 0)]).sort((E, L) => E[1] - L[1])[0]) == null ? void 0 : T[0];
-              k && (S = k);
-              break;
-            }
-            case "initialPlacement":
-              S = d;
-              break;
-          }
-        if (n !== S)
-          return {
-            reset: {
-              placement: S
-            }
-          };
-      }
-      return {};
-    }
-  };
+var C = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "autoPlacement",
+		options: e,
+		async fn(r) {
+			let { rects: a, middlewareData: o, placement: s, platform: c, elements: l } = r, { crossAxis: u = !1, alignment: d, allowedPlacements: p = g, autoAlignment: m = !0, ...h } = t(e, r), _ = d !== void 0 || p === g ? S(d || null, m, p) : p, v = await b(r, h), y = o.autoPlacement?.index || 0, x = _[y];
+			if (x == null) return {};
+			let C = i(x, a, await (c.isRTL == null ? void 0 : c.isRTL(l.floating)));
+			if (s !== x) return { reset: { placement: _[0] } };
+			let w = [
+				v[f(x)],
+				v[C[0]],
+				v[C[1]]
+			], T = [...o.autoPlacement?.overflows || [], {
+				placement: x,
+				overflows: w
+			}], E = _[y + 1];
+			if (E) return {
+				data: {
+					index: y + 1,
+					overflows: T
+				},
+				reset: { placement: E }
+			};
+			let D = T.map((e) => {
+				let t = n(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, n(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 }
+			};
+		}
+	};
+}, w = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "flip",
+		options: e,
+		async fn(n) {
+			var r;
+			let { placement: a, middlewareData: s, rects: c, initialPlacement: d, platform: p, elements: m } = n, { mainAxis: h = !0, crossAxis: g = !0, fallbackPlacements: _, fallbackStrategy: v = "bestFit", fallbackAxisSideDirection: y = "none", flipAlignment: x = !0, ...S } = t(e, n);
+			if ((r = s.arrow) != null && r.alignmentOffset) return {};
+			let C = f(a), w = f(d) === d, T = await (p.isRTL == null ? void 0 : p.isRTL(m.floating)), E = _ || (w || !x ? [u(d)] : o(d));
+			!_ && y !== "none" && E.push(...l(d, x, y, T));
+			let D = [d, ...E], O = await b(n, S), k = [], A = s.flip?.overflows || [];
+			if (h && k.push(O[C]), g) {
+				let e = i(a, c, T);
+				k.push(O[e[0]], O[e[1]]);
+			}
+			if (A = [...A, {
+				placement: a,
+				overflows: k
+			}], !k.every((e) => e <= 0)) {
+				let e = (s.flip?.index || 0) + 1, t = D[e];
+				if (t) return {
+					data: {
+						index: e,
+						overflows: A
+					},
+					reset: { placement: t }
+				};
+				let n = A.filter((e) => e.overflows[0] <= 0).sort((e, t) => e.overflows[1] - t.overflows[1])[0]?.placement;
+				if (!n) switch (v) {
+					case "bestFit": {
+						let e = A.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 = d;
+						break;
+				}
+				if (a !== n) return { reset: { placement: n } };
+			}
+			return {};
+		}
+	};
 };
-async function ne(e, i) {
-  const {
-    placement: c,
-    platform: o,
-    elements: n
-  } = e, s = await (o.isRTL == null ? void 0 : o.isRTL(n.floating)), m = B(c), d = M(c), l = j(c) === "y", g = ["left", "top"].includes(m) ? -1 : 1, u = s && l ? -1 : 1, r = V(i, e);
-  let {
-    mainAxis: f,
-    crossAxis: t,
-    alignmentAxis: a
-  } = typeof r == "number" ? {
-    mainAxis: r,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...r
-  };
-  return d && typeof a == "number" && (t = d === "end" ? a * -1 : a), l ? {
-    x: t * u,
-    y: f * g
-  } : {
-    x: f * g,
-    y: t * u
-  };
+async function T(e, r) {
+	let { placement: i, platform: a, elements: o } = e, s = await (a.isRTL == null ? void 0 : a.isRTL(o.floating)), c = f(i), l = n(i), u = p(i) === "y", d = ["left", "top"].includes(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: 0,
+		crossAxis: 0,
+		alignmentAxis: null,
+		...h
+	};
+	return l && typeof v == "number" && (_ = l === "end" ? v * -1 : v), u ? {
+		x: _ * m,
+		y: g * d
+	} : {
+		x: g * d,
+		y: _ * m
+	};
 }
-const ce = function(e) {
-  return e === void 0 && (e = 0), {
-    name: "offset",
-    options: e,
-    async fn(i) {
-      var c, o;
-      const {
-        x: n,
-        y: s,
-        placement: m,
-        middlewareData: d
-      } = i, l = await ne(i, e);
-      return m === ((c = d.offset) == null ? void 0 : c.placement) && (o = d.arrow) != null && o.alignmentOffset ? {} : {
-        x: n + l.x,
-        y: s + l.y,
-        data: {
-          ...l,
-          placement: m
-        }
-      };
-    }
-  };
-}, re = function(e) {
-  return e === void 0 && (e = {}), {
-    name: "shift",
-    options: e,
-    async fn(i) {
-      const {
-        x: c,
-        y: o,
-        placement: n
-      } = i, {
-        mainAxis: s = !0,
-        crossAxis: m = !1,
-        limiter: d = {
-          fn: (w) => {
-            let {
-              x: v,
-              y: p
-            } = w;
-            return {
-              x: v,
-              y: p
-            };
-          }
-        },
-        ...l
-      } = V(e, i), g = {
-        x: c,
-        y: o
-      }, u = await H(i, l), r = j(B(n)), f = ee(r);
-      let t = g[f], a = g[r];
-      if (s) {
-        const w = f === "y" ? "top" : "left", v = f === "y" ? "bottom" : "right", p = t + u[w], h = t - u[v];
-        t = W(p, t, h);
-      }
-      if (m) {
-        const w = r === "y" ? "top" : "left", v = r === "y" ? "bottom" : "right", p = a + u[w], h = a - u[v];
-        a = W(p, a, h);
-      }
-      const x = d.fn({
-        ...i,
-        [f]: t,
-        [r]: a
-      });
-      return {
-        ...x,
-        data: {
-          x: x.x - c,
-          y: x.y - o
-        }
-      };
-    }
-  };
-}, fe = function(e) {
-  return e === void 0 && (e = {}), {
-    name: "size",
-    options: e,
-    async fn(i) {
-      const {
-        placement: c,
-        rects: o,
-        platform: n,
-        elements: s
-      } = i, {
-        apply: m = () => {
-        },
-        ...d
-      } = V(e, i), l = await H(i, d), g = B(c), u = M(c), r = j(c) === "y", {
-        width: f,
-        height: t
-      } = o.floating;
-      let a, x;
-      g === "top" || g === "bottom" ? (a = g, x = u === (await (n.isRTL == null ? void 0 : n.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (x = g, a = u === "end" ? "top" : "bottom");
-      const w = t - l[a], v = f - l[x], p = !i.middlewareData.shift;
-      let h = w, P = v;
-      if (r) {
-        const A = f - l.left - l.right;
-        P = u || p ? _(v, A) : A;
-      } else {
-        const A = t - l.top - l.bottom;
-        h = u || p ? _(w, A) : A;
-      }
-      if (p && !u) {
-        const A = $(l.left, 0), b = $(l.right, 0), D = $(l.top, 0), C = $(l.bottom, 0);
-        r ? P = f - 2 * (A !== 0 || b !== 0 ? A + b : $(l.left, l.right)) : h = t - 2 * (D !== 0 || C !== 0 ? D + C : $(l.top, l.bottom));
-      }
-      await m({
-        ...i,
-        availableWidth: P,
-        availableHeight: h
-      });
-      const y = await n.getDimensions(s.floating);
-      return f !== y.width || t !== y.height ? {
-        reset: {
-          rects: !0
-        }
-      } : {};
-    }
-  };
-};
-export {
-  se as arrow,
-  le as autoPlacement,
-  oe as computePosition,
-  H as detectOverflow,
-  ae as flip,
-  ce as offset,
-  z as rectToClientRect,
-  re as shift,
-  fe as size
+var E = 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 T(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
+				}
+			};
+		}
+	};
+}, D = function(n) {
+	return n === void 0 && (n = {}), {
+		name: "shift",
+		options: n,
+		async fn(r) {
+			let { x: i, y: a, placement: o } = r, { mainAxis: s = !0, crossAxis: l = !1, limiter: u = { fn: (e) => {
+				let { x: t, y: n } = e;
+				return {
+					x: t,
+					y: n
+				};
+			} }, ...d } = t(n, r), m = {
+				x: i,
+				y: a
+			}, h = await b(r, d), g = p(f(o)), _ = c(g), v = m[_], y = m[g];
+			if (s) {
+				let t = _ === "y" ? "top" : "left", n = _ === "y" ? "bottom" : "right", r = v + h[t], i = v - h[n];
+				v = e(r, v, i);
+			}
+			if (l) {
+				let t = g === "y" ? "top" : "left", n = g === "y" ? "bottom" : "right", r = y + h[t], i = y - h[n];
+				y = e(r, y, i);
+			}
+			let x = u.fn({
+				...r,
+				[_]: v,
+				[g]: y
+			});
+			return {
+				...x,
+				data: {
+					x: x.x - i,
+					y: x.y - a
+				}
+			};
+		}
+	};
+}, O = function(e) {
+	return e === void 0 && (e = {}), {
+		name: "size",
+		options: e,
+		async fn(r) {
+			let { placement: i, rects: a, platform: o, elements: s } = r, { apply: c = () => {}, ...l } = t(e, r), u = await b(r, l), d = f(i), g = n(i), _ = p(i) === "y", { width: v, height: y } = a.floating, x, S;
+			d === "top" || d === "bottom" ? (x = d, S = g === (await (o.isRTL == null ? void 0 : o.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (S = d, x = g === "end" ? "top" : "bottom");
+			let C = y - u[x], w = v - u[S], T = !r.middlewareData.shift, E = C, D = w;
+			if (_) {
+				let e = v - u.left - u.right;
+				D = g || T ? h(w, e) : e;
+			} else {
+				let e = y - u.top - u.bottom;
+				E = g || T ? h(C, e) : e;
+			}
+			if (T && !g) {
+				let e = m(u.left, 0), t = m(u.right, 0), n = m(u.top, 0), r = m(u.bottom, 0);
+				_ ? D = v - 2 * (e !== 0 || t !== 0 ? e + t : m(u.left, u.right)) : E = y - 2 * (n !== 0 || r !== 0 ? n + r : m(u.top, u.bottom));
+			}
+			await c({
+				...r,
+				availableWidth: D,
+				availableHeight: E
+			});
+			let O = await o.getDimensions(s.floating);
+			return v !== O.width || y !== O.height ? { reset: { rects: !0 } } : {};
+		}
+	};
 };
+//#endregion
+export { x as arrow, C as autoPlacement, y as computePosition, b as detectOverflow, w as flip, E as offset, D as shift, O as size };