@prokodo/ui 0.0.26 → 0.0.28

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

@@ -1,353 +1,456 @@
-import { evaluate as D, getSide as E, getSideAxis as C, getOppositePlacement as H, getExpandedPlacements as J, getOppositeAxisPlacements as K, getAlignmentSides as N, clamp as X, getAlignment as _, getPaddingObject as Q, rectToClientRect as Y, getOppositeAxis as U, getAlignmentAxis as W, getAxisLength as Z } from "../../../../../@floating-ui_utils@0.2.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
-function $(l, s, f) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { evaluate, getSide, getSideAxis, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, getAlignmentSides, clamp, getAlignment, getPaddingObject, rectToClientRect, getOppositeAxis, getAlignmentAxis, getAxisLength } from "../../../../../@floating-ui_utils@0.2.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
-    reference: t,
-    floating: a
-  } = l;
-  const e = C(s), c = W(s), o = Z(c), x = E(s), u = e === "y", m = t.x + t.width / 2 - a.width / 2, n = t.y + t.height / 2 - a.height / 2, r = t[o] / 2 - a[o] / 2;
-  let i;
-  switch (x) {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
     case "top":
-      i = {
-        x: m,
-        y: t.y - a.height
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
       };
       break;
     case "bottom":
-      i = {
-        x: m,
-        y: t.y + t.height
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
       };
       break;
     case "right":
-      i = {
-        x: t.x + t.width,
-        y: n
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
       };
       break;
     case "left":
-      i = {
-        x: t.x - a.width,
-        y: n
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
       };
       break;
     default:
-      i = {
-        x: t.x,
-        y: t.y
+      coords = {
+        x: reference.x,
+        y: reference.y
       };
   }
-  switch (_(s)) {
+  switch (getAlignment(placement)) {
     case "start":
-      i[c] -= r * (f && u ? -1 : 1);
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
     case "end":
-      i[c] += r * (f && u ? -1 : 1);
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
       break;
   }
-  return i;
+  return coords;
 }
-const nt = async (l, s, f) => {
+__name(computeCoordsFromPlacement, "computeCoordsFromPlacement");
+const computePosition = /* @__PURE__ */ __name(async (reference, floating, config) => {
   const {
-    placement: t = "bottom",
-    strategy: a = "absolute",
-    middleware: e = [],
-    platform: c
-  } = f, o = e.filter(Boolean), x = await (c.isRTL == null ? void 0 : c.isRTL(s));
-  let u = await c.getElementRects({
-    reference: l,
-    floating: s,
-    strategy: a
-  }), {
-    x: m,
-    y: n
-  } = $(u, t, x), r = t, i = {}, d = 0;
-  for (let y = 0; y < o.length; y++) {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+  let rects = await platform.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
     const {
-      name: w,
-      fn: p
-    } = o[y], {
-      x: v,
-      y: A,
-      data: b,
-      reset: g
-    } = await p({
-      x: m,
-      y: n,
-      initialPlacement: t,
-      placement: r,
-      strategy: a,
-      middlewareData: i,
-      rects: u,
-      platform: c,
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform,
       elements: {
-        reference: l,
-        floating: s
+        reference,
+        floating
       }
     });
-    m = v ?? m, n = A ?? n, i = {
-      ...i,
-      [w]: {
-        ...i[w],
-        ...b
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
       }
-    }, g && d <= 50 && (d++, typeof g == "object" && (g.placement && (r = g.placement), g.rects && (u = g.rects === !0 ? await c.getElementRects({
-      reference: l,
-      floating: s,
-      strategy: a
-    }) : g.rects), {
-      x: m,
-      y: n
-    } = $(u, r, x)), y = -1);
+      i = -1;
+    }
   }
   return {
-    x: m,
-    y: n,
-    placement: r,
-    strategy: a,
-    middlewareData: i
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
   };
-};
-async function q(l, s) {
-  var f;
-  s === void 0 && (s = {});
+}, "computePosition");
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform,
+    rects,
+    elements,
+    strategy
+  } = state;
   const {
-    x: t,
-    y: a,
-    platform: e,
-    rects: c,
-    elements: o,
-    strategy: x
-  } = l, {
-    boundary: u = "clippingAncestors",
-    rootBoundary: m = "viewport",
-    elementContext: n = "floating",
-    altBoundary: r = !1,
-    padding: i = 0
-  } = D(s, l), d = Q(i), w = o[r ? n === "floating" ? "reference" : "floating" : n], p = Y(await e.getClippingRect({
-    element: (f = await (e.isElement == null ? void 0 : e.isElement(w))) == null || f ? w : w.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(o.floating)),
-    boundary: u,
-    rootBoundary: m,
-    strategy: x
-  })), v = n === "floating" ? {
-    x: t,
-    y: a,
-    width: c.floating.width,
-    height: c.floating.height
-  } : c.reference, A = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(o.floating)), b = await (e.isElement == null ? void 0 : e.isElement(A)) ? await (e.getScale == null ? void 0 : e.getScale(A)) || {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+  const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
     x: 1,
     y: 1
   } : {
     x: 1,
     y: 1
-  }, g = Y(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: o,
-    rect: v,
-    offsetParent: A,
-    strategy: x
-  }) : v);
+  };
+  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
   return {
-    top: (p.top - g.top + d.top) / b.y,
-    bottom: (g.bottom - p.bottom + d.bottom) / b.y,
-    left: (p.left - g.left + d.left) / b.x,
-    right: (g.right - p.right + d.right) / b.x
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-const it = function(l) {
-  return l === void 0 && (l = {}), {
+__name(detectOverflow, "detectOverflow");
+const flip = /* @__PURE__ */ __name(function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "flip",
-    options: l,
-    async fn(s) {
-      var f, t;
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform,
+        elements
+      } = state;
       const {
-        placement: a,
-        middlewareData: e,
-        rects: c,
-        initialPlacement: o,
-        platform: x,
-        elements: u
-      } = s, {
-        mainAxis: m = !0,
-        crossAxis: n = !0,
-        fallbackPlacements: r,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: d = "none",
-        flipAlignment: y = !0,
-        ...w
-      } = D(l, s);
-      if ((f = e.arrow) != null && f.alignmentOffset)
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
-      const p = E(a), v = C(o), A = E(o) === o, b = await (x.isRTL == null ? void 0 : x.isRTL(u.floating)), g = r || (A || !y ? [H(o)] : J(o)), V = d !== "none";
-      !r && V && g.push(...K(o, y, d, b));
-      const z = [o, ...g], L = await q(s, w), T = [];
-      let O = ((t = e.flip) == null ? void 0 : t.overflows) || [];
-      if (m && T.push(L[p]), n) {
-        const k = N(a, c, b);
-        T.push(L[k[0]], L[k[1]]);
       }
-      if (O = [...O, {
-        placement: a,
-        overflows: T
-      }], !T.every((k) => k <= 0)) {
-        var F, B;
-        const k = (((F = e.flip) == null ? void 0 : F.index) || 0) + 1, M = z[k];
-        if (M) {
-          var j;
-          const P = n === "alignment" ? v !== C(M) : !1, h = ((j = O[0]) == null ? void 0 : j.overflows[0]) > 0;
-          if (!P || h)
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          var _overflowsData$;
+          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
+          const hasInitialMainAxisOverflow = ((_overflowsData$ = overflowsData[0]) == null ? void 0 : _overflowsData$.overflows[0]) > 0;
+          if (!ignoreCrossAxisOverflow || hasInitialMainAxisOverflow) {
             return {
               data: {
-                index: k,
-                overflows: O
+                index: nextIndex,
+                overflows: overflowsData
               },
               reset: {
-                placement: M
+                placement: nextPlacement
               }
             };
+          }
         }
-        let S = (B = O.filter((P) => P.overflows[0] <= 0).sort((P, h) => P.overflows[1] - h.overflows[1])[0]) == null ? void 0 : B.placement;
-        if (!S)
-          switch (i) {
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
             case "bestFit": {
-              var I;
-              const P = (I = O.filter((h) => {
-                if (V) {
-                  const R = C(h.placement);
-                  return R === v || // Create a bias to the `y` side axis due to horizontal
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
                   // reading directions favoring greater width.
-                  R === "y";
+                  currentSideAxis === "y";
                 }
-                return !0;
-              }).map((h) => [h.placement, h.overflows.filter((R) => R > 0).reduce((R, G) => R + G, 0)]).sort((h, R) => h[1] - R[1])[0]) == null ? void 0 : I[0];
-              P && (S = P);
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
               break;
             }
             case "initialPlacement":
-              S = o;
+              resetPlacement = initialPlacement;
               break;
           }
-        if (a !== S)
+        }
+        if (placement !== resetPlacement) {
           return {
             reset: {
-              placement: S
+              placement: resetPlacement
             }
           };
+        }
       }
       return {};
     }
   };
-};
-async function tt(l, s) {
+}, "flip");
+async function convertValueToCoords(state, options) {
   const {
-    placement: f,
-    platform: t,
-    elements: a
-  } = l, e = await (t.isRTL == null ? void 0 : t.isRTL(a.floating)), c = E(f), o = _(f), x = C(f) === "y", u = ["left", "top"].includes(c) ? -1 : 1, m = e && x ? -1 : 1, n = D(s, l);
+    placement,
+    platform,
+    elements
+  } = state;
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
   let {
-    mainAxis: r,
-    crossAxis: i,
-    alignmentAxis: d
-  } = typeof n == "number" ? {
-    mainAxis: n,
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
     crossAxis: 0,
     alignmentAxis: null
   } : {
-    mainAxis: n.mainAxis || 0,
-    crossAxis: n.crossAxis || 0,
-    alignmentAxis: n.alignmentAxis
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
   };
-  return o && typeof d == "number" && (i = o === "end" ? d * -1 : d), x ? {
-    x: i * m,
-    y: r * u
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
   } : {
-    x: r * u,
-    y: i * m
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
   };
 }
-const st = function(l) {
-  return l === void 0 && (l = 0), {
+__name(convertValueToCoords, "convertValueToCoords");
+const offset = /* @__PURE__ */ __name(function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
     name: "offset",
-    options: l,
-    async fn(s) {
-      var f, t;
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
       const {
-        x: a,
-        y: e,
-        placement: c,
-        middlewareData: o
-      } = s, x = await tt(s, l);
-      return c === ((f = o.offset) == null ? void 0 : f.placement) && (t = o.arrow) != null && t.alignmentOffset ? {} : {
-        x: a + x.x,
-        y: e + x.y,
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
         data: {
-          ...x,
-          placement: c
+          ...diffCoords,
+          placement
         }
       };
     }
   };
-}, ot = function(l) {
-  return l === void 0 && (l = {}), {
+}, "offset");
+const shift = /* @__PURE__ */ __name(function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "shift",
-    options: l,
-    async fn(s) {
+    options,
+    async fn(state) {
       const {
-        x: f,
-        y: t,
-        placement: a
-      } = s, {
-        mainAxis: e = !0,
-        crossAxis: c = !1,
-        limiter: o = {
-          fn: (w) => {
+        x,
+        y,
+        placement
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: /* @__PURE__ */ __name((_ref) => {
             let {
-              x: p,
-              y: v
-            } = w;
+              x: x2,
+              y: y2
+            } = _ref;
             return {
-              x: p,
-              y: v
+              x: x2,
+              y: y2
             };
-          }
+          }, "fn")
         },
-        ...x
-      } = D(l, s), u = {
-        x: f,
-        y: t
-      }, m = await q(s, x), n = C(E(a)), r = U(n);
-      let i = u[r], d = u[n];
-      if (e) {
-        const w = r === "y" ? "top" : "left", p = r === "y" ? "bottom" : "right", v = i + m[w], A = i - m[p];
-        i = X(v, i, A);
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min = mainAxisCoord + overflow[minSide];
+        const max = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min, mainAxisCoord, max);
       }
-      if (c) {
-        const w = n === "y" ? "top" : "left", p = n === "y" ? "bottom" : "right", v = d + m[w], A = d - m[p];
-        d = X(v, d, A);
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min = crossAxisCoord + overflow[minSide];
+        const max = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min, crossAxisCoord, max);
       }
-      const y = o.fn({
-        ...s,
-        [r]: i,
-        [n]: d
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
       });
       return {
-        ...y,
+        ...limitedCoords,
         data: {
-          x: y.x - f,
-          y: y.y - t,
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
           enabled: {
-            [r]: e,
-            [n]: c
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
           }
         }
       };
     }
   };
-};
+}, "shift");
 export {
-  nt as computePosition,
-  q as detectOverflow,
-  it as flip,
-  st as offset,
-  Y as rectToClientRect,
-  ot as shift
+  computePosition,
+  detectOverflow,
+  flip,
+  offset,
+  rectToClientRect,
+  shift
 };