@opentiny/vue-hooks 2.19.0

package/index.js

@@ -0,0 +1,2269 @@
+import { hooks } from '@opentiny/vue-common';
+
+var _excluded = ["mainAxis", "crossAxis", "fallbackPlacements", "fallbackStrategy", "fallbackAxisSideDirection", "flipAlignment"], _excluded2 = ["strategy"], _excluded3 = ["mainAxis", "crossAxis", "limiter"];
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r)
+    return {};
+  var t = {};
+  for (var n in r)
+    if ({}.hasOwnProperty.call(r, n)) {
+      if (e.includes(n))
+        continue;
+      t[n] = r[n];
+    }
+  return t;
+}
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  _regeneratorRuntime = function _regeneratorRuntime2() {
+    return e;
+  };
+  var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
+    t2[e2] = r2.value;
+  }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
+  function define(t2, e2, r2) {
+    return Object.defineProperty(t2, e2, { value: r2, enumerable: true, configurable: true, writable: true }), t2[e2];
+  }
+  try {
+    define({}, "");
+  } catch (t2) {
+    define = function define2(t3, e2, r2) {
+      return t3[e2] = r2;
+    };
+  }
+  function wrap(t2, e2, r2, n2) {
+    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c2 = new Context(n2 || []);
+    return o(a2, "_invoke", { value: makeInvokeMethod(t2, r2, c2) }), a2;
+  }
+  function tryCatch(t2, e2, r2) {
+    try {
+      return { type: "normal", arg: t2.call(e2, r2) };
+    } catch (t3) {
+      return { type: "throw", arg: t3 };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
+  function Generator() {
+  }
+  function GeneratorFunction() {
+  }
+  function GeneratorFunctionPrototype() {
+  }
+  var p = {};
+  define(p, a, function() {
+    return this;
+  });
+  var d = Object.getPrototypeOf, v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t2) {
+    ["next", "throw", "return"].forEach(function(e2) {
+      define(t2, e2, function(t3) {
+        return this._invoke(e2, t3);
+      });
+    });
+  }
+  function AsyncIterator(t2, e2) {
+    function invoke(r3, o2, i2, a2) {
+      var c2 = tryCatch(t2[r3], t2, o2);
+      if ("throw" !== c2.type) {
+        var u2 = c2.arg, h2 = u2.value;
+        return h2 && "object" == typeof h2 && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
+          invoke("next", t3, i2, a2);
+        }, function(t3) {
+          invoke("throw", t3, i2, a2);
+        }) : e2.resolve(h2).then(function(t3) {
+          u2.value = t3, i2(u2);
+        }, function(t3) {
+          return invoke("throw", t3, i2, a2);
+        });
+      }
+      a2(c2.arg);
+    }
+    var r2;
+    o(this, "_invoke", { value: function value(t3, n2) {
+      function callInvokeWithMethodAndArg() {
+        return new e2(function(e3, r3) {
+          invoke(t3, n2, e3, r3);
+        });
+      }
+      return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    } });
+  }
+  function makeInvokeMethod(e2, r2, n2) {
+    var o2 = h;
+    return function(i2, a2) {
+      if (o2 === f)
+        throw Error("Generator is already running");
+      if (o2 === s) {
+        if ("throw" === i2)
+          throw a2;
+        return { value: t, done: true };
+      }
+      for (n2.method = i2, n2.arg = a2; ; ) {
+        var c2 = n2.delegate;
+        if (c2) {
+          var u2 = maybeInvokeDelegate(c2, n2);
+          if (u2) {
+            if (u2 === y)
+              continue;
+            return u2;
+          }
+        }
+        if ("next" === n2.method)
+          n2.sent = n2._sent = n2.arg;
+        else if ("throw" === n2.method) {
+          if (o2 === h)
+            throw o2 = s, n2.arg;
+          n2.dispatchException(n2.arg);
+        } else
+          "return" === n2.method && n2.abrupt("return", n2.arg);
+        o2 = f;
+        var p2 = tryCatch(e2, r2, n2);
+        if ("normal" === p2.type) {
+          if (o2 = n2.done ? s : l, p2.arg === y)
+            continue;
+          return { value: p2.arg, done: n2.done };
+        }
+        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e2, r2) {
+    var n2 = r2.method, o2 = e2.iterator[n2];
+    if (o2 === t)
+      return r2.delegate = null, "throw" === n2 && e2.iterator.return && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
+    var i2 = tryCatch(o2, e2.iterator, r2.arg);
+    if ("throw" === i2.type)
+      return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
+    var a2 = i2.arg;
+    return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
+  }
+  function pushTryEntry(t2) {
+    var e2 = { tryLoc: t2[0] };
+    1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
+  }
+  function resetTryEntry(t2) {
+    var e2 = t2.completion || {};
+    e2.type = "normal", delete e2.arg, t2.completion = e2;
+  }
+  function Context(t2) {
+    this.tryEntries = [{ tryLoc: "root" }], t2.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e2) {
+    if (e2 || "" === e2) {
+      var r2 = e2[a];
+      if (r2)
+        return r2.call(e2);
+      if ("function" == typeof e2.next)
+        return e2;
+      if (!isNaN(e2.length)) {
+        var o2 = -1, i2 = function next() {
+          for (; ++o2 < e2.length; )
+            if (n.call(e2, o2))
+              return next.value = e2[o2], next.done = false, next;
+          return next.value = t, next.done = true, next;
+        };
+        return i2.next = i2;
+      }
+    }
+    throw new TypeError(typeof e2 + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: true }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: true }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
+    var e2 = "function" == typeof t2 && t2.constructor;
+    return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
+  }, e.mark = function(t2) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+  }, e.awrap = function(t2) {
+    return { __await: t2 };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function() {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
+    void 0 === i2 && (i2 = Promise);
+    var a2 = new AsyncIterator(wrap(t2, r2, n2, o2), i2);
+    return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
+      return t3.done ? t3.value : a2.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
+    return this;
+  }), define(g, "toString", function() {
+    return "[object Generator]";
+  }), e.keys = function(t2) {
+    var e2 = Object(t2), r2 = [];
+    for (var n2 in e2)
+      r2.push(n2);
+    return r2.reverse(), function next() {
+      for (; r2.length; ) {
+        var t3 = r2.pop();
+        if (t3 in e2)
+          return next.value = t3, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e2) {
+    if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2)
+      for (var r2 in this)
+        "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
+  }, stop: function stop() {
+    this.done = true;
+    var t2 = this.tryEntries[0].completion;
+    if ("throw" === t2.type)
+      throw t2.arg;
+    return this.rval;
+  }, dispatchException: function dispatchException(e2) {
+    if (this.done)
+      throw e2;
+    var r2 = this;
+    function handle(n2, o3) {
+      return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
+    }
+    for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
+      var i2 = this.tryEntries[o2], a2 = i2.completion;
+      if ("root" === i2.tryLoc)
+        return handle("end");
+      if (i2.tryLoc <= this.prev) {
+        var c2 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
+        if (c2 && u2) {
+          if (this.prev < i2.catchLoc)
+            return handle(i2.catchLoc, true);
+          if (this.prev < i2.finallyLoc)
+            return handle(i2.finallyLoc);
+        } else if (c2) {
+          if (this.prev < i2.catchLoc)
+            return handle(i2.catchLoc, true);
+        } else {
+          if (!u2)
+            throw Error("try statement without catch or finally");
+          if (this.prev < i2.finallyLoc)
+            return handle(i2.finallyLoc);
+        }
+      }
+    }
+  }, abrupt: function abrupt(t2, e2) {
+    for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+      var o2 = this.tryEntries[r2];
+      if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
+        var i2 = o2;
+        break;
+      }
+    }
+    i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
+    var a2 = i2 ? i2.completion : {};
+    return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
+  }, complete: function complete(t2, e2) {
+    if ("throw" === t2.type)
+      throw t2.arg;
+    return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
+  }, finish: function finish(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.finallyLoc === t2)
+        return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
+    }
+  }, catch: function _catch(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.tryLoc === t2) {
+        var n2 = r2.completion;
+        if ("throw" === n2.type) {
+          var o2 = n2.arg;
+          resetTryEntry(r2);
+        }
+        return o2;
+      }
+    }
+    throw Error("illegal catch attempt");
+  }, delegateYield: function delegateYield(e2, r2, n2) {
+    return this.delegate = { iterator: values(e2), resultName: r2, nextLoc: n2 }, "next" === this.method && (this.arg = t), y;
+  } }, e;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c), u = i.value;
+  } catch (n2) {
+    return void e(n2);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(r, o) {
+      var a = n.apply(t, e);
+      function _next(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
+      }
+      function _throw(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t)
+        ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+var sides = ["top", "right", "bottom", "left"];
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = function createCoords2(v) {
+  return {
+    x: v,
+    y: v
+  };
+};
+var oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+var oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  var alignment = getAlignment(placement);
+  var alignmentAxis = getAlignmentAxis(placement);
+  var length = getAxisLength(alignmentAxis);
+  var mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  var oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, function(alignment) {
+    return oppositeAlignmentMap[alignment];
+  });
+}
+function getSideList(side, isStart, rtl) {
+  var lr = ["left", "right"];
+  var rl = ["right", "left"];
+  var tb = ["top", "bottom"];
+  var bt = ["bottom", "top"];
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl)
+        return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case "left":
+    case "right":
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  var alignment = getAlignment(placement);
+  var list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map(function(side) {
+      return side + "-" + alignment;
+    });
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, function(side) {
+    return oppositeSideMap[side];
+  });
+}
+function expandPaddingObject(padding) {
+  return _extends({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, padding);
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  var x = rect.x, y = rect.y, width = rect.width, height = rect.height;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  var reference = _ref.reference, floating = _ref.floating;
+  var sideAxis = getSideAxis(placement);
+  var alignmentAxis = getAlignmentAxis(placement);
+  var alignLength = getAxisLength(alignmentAxis);
+  var side = getSide(placement);
+  var isVertical = sideAxis === "y";
+  var commonX = reference.x + reference.width / 2 - floating.width / 2;
+  var commonY = reference.y + reference.height / 2 - floating.height / 2;
+  var commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  var coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case "end":
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+var computePosition$1 = /* @__PURE__ */ function() {
+  var _ref2 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee(reference, floating, config) {
+    var _config$placement, placement, _config$strategy, strategy, _config$middleware, middleware, platform2, validMiddleware, rtl, rects, _computeCoordsFromPla, x, y, statefulPlacement, middlewareData, resetCount, i, _extends2, _validMiddleware$i2, name, fn, _yield$fn2, nextX, nextY, data, reset, _computeCoordsFromPla2;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1)
+        switch (_context.prev = _context.next) {
+          case 0:
+            _config$placement = config.placement, placement = _config$placement === void 0 ? "bottom" : _config$placement, _config$strategy = config.strategy, strategy = _config$strategy === void 0 ? "absolute" : _config$strategy, _config$middleware = config.middleware, middleware = _config$middleware === void 0 ? [] : _config$middleware, platform2 = config.platform;
+            validMiddleware = middleware.filter(Boolean);
+            _context.next = 4;
+            return platform2.isRTL == null ? void 0 : platform2.isRTL(floating);
+          case 4:
+            rtl = _context.sent;
+            _context.next = 7;
+            return platform2.getElementRects({
+              reference,
+              floating,
+              strategy
+            });
+          case 7:
+            rects = _context.sent;
+            _computeCoordsFromPla = computeCoordsFromPlacement(rects, placement, rtl), x = _computeCoordsFromPla.x, y = _computeCoordsFromPla.y;
+            statefulPlacement = placement;
+            middlewareData = {};
+            resetCount = 0;
+            i = 0;
+          case 13:
+            if (!(i < validMiddleware.length)) {
+              _context.next = 45;
+              break;
+            }
+            _validMiddleware$i2 = validMiddleware[i], name = _validMiddleware$i2.name, fn = _validMiddleware$i2.fn;
+            _context.next = 17;
+            return fn({
+              x,
+              y,
+              initialPlacement: placement,
+              placement: statefulPlacement,
+              strategy,
+              middlewareData,
+              rects,
+              platform: platform2,
+              elements: {
+                reference,
+                floating
+              }
+            });
+          case 17:
+            _yield$fn2 = _context.sent;
+            nextX = _yield$fn2.x;
+            nextY = _yield$fn2.y;
+            data = _yield$fn2.data;
+            reset = _yield$fn2.reset;
+            x = nextX != null ? nextX : x;
+            y = nextY != null ? nextY : y;
+            middlewareData = _extends({}, middlewareData, (_extends2 = {}, _extends2[name] = _extends({}, middlewareData[name], data), _extends2));
+            if (!(reset && resetCount <= 50)) {
+              _context.next = 42;
+              break;
+            }
+            resetCount++;
+            if (!(typeof reset === "object")) {
+              _context.next = 41;
+              break;
+            }
+            if (reset.placement) {
+              statefulPlacement = reset.placement;
+            }
+            if (!reset.rects) {
+              _context.next = 38;
+              break;
+            }
+            if (!(reset.rects === true)) {
+              _context.next = 36;
+              break;
+            }
+            _context.next = 33;
+            return platform2.getElementRects({
+              reference,
+              floating,
+              strategy
+            });
+          case 33:
+            _context.t0 = _context.sent;
+            _context.next = 37;
+            break;
+          case 36:
+            _context.t0 = reset.rects;
+          case 37:
+            rects = _context.t0;
+          case 38:
+            _computeCoordsFromPla2 = computeCoordsFromPlacement(rects, statefulPlacement, rtl);
+            x = _computeCoordsFromPla2.x;
+            y = _computeCoordsFromPla2.y;
+          case 41:
+            i = -1;
+          case 42:
+            i++;
+            _context.next = 13;
+            break;
+          case 45:
+            return _context.abrupt("return", {
+              x,
+              y,
+              placement: statefulPlacement,
+              strategy,
+              middlewareData
+            });
+          case 46:
+          case "end":
+            return _context.stop();
+        }
+    }, _callee);
+  }));
+  return function computePosition$12(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+function detectOverflow(_x4, _x5) {
+  return _detectOverflow.apply(this, arguments);
+}
+function _detectOverflow() {
+  _detectOverflow = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee8(state, options) {
+    var _await$platform$isEle, x, y, platform2, rects, elements, strategy, _evaluate5, _evaluate5$boundary, boundary, _evaluate5$rootBounda, rootBoundary, _evaluate5$elementCon, elementContext, _evaluate5$altBoundar, altBoundary, _evaluate5$padding, padding, paddingObject, altContext, element, clippingClientRect, rect, offsetParent, offsetScale, elementClientRect;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1)
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            x = state.x, y = state.y, platform2 = state.platform, rects = state.rects, elements = state.elements, strategy = state.strategy;
+            _evaluate5 = evaluate(options, state), _evaluate5$boundary = _evaluate5.boundary, boundary = _evaluate5$boundary === void 0 ? "clippingAncestors" : _evaluate5$boundary, _evaluate5$rootBounda = _evaluate5.rootBoundary, rootBoundary = _evaluate5$rootBounda === void 0 ? "viewport" : _evaluate5$rootBounda, _evaluate5$elementCon = _evaluate5.elementContext, elementContext = _evaluate5$elementCon === void 0 ? "floating" : _evaluate5$elementCon, _evaluate5$altBoundar = _evaluate5.altBoundary, altBoundary = _evaluate5$altBoundar === void 0 ? false : _evaluate5$altBoundar, _evaluate5$padding = _evaluate5.padding, padding = _evaluate5$padding === void 0 ? 0 : _evaluate5$padding;
+            paddingObject = getPaddingObject(padding);
+            altContext = elementContext === "floating" ? "reference" : "floating";
+            element = elements[altBoundary ? altContext : elementContext];
+            _context8.t0 = rectToClientRect;
+            _context8.t1 = platform2;
+            _context8.next = 10;
+            return platform2.isElement == null ? void 0 : platform2.isElement(element);
+          case 10:
+            _context8.t2 = _await$platform$isEle = _context8.sent;
+            if (!(_context8.t2 != null)) {
+              _context8.next = 15;
+              break;
+            }
+            _context8.t3 = _await$platform$isEle;
+            _context8.next = 16;
+            break;
+          case 15:
+            _context8.t3 = true;
+          case 16:
+            if (!_context8.t3) {
+              _context8.next = 20;
+              break;
+            }
+            _context8.t4 = element;
+            _context8.next = 26;
+            break;
+          case 20:
+            _context8.t5 = element.contextElement;
+            if (_context8.t5) {
+              _context8.next = 25;
+              break;
+            }
+            _context8.next = 24;
+            return platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating);
+          case 24:
+            _context8.t5 = _context8.sent;
+          case 25:
+            _context8.t4 = _context8.t5;
+          case 26:
+            _context8.t6 = _context8.t4;
+            _context8.t7 = boundary;
+            _context8.t8 = rootBoundary;
+            _context8.t9 = strategy;
+            _context8.t10 = {
+              element: _context8.t6,
+              boundary: _context8.t7,
+              rootBoundary: _context8.t8,
+              strategy: _context8.t9
+            };
+            _context8.next = 33;
+            return _context8.t1.getClippingRect.call(_context8.t1, _context8.t10);
+          case 33:
+            _context8.t11 = _context8.sent;
+            clippingClientRect = (0, _context8.t0)(_context8.t11);
+            rect = elementContext === "floating" ? {
+              x,
+              y,
+              width: rects.floating.width,
+              height: rects.floating.height
+            } : rects.reference;
+            _context8.next = 38;
+            return platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating);
+          case 38:
+            offsetParent = _context8.sent;
+            _context8.next = 41;
+            return platform2.isElement == null ? void 0 : platform2.isElement(offsetParent);
+          case 41:
+            if (!_context8.sent) {
+              _context8.next = 50;
+              break;
+            }
+            _context8.next = 44;
+            return platform2.getScale == null ? void 0 : platform2.getScale(offsetParent);
+          case 44:
+            _context8.t13 = _context8.sent;
+            if (_context8.t13) {
+              _context8.next = 47;
+              break;
+            }
+            _context8.t13 = {
+              x: 1,
+              y: 1
+            };
+          case 47:
+            _context8.t12 = _context8.t13;
+            _context8.next = 51;
+            break;
+          case 50:
+            _context8.t12 = {
+              x: 1,
+              y: 1
+            };
+          case 51:
+            offsetScale = _context8.t12;
+            _context8.t14 = rectToClientRect;
+            if (!platform2.convertOffsetParentRelativeRectToViewportRelativeRect) {
+              _context8.next = 59;
+              break;
+            }
+            _context8.next = 56;
+            return platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+              elements,
+              rect,
+              offsetParent,
+              strategy
+            });
+          case 56:
+            _context8.t15 = _context8.sent;
+            _context8.next = 60;
+            break;
+          case 59:
+            _context8.t15 = rect;
+          case 60:
+            _context8.t16 = _context8.t15;
+            elementClientRect = (0, _context8.t14)(_context8.t16);
+            return _context8.abrupt("return", {
+              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
+            });
+          case 63:
+          case "end":
+            return _context8.stop();
+        }
+    }, _callee8);
+  }));
+  return _detectOverflow.apply(this, arguments);
+}
+var arrow$1 = function arrow$12(options) {
+  return {
+    name: "arrow",
+    options,
+    fn: function fn(state) {
+      return _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee2() {
+        var _extends3, _ref4;
+        var x, y, placement, rects, platform2, elements, middlewareData, _ref3, element, _ref3$padding, padding, paddingObject, coords, axis, length, arrowDimensions, isYAxis, minProp, maxProp, clientProp, endDiff, startDiff, arrowOffsetParent, clientSize, centerToReference, largestPossiblePadding, minPadding, maxPadding, min$1, max2, center, offset2, shouldAddOffset, alignmentOffset;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1)
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                x = state.x, y = state.y, placement = state.placement, rects = state.rects, platform2 = state.platform, elements = state.elements, middlewareData = state.middlewareData;
+                _ref3 = evaluate(options, state) || {}, element = _ref3.element, _ref3$padding = _ref3.padding, padding = _ref3$padding === void 0 ? 0 : _ref3$padding;
+                if (!(element == null)) {
+                  _context2.next = 4;
+                  break;
+                }
+                return _context2.abrupt("return", {});
+              case 4:
+                paddingObject = getPaddingObject(padding);
+                coords = {
+                  x,
+                  y
+                };
+                axis = getAlignmentAxis(placement);
+                length = getAxisLength(axis);
+                _context2.next = 10;
+                return platform2.getDimensions(element);
+              case 10:
+                arrowDimensions = _context2.sent;
+                isYAxis = axis === "y";
+                minProp = isYAxis ? "top" : "left";
+                maxProp = isYAxis ? "bottom" : "right";
+                clientProp = isYAxis ? "clientHeight" : "clientWidth";
+                endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+                startDiff = coords[axis] - rects.reference[axis];
+                _context2.next = 19;
+                return platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element);
+              case 19:
+                arrowOffsetParent = _context2.sent;
+                clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+                _context2.t0 = !clientSize;
+                if (_context2.t0) {
+                  _context2.next = 26;
+                  break;
+                }
+                _context2.next = 25;
+                return platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent);
+              case 25:
+                _context2.t0 = !_context2.sent;
+              case 26:
+                if (!_context2.t0) {
+                  _context2.next = 28;
+                  break;
+                }
+                clientSize = elements.floating[clientProp] || rects.floating[length];
+              case 28:
+                centerToReference = endDiff / 2 - startDiff / 2;
+                largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+                minPadding = min(paddingObject[minProp], largestPossiblePadding);
+                maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+                min$1 = minPadding;
+                max2 = clientSize - arrowDimensions[length] - maxPadding;
+                center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+                offset2 = clamp(min$1, center, max2);
+                shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+                alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
+                return _context2.abrupt("return", (_ref4 = {}, _ref4[axis] = coords[axis] + alignmentOffset, _ref4.data = _extends((_extends3 = {}, _extends3[axis] = offset2, _extends3.centerOffset = center - offset2 - alignmentOffset, _extends3), shouldAddOffset && {
+                  alignmentOffset
+                }), _ref4.reset = shouldAddOffset, _ref4));
+              case 39:
+              case "end":
+                return _context2.stop();
+            }
+        }, _callee2);
+      }))();
+    }
+  };
+};
+var flip$1 = function flip$12(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    fn: function fn(state) {
+      return _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee3() {
+        var _middlewareData$arrow, _middlewareData$flip, placement, middlewareData, rects, initialPlacement, platform2, elements, _evaluate, _evaluate$mainAxis, checkMainAxis, _evaluate$crossAxis, checkCrossAxis, specifiedFallbackPlacements, _evaluate$fallbackStr, fallbackStrategy, _evaluate$fallbackAxi, fallbackAxisSideDirection, _evaluate$flipAlignme, flipAlignment, detectOverflowOptions, side, initialSideAxis, isBasePlacement, rtl, fallbackPlacements, hasFallbackAxisSideDirection, placements, overflow, overflows, overflowsData, _sides, _middlewareData$flip2, _overflowsData$filter, nextIndex, nextPlacement, resetPlacement, _overflowsData$filter2, _placement;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1)
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                placement = state.placement, middlewareData = state.middlewareData, rects = state.rects, initialPlacement = state.initialPlacement, platform2 = state.platform, elements = state.elements;
+                _evaluate = evaluate(options, state), _evaluate$mainAxis = _evaluate.mainAxis, checkMainAxis = _evaluate$mainAxis === void 0 ? true : _evaluate$mainAxis, _evaluate$crossAxis = _evaluate.crossAxis, checkCrossAxis = _evaluate$crossAxis === void 0 ? true : _evaluate$crossAxis, specifiedFallbackPlacements = _evaluate.fallbackPlacements, _evaluate$fallbackStr = _evaluate.fallbackStrategy, fallbackStrategy = _evaluate$fallbackStr === void 0 ? "bestFit" : _evaluate$fallbackStr, _evaluate$fallbackAxi = _evaluate.fallbackAxisSideDirection, fallbackAxisSideDirection = _evaluate$fallbackAxi === void 0 ? "none" : _evaluate$fallbackAxi, _evaluate$flipAlignme = _evaluate.flipAlignment, flipAlignment = _evaluate$flipAlignme === void 0 ? true : _evaluate$flipAlignme, detectOverflowOptions = _objectWithoutPropertiesLoose(_evaluate, _excluded);
+                if (!((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)) {
+                  _context3.next = 4;
+                  break;
+                }
+                return _context3.abrupt("return", {});
+              case 4:
+                side = getSide(placement);
+                initialSideAxis = getSideAxis(initialPlacement);
+                isBasePlacement = getSide(initialPlacement) === initialPlacement;
+                _context3.next = 9;
+                return platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating);
+              case 9:
+                rtl = _context3.sent;
+                fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+                hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+                if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+                  fallbackPlacements.push.apply(fallbackPlacements, getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+                }
+                placements = [initialPlacement].concat(fallbackPlacements);
+                _context3.next = 16;
+                return detectOverflow(state, detectOverflowOptions);
+              case 16:
+                overflow = _context3.sent;
+                overflows = [];
+                overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+                if (checkMainAxis) {
+                  overflows.push(overflow[side]);
+                }
+                if (checkCrossAxis) {
+                  _sides = getAlignmentSides(placement, rects, rtl);
+                  overflows.push(overflow[_sides[0]], overflow[_sides[1]]);
+                }
+                overflowsData = [].concat(overflowsData, [{
+                  placement,
+                  overflows
+                }]);
+                if (overflows.every(function(side2) {
+                  return side2 <= 0;
+                })) {
+                  _context3.next = 39;
+                  break;
+                }
+                nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+                nextPlacement = placements[nextIndex];
+                if (!nextPlacement) {
+                  _context3.next = 27;
+                  break;
+                }
+                return _context3.abrupt("return", {
+                  data: {
+                    index: nextIndex,
+                    overflows: overflowsData
+                  },
+                  reset: {
+                    placement: nextPlacement
+                  }
+                });
+              case 27:
+                resetPlacement = (_overflowsData$filter = overflowsData.filter(function(d) {
+                  return d.overflows[0] <= 0;
+                }).sort(function(a, b) {
+                  return a.overflows[1] - b.overflows[1];
+                })[0]) == null ? void 0 : _overflowsData$filter.placement;
+                if (resetPlacement) {
+                  _context3.next = 37;
+                  break;
+                }
+                _context3.t0 = fallbackStrategy;
+                _context3.next = _context3.t0 === "bestFit" ? 32 : _context3.t0 === "initialPlacement" ? 35 : 37;
+                break;
+              case 32:
+                _placement = (_overflowsData$filter2 = overflowsData.filter(function(d) {
+                  if (hasFallbackAxisSideDirection) {
+                    var currentSideAxis = getSideAxis(d.placement);
+                    return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                    // reading directions favoring greater width.
+                    currentSideAxis === "y";
+                  }
+                  return true;
+                }).map(function(d) {
+                  return [d.placement, d.overflows.filter(function(overflow2) {
+                    return overflow2 > 0;
+                  }).reduce(function(acc, overflow2) {
+                    return acc + overflow2;
+                  }, 0)];
+                }).sort(function(a, b) {
+                  return a[1] - b[1];
+                })[0]) == null ? void 0 : _overflowsData$filter2[0];
+                if (_placement) {
+                  resetPlacement = _placement;
+                }
+                return _context3.abrupt("break", 37);
+              case 35:
+                resetPlacement = initialPlacement;
+                return _context3.abrupt("break", 37);
+              case 37:
+                if (!(placement !== resetPlacement)) {
+                  _context3.next = 39;
+                  break;
+                }
+                return _context3.abrupt("return", {
+                  reset: {
+                    placement: resetPlacement
+                  }
+                });
+              case 39:
+                return _context3.abrupt("return", {});
+              case 40:
+              case "end":
+                return _context3.stop();
+            }
+        }, _callee3);
+      }))();
+    }
+  };
+};
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+function isAnySideFullyClipped(overflow) {
+  return sides.some(function(side) {
+    return overflow[side] >= 0;
+  });
+}
+var hide$1 = function hide$12(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "hide",
+    options,
+    fn: function fn(state) {
+      return _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee4() {
+        var rects, _evaluate2, _evaluate2$strategy, strategy, detectOverflowOptions, overflow, offsets, _overflow, _offsets;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1)
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                rects = state.rects;
+                _evaluate2 = evaluate(options, state), _evaluate2$strategy = _evaluate2.strategy, strategy = _evaluate2$strategy === void 0 ? "referenceHidden" : _evaluate2$strategy, detectOverflowOptions = _objectWithoutPropertiesLoose(_evaluate2, _excluded2);
+                _context4.t0 = strategy;
+                _context4.next = _context4.t0 === "referenceHidden" ? 5 : _context4.t0 === "escaped" ? 10 : 15;
+                break;
+              case 5:
+                _context4.next = 7;
+                return detectOverflow(state, _extends({}, detectOverflowOptions, {
+                  elementContext: "reference"
+                }));
+              case 7:
+                overflow = _context4.sent;
+                offsets = getSideOffsets(overflow, rects.reference);
+                return _context4.abrupt("return", {
+                  data: {
+                    referenceHiddenOffsets: offsets,
+                    referenceHidden: isAnySideFullyClipped(offsets)
+                  }
+                });
+              case 10:
+                _context4.next = 12;
+                return detectOverflow(state, _extends({}, detectOverflowOptions, {
+                  altBoundary: true
+                }));
+              case 12:
+                _overflow = _context4.sent;
+                _offsets = getSideOffsets(_overflow, rects.floating);
+                return _context4.abrupt("return", {
+                  data: {
+                    escapedOffsets: _offsets,
+                    escaped: isAnySideFullyClipped(_offsets)
+                  }
+                });
+              case 15:
+                return _context4.abrupt("return", {});
+              case 16:
+              case "end":
+                return _context4.stop();
+            }
+        }, _callee4);
+      }))();
+    }
+  };
+};
+function convertValueToCoords(_x6, _x7) {
+  return _convertValueToCoords.apply(this, arguments);
+}
+function _convertValueToCoords() {
+  _convertValueToCoords = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee9(state, options) {
+    var placement, platform2, elements, rtl, side, alignment, isVertical, mainAxisMulti, crossAxisMulti, rawValue, _ref7, mainAxis, crossAxis, alignmentAxis;
+    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1)
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            placement = state.placement, platform2 = state.platform, elements = state.elements;
+            _context9.next = 3;
+            return platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating);
+          case 3:
+            rtl = _context9.sent;
+            side = getSide(placement);
+            alignment = getAlignment(placement);
+            isVertical = getSideAxis(placement) === "y";
+            mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+            crossAxisMulti = rtl && isVertical ? -1 : 1;
+            rawValue = evaluate(options, state);
+            _ref7 = typeof rawValue === "number" ? {
+              mainAxis: rawValue,
+              crossAxis: 0,
+              alignmentAxis: null
+            } : {
+              mainAxis: rawValue.mainAxis || 0,
+              crossAxis: rawValue.crossAxis || 0,
+              alignmentAxis: rawValue.alignmentAxis
+            }, mainAxis = _ref7.mainAxis, crossAxis = _ref7.crossAxis, alignmentAxis = _ref7.alignmentAxis;
+            if (alignment && typeof alignmentAxis === "number") {
+              crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+            }
+            return _context9.abrupt("return", isVertical ? {
+              x: crossAxis * crossAxisMulti,
+              y: mainAxis * mainAxisMulti
+            } : {
+              x: mainAxis * mainAxisMulti,
+              y: crossAxis * crossAxisMulti
+            });
+          case 13:
+          case "end":
+            return _context9.stop();
+        }
+    }, _callee9);
+  }));
+  return _convertValueToCoords.apply(this, arguments);
+}
+var offset$1 = function offset$12(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    fn: function fn(state) {
+      return _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee5() {
+        var _middlewareData$offse, _middlewareData$arrow, x, y, placement, middlewareData, diffCoords;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1)
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                x = state.x, y = state.y, placement = state.placement, middlewareData = state.middlewareData;
+                _context5.next = 3;
+                return convertValueToCoords(state, options);
+              case 3:
+                diffCoords = _context5.sent;
+                if (!(placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)) {
+                  _context5.next = 6;
+                  break;
+                }
+                return _context5.abrupt("return", {});
+              case 6:
+                return _context5.abrupt("return", {
+                  x: x + diffCoords.x,
+                  y: y + diffCoords.y,
+                  data: _extends({}, diffCoords, {
+                    placement
+                  })
+                });
+              case 7:
+              case "end":
+                return _context5.stop();
+            }
+        }, _callee5);
+      }))();
+    }
+  };
+};
+var shift$1 = function shift$12(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    fn: function fn(state) {
+      return _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee6() {
+        var _extends4, _enabled;
+        var x, y, placement, _evaluate3, _evaluate3$mainAxis, checkMainAxis, _evaluate3$crossAxis, checkCrossAxis, _evaluate3$limiter, limiter, detectOverflowOptions, coords, overflow, crossAxis, mainAxis, mainAxisCoord, crossAxisCoord, minSide, maxSide, _min, _max, _minSide, _maxSide, _min2, _max2, limitedCoords;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1)
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                x = state.x, y = state.y, placement = state.placement;
+                _evaluate3 = evaluate(options, state), _evaluate3$mainAxis = _evaluate3.mainAxis, checkMainAxis = _evaluate3$mainAxis === void 0 ? true : _evaluate3$mainAxis, _evaluate3$crossAxis = _evaluate3.crossAxis, checkCrossAxis = _evaluate3$crossAxis === void 0 ? false : _evaluate3$crossAxis, _evaluate3$limiter = _evaluate3.limiter, limiter = _evaluate3$limiter === void 0 ? {
+                  fn: function fn2(_ref) {
+                    var x2 = _ref.x, y2 = _ref.y;
+                    return {
+                      x: x2,
+                      y: y2
+                    };
+                  }
+                } : _evaluate3$limiter, detectOverflowOptions = _objectWithoutPropertiesLoose(_evaluate3, _excluded3);
+                coords = {
+                  x,
+                  y
+                };
+                _context6.next = 5;
+                return detectOverflow(state, detectOverflowOptions);
+              case 5:
+                overflow = _context6.sent;
+                crossAxis = getSideAxis(getSide(placement));
+                mainAxis = getOppositeAxis(crossAxis);
+                mainAxisCoord = coords[mainAxis];
+                crossAxisCoord = coords[crossAxis];
+                if (checkMainAxis) {
+                  minSide = mainAxis === "y" ? "top" : "left";
+                  maxSide = mainAxis === "y" ? "bottom" : "right";
+                  _min = mainAxisCoord + overflow[minSide];
+                  _max = mainAxisCoord - overflow[maxSide];
+                  mainAxisCoord = clamp(_min, mainAxisCoord, _max);
+                }
+                if (checkCrossAxis) {
+                  _minSide = crossAxis === "y" ? "top" : "left";
+                  _maxSide = crossAxis === "y" ? "bottom" : "right";
+                  _min2 = crossAxisCoord + overflow[_minSide];
+                  _max2 = crossAxisCoord - overflow[_maxSide];
+                  crossAxisCoord = clamp(_min2, crossAxisCoord, _max2);
+                }
+                limitedCoords = limiter.fn(_extends({}, state, (_extends4 = {}, _extends4[mainAxis] = mainAxisCoord, _extends4[crossAxis] = crossAxisCoord, _extends4)));
+                return _context6.abrupt("return", _extends({}, limitedCoords, {
+                  data: {
+                    x: limitedCoords.x - x,
+                    y: limitedCoords.y - y,
+                    enabled: (_enabled = {}, _enabled[mainAxis] = checkMainAxis, _enabled[crossAxis] = checkCrossAxis, _enabled)
+                  }
+                }));
+              case 14:
+              case "end":
+                return _context6.stop();
+            }
+        }, _callee6);
+      }))();
+    }
+  };
+};
+var limitShift$1 = function limitShift$12(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options,
+    fn: function fn(state) {
+      var _ref5;
+      var x = state.x, y = state.y, placement = state.placement, rects = state.rects, middlewareData = state.middlewareData;
+      var _evaluate4 = evaluate(options, state), _evaluate4$offset = _evaluate4.offset, offset2 = _evaluate4$offset === void 0 ? 0 : _evaluate4$offset, _evaluate4$mainAxis = _evaluate4.mainAxis, checkMainAxis = _evaluate4$mainAxis === void 0 ? true : _evaluate4$mainAxis, _evaluate4$crossAxis = _evaluate4.crossAxis, checkCrossAxis = _evaluate4$crossAxis === void 0 ? true : _evaluate4$crossAxis;
+      var coords = {
+        x,
+        y
+      };
+      var crossAxis = getSideAxis(placement);
+      var mainAxis = getOppositeAxis(crossAxis);
+      var mainAxisCoord = coords[mainAxis];
+      var crossAxisCoord = coords[crossAxis];
+      var rawOffset = evaluate(offset2, state);
+      var computedOffset = typeof rawOffset === "number" ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : _extends({
+        mainAxis: 0,
+        crossAxis: 0
+      }, rawOffset);
+      if (checkMainAxis) {
+        var len = mainAxis === "y" ? "height" : "width";
+        var limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        var limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        var _len = mainAxis === "y" ? "width" : "height";
+        var isOriginSide = ["top", "left"].includes(getSide(placement));
+        var _limitMin = rects.reference[crossAxis] - rects.floating[_len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        var _limitMax = rects.reference[crossAxis] + rects.reference[_len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        if (crossAxisCoord < _limitMin) {
+          crossAxisCoord = _limitMin;
+        } else if (crossAxisCoord > _limitMax) {
+          crossAxisCoord = _limitMax;
+        }
+      }
+      return _ref5 = {}, _ref5[mainAxis] = mainAxisCoord, _ref5[crossAxis] = crossAxisCoord, _ref5;
+    }
+  };
+};
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY, display = _getComputedStyle.display;
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [":popover-open", ":modal"].some(function(selector) {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  var webkit = isWebKit();
+  var css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some(function(value) {
+    return (css.willChange || "").includes(value);
+  }) || ["paint", "layout", "strict", "content"].some(function(value) {
+    return (css.contain || "").includes(value);
+  });
+}
+function getContainingBlock(element) {
+  var currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports)
+    return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  var result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  var parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  var scrollableAncestor = getNearestOverflowAncestor(node);
+  var isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  var win = getWindow(scrollableAncestor);
+  if (isBody) {
+    var frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+function getCssDimensions(element) {
+  var css = getComputedStyle(element);
+  var width = parseFloat(css.width) || 0;
+  var height = parseFloat(css.height) || 0;
+  var hasOffset = isHTMLElement(element);
+  var offsetWidth = hasOffset ? element.offsetWidth : width;
+  var offsetHeight = hasOffset ? element.offsetHeight : height;
+  var shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+  var domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  var rect = domElement.getBoundingClientRect();
+  var _getCssDimensions = getCssDimensions(domElement), width = _getCssDimensions.width, height = _getCssDimensions.height, $ = _getCssDimensions.$;
+  var x = ($ ? round(rect.width) : rect.width) / width;
+  var y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  var win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  var clientRect = element.getBoundingClientRect();
+  var domElement = unwrapElement(element);
+  var scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  var visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  var x = (clientRect.left + visualOffsets.x) / scale.x;
+  var y = (clientRect.top + visualOffsets.y) / scale.y;
+  var width = clientRect.width / scale.x;
+  var height = clientRect.height / scale.y;
+  if (domElement) {
+    var win = getWindow(domElement);
+    var offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    var currentWin = win;
+    var currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      var iframeScale = getScale(currentIFrame);
+      var iframeRect = currentIFrame.getBoundingClientRect();
+      var css = getComputedStyle(currentIFrame);
+      var left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      var top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  var elements = _ref.elements, rect = _ref.rect, offsetParent = _ref.offsetParent, strategy = _ref.strategy;
+  var isFixed = strategy === "fixed";
+  var documentElement = getDocumentElement(offsetParent);
+  var topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  var scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  var scale = createCoords(1);
+  var offsets = createCoords(0);
+  var isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      var offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
+  };
+}
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getWindowScrollBarX(element) {
+  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+}
+function getDocumentRect(element) {
+  var html = getDocumentElement(element);
+  var scroll = getNodeScroll(element);
+  var body = element.ownerDocument.body;
+  var width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  var height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  var x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  var y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getViewportRect(element, strategy) {
+  var win = getWindow(element);
+  var html = getDocumentElement(element);
+  var visualViewport = win.visualViewport;
+  var width = html.clientWidth;
+  var height = html.clientHeight;
+  var x = 0;
+  var y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    var visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getInnerBoundingClientRect(element, strategy) {
+  var clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  var top = clientRect.top + element.clientTop;
+  var left = clientRect.left + element.clientLeft;
+  var scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  var width = element.clientWidth * scale.x;
+  var height = element.clientHeight * scale.y;
+  var x = left * scale.x;
+  var y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  var rect;
+  if (clippingAncestor === "viewport") {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    var visualOffsets = getVisualOffsets(element);
+    rect = _extends({}, clippingAncestor, {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y
+    });
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  var parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  var cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  var result = getOverflowAncestors(element, [], false).filter(function(el) {
+    return isElement(el) && getNodeName(el) !== "body";
+  });
+  var currentContainingBlockComputedStyle = null;
+  var elementIsFixed = getComputedStyle(element).position === "fixed";
+  var currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    var computedStyle = getComputedStyle(currentNode);
+    var currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    var shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      result = result.filter(function(ancestor) {
+        return ancestor !== currentNode;
+      });
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  var element = _ref.element, boundary = _ref.boundary, rootBoundary = _ref.rootBoundary, strategy = _ref.strategy;
+  var elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  var clippingAncestors = [].concat(elementClippingAncestors, [rootBoundary]);
+  var firstClippingAncestor = clippingAncestors[0];
+  var clippingRect = clippingAncestors.reduce(function(accRect, clippingAncestor) {
+    var rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+function getDimensions(element) {
+  var _getCssDimensions2 = getCssDimensions(element), width = _getCssDimensions2.width, height = _getCssDimensions2.height;
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  var isOffsetParentAnElement = isHTMLElement(offsetParent);
+  var documentElement = getDocumentElement(offsetParent);
+  var isFixed = strategy === "fixed";
+  var rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  var scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  var offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      var offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  var x = rect.left + scroll.scrollLeft - offsets.x;
+  var y = rect.top + scroll.scrollTop - offsets.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  return element.offsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  var win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    var svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  var offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+var getElementRects = /* @__PURE__ */ function() {
+  var _ref6 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee7(data) {
+    var getOffsetParentFn, getDimensionsFn, floatingDimensions;
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1)
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+            getDimensionsFn = this.getDimensions;
+            _context7.next = 4;
+            return getDimensionsFn(data.floating);
+          case 4:
+            floatingDimensions = _context7.sent;
+            _context7.t0 = getRectRelativeToOffsetParent;
+            _context7.t1 = data.reference;
+            _context7.next = 9;
+            return getOffsetParentFn(data.floating);
+          case 9:
+            _context7.t2 = _context7.sent;
+            _context7.t3 = data.strategy;
+            _context7.t4 = (0, _context7.t0)(_context7.t1, _context7.t2, _context7.t3);
+            _context7.t5 = {
+              x: 0,
+              y: 0,
+              width: floatingDimensions.width,
+              height: floatingDimensions.height
+            };
+            return _context7.abrupt("return", {
+              reference: _context7.t4,
+              floating: _context7.t5
+            });
+          case 14:
+          case "end":
+            return _context7.stop();
+        }
+    }, _callee7, this);
+  }));
+  return function getElementRects2(_x8) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+function isRTL(element) {
+  return getComputedStyle(element).direction === "rtl";
+}
+var platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function observeMove(element, onMove) {
+  var io = null;
+  var timeoutId;
+  var root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    var _element$getBoundingC = element.getBoundingClientRect(), left = _element$getBoundingC.left, top = _element$getBoundingC.top, width = _element$getBoundingC.width, height = _element$getBoundingC.height;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    var insetTop = floor(top);
+    var insetRight = floor(root.clientWidth - (left + width));
+    var insetBottom = floor(root.clientHeight - (top + height));
+    var insetLeft = floor(left);
+    var rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    var options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    var isFirstUpdate = true;
+    function handleObserve(entries) {
+      var ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(function() {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, _extends({}, options, {
+        // Handle <iframe>s
+        root: root.ownerDocument
+      }));
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options, _options$ancestorScro = _options.ancestorScroll, ancestorScroll = _options$ancestorScro === void 0 ? true : _options$ancestorScro, _options$ancestorResi = _options.ancestorResize, ancestorResize = _options$ancestorResi === void 0 ? true : _options$ancestorResi, _options$elementResiz = _options.elementResize, elementResize = _options$elementResiz === void 0 ? typeof ResizeObserver === "function" : _options$elementResiz, _options$layoutShift = _options.layoutShift, layoutShift = _options$layoutShift === void 0 ? typeof IntersectionObserver === "function" : _options$layoutShift, _options$animationFra = _options.animationFrame, animationFrame = _options$animationFra === void 0 ? false : _options$animationFra;
+  var referenceEl = unwrapElement(reference);
+  var ancestors = ancestorScroll || ancestorResize ? [].concat(referenceEl ? getOverflowAncestors(referenceEl) : [], getOverflowAncestors(floating)) : [];
+  ancestors.forEach(function(ancestor) {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  var cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  var reobserveFrame = -1;
+  var resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver(function(_ref) {
+      var firstEntry = _ref[0];
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(function() {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  var frameId;
+  var prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    var nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return function() {
+    var _resizeObserver2;
+    ancestors.forEach(function(ancestor) {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+var offset = offset$1;
+var shift = shift$1;
+var flip = flip$1;
+var hide = hide$1;
+var arrow = arrow$1;
+var limitShift = limitShift$1;
+var computePosition = function computePosition2(reference, floating, options) {
+  var cache = /* @__PURE__ */ new Map();
+  var mergedOptions = _extends({
+    platform
+  }, options);
+  var platformWithCache = _extends({}, mergedOptions.platform, {
+    _c: cache
+  });
+  return computePosition$1(reference, floating, _extends({}, mergedOptions, {
+    platform: platformWithCache
+  }));
+};
+
+var reactive = hooks.reactive, watch$1 = hooks.watch, markRaw = hooks.markRaw, onBeforeUnmount = hooks.onBeforeUnmount;
+var defaultOption = {
+  reference: null,
+  popper: null,
+  show: false,
+  autoUpdate: true,
+  strategy: "absolute",
+  placement: "bottom",
+  offset: 6,
+  arrowVisible: true,
+  rootBoundary: "viewport",
+  boundary: "clippingAncestors",
+  boundaryPadding: 5,
+  syncHide: true,
+  autoHide: false,
+  gpuAcceleration: false,
+  animate: true,
+  animateName: "fade-in-linear",
+  appendToBody: false,
+  customClass: "",
+  flipAble: true,
+  shiftAble: true
+};
+var oppositeSidesMap = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+};
+var toMs = function toMs2(s) {
+  if (s === "auto")
+    return 0;
+  return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+};
+var getTransitionInfo = function getTransitionInfo2(el) {
+  var styles = window.getComputedStyle(el);
+  var timeout = toMs(styles.transitionDelay) + toMs(styles.transitionDuration);
+  if (timeout)
+    return timeout;
+  timeout = toMs(styles.animationDelay) + toMs(styles.animationDuration);
+  if (timeout)
+    return timeout;
+  return 0;
+};
+var applyClass = function applyClass2(el, classes, force) {
+  classes.split(" ").forEach(function(c) {
+    return c && el.classList.toggle(c, force);
+  });
+};
+var updatePopper = function updatePopper2(state) {
+  var middleware = [offset(state.offset)];
+  state.flipAble && middleware.push(flip({
+    rootBoundary: state.rootBoundary,
+    boundary: state.boundary,
+    padding: state.boundaryPadding
+  }));
+  state.shiftAble && middleware.push(shift({
+    limiter: limitShift()
+  }));
+  state.arrowVisible && middleware.push(arrow({
+    element: state.popper.querySelector(".tiny-popper__arrow"),
+    padding: 8
+  }));
+  middleware.push(hide());
+  computePosition(state.reference, state.popper, {
+    placement: state.placement,
+    strategy: state.strategy,
+    middleware
+  }).then(function(_ref) {
+    var _state$_last;
+    var x = _ref.x, y = _ref.y, placement = _ref.placement, strategy = _ref.strategy, middlewareData = _ref.middlewareData;
+    if (state.autoHide && state._last.show) {
+      var timestamp = /* @__PURE__ */ (/* @__PURE__ */ new Date()).getTime();
+      if (timestamp > state._last.timestamp + 300) {
+        state.show = false;
+        return;
+      }
+    }
+    var finalStyles = {};
+    Object.assign(finalStyles, {
+      position: strategy
+    });
+    if (state.gpuAcceleration) {
+      Object.assign(finalStyles, {
+        transform: "translate(" + x + "px," + y + "px)",
+        left: "0",
+        top: "0"
+      });
+    } else {
+      Object.assign(finalStyles, {
+        left: x + "px",
+        top: y + "px"
+      });
+    }
+    if (state.syncHide) {
+      if (middlewareData.hide) {
+        Object.assign(finalStyles, {
+          visibility: middlewareData.hide.referenceHidden ? "hidden" : "visible"
+        });
+      }
+    }
+    Object.assign(state.popper.style, finalStyles);
+    if (state._last.customClass && state._last.customClass !== state.customClass) {
+      applyClass(state.popper, state._last.customClass, false);
+    }
+    if (state.customClass && ((_state$_last = state._last) == null ? void 0 : _state$_last.customClass) !== state.customClass) {
+      applyClass(state.popper, state.customClass, true);
+      state._last.customClass = state.customClass;
+    }
+    if (state.arrowVisible) {
+      var _arrowStyle;
+      var _middlewareData$arrow2 = middlewareData.arrow, arrowX = _middlewareData$arrow2.x, arrowY = _middlewareData$arrow2.y;
+      var arrowElement = state._last.arrowEl;
+      var staticSide = oppositeSidesMap[placement.split("-")[0]];
+      var arrowStyle = (_arrowStyle = {
+        left: arrowX !== null ? arrowX + "px" : "",
+        top: arrowY !== null ? arrowY + "px" : "",
+        right: "",
+        bottom: ""
+      }, _arrowStyle[staticSide] = "-4px", _arrowStyle.display = "block", _arrowStyle);
+      Object.assign(arrowElement.style, arrowStyle);
+    } else {
+      if (state._last.arrowInserted) {
+        state._last.arrowEl.style.display = "none";
+      }
+    }
+    emit(state, "update", {
+      x,
+      y,
+      placement,
+      strategy,
+      middlewareData
+    });
+  });
+};
+var autoUpdatePopper = function autoUpdatePopper2(state) {
+  return autoUpdate(state.reference, state.popper, function() {
+    updatePopper(state);
+  });
+};
+var appendPopper = function appendPopper2(state) {
+  if (state._last.show && state._last.popper === state.popper)
+    return;
+  if (state._last.popper && state._last.popper !== state.popper) {
+    if (state._last.appendToBody) {
+      state._last.popper.remove();
+    } else {
+      state._last.popper.style.display = "none";
+    }
+    state._last.arrowInserted = false;
+    state._last.arrowEl = null;
+  }
+  if (state.popper) {
+    if (state.appendToBody) {
+      document.body.append(state.popper);
+    } else {
+      state.popper.style.display = "block";
+    }
+    if (!state._last.arrowInserted) {
+      var arrowEl = document.createElement("div");
+      arrowEl.className = "tiny-popper__arrow";
+      state.popper.append(arrowEl);
+      state._last.arrowInserted = true;
+      state._last.arrowEl = arrowEl;
+    }
+    if (state.animate) {
+      var enterName = state.animateName + "-enter-from";
+      var activeName = state.animateName + "-enter-active";
+      state.popper.classList.add(enterName, activeName);
+      setTimeout(function() {
+        state.popper.classList.remove(enterName);
+      }, 0);
+      var timeout = getTransitionInfo(state.popper);
+      setTimeout(function() {
+        state.popper.classList.remove(activeName);
+      }, timeout);
+    }
+    emit(state, "show");
+  }
+};
+var closePopper = function closePopper2(state) {
+  if (!state._last.show)
+    return;
+  if (state.popper) {
+    if (state.animate && state.animateName) {
+      var leaveName = state.animateName + "-leave-to";
+      var activeName = state.animateName + "-leave-active";
+      state.popper.classList.add(leaveName, activeName);
+      var timeout = getTransitionInfo(state.popper);
+      setTimeout(function() {
+        state.popper.classList.remove(leaveName, activeName);
+        if (state.appendToBody) {
+          state.popper.remove();
+        } else {
+          state.popper.style.display = "none";
+        }
+        emit(state, "hide");
+      }, timeout);
+    } else {
+      if (state.appendToBody) {
+        state.popper.remove();
+      } else {
+        state.popper.style.display = "none";
+      }
+      emit(state, "hide");
+    }
+  }
+};
+var emit = function emit2(state, eventName, params) {
+  state._events[eventName].forEach(function(cb) {
+    return cb(params);
+  });
+};
+var virtualEl = function virtualEl2(x, y, w, h) {
+  if (w === void 0) {
+    w = 0;
+  }
+  if (h === void 0) {
+    h = 0;
+  }
+  return {
+    getBoundingClientRect: function getBoundingClientRect() {
+      return {
+        width: 0,
+        height: 0,
+        x,
+        y,
+        top: y,
+        left: x,
+        right: x + w,
+        bottom: y + h
+      };
+    }
+  };
+};
+var useFloating = function useFloating2(option) {
+  if (option === void 0) {
+    option = {};
+  }
+  var state = reactive(option);
+  var cleanup = null;
+  Object.keys(defaultOption).forEach(function(key) {
+    if (!Object.prototype.hasOwnProperty.call(state, key)) {
+      state[key] = defaultOption[key];
+    }
+  });
+  state._last = markRaw({});
+  state._events = markRaw({
+    show: [],
+    hide: [],
+    update: []
+  });
+  var watchState = function watchState2() {
+    if (state.popper && state.reference) {
+      if (state.show) {
+        appendPopper(state);
+        if (state.autoUpdate) {
+          cleanup && cleanup();
+          cleanup = autoUpdatePopper(state);
+        } else {
+          updatePopper(state);
+        }
+      } else {
+        cleanup && cleanup();
+        closePopper(state);
+      }
+    } else {
+      cleanup && cleanup();
+      closePopper(state);
+    }
+    state._last.popper = state.popper;
+    state._last.reference = state.reference;
+    state._last.show = state.show && state.popper && state.reference;
+    state._last.appendToBody = state.appendToBody;
+    state._last.timestamp = /* @__PURE__ */ (/* @__PURE__ */ new Date()).getTime();
+  };
+  watch$1(state, watchState, {
+    immediate: true
+  });
+  var on = function on2(eventName, cb) {
+    return state._events[eventName].push(cb);
+  };
+  var off = function off2(eventName, cb) {
+    return state._events[eventName] = state._events[eventName].filter(function(i) {
+      return i !== cb;
+    });
+  };
+  onBeforeUnmount(function() {
+    cleanup && cleanup();
+    closePopper(state);
+  });
+  return {
+    state,
+    on,
+    off,
+    virtualEl,
+    forceUpdate: watchState
+  };
+};
+var ref = hooks.ref, watch = hooks.watch, isRef = hooks.isRef;
+var useLazyShow = function useLazyShow2(show) {
+  var lazyShow = ref(isRef(show) ? show.value : show);
+  if (!lazyShow.value) {
+    var stop = watch(show, function(v) {
+      return v && (lazyShow.value = true) && stop();
+    }, {
+      flush: "sync"
+    });
+  }
+  return {
+    lazyShow
+  };
+};
+
+export { useFloating, useLazyShow };