dap-design-system 0.60.2 → 0.61.0

package/dist/node_modules/@babel/runtime/helpers/esm/classCallCheck.js

@@ -0,0 +1,7 @@
+function c(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+export {
+  c as default
+};
+//# sourceMappingURL=classCallCheck.js.map

package/dist/node_modules/@babel/runtime/helpers/esm/classCallCheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classCallCheck.js","sources":["../../../../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js"],"sourcesContent":["function _classCallCheck(a, n) {\n  if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nexport { _classCallCheck as default };"],"names":["_classCallCheck"],"mappings":"AAAA,SAASA,EAAgB,GAAG,GAAG;AAC7B,MAAI,EAAE,aAAa,GAAI,OAAM,IAAI,UAAU,mCAAmC;AAChF;","x_google_ignoreList":[0]}

package/dist/node_modules/@babel/runtime/helpers/esm/createClass.js

@@ -0,0 +1,16 @@
+import n from "./toPropertyKey.js";
+function f(r, t) {
+  for (var a = 0; a < t.length; a++) {
+    var e = t[a];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(r, n(e.key), e);
+  }
+}
+function l(r, t, a) {
+  return t && f(r.prototype, t), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), r;
+}
+export {
+  l as default
+};
+//# sourceMappingURL=createClass.js.map

package/dist/node_modules/@babel/runtime/helpers/esm/createClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClass.js","sources":["../../../../../../node_modules/@babel/runtime/helpers/esm/createClass.js"],"sourcesContent":["import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nexport { _createClass as default };"],"names":["_defineProperties","e","r","t","o","toPropertyKey","_createClass"],"mappings":";AACA,SAASA,EAAkBC,GAAGC,GAAG;AAC/B,WAASC,IAAI,GAAGA,IAAID,EAAE,QAAQC,KAAK;AACjC,QAAIC,IAAIF,EAAEC,CAAC;AACX,IAAAC,EAAE,aAAaA,EAAE,cAAc,IAAIA,EAAE,eAAe,IAAI,WAAWA,MAAMA,EAAE,WAAW,KAAK,OAAO,eAAeH,GAAGI,EAAcD,EAAE,GAAG,GAAGA,CAAC;AAAA,EAC/I;AACA;AACA,SAASE,EAAaL,GAAGC,GAAGC,GAAG;AAC7B,SAAOD,KAAKF,EAAkBC,EAAE,WAAWC,CAAC,GAAiC,OAAO,eAAeD,GAAG,aAAa;AAAA,IACjH,UAAU;AAAA,EACX,CAAA,GAAGA;AACN;","x_google_ignoreList":[0]}

package/dist/node_modules/@babel/runtime/helpers/esm/toPrimitive.js

@@ -0,0 +1,15 @@
+import t from "./typeof.js";
+function n(r, o) {
+  if (t(r) != "object" || !r) return r;
+  var i = r[Symbol.toPrimitive];
+  if (i !== void 0) {
+    var e = i.call(r, o);
+    if (t(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+export {
+  n as default
+};
+//# sourceMappingURL=toPrimitive.js.map

package/dist/node_modules/@babel/runtime/helpers/esm/toPrimitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPrimitive.js","sources":["../../../../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"],"sourcesContent":["import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };"],"names":["toPrimitive","t","r","_typeof","e","i"],"mappings":";AACA,SAASA,EAAYC,GAAGC,GAAG;AACzB,MAAgBC,EAAQF,CAAC,KAArB,YAA0B,CAACA,EAAG,QAAOA;AACzC,MAAIG,IAAIH,EAAE,OAAO,WAAW;AAC5B,MAAeG,MAAX,QAAc;AAChB,QAAIC,IAAID,EAAE,KAAKH,GAAGC,CAAc;AAChC,QAAgBC,EAAQE,CAAC,KAArB,SAAwB,QAAOA;AACnC,UAAM,IAAI,UAAU,8CAA8C;AAAA,EACtE;AACE,SAAyB,OAAiBJ,CAAC;AAC7C;","x_google_ignoreList":[0]}

package/dist/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js

@@ -0,0 +1,10 @@
+import o from "./typeof.js";
+import i from "./toPrimitive.js";
+function f(t) {
+  var r = i(t, "string");
+  return o(r) == "symbol" ? r : r + "";
+}
+export {
+  f as default
+};
+//# sourceMappingURL=toPropertyKey.js.map

package/dist/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPropertyKey.js","sources":["../../../../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"],"sourcesContent":["import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };"],"names":["toPropertyKey","i","toPrimitive","_typeof"],"mappings":";;AAEA,SAASA,EAAc,GAAG;AACxB,MAAIC,IAAIC,EAAY,GAAG,QAAQ;AAC/B,SAAmBC,EAAQF,CAAC,KAArB,WAAyBA,IAAIA,IAAI;AAC1C;","x_google_ignoreList":[0]}

package/dist/node_modules/@babel/runtime/helpers/esm/typeof.js

@@ -0,0 +1,12 @@
+function o(e) {
+  "@babel/helpers - typeof";
+  return o = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, o(e);
+}
+export {
+  o as default
+};
+//# sourceMappingURL=typeof.js.map

package/dist/node_modules/@babel/runtime/helpers/esm/typeof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeof.js","sources":["../../../../../../node_modules/@babel/runtime/helpers/esm/typeof.js"],"sourcesContent":["function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };"],"names":["_typeof","o"],"mappings":"AAAA,SAASA,EAAQC,GAAG;AAClB;AAEA,SAAOD,IAAwB,OAAO,UAArB,cAA2C,OAAO,OAAO,YAA1B,WAAqC,SAAUC,GAAG;AAChG,WAAO,OAAOA;AAAA,EACf,IAAG,SAAUA,GAAG;AACf,WAAOA,KAAmB,OAAO,UAArB,cAA+BA,EAAE,gBAAgB,UAAUA,MAAM,OAAO,YAAY,WAAW,OAAOA;AAAA,EACtH,GAAKD,EAAQC,CAAC;AACd;","x_google_ignoreList":[0]}

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,483 @@
+var at = Object.defineProperty, lt = Object.defineProperties;
+var ct = Object.getOwnPropertyDescriptors;
+var I = Object.getOwnPropertySymbols;
+var U = Object.prototype.hasOwnProperty, Z = Object.prototype.propertyIsEnumerable;
+var Q = (t, r, e) => r in t ? at(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e, T = (t, r) => {
+  for (var e in r || (r = {}))
+    U.call(r, e) && Q(t, e, r[e]);
+  if (I)
+    for (var e of I(r))
+      Z.call(r, e) && Q(t, e, r[e]);
+  return t;
+}, Y = (t, r) => lt(t, ct(r));
+var q = (t, r) => {
+  var e = {};
+  for (var n in t)
+    U.call(t, n) && r.indexOf(n) < 0 && (e[n] = t[n]);
+  if (t != null && I)
+    for (var n of I(t))
+      r.indexOf(n) < 0 && Z.call(t, n) && (e[n] = t[n]);
+  return e;
+};
+var L = (t, r, e) => new Promise((n, f) => {
+  var o = (s) => {
+    try {
+      c(e.next(s));
+    } catch (g) {
+      f(g);
+    }
+  }, l = (s) => {
+    try {
+      c(e.throw(s));
+    } catch (g) {
+      f(g);
+    }
+  }, c = (s) => s.done ? n(s.value) : Promise.resolve(s.value).then(o, l);
+  c((e = e.apply(t, r)).next());
+});
+import { evaluate as X, getSide as z, getSideAxis as j, getOppositePlacement as rt, getExpandedPlacements as ft, getOppositeAxisPlacements as mt, getAlignmentSides as dt, clamp as K, getAlignment as J, min as G, max as _, getPaddingObject as nt, getAlignmentAxis as it, rectToClientRect as tt, getOppositeAxis as gt, getAxisLength as ot } from "../../utils/dist/floating-ui.utils.js";
+function et(t, r, e) {
+  let {
+    reference: n,
+    floating: f
+  } = t;
+  const o = j(r), l = it(r), c = ot(l), s = z(r), g = o === "y", u = n.x + n.width / 2 - f.width / 2, i = n.y + n.height / 2 - f.height / 2, d = n[c] / 2 - f[c] / 2;
+  let a;
+  switch (s) {
+    case "top":
+      a = {
+        x: u,
+        y: n.y - f.height
+      };
+      break;
+    case "bottom":
+      a = {
+        x: u,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      a = {
+        x: n.x + n.width,
+        y: i
+      };
+      break;
+    case "left":
+      a = {
+        x: n.x - f.width,
+        y: i
+      };
+      break;
+    default:
+      a = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (J(r)) {
+    case "start":
+      a[l] -= d * (e && g ? -1 : 1);
+      break;
+    case "end":
+      a[l] += d * (e && g ? -1 : 1);
+      break;
+  }
+  return a;
+}
+const ht = (t, r, e) => L(null, null, function* () {
+  const {
+    placement: n = "bottom",
+    strategy: f = "absolute",
+    middleware: o = [],
+    platform: l
+  } = e, c = o.filter(Boolean), s = yield l.isRTL == null ? void 0 : l.isRTL(r);
+  let g = yield l.getElementRects({
+    reference: t,
+    floating: r,
+    strategy: f
+  }), {
+    x: u,
+    y: i
+  } = et(g, n, s), d = n, a = {}, m = 0;
+  for (let x = 0; x < c.length; x++) {
+    const {
+      name: w,
+      fn: y
+    } = c[x], {
+      x: A,
+      y: h,
+      data: v,
+      reset: p
+    } = yield y({
+      x: u,
+      y: i,
+      initialPlacement: n,
+      placement: d,
+      strategy: f,
+      middlewareData: a,
+      rects: g,
+      platform: l,
+      elements: {
+        reference: t,
+        floating: r
+      }
+    });
+    u = A != null ? A : u, i = h != null ? h : i, a = Y(T({}, a), {
+      [w]: T(T({}, a[w]), v)
+    }), p && m <= 50 && (m++, typeof p == "object" && (p.placement && (d = p.placement), p.rects && (g = p.rects === !0 ? yield l.getElementRects({
+      reference: t,
+      floating: r,
+      strategy: f
+    }) : p.rects), {
+      x: u,
+      y: i
+    } = et(g, d, s)), x = -1);
+  }
+  return {
+    x: u,
+    y: i,
+    placement: d,
+    strategy: f,
+    middlewareData: a
+  };
+});
+function N(t, r) {
+  return L(this, null, function* () {
+    var e;
+    r === void 0 && (r = {});
+    const {
+      x: n,
+      y: f,
+      platform: o,
+      rects: l,
+      elements: c,
+      strategy: s
+    } = t, {
+      boundary: g = "clippingAncestors",
+      rootBoundary: u = "viewport",
+      elementContext: i = "floating",
+      altBoundary: d = !1,
+      padding: a = 0
+    } = X(r, t), m = nt(a), w = c[d ? i === "floating" ? "reference" : "floating" : i], y = tt(yield o.getClippingRect({
+      element: (e = yield o.isElement == null ? void 0 : o.isElement(w)) == null || e ? w : w.contextElement || (yield o.getDocumentElement == null ? void 0 : o.getDocumentElement(c.floating)),
+      boundary: g,
+      rootBoundary: u,
+      strategy: s
+    })), A = i === "floating" ? {
+      x: n,
+      y: f,
+      width: l.floating.width,
+      height: l.floating.height
+    } : l.reference, h = yield o.getOffsetParent == null ? void 0 : o.getOffsetParent(c.floating), v = (yield o.isElement == null ? void 0 : o.isElement(h)) ? (yield o.getScale == null ? void 0 : o.getScale(h)) || {
+      x: 1,
+      y: 1
+    } : {
+      x: 1,
+      y: 1
+    }, p = tt(o.convertOffsetParentRelativeRectToViewportRelativeRect ? yield o.convertOffsetParentRelativeRectToViewportRelativeRect({
+      elements: c,
+      rect: A,
+      offsetParent: h,
+      strategy: s
+    }) : A);
+    return {
+      top: (y.top - p.top + m.top) / v.y,
+      bottom: (p.bottom - y.bottom + m.bottom) / v.y,
+      left: (y.left - p.left + m.left) / v.x,
+      right: (p.right - y.right + m.right) / v.x
+    };
+  });
+}
+const vt = (t) => ({
+  name: "arrow",
+  options: t,
+  fn(e) {
+    return L(this, null, function* () {
+      const {
+        x: n,
+        y: f,
+        placement: o,
+        rects: l,
+        platform: c,
+        elements: s,
+        middlewareData: g
+      } = e, {
+        element: u,
+        padding: i = 0
+      } = X(t, e) || {};
+      if (u == null)
+        return {};
+      const d = nt(i), a = {
+        x: n,
+        y: f
+      }, m = it(o), x = ot(m), w = yield c.getDimensions(u), y = m === "y", A = y ? "top" : "left", h = y ? "bottom" : "right", v = y ? "clientHeight" : "clientWidth", p = l.reference[x] + l.reference[m] - a[m] - l.floating[x], W = a[m] - l.reference[m], M = yield c.getOffsetParent == null ? void 0 : c.getOffsetParent(u);
+      let O = M ? M[v] : 0;
+      (!O || !(yield c.isElement == null ? void 0 : c.isElement(M))) && (O = s.floating[v] || l.floating[x]);
+      const k = p / 2 - W / 2, S = O / 2 - w[x] / 2 - 1, P = G(d[A], S), V = G(d[h], S), C = P, $ = O - w[x] - V, b = O / 2 - w[x] / 2 + k, R = K(C, b, $), B = !g.arrow && J(o) != null && b !== R && l.reference[x] / 2 - (b < C ? P : V) - w[x] / 2 < 0, E = B ? b < C ? b - C : b - $ : 0;
+      return {
+        [m]: a[m] + E,
+        data: T({
+          [m]: R,
+          centerOffset: b - R - E
+        }, B && {
+          alignmentOffset: E
+        }),
+        reset: B
+      };
+    });
+  }
+}), yt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    fn(e) {
+      return L(this, null, function* () {
+        var n, f;
+        const {
+          placement: o,
+          middlewareData: l,
+          rects: c,
+          initialPlacement: s,
+          platform: g,
+          elements: u
+        } = e, b = X(t, e), {
+          mainAxis: i = !0,
+          crossAxis: d = !0,
+          fallbackPlacements: a,
+          fallbackStrategy: m = "bestFit",
+          fallbackAxisSideDirection: x = "none",
+          flipAlignment: w = !0
+        } = b, y = q(b, [
+          "mainAxis",
+          "crossAxis",
+          "fallbackPlacements",
+          "fallbackStrategy",
+          "fallbackAxisSideDirection",
+          "flipAlignment"
+        ]);
+        if ((n = l.arrow) != null && n.alignmentOffset)
+          return {};
+        const A = z(o), h = j(s), v = z(s) === s, p = yield g.isRTL == null ? void 0 : g.isRTL(u.floating), W = a || (v || !w ? [rt(s)] : ft(s)), M = x !== "none";
+        !a && M && W.push(...mt(s, w, x, p));
+        const O = [s, ...W], k = yield N(e, y), S = [];
+        let P = ((f = l.flip) == null ? void 0 : f.overflows) || [];
+        if (i && S.push(k[A]), d) {
+          const R = dt(o, c, p);
+          S.push(k[R[0]], k[R[1]]);
+        }
+        if (P = [...P, {
+          placement: o,
+          overflows: S
+        }], !S.every((R) => R <= 0)) {
+          var V, C;
+          const R = (((V = l.flip) == null ? void 0 : V.index) || 0) + 1, B = O[R];
+          if (B && (!(d === "alignment" ? h !== j(B) : !1) || // We leave the current main axis only if every placement on that axis
+          // overflows the main axis.
+          P.every((D) => j(D.placement) === h ? D.overflows[0] > 0 : !0)))
+            return {
+              data: {
+                index: R,
+                overflows: P
+              },
+              reset: {
+                placement: B
+              }
+            };
+          let E = (C = P.filter((H) => H.overflows[0] <= 0).sort((H, D) => H.overflows[1] - D.overflows[1])[0]) == null ? void 0 : C.placement;
+          if (!E)
+            switch (m) {
+              case "bestFit": {
+                var $;
+                const H = ($ = P.filter((D) => {
+                  if (M) {
+                    const F = j(D.placement);
+                    return F === h || // Create a bias to the `y` side axis due to horizontal
+                    // reading directions favoring greater width.
+                    F === "y";
+                  }
+                  return !0;
+                }).map((D) => [D.placement, D.overflows.filter((F) => F > 0).reduce((F, st) => F + st, 0)]).sort((D, F) => D[1] - F[1])[0]) == null ? void 0 : $[0];
+                H && (E = H);
+                break;
+              }
+              case "initialPlacement":
+                E = s;
+                break;
+            }
+          if (o !== E)
+            return {
+              reset: {
+                placement: E
+              }
+            };
+        }
+        return {};
+      });
+    }
+  };
+}, xt = /* @__PURE__ */ new Set(["left", "top"]);
+function ut(t, r) {
+  return L(this, null, function* () {
+    const {
+      placement: e,
+      platform: n,
+      elements: f
+    } = t, o = yield n.isRTL == null ? void 0 : n.isRTL(f.floating), l = z(e), c = J(e), s = j(e) === "y", g = xt.has(l) ? -1 : 1, u = o && s ? -1 : 1, i = X(r, t);
+    let {
+      mainAxis: d,
+      crossAxis: a,
+      alignmentAxis: m
+    } = typeof i == "number" ? {
+      mainAxis: i,
+      crossAxis: 0,
+      alignmentAxis: null
+    } : {
+      mainAxis: i.mainAxis || 0,
+      crossAxis: i.crossAxis || 0,
+      alignmentAxis: i.alignmentAxis
+    };
+    return c && typeof m == "number" && (a = c === "end" ? m * -1 : m), s ? {
+      x: a * u,
+      y: d * g
+    } : {
+      x: d * g,
+      y: a * u
+    };
+  });
+}
+const At = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    fn(e) {
+      return L(this, null, function* () {
+        var n, f;
+        const {
+          x: o,
+          y: l,
+          placement: c,
+          middlewareData: s
+        } = e, g = yield ut(e, t);
+        return c === ((n = s.offset) == null ? void 0 : n.placement) && (f = s.arrow) != null && f.alignmentOffset ? {} : {
+          x: o + g.x,
+          y: l + g.y,
+          data: Y(T({}, g), {
+            placement: c
+          })
+        };
+      });
+    }
+  };
+}, bt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    fn(e) {
+      return L(this, null, function* () {
+        const {
+          x: n,
+          y: f,
+          placement: o
+        } = e, y = X(t, e), {
+          mainAxis: l = !0,
+          crossAxis: c = !1,
+          limiter: s = {
+            fn: (A) => {
+              let {
+                x: h,
+                y: v
+              } = A;
+              return {
+                x: h,
+                y: v
+              };
+            }
+          }
+        } = y, g = q(y, [
+          "mainAxis",
+          "crossAxis",
+          "limiter"
+        ]), u = {
+          x: n,
+          y: f
+        }, i = yield N(e, g), d = j(z(o)), a = gt(d);
+        let m = u[a], x = u[d];
+        if (l) {
+          const A = a === "y" ? "top" : "left", h = a === "y" ? "bottom" : "right", v = m + i[A], p = m - i[h];
+          m = K(v, m, p);
+        }
+        if (c) {
+          const A = d === "y" ? "top" : "left", h = d === "y" ? "bottom" : "right", v = x + i[A], p = x - i[h];
+          x = K(v, x, p);
+        }
+        const w = s.fn(Y(T({}, e), {
+          [a]: m,
+          [d]: x
+        }));
+        return Y(T({}, w), {
+          data: {
+            x: w.x - n,
+            y: w.y - f,
+            enabled: {
+              [a]: l,
+              [d]: c
+            }
+          }
+        });
+      });
+    }
+  };
+}, Pt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    fn(e) {
+      return L(this, null, function* () {
+        var n, f;
+        const {
+          placement: o,
+          rects: l,
+          platform: c,
+          elements: s
+        } = e, P = X(t, e), {
+          apply: g = () => {
+          }
+        } = P, u = q(P, [
+          "apply"
+        ]), i = yield N(e, u), d = z(o), a = J(o), m = j(o) === "y", {
+          width: x,
+          height: w
+        } = l.floating;
+        let y, A;
+        d === "top" || d === "bottom" ? (y = d, A = a === ((yield c.isRTL == null ? void 0 : c.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (A = d, y = a === "end" ? "top" : "bottom");
+        const h = w - i.top - i.bottom, v = x - i.left - i.right, p = G(w - i[y], h), W = G(x - i[A], v), M = !e.middlewareData.shift;
+        let O = p, k = W;
+        if ((n = e.middlewareData.shift) != null && n.enabled.x && (k = v), (f = e.middlewareData.shift) != null && f.enabled.y && (O = h), M && !a) {
+          const V = _(i.left, 0), C = _(i.right, 0), $ = _(i.top, 0), b = _(i.bottom, 0);
+          m ? k = x - 2 * (V !== 0 || C !== 0 ? V + C : _(i.left, i.right)) : O = w - 2 * ($ !== 0 || b !== 0 ? $ + b : _(i.top, i.bottom));
+        }
+        yield g(Y(T({}, e), {
+          availableWidth: k,
+          availableHeight: O
+        }));
+        const S = yield c.getDimensions(s.floating);
+        return x !== S.width || w !== S.height ? {
+          reset: {
+            rects: !0
+          }
+        } : {};
+      });
+    }
+  };
+};
+export {
+  vt as arrow,
+  ht as computePosition,
+  N as detectOverflow,
+  yt as flip,
+  At as offset,
+  tt as rectToClientRect,
+  bt as shift,
+  Pt as size
+};
+//# sourceMappingURL=floating-ui.core.js.map