@t-headless-ui/react 1.1.1 → 1.1.3

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
+};

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

@@ -0,0 +1,12 @@
+function i(t) {
+  if (t == null)
+    return window;
+  if (t.toString() !== "[object Window]") {
+    const { ownerDocument: n } = t;
+    return n && n.defaultView || window;
+  }
+  return t;
+}
+export {
+  i as default
+};

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

@@ -0,0 +1,10 @@
+function e() {
+  const o = window.pageXOffset, t = window.pageYOffset;
+  return {
+    scrollLeft: o,
+    scrollTop: t
+  };
+}
+export {
+  e as getWindowScroll
+};

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

@@ -0,0 +1,9 @@
+import { getBoundingClientRect as o } from "./getBoundingClientRect.mjs";
+import { getDocumentElement as e } from "./getDocumentElement.mjs";
+import { getWindowScroll as r } from "./getWindowScroll.mjs";
+function m(t) {
+  return o(e(t)).left + r().scrollLeft;
+}
+export {
+  m as getWindowScrollBarX
+};

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

@@ -0,0 +1,8 @@
+import { isSafari as r } from "./isSafari.mjs";
+function a(o) {
+  const t = r(), e = getComputedStyle(o);
+  return e.transform !== "none" || e.perspective !== "none" || (e.containerType ? e.containerType !== "normal" : !1) || !t && (e.backdropFilter ? e.backdropFilter !== "none" : !1) || !t && (e.filter ? e.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((n) => (e.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (e.contain || "").includes(n));
+}
+export {
+  a as isContainingBlock
+};

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

@@ -0,0 +1,6 @@
+function e(n) {
+  return n instanceof window.Element;
+}
+export {
+  e as isElement
+};

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

@@ -0,0 +1,6 @@
+function e(n) {
+  return n instanceof window.HTMLElement;
+}
+export {
+  e as isHTMLElement
+};

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

@@ -0,0 +1,6 @@
+function e() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+export {
+  e as isSafari
+};

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

@@ -0,0 +1,7 @@
+function n(o) {
+  const { overflow: e, overflowX: t, overflowY: l, display: r } = getComputedStyle(o);
+  return /auto|scroll|overlay|hidden|clip/.test(e + l + t) && !["contents"].includes(r);
+}
+export {
+  n as isScrollParent
+};

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

@@ -0,0 +1,7 @@
+import { getNodeName as t } from "./getNodeName.mjs";
+function o(e) {
+  return ["table", "td", "th"].indexOf(t(e)) >= 0;
+}
+export {
+  o as isTableElement
+};

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

@@ -0,0 +1,12 @@
+import { getParentNode as a } from "./getParentNode.mjs";
+import { getScrollParent as l } from "./getScrollParent.mjs";
+import { isScrollParent as m } from "./isScrollParent.mjs";
+import p from "./getWindow.mjs";
+function d(t, s = []) {
+  var i;
+  const o = l(t), r = o === ((i = t.ownerDocument) == null ? void 0 : i.body), n = p(o), c = r ? [n].concat(n.visualViewport || [], m(o) ? o : []) : o, e = s.concat(c);
+  return r ? e : e.concat(d(a(c)));
+}
+export {
+  d as listScrollParents
+};

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

@@ -0,0 +1,15 @@
+function e(s) {
+  const n = s.reduce((o, a) => {
+    const t = o[a.name];
+    return o[a.name] = t ? {
+      ...t,
+      ...a,
+      options: { ...t.options, ...a.options },
+      data: { ...t.data, ...a.data }
+    } : a, o;
+  }, {});
+  return Object.keys(n).map((o) => n[o]);
+}
+export {
+  e as mergeByName
+};

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

@@ -0,0 +1,12 @@
+function o(t) {
+  return {
+    ...t,
+    left: t.x,
+    top: t.y,
+    right: t.x + t.width,
+    bottom: t.y + t.height
+  };
+}
+export {
+  o as rectToClientRect
+};