@t-headless-ui/react 1.1.1 → 1.1.2

package/dist/es/link/link.mjs

@@ -1,19 +1,18 @@
 "use client";
-import { jsx as f } from "react/jsx-runtime";
+import { jsx as d } from "react/jsx-runtime";
 import { forwardRef as n } from "react";
-function k(s, a) {
-  const { children: c, disabled: l, onClick: i, ...d } = s;
-  return /* @__PURE__ */ f("a", { ...d, ref: a, onClick: (r) => {
-    var o;
+function k(c, s) {
+  const { children: f, disabled: l, onClick: o, ...a } = c;
+  return /* @__PURE__ */ d("a", { ...a, ref: s, onClick: (r) => {
+    var i;
     if (l) {
-      (o = r == null ? void 0 : r.preventDefault) == null || o.call(r);
+      (i = r == null ? void 0 : r.preventDefault) == null || i.call(r);
       return;
     }
-    i == null || i(r);
-  }, children: c });
+    o == null || o(r);
+  }, children: f });
 }
-const p = n(k), m = p;
-m.displayName = "TUI.Link";
+const p = n(k), h = p;
 export {
-  m as Link
+  h as Link
 };

package/dist/es/mini-floating-ui/constants.mjs

@@ -0,0 +1,19 @@
+const o = "top", n = "bottom", r = "right", c = "left", s = "start", p = "end", a = "clippingParents", l = "popper", d = "reference", m = "viewport", i = [o, n, r, c], f = [...i].reduce(
+  (t, e) => t.concat([e, `${e}-${s}`, `${e}-${p}`]),
+  []
+), g = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
+export {
+  g as INVALID_ELEMENT_ERROR,
+  i as basePlacements,
+  n as bottom,
+  a as clippingParents,
+  p as end,
+  c as left,
+  f as placements,
+  l as popper,
+  d as reference,
+  r as right,
+  s as start,
+  o as top,
+  m as viewport
+};

package/dist/es/mini-floating-ui/createPopper.mjs

@@ -0,0 +1,93 @@
+"use client";
+import l from "./utils/getLayoutRect.mjs";
+import { INVALID_ELEMENT_ERROR as u } from "./constants.mjs";
+import y from "./debounce.mjs";
+import { isElement as E } from "./utils/isElement.mjs";
+import { areValidElements as M } from "./utils/areValidElements.mjs";
+import { getCompositeRect as g } from "./utils/getCompositeRect.mjs";
+import { getOffsetParent as O } from "./utils/getOffsetParent.mjs";
+import { listScrollParents as a } from "./utils/listScrollParents.mjs";
+import { mergeByName as P } from "./utils/mergeByName.mjs";
+import D from "./modifiers/popperOffsets.mjs";
+import R from "./modifiers/offset.mjs";
+import b from "./modifiers/flip.mjs";
+import L from "./modifiers/computeStyles.mjs";
+const N = [D, R, b, L], x = {
+  placement: "bottom",
+  modifiers: [],
+  strategy: "absolute"
+};
+function k(i, n, p = {}) {
+  let e = {
+    placement: "bottom",
+    orderedModifiers: [],
+    options: { ...x, ...p },
+    modifiersData: {},
+    elements: {
+      reference: i,
+      popper: n
+    },
+    styles: {}
+  }, f = !1;
+  const r = {
+    state: e,
+    setOptions(t) {
+      e.options = {
+        ...e.options,
+        ...t
+      }, e.scrollParents = {
+        reference: E(i) ? a(i) : [],
+        popper: a(n)
+      };
+      const s = P([...N, ...e.options.modifiers]);
+      return e.orderedModifiers = s, r.update();
+    },
+    // Sync update – it will always be executed, even if not necessary. This
+    // is useful for low frequency updates where sync behavior simplifies the
+    // logic.
+    // For high frequency updates (e.g. `resize` and `scroll` events), always
+    // prefer the async Popper#update method
+    forceUpdate() {
+      if (f)
+        return;
+      const { reference: t, popper: s } = e.elements;
+      if (!M(t, s)) {
+        console.error(u);
+        return;
+      }
+      e.rects = {
+        // getOffsetParent 在某些情况下，会强制设置为 window
+        // reference, popper 到 reference 元素的距离，以及 reference 元素的宽度高度
+        reference: g(t, O(s), e.options.strategy === "fixed"),
+        popper: l(s)
+      }, e.reset = !1, e.placement = e.options.placement, e.orderedModifiers.forEach(
+        // eslint-disable-next-line no-return-assign
+        (o) => e.modifiersData[o.name] = {
+          ...o.data
+        }
+      );
+      for (let o = 0; o < e.orderedModifiers.length; o++) {
+        if (e.reset === !0) {
+          e.reset = !1, o = -1;
+          continue;
+        }
+        const { fn: m, options: d = {}, name: c } = e.orderedModifiers[o];
+        typeof m == "function" && (e = m({ state: e, options: d, name: c, instance: r }) || e);
+      }
+    },
+    // Async and optimistically optimized update – it will not be executed if
+    // not necessary (debounced to run at most once-per-tick)
+    update: y(
+      () => new Promise((t) => {
+        r.forceUpdate(), t(e);
+      })
+    ),
+    destroy() {
+      f = !0;
+    }
+  };
+  return r.setOptions(p), r;
+}
+export {
+  k as createPopper
+};

package/dist/es/mini-floating-ui/debounce.mjs

@@ -0,0 +1,11 @@
+function o(n) {
+  let e;
+  return () => (e || (e = new Promise((r) => {
+    Promise.resolve().then(() => {
+      e = void 0, r(n());
+    });
+  })), e);
+}
+export {
+  o as default
+};

package/dist/es/mini-floating-ui/modifiers/computeStyles.mjs

@@ -0,0 +1,60 @@
+import { left as y, top as u } from "../constants.mjs";
+import { getVariation as x } from "../utils/getVariation.mjs";
+import { getBasePlacement as w } from "../utils/getBasePlacement.mjs";
+function h({ x: e, y: p }, i) {
+  const o = i.devicePixelRatio || 1;
+  return {
+    x: Math.round(e * o) / o || 0,
+    y: Math.round(p * o) / o || 0
+  };
+}
+function P({
+  popper: e,
+  popperRect: p,
+  placement: i,
+  variation: o,
+  offsets: r,
+  position: s,
+  isFixed: O
+}) {
+  let { x: t = 0, y: n = 0 } = r;
+  const a = r.hasOwnProperty("x"), c = r.hasOwnProperty("y"), m = y, l = u, d = window, f = {
+    position: s
+  };
+  return { x: t, y: n } = h({ x: t, y: n }, window), {
+    ...f,
+    [l]: c ? "0" : "",
+    [m]: a ? "0" : "",
+    // Layer acceleration can disable subpixel rendering which causes slightly
+    // blurry text on low PPI displays, so we want to use 2D transforms
+    // instead
+    transform: (d.devicePixelRatio || 1) <= 1 ? `translate(${t}px, ${n}px)` : `translate3d(${t}px, ${n}px, 0)`
+  };
+}
+function S({ state: e }) {
+  const p = {
+    placement: w(e.placement),
+    variation: x(e.placement),
+    popper: e.elements.popper,
+    popperRect: e.rects.popper,
+    isFixed: e.options.strategy === "fixed"
+  };
+  e.modifiersData.popperOffsets != null && (e.styles.popper = {
+    ...e.styles.popper,
+    ...P({
+      ...p,
+      offsets: e.modifiersData.popperOffsets,
+      position: e.options.strategy
+    })
+  });
+}
+const v = {
+  name: "computeStyles",
+  fn: S,
+  data: {}
+};
+export {
+  v as default,
+  P as mapToStyles,
+  h as roundOffsetsByDPR
+};

package/dist/es/mini-floating-ui/modifiers/flip.mjs

@@ -0,0 +1,34 @@
+import { getOppositePlacement as p } from "../utils/getOppositePlacement.mjs";
+import { detectOverflow as x } from "../utils/detectOverflow.mjs";
+import { getBasePlacement as m } from "../utils/getBasePlacement.mjs";
+function B(e) {
+  return [p(e)];
+}
+function v({ state: e, options: i, name: l }) {
+  var r;
+  if ((r = e.modifiersData[l]) != null && r._skip)
+    return;
+  const { mainAxis: f = !0, boundary: P, rootBoundary: u } = i, t = e.options.placement, d = m(t) === t ? [p(t)] : B(t), c = [t, ...d], k = /* @__PURE__ */ new Map();
+  let a = c[0];
+  for (let o = 0; o < c.length; o++) {
+    const n = c[o], b = m(n), g = x(e, {
+      placement: n,
+      boundary: P,
+      rootBoundary: u
+    }), s = [];
+    if (f && s.push(g[b] <= 0), s.every((h) => h)) {
+      a = n;
+      break;
+    }
+    k.set(n, s);
+  }
+  e.placement !== a && (e.modifiersData[l]._skip = !0, e.placement = a, e.reset = !0);
+}
+const D = {
+  name: "flip",
+  fn: v,
+  data: { _skip: !1 }
+};
+export {
+  D as default
+};

package/dist/es/mini-floating-ui/modifiers/offset.mjs

@@ -0,0 +1,22 @@
+import { placements as c, left as a, right as p, top as m } from "../constants.mjs";
+import { getBasePlacement as u } from "../utils/getBasePlacement.mjs";
+function l(e, s, n) {
+  const o = u(e), i = [a, m].indexOf(o) >= 0 ? -1 : 1;
+  let [t, f] = typeof n == "function" ? n({
+    ...s,
+    placement: e
+  }) : n;
+  return t = t || 0, f = (f || 0) * i, [a, p].indexOf(o) >= 0 ? { x: f, y: t } : { x: t, y: f };
+}
+function x({ state: e, options: s, name: n }) {
+  const { offset: o = [0, 0] } = s, i = c.reduce((r, d) => (r[d] = l(d, e.rects, o), r), {}), { x: t, y: f } = i[e.placement];
+  e.modifiersData.popperOffsets != null && (e.modifiersData.popperOffsets.x += t, e.modifiersData.popperOffsets.y += f), e.modifiersData[n] = i;
+}
+const O = {
+  name: "offset",
+  fn: x
+};
+export {
+  O as default,
+  l as distanceAndSkiddingToXY
+};

package/dist/es/mini-floating-ui/modifiers/popperOffsets.mjs

@@ -0,0 +1,16 @@
+import { computeOffsets as f } from "../utils/computeOffsets.mjs";
+function r({ state: e, name: p }) {
+  e.modifiersData[p] = f({
+    reference: e.rects.reference,
+    element: e.rects.popper,
+    placement: e.placement
+  });
+}
+const t = {
+  name: "popperOffsets",
+  fn: r,
+  data: {}
+};
+export {
+  t as default
+};

package/dist/es/mini-floating-ui/utils/areValidElements.mjs

@@ -0,0 +1,6 @@
+function e(...t) {
+  return !t.some((n) => !(n && typeof n.getBoundingClientRect == "function"));
+}
+export {
+  e as areValidElements
+};

package/dist/es/mini-floating-ui/utils/computeOffsets.mjs

@@ -0,0 +1,59 @@
+import { left as b, right as u, bottom as d, top as l, end as w, start as k } from "../constants.mjs";
+import { getMainAxisFromPlacement as c } from "./getMainAxisFromPlacement.mjs";
+import { getBasePlacement as p } from "./getBasePlacement.mjs";
+import { getVariation as n } from "./getVariation.mjs";
+function F({
+  reference: t,
+  element: i,
+  placement: a
+}) {
+  const x = a ? p(a) : null, g = a ? n(a) : null, m = t.x + t.width / 2 - i.width / 2, y = t.y + t.height / 2 - i.height / 2;
+  let o;
+  switch (x) {
+    case l:
+      o = {
+        x: m,
+        y: t.y - i.height
+      };
+      break;
+    case d:
+      o = {
+        x: m,
+        y: t.y + t.height
+      };
+      break;
+    case u:
+      o = {
+        x: t.x + t.width,
+        y
+      };
+      break;
+    case b:
+      o = {
+        x: t.x - i.width,
+        y
+      };
+      break;
+    default:
+      o = {
+        x: t.x,
+        y: t.y
+      };
+  }
+  const s = x ? c(x) : null;
+  if (s !== null) {
+    const h = s === "y" ? "height" : "width";
+    switch (g) {
+      case k:
+        o[s] = o[s] - (t[h] / 2 - i[h] / 2);
+        break;
+      case w:
+        o[s] = o[s] + (t[h] / 2 - i[h] / 2);
+        break;
+    }
+  }
+  return o;
+}
+export {
+  F as computeOffsets
+};

package/dist/es/mini-floating-ui/utils/contains.mjs

@@ -0,0 +1,6 @@
+function r(n, t) {
+  return !!n.contains(t);
+}
+export {
+  r as contains
+};

package/dist/es/mini-floating-ui/utils/detectOverflow.mjs

@@ -0,0 +1,38 @@
+import { clippingParents as w, viewport as B, popper as e, reference as D, top as j, bottom as m, right as E } from "../constants.mjs";
+import { computeOffsets as P } from "./computeOffsets.mjs";
+import { getBoundingClientRect as T } from "./getBoundingClientRect.mjs";
+import { getClippingRect as q } from "./getClippingRect.mjs";
+import { rectToClientRect as z } from "./rectToClientRect.mjs";
+function J(t, a = {}) {
+  const {
+    placement: f = t.placement,
+    strategy: g = t.strategy,
+    boundary: C = w,
+    rootBoundary: d = B,
+    elementContext: o = e,
+    altBoundary: u = !1
+  } = a, R = o === e ? D : e, i = t.rects.popper, x = t.elements[u ? R : o], n = q(x, C, d, g), s = T(t.elements.reference), O = P({
+    reference: s,
+    element: i,
+    placement: f
+  }), b = z({
+    ...i,
+    ...O
+  }), r = o === e ? b : s, c = {
+    top: n.top - r.top,
+    bottom: r.bottom - n.bottom,
+    left: n.left - r.left,
+    right: r.right - n.right
+  }, l = t.modifiersData.offset;
+  if (o === e && l) {
+    const y = l[f];
+    Object.keys(c).forEach((p) => {
+      const h = [E, m].indexOf(p) >= 0 ? 1 : -1, v = [j, m].indexOf(p) >= 0 ? "y" : "x";
+      c[p] += y[v] * h;
+    });
+  }
+  return c;
+}
+export {
+  J as detectOverflow
+};

package/dist/es/mini-floating-ui/utils/getBasePlacement.mjs

@@ -0,0 +1,6 @@
+function t(e) {
+  return e.split("-")[0];
+}
+export {
+  t as getBasePlacement
+};

package/dist/es/mini-floating-ui/utils/getBoundingClientRect.mjs

@@ -0,0 +1,16 @@
+function g(c) {
+  const t = c.getBoundingClientRect(), n = t.left, e = t.top, o = t.width, i = t.height;
+  return {
+    width: o,
+    height: i,
+    top: e,
+    right: n + o,
+    bottom: e + i,
+    left: n,
+    x: n,
+    y: e
+  };
+}
+export {
+  g as getBoundingClientRect
+};

package/dist/es/mini-floating-ui/utils/getClippingRect.mjs

@@ -0,0 +1,38 @@
+import { viewport as u } from "../constants.mjs";
+import { listScrollParents as d } from "./listScrollParents.mjs";
+import { isHTMLElement as C } from "./isHTMLElement.mjs";
+import { getOffsetParent as a } from "./getOffsetParent.mjs";
+import { isElement as m } from "./isElement.mjs";
+import { getNodeName as x } from "./getNodeName.mjs";
+import { contains as b } from "./contains.mjs";
+import { getBoundingClientRect as E } from "./getBoundingClientRect.mjs";
+import { rectToClientRect as s } from "./rectToClientRect.mjs";
+import { getViewportRect as M } from "./getViewportRect.mjs";
+import { getDocumentRect as P } from "./getDocumentRect.mjs";
+import { getDocumentElement as w } from "./getDocumentElement.mjs";
+function T(i) {
+  const t = E(i);
+  return t.top += i.clientTop, t.left += i.clientLeft, t.bottom = t.top + i.clientHeight, t.right = t.left + i.clientWidth, t.width = i.clientWidth, t.height = i.clientHeight, t.x = t.left, t.y = t.top, t;
+}
+function l(i, t, p) {
+  return t === u ? s(M(i, p)) : m(t) ? T(t) : s(P(w(i)));
+}
+function y(i) {
+  const t = d(i), n = ["absolute", "fixed"].indexOf(getComputedStyle(i).position) >= 0 && C(i) ? a(i) : i;
+  return m(n) ? t.filter(
+    (e) => m(e) && b(e, n) && x(e) !== "body"
+  ) : [];
+}
+function j(i, t, p, n) {
+  const g = [...t === "clippingParents" ? y(i) : [].concat(t), p], h = g[0], o = g.reduce(
+    (r, c) => {
+      const f = l(i, c, n);
+      return r.top = Math.max(f.top, r.top), r.right = Math.min(f.right, r.right), r.bottom = Math.min(f.bottom, r.bottom), r.left = Math.max(f.left, r.left), r;
+    },
+    l(i, h, n)
+  );
+  return o.width = o.right - o.left, o.height = o.bottom - o.top, o.x = o.left, o.y = o.top, o;
+}
+export {
+  j as getClippingRect
+};

package/dist/es/mini-floating-ui/utils/getCompositeRect.mjs

@@ -0,0 +1,21 @@
+import { getBoundingClientRect as m } from "./getBoundingClientRect.mjs";
+import { getDocumentElement as p } from "./getDocumentElement.mjs";
+import { getNodeName as s } from "./getNodeName.mjs";
+import { getNodeScroll as f } from "./getNodeScroll.mjs";
+import { isHTMLElement as g } from "./isHTMLElement.mjs";
+import { isScrollParent as d } from "./isScrollParent.mjs";
+import { getWindowScrollBarX as h } from "./getWindowScrollBarX.mjs";
+function N(c, o, n = !1) {
+  const l = g(o), i = p(o), e = m(c);
+  let r = { scrollLeft: 0, scrollTop: 0 }, t = { x: 0, y: 0 };
+  return (l || !l && !n) && ((s(o) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
+  d(i)) && (r = f(o)), l ? (t = m(o), t.x += o.clientLeft, t.y += o.clientTop) : i && (t.x = h(i))), {
+    x: e.left + r.scrollLeft - t.x,
+    y: e.top + r.scrollTop - t.y,
+    width: e.width,
+    height: e.height
+  };
+}
+export {
+  N as getCompositeRect
+};

package/dist/es/mini-floating-ui/utils/getContainingBlock.mjs

@@ -0,0 +1,16 @@
+import { getNodeName as n } from "./getNodeName.mjs";
+import { getParentNode as t } from "./getParentNode.mjs";
+import { isContainingBlock as r } from "./isContainingBlock.mjs";
+import { isHTMLElement as i } from "./isHTMLElement.mjs";
+function u(e) {
+  let o = t(e);
+  for (; i(o) && ["html", "body", "#document"].indexOf(n(o)) < 0; ) {
+    if (r(o))
+      return o;
+    o = t(o);
+  }
+  return null;
+}
+export {
+  u as getContainingBlock
+};

package/dist/es/mini-floating-ui/utils/getDocumentElement.mjs

@@ -0,0 +1,7 @@
+import { isElement as o } from "./isElement.mjs";
+function e(n) {
+  return ((o(n) ? n.ownerDocument : n.document) || window.document).documentElement;
+}
+export {
+  e as getDocumentElement
+};

package/dist/es/mini-floating-ui/utils/getDocumentRect.mjs

@@ -0,0 +1,11 @@
+import { getDocumentElement as s } from "./getDocumentElement.mjs";
+import { getWindowScroll as m } from "./getWindowScroll.mjs";
+import { getWindowScrollBarX as d } from "./getWindowScrollBarX.mjs";
+function f(c) {
+  var i;
+  const t = s(c), l = m(), o = (i = c.ownerDocument) == null ? void 0 : i.body, n = Math.max(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), r = Math.max(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight), e = -l.scrollLeft + d(c), h = -l.scrollTop;
+  return { width: n, height: r, x: e, y: h };
+}
+export {
+  f as getDocumentRect
+};

package/dist/es/mini-floating-ui/utils/getHTMLElementScroll.mjs

@@ -0,0 +1,9 @@
+function o(l) {
+  return {
+    scrollLeft: l.scrollLeft,
+    scrollTop: l.scrollTop
+  };
+}
+export {
+  o as getHTMLElementScroll
+};

package/dist/es/mini-floating-ui/utils/getLayoutRect.mjs

@@ -0,0 +1,13 @@
+import { getBoundingClientRect as e } from "./getBoundingClientRect.mjs";
+function f(t) {
+  const o = e(t);
+  return {
+    x: t.offsetLeft,
+    y: t.offsetTop,
+    width: o.width,
+    height: o.height
+  };
+}
+export {
+  f as default
+};

package/dist/es/mini-floating-ui/utils/getMainAxisFromPlacement.mjs

@@ -0,0 +1,6 @@
+function e(t) {
+  return ["top", "bottom"].indexOf(t) >= 0 ? "x" : "y";
+}
+export {
+  e as getMainAxisFromPlacement
+};

package/dist/es/mini-floating-ui/utils/getNodeName.mjs

@@ -0,0 +1,6 @@
+function r(o) {
+  return ((o == null ? void 0 : o.nodeName) || "").toLowerCase();
+}
+export {
+  r as getNodeName
+};

package/dist/es/mini-floating-ui/utils/getNodeScroll.mjs

@@ -0,0 +1,9 @@
+import { getHTMLElementScroll as o } from "./getHTMLElementScroll.mjs";
+import { getWindowScroll as t } from "./getWindowScroll.mjs";
+import { isHTMLElement as e } from "./isHTMLElement.mjs";
+function n(r) {
+  return r === window || !e(r) ? t() : o(r);
+}
+export {
+  n as getNodeScroll
+};

package/dist/es/mini-floating-ui/utils/getOffsetParent.mjs

@@ -0,0 +1,16 @@
+import { getContainingBlock as n } from "./getContainingBlock.mjs";
+import { getNodeName as e } from "./getNodeName.mjs";
+import { getTrueOffsetParent as r } from "./getTrueOffsetParent.mjs";
+import m from "./getWindow.mjs";
+import { isContainingBlock as f } from "./isContainingBlock.mjs";
+import { isTableElement as p } from "./isTableElement.mjs";
+function u(o) {
+  const i = m(o);
+  let t = r(o);
+  for (; t && p(t) && getComputedStyle(t).position === "static"; )
+    t = r(t);
+  return t && (e(t) === "html" || e(t) === "body" && getComputedStyle(t).position === "static" && !f(t)) ? i : t || n(o) || i;
+}
+export {
+  u as getOffsetParent
+};

package/dist/es/mini-floating-ui/utils/getOppositePlacement.mjs

@@ -0,0 +1,7 @@
+const e = { left: "right", right: "left", bottom: "top", top: "bottom" };
+function p(t) {
+  return t.replace(/left|right|bottom|top/g, (o) => e[o]);
+}
+export {
+  p as getOppositePlacement
+};

package/dist/es/mini-floating-ui/utils/getParentNode.mjs

@@ -0,0 +1,9 @@
+import { getNodeName as t } from "./getNodeName.mjs";
+import { getDocumentElement as o } from "./getDocumentElement.mjs";
+function n(r) {
+  return t(r) === "html" ? r : r.parentNode || // Fallback.
+  o(r);
+}
+export {
+  n as getParentNode
+};

package/dist/es/mini-floating-ui/utils/getScrollParent.mjs

@@ -0,0 +1,10 @@
+import { getParentNode as t } from "./getParentNode.mjs";
+import { isScrollParent as e } from "./isScrollParent.mjs";
+import { getNodeName as o } from "./getNodeName.mjs";
+import { isHTMLElement as m } from "./isHTMLElement.mjs";
+function i(r) {
+  return ["html", "body", "#document"].indexOf(o(r)) >= 0 ? r.ownerDocument.body : m(r) && e(r) ? r : i(t(r));
+}
+export {
+  i as getScrollParent
+};

package/dist/es/mini-floating-ui/utils/getTrueOffsetParent.mjs

@@ -0,0 +1,7 @@
+import { isHTMLElement as r } from "./isHTMLElement.mjs";
+function f(t) {
+  return !r(t) || getComputedStyle(t).position === "fixed" ? null : t.offsetParent;
+}
+export {
+  f as getTrueOffsetParent
+};

package/dist/es/mini-floating-ui/utils/getVariation.mjs

@@ -0,0 +1,6 @@
+function i(t) {
+  return t.split("-")[1];
+}
+export {
+  i as getVariation
+};

package/dist/es/mini-floating-ui/utils/getViewportRect.mjs

@@ -0,0 +1,20 @@
+import { getDocumentElement as c } from "./getDocumentElement.mjs";
+import { isSafari as m } from "./isSafari.mjs";
+function w(l, h) {
+  const e = c(l), { visualViewport: t } = window;
+  let i = e.clientWidth, o = e.clientHeight, f = 0, n = 0;
+  if (t) {
+    i = t.width, o = t.height;
+    const r = m();
+    (r || !r && h === "fixed") && (f = t.offsetLeft, n = t.offsetTop);
+  }
+  return {
+    width: i,
+    height: o,
+    x: f,
+    y: n
+  };
+}
+export {
+  w as getViewportRect
+};