wj-elements 0.0.11 → 0.0.13

package/dist/wj-popup.js

@@ -1,900 +1,1278 @@
-var Ot = Object.defineProperty;
-var Lt = (t, e, n) => e in t ? Ot(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
-var ut = (t, e, n) => (Lt(t, typeof e != "symbol" ? e + "" : e, n), n);
-import Tt, { event as U } from "./wj-element.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import WJElement, { event } from "./wj-element.js";
 import "./wj-store.js";
-const N = Math.min, R = Math.max, Z = Math.round, Q = Math.floor, B = (t) => ({
-  x: t,
-  y: t
-}), Pt = {
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
   left: "right",
   right: "left",
   bottom: "top",
   top: "bottom"
-}, St = {
+};
+const oppositeAlignmentMap = {
   start: "end",
   end: "start"
 };
-function Dt(t, e, n) {
-  return R(t, N(e, n));
+function clamp(start, value, end) {
+  return max(start, min(value, end));
 }
-function K(t, e) {
-  return typeof t == "function" ? t(e) : t;
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
 }
-function V(t) {
-  return t.split("-")[0];
+function getSide(placement) {
+  return placement.split("-")[0];
 }
-function _(t) {
-  return t.split("-")[1];
+function getAlignment(placement) {
+  return placement.split("-")[1];
 }
-function kt(t) {
-  return t === "x" ? "y" : "x";
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
 }
-function rt(t) {
-  return t === "y" ? "height" : "width";
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
 }
-function nt(t) {
-  return ["top", "bottom"].includes(V(t)) ? "y" : "x";
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
 }
-function ct(t) {
-  return kt(nt(t));
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
 }
-function Wt(t, e, n) {
-  n === void 0 && (n = !1);
-  const o = _(t), i = ct(t), s = rt(i);
-  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
-  return e.reference[s] > e.floating[s] && (r = tt(r)), [r, tt(r)];
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let 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 Ht(t) {
-  const e = tt(t);
-  return [st(t), e, st(e)];
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
 }
-function st(t) {
-  return t.replace(/start|end/g, (e) => St[e]);
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
 }
-function Mt(t, e, n) {
-  const o = ["left", "right"], i = ["right", "left"], s = ["top", "bottom"], r = ["bottom", "top"];
-  switch (t) {
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
     case "top":
     case "bottom":
-      return n ? e ? i : o : e ? o : i;
+      if (rtl)
+        return isStart ? rl : lr;
+      return isStart ? lr : rl;
     case "left":
     case "right":
-      return e ? s : r;
+      return isStart ? tb : bt;
     default:
       return [];
   }
 }
-function Ft(t, e, n, o) {
-  const i = _(t);
-  let s = Mt(V(t), n === "start", o);
-  return i && (s = s.map((r) => r + "-" + i), e && (s = s.concat(s.map(st)))), s;
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
 }
-function tt(t) {
-  return t.replace(/left|right|bottom|top/g, (e) => Pt[e]);
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
 }
-function Nt(t) {
+function expandPaddingObject(padding) {
   return {
     top: 0,
     right: 0,
     bottom: 0,
     left: 0,
-    ...t
+    ...padding
   };
 }
-function gt(t) {
-  return typeof t != "number" ? Nt(t) : {
-    top: t,
-    right: t,
-    bottom: t,
-    left: t
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
   };
 }
-function et(t) {
+function rectToClientRect(rect) {
   return {
-    ...t,
-    top: t.y,
-    left: t.x,
-    right: t.x + t.width,
-    bottom: t.y + t.height
+    ...rect,
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
   };
 }
-function ht(t, e, n) {
+function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
-    reference: o,
-    floating: i
-  } = t;
-  const s = nt(e), r = ct(e), l = rt(r), c = V(e), a = s === "y", d = o.x + o.width / 2 - i.width / 2, u = o.y + o.height / 2 - i.height / 2, p = o[l] / 2 - i[l] / 2;
-  let f;
-  switch (c) {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
     case "top":
-      f = {
-        x: d,
-        y: o.y - i.height
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
       };
       break;
     case "bottom":
-      f = {
-        x: d,
-        y: o.y + o.height
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
       };
       break;
     case "right":
-      f = {
-        x: o.x + o.width,
-        y: u
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
       };
       break;
     case "left":
-      f = {
-        x: o.x - i.width,
-        y: u
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
       };
       break;
     default:
-      f = {
-        x: o.x,
-        y: o.y
+      coords = {
+        x: reference.x,
+        y: reference.y
       };
   }
-  switch (_(e)) {
+  switch (getAlignment(placement)) {
     case "start":
-      f[r] -= p * (n && a ? -1 : 1);
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
     case "end":
-      f[r] += p * (n && a ? -1 : 1);
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
       break;
   }
-  return f;
+  return coords;
 }
-const Bt = async (t, e, n) => {
+const computePosition$1 = async (reference, floating, config) => {
   const {
-    placement: o = "bottom",
-    strategy: i = "absolute",
-    middleware: s = [],
-    platform: r
-  } = n, l = s.filter(Boolean), c = await (r.isRTL == null ? void 0 : r.isRTL(e));
-  let a = await r.getElementRects({
-    reference: t,
-    floating: e,
-    strategy: i
-  }), {
-    x: d,
-    y: u
-  } = ht(a, o, c), p = o, f = {}, h = 0;
-  for (let m = 0; m < l.length; m++) {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
     const {
-      name: w,
-      fn: g
-    } = l[m], {
-      x: v,
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
       y,
-      data: A,
-      reset: x
-    } = await g({
-      x: d,
-      y: u,
-      initialPlacement: o,
-      placement: p,
-      strategy: i,
-      middlewareData: f,
-      rects: a,
-      platform: r,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
       elements: {
-        reference: t,
-        floating: e
+        reference,
+        floating
       }
     });
-    if (d = v ?? d, u = y ?? u, f = {
-      ...f,
-      [w]: {
-        ...f[w],
-        ...A
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
       }
-    }, x && h <= 50) {
-      h++, typeof x == "object" && (x.placement && (p = x.placement), x.rects && (a = x.rects === !0 ? await r.getElementRects({
-        reference: t,
-        floating: e,
-        strategy: i
-      }) : x.rects), {
-        x: d,
-        y: u
-      } = ht(a, p, c)), m = -1;
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
       continue;
     }
   }
   return {
-    x: d,
-    y: u,
-    placement: p,
-    strategy: i,
-    middlewareData: f
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
   };
 };
-async function wt(t, e) {
-  var n;
-  e === void 0 && (e = {});
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
   const {
-    x: o,
-    y: i,
-    platform: s,
-    rects: r,
-    elements: l,
-    strategy: c
-  } = t, {
-    boundary: a = "clippingAncestors",
-    rootBoundary: d = "viewport",
-    elementContext: u = "floating",
-    altBoundary: p = !1,
-    padding: f = 0
-  } = K(e, t), h = gt(f), w = l[p ? u === "floating" ? "reference" : "floating" : u], g = et(await s.getClippingRect({
-    element: (n = await (s.isElement == null ? void 0 : s.isElement(w))) == null || n ? w : w.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(l.floating)),
-    boundary: a,
-    rootBoundary: d,
-    strategy: c
-  })), v = u === "floating" ? {
-    ...r.floating,
-    x: o,
-    y: i
-  } : r.reference, y = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l.floating)), A = await (s.isElement == null ? void 0 : s.isElement(y)) ? await (s.getScale == null ? void 0 : s.getScale(y)) || {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    ...rects.floating,
+    x,
+    y
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
     x: 1,
     y: 1
   } : {
     x: 1,
     y: 1
-  }, x = et(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
-    rect: v,
-    offsetParent: y,
-    strategy: c
-  }) : v);
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
   return {
-    top: (g.top - x.top + h.top) / A.y,
-    bottom: (x.bottom - g.bottom + h.bottom) / A.y,
-    left: (g.left - x.left + h.left) / A.x,
-    right: (x.right - g.right + h.right) / A.x
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-const jt = (t) => ({
+const arrow = (options) => ({
   name: "arrow",
-  options: t,
-  async fn(e) {
+  options,
+  async fn(state) {
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform: platform2,
+      elements,
+      middlewareData
+    } = state;
     const {
-      x: n,
-      y: o,
-      placement: i,
-      rects: s,
-      platform: r,
-      elements: l,
-      middlewareData: c
-    } = e, {
-      element: a,
-      padding: d = 0
-    } = K(t, e) || {};
-    if (a == null)
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
       return {};
-    const u = gt(d), p = {
-      x: n,
-      y: o
-    }, f = ct(i), h = rt(f), m = await r.getDimensions(a), w = f === "y", g = w ? "top" : "left", v = w ? "bottom" : "right", y = w ? "clientHeight" : "clientWidth", A = s.reference[h] + s.reference[f] - p[f] - s.floating[h], x = p[f] - s.reference[f], b = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(a));
-    let E = b ? b[y] : 0;
-    (!E || !await (r.isElement == null ? void 0 : r.isElement(b))) && (E = l.floating[y] || s.floating[h]);
-    const P = A / 2 - x / 2, F = E / 2 - m[h] / 2 - 1, Y = N(u[g], F), X = N(u[v], F), L = Y, q = E - m[h] - X, C = E / 2 - m[h] / 2 + P, S = Dt(L, C, q), D = !c.arrow && _(i) != null && C != S && s.reference[h] / 2 - (C < L ? Y : X) - m[h] / 2 < 0, W = D ? C < L ? C - L : C - q : 0;
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform2.getDimensions(element);
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const min$1 = minPadding;
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = clamp(min$1, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
-      [f]: p[f] + W,
+      [axis]: coords[axis] + alignmentOffset,
       data: {
-        [f]: S,
-        centerOffset: C - S - W,
-        ...D && {
-          alignmentOffset: W
+        [axis]: offset2,
+        centerOffset: center - offset2 - alignmentOffset,
+        ...shouldAddOffset && {
+          alignmentOffset
         }
       },
-      reset: D
+      reset: shouldAddOffset
     };
   }
-}), Vt = function(t) {
-  return t === void 0 && (t = {}), {
+});
+const flip = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "flip",
-    options: t,
-    async fn(e) {
-      var n, o;
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
       const {
-        placement: i,
-        middlewareData: s,
-        rects: r,
-        initialPlacement: l,
-        platform: c,
-        elements: a
-      } = e, {
-        mainAxis: d = !0,
-        crossAxis: u = !0,
-        fallbackPlacements: p,
-        fallbackStrategy: f = "bestFit",
-        fallbackAxisSideDirection: h = "none",
-        flipAlignment: m = !0,
-        ...w
-      } = K(t, e);
-      if ((n = s.arrow) != null && n.alignmentOffset)
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
-      const g = V(i), v = V(l) === l, y = await (c.isRTL == null ? void 0 : c.isRTL(a.floating)), A = p || (v || !m ? [tt(l)] : Ht(l));
-      !p && h !== "none" && A.push(...Ft(l, m, h, y));
-      const x = [l, ...A], b = await wt(e, w), E = [];
-      let P = ((o = s.flip) == null ? void 0 : o.overflows) || [];
-      if (d && E.push(b[g]), u) {
-        const L = Wt(i, r, y);
-        E.push(b[L[0]], b[L[1]]);
       }
-      if (P = [...P, {
-        placement: i,
-        overflows: E
-      }], !E.every((L) => L <= 0)) {
-        var F, Y;
-        const L = (((F = s.flip) == null ? void 0 : F.index) || 0) + 1, q = x[L];
-        if (q)
+      const side = getSide(placement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
           return {
             data: {
-              index: L,
-              overflows: P
+              index: nextIndex,
+              overflows: overflowsData
             },
             reset: {
-              placement: q
+              placement: nextPlacement
             }
           };
-        let C = (Y = P.filter((S) => S.overflows[0] <= 0).sort((S, D) => S.overflows[1] - D.overflows[1])[0]) == null ? void 0 : Y.placement;
-        if (!C)
-          switch (f) {
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
             case "bestFit": {
-              var X;
-              const S = (X = P.map((D) => [D.placement, D.overflows.filter((W) => W > 0).reduce((W, Rt) => W + Rt, 0)]).sort((D, W) => D[1] - W[1])[0]) == null ? void 0 : X[0];
-              S && (C = S);
+              var _overflowsData$map$so;
+              const placement2 = (_overflowsData$map$so = overflowsData.map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
               break;
             }
             case "initialPlacement":
-              C = l;
+              resetPlacement = initialPlacement;
               break;
           }
-        if (i !== C)
+        }
+        if (placement !== resetPlacement) {
           return {
             reset: {
-              placement: C
+              placement: resetPlacement
             }
           };
+        }
       }
       return {};
     }
   };
 };
-async function zt(t, e) {
+async function convertValueToCoords(state, options) {
   const {
-    placement: n,
-    platform: o,
-    elements: i
-  } = t, s = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = V(n), l = _(n), c = nt(n) === "y", a = ["left", "top"].includes(r) ? -1 : 1, d = s && c ? -1 : 1, u = K(e, t);
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
   let {
-    mainAxis: p,
-    crossAxis: f,
-    alignmentAxis: h
-  } = typeof u == "number" ? {
-    mainAxis: u,
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
     crossAxis: 0,
     alignmentAxis: null
   } : {
     mainAxis: 0,
     crossAxis: 0,
     alignmentAxis: null,
-    ...u
+    ...rawValue
   };
-  return l && typeof h == "number" && (f = l === "end" ? h * -1 : h), c ? {
-    x: f * d,
-    y: p * a
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
   } : {
-    x: p * a,
-    y: f * d
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
   };
 }
-const $t = function(t) {
-  return t === void 0 && (t = 0), {
+const offset = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
     name: "offset",
-    options: t,
-    async fn(e) {
+    options,
+    async fn(state) {
       const {
-        x: n,
-        y: o
-      } = e, i = await zt(e, t);
+        x,
+        y
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
       return {
-        x: n + i.x,
-        y: o + i.y,
-        data: i
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: diffCoords
       };
     }
   };
-}, It = function(t) {
-  return t === void 0 && (t = {}), {
+};
+const size = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "size",
-    options: t,
-    async fn(e) {
+    options,
+    async fn(state) {
+      const {
+        placement,
+        rects,
+        platform: platform2,
+        elements
+      } = state;
       const {
-        placement: n,
-        rects: o,
-        platform: i,
-        elements: s
-      } = e, {
-        apply: r = () => {
+        apply = () => {
         },
-        ...l
-      } = K(t, e), c = await wt(e, l), a = V(n), d = _(n), u = nt(n) === "y", {
-        width: p,
-        height: f
-      } = o.floating;
-      let h, m;
-      a === "top" || a === "bottom" ? (h = a, m = d === (await (i.isRTL == null ? void 0 : i.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (m = a, h = d === "end" ? "top" : "bottom");
-      const w = f - c[h], g = p - c[m], v = !e.middlewareData.shift;
-      let y = w, A = g;
-      if (u) {
-        const b = p - c.left - c.right;
-        A = d || v ? N(g, b) : b;
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const side = getSide(placement);
+      const alignment = getAlignment(placement);
+      const isYAxis = getSideAxis(placement) === "y";
+      const {
+        width,
+        height
+      } = rects.floating;
+      let heightSide;
+      let widthSide;
+      if (side === "top" || side === "bottom") {
+        heightSide = side;
+        widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
       } else {
-        const b = f - c.top - c.bottom;
-        y = d || v ? N(w, b) : b;
+        widthSide = side;
+        heightSide = alignment === "end" ? "top" : "bottom";
       }
-      if (v && !d) {
-        const b = R(c.left, 0), E = R(c.right, 0), P = R(c.top, 0), F = R(c.bottom, 0);
-        u ? A = p - 2 * (b !== 0 || E !== 0 ? b + E : R(c.left, c.right)) : y = f - 2 * (P !== 0 || F !== 0 ? P + F : R(c.top, c.bottom));
+      const overflowAvailableHeight = height - overflow[heightSide];
+      const overflowAvailableWidth = width - overflow[widthSide];
+      const noShift = !state.middlewareData.shift;
+      let availableHeight = overflowAvailableHeight;
+      let availableWidth = overflowAvailableWidth;
+      if (isYAxis) {
+        const maximumClippingWidth = width - overflow.left - overflow.right;
+        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
+      } else {
+        const maximumClippingHeight = height - overflow.top - overflow.bottom;
+        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
       }
-      await r({
-        ...e,
-        availableWidth: A,
-        availableHeight: y
-      });
-      const x = await i.getDimensions(s.floating);
-      return p !== x.width || f !== x.height ? {
-        reset: {
-          rects: !0
+      if (noShift && !alignment) {
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        if (isYAxis) {
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+        } else {
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
         }
-      } : {};
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform2.getDimensions(elements.floating);
+      if (width !== nextDimensions.width || height !== nextDimensions.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
     }
   };
 };
-function j(t) {
-  return xt(t) ? (t.nodeName || "").toLowerCase() : "#document";
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
 }
-function O(t) {
-  var e;
-  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
 }
-function M(t) {
-  var e;
-  return (e = (xt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
 }
-function xt(t) {
-  return t instanceof Node || t instanceof O(t).Node;
+function isNode(value) {
+  return value instanceof Node || value instanceof getWindow(value).Node;
 }
-function H(t) {
-  return t instanceof Element || t instanceof O(t).Element;
+function isElement(value) {
+  return value instanceof Element || value instanceof getWindow(value).Element;
 }
-function k(t) {
-  return t instanceof HTMLElement || t instanceof O(t).HTMLElement;
+function isHTMLElement(value) {
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
 }
-function dt(t) {
-  return typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof O(t).ShadowRoot;
+function isShadowRoot(value) {
+  if (typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
-function G(t) {
+function isOverflowElement(element) {
   const {
-    overflow: e,
-    overflowX: n,
-    overflowY: o,
-    display: i
-  } = T(t);
-  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !["inline", "contents"].includes(i);
-}
-function _t(t) {
-  return ["table", "td", "th"].includes(j(t));
-}
-function lt(t) {
-  const e = at(), n = T(t);
-  return n.transform !== "none" || n.perspective !== "none" || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((o) => (n.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (n.contain || "").includes(o));
-}
-function Yt(t) {
-  let e = I(t);
-  for (; k(e) && !ot(e); ) {
-    if (lt(e))
-      return e;
-    e = I(e);
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  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 isContainingBlock(element) {
+  const webkit = isWebKit();
+  const css = getComputedStyle(element);
+  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((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else {
+      currentNode = getParentNode(currentNode);
+    }
   }
   return null;
 }
-function at() {
-  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports)
+    return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
 }
-function ot(t) {
-  return ["html", "body", "#document"].includes(j(t));
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
 }
-function T(t) {
-  return O(t).getComputedStyle(t);
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
 }
-function it(t) {
-  return H(t) ? {
-    scrollLeft: t.scrollLeft,
-    scrollTop: t.scrollTop
-  } : {
-    scrollLeft: t.pageXOffset,
-    scrollTop: t.pageYOffset
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.pageXOffset,
+    scrollTop: element.pageYOffset
   };
 }
-function I(t) {
-  if (j(t) === "html")
-    return t;
-  const e = (
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
     // Step into the shadow DOM of the parent of a slotted node.
-    t.assignedSlot || // DOM Element detected.
-    t.parentNode || // ShadowRoot detected.
-    dt(t) && t.host || // Fallback.
-    M(t)
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
   );
-  return dt(e) ? e.host : e;
-}
-function vt(t) {
-  const e = I(t);
-  return ot(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : k(e) && G(e) ? e : vt(e);
-}
-function J(t, e, n) {
-  var o;
-  e === void 0 && (e = []), n === void 0 && (n = !0);
-  const i = vt(t), s = i === ((o = t.ownerDocument) == null ? void 0 : o.body), r = O(i);
-  return s ? e.concat(r, r.visualViewport || [], G(i) ? i : [], r.frameElement && n ? J(r.frameElement) : []) : e.concat(i, J(i, [], n));
-}
-function yt(t) {
-  const e = T(t);
-  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
-  const i = k(t), s = i ? t.offsetWidth : n, r = i ? t.offsetHeight : o, l = Z(n) !== s || Z(o) !== r;
-  return l && (n = s, o = r), {
-    width: n,
-    height: o,
-    $: l
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const 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;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
   };
 }
-function ft(t) {
-  return H(t) ? t : t.contextElement;
-}
-function $(t) {
-  const e = ft(t);
-  if (!k(e))
-    return B(1);
-  const n = e.getBoundingClientRect(), {
-    width: o,
-    height: i,
-    $: s
-  } = yt(e);
-  let r = (s ? Z(n.width) : n.width) / o, l = (s ? Z(n.height) : n.height) / i;
-  return (!r || !Number.isFinite(r)) && (r = 1), (!l || !Number.isFinite(l)) && (l = 1), {
-    x: r,
-    y: l
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
   };
 }
-const Xt = /* @__PURE__ */ B(0);
-function bt(t) {
-  const e = O(t);
-  return !at() || !e.visualViewport ? Xt : {
-    x: e.visualViewport.offsetLeft,
-    y: e.visualViewport.offsetTop
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
   };
 }
-function qt(t, e, n) {
-  return e === void 0 && (e = !1), !n || e && n !== O(t) ? !1 : e;
-}
-function z(t, e, n, o) {
-  e === void 0 && (e = !1), n === void 0 && (n = !1);
-  const i = t.getBoundingClientRect(), s = ft(t);
-  let r = B(1);
-  e && (o ? H(o) && (r = $(o)) : r = $(t));
-  const l = qt(s, n, o) ? bt(s) : B(0);
-  let c = (i.left + l.x) / r.x, a = (i.top + l.y) / r.y, d = i.width / r.x, u = i.height / r.y;
-  if (s) {
-    const p = O(s), f = o && H(o) ? O(o) : o;
-    let h = p.frameElement;
-    for (; h && o && f !== p; ) {
-      const m = $(h), w = h.getBoundingClientRect(), g = T(h), v = w.left + (h.clientLeft + parseFloat(g.paddingLeft)) * m.x, y = w.top + (h.clientTop + parseFloat(g.paddingTop)) * m.y;
-      c *= m.x, a *= m.y, d *= m.x, u *= m.y, c += v, a += y, h = O(h).frameElement;
-    }
-  }
-  return et({
-    width: d,
-    height: u,
-    x: c,
-    y: a
+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;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentIFrame = win.frameElement;
+    while (currentIFrame && offsetParent && offsetWin !== win) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const 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;
+      currentIFrame = getWindow(currentIFrame).frameElement;
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
   });
 }
-function Ut(t) {
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   let {
-    rect: e,
-    offsetParent: n,
-    strategy: o
-  } = t;
-  const i = k(n), s = M(n);
-  if (n === s)
-    return e;
-  let r = {
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  if (offsetParent === documentElement) {
+    return rect;
+  }
+  let scroll = {
     scrollLeft: 0,
     scrollTop: 0
-  }, l = B(1);
-  const c = B(0);
-  if ((i || !i && o !== "fixed") && ((j(n) !== "body" || G(s)) && (r = it(n)), k(n))) {
-    const a = z(n);
-    l = $(n), c.x = a.x + n.clientLeft, c.y = a.y + n.clientTop;
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
   }
   return {
-    width: e.width * l.x,
-    height: e.height * l.y,
-    x: e.x * l.x - r.scrollLeft * l.x + c.x,
-    y: e.y * l.y - r.scrollTop * l.y + c.y
+    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 Jt(t) {
-  return Array.from(t.getClientRects());
-}
-function At(t) {
-  return z(M(t)).left + it(t).scrollLeft;
-}
-function Kt(t) {
-  const e = M(t), n = it(t), o = t.ownerDocument.body, i = R(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), s = R(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
-  let r = -n.scrollLeft + At(t);
-  const l = -n.scrollTop;
-  return T(o).direction === "rtl" && (r += R(e.clientWidth, o.clientWidth) - i), {
-    width: i,
-    height: s,
-    x: r,
-    y: l
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getWindowScrollBarX(element) {
+  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+}
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
   };
 }
-function Gt(t, e) {
-  const n = O(t), o = M(t), i = n.visualViewport;
-  let s = o.clientWidth, r = o.clientHeight, l = 0, c = 0;
-  if (i) {
-    s = i.width, r = i.height;
-    const a = at();
-    (!a || a && e === "fixed") && (l = i.offsetLeft, c = i.offsetTop);
+function getViewportRect(element, strategy) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
   }
   return {
-    width: s,
-    height: r,
-    x: l,
-    y: c
+    width,
+    height,
+    x,
+    y
   };
 }
-function Qt(t, e) {
-  const n = z(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, s = k(t) ? $(t) : B(1), r = t.clientWidth * s.x, l = t.clientHeight * s.y, c = i * s.x, a = o * s.y;
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
   return {
-    width: r,
-    height: l,
-    x: c,
-    y: a
+    width,
+    height,
+    x,
+    y
   };
 }
-function pt(t, e, n) {
-  let o;
-  if (e === "viewport")
-    o = Gt(t, n);
-  else if (e === "document")
-    o = Kt(M(t));
-  else if (H(e))
-    o = Qt(e, n);
-  else {
-    const i = bt(t);
-    o = {
-      ...e,
-      x: e.x - i.x,
-      y: e.y - i.y
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let 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 {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      ...clippingAncestor,
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y
     };
   }
-  return et(o);
+  return rectToClientRect(rect);
 }
-function Et(t, e) {
-  const n = I(t);
-  return n === e || !H(n) || ot(n) ? !1 : T(n).position === "fixed" || Et(n, e);
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
 }
-function Zt(t, e) {
-  const n = e.get(t);
-  if (n)
-    return n;
-  let o = J(t, [], !1).filter((l) => H(l) && j(l) !== "body"), i = null;
-  const s = T(t).position === "fixed";
-  let r = s ? I(t) : t;
-  for (; H(r) && !ot(r); ) {
-    const l = T(r), c = lt(r);
-    !c && l.position === "fixed" && (i = null), (s ? !c && !i : !c && l.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || G(r) && !c && Et(t, r)) ? o = o.filter((d) => d !== r) : i = l, r = I(r);
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
   }
-  return e.set(t, o), o;
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    const 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((ancestor) => ancestor !== currentNode);
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
 }
-function te(t) {
+function getClippingRect(_ref) {
   let {
-    element: e,
-    boundary: n,
-    rootBoundary: o,
-    strategy: i
-  } = t;
-  const r = [...n === "clippingAncestors" ? Zt(e, this._c) : [].concat(n), o], l = r[0], c = r.reduce((a, d) => {
-    const u = pt(e, d, i);
-    return a.top = R(u.top, a.top), a.right = N(u.right, a.right), a.bottom = N(u.bottom, a.bottom), a.left = R(u.left, a.left), a;
-  }, pt(e, l, i));
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const 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: c.right - c.left,
-    height: c.bottom - c.top,
-    x: c.left,
-    y: c.top
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
   };
 }
-function ee(t) {
-  return yt(t);
+function getDimensions(element) {
+  return getCssDimensions(element);
 }
-function ne(t, e, n) {
-  const o = k(e), i = M(e), s = n === "fixed", r = z(t, !0, s, e);
-  let l = {
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const c = B(0);
-  if (o || !o && !s)
-    if ((j(e) !== "body" || G(i)) && (l = it(e)), o) {
-      const a = z(e, !0, s, e);
-      c.x = a.x + e.clientLeft, c.y = a.y + e.clientTop;
-    } else
-      i && (c.x = At(i));
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const 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);
+    }
+  }
   return {
-    x: r.left + l.scrollLeft - c.x,
-    y: r.top + l.scrollTop - c.y,
-    width: r.width,
-    height: r.height
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
   };
 }
-function mt(t, e) {
-  return !k(t) || T(t).position === "fixed" ? null : e ? e(t) : t.offsetParent;
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  return element.offsetParent;
 }
-function Ct(t, e) {
-  const n = O(t);
-  if (!k(t))
-    return n;
-  let o = mt(t, e);
-  for (; o && _t(o) && T(o).position === "static"; )
-    o = mt(o, e);
-  return o && (j(o) === "html" || j(o) === "body" && T(o).position === "static" && !lt(o)) ? n : o || Yt(t) || n;
+function getOffsetParent(element, polyfill) {
+  const window2 = getWindow(element);
+  if (!isHTMLElement(element)) {
+    return window2;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
+    return window2;
+  }
+  return offsetParent || getContainingBlock(element) || window2;
 }
-const oe = async function(t) {
+const getElementRects = async function(_ref) {
   let {
-    reference: e,
-    floating: n,
-    strategy: o
-  } = t;
-  const i = this.getOffsetParent || Ct, s = this.getDimensions;
+    reference,
+    floating,
+    strategy
+  } = _ref;
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
   return {
-    reference: ne(e, await i(n), o),
+    reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
     floating: {
       x: 0,
       y: 0,
-      ...await s(n)
+      ...await getDimensionsFn(floating)
     }
   };
 };
-function ie(t) {
-  return T(t).direction === "rtl";
-}
-const se = {
-  convertOffsetParentRelativeRectToViewportRelativeRect: Ut,
-  getDocumentElement: M,
-  getClippingRect: te,
-  getOffsetParent: Ct,
-  getElementRects: oe,
-  getClientRects: Jt,
-  getDimensions: ee,
-  getScale: $,
-  isElement: H,
-  isRTL: ie
+function isRTL(element) {
+  return getComputedStyle(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
 };
-function re(t, e) {
-  let n = null, o;
-  const i = M(t);
-  function s() {
-    clearTimeout(o), n && n.disconnect(), n = null;
-  }
-  function r(l, c) {
-    l === void 0 && (l = !1), c === void 0 && (c = 1), s();
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    clearTimeout(timeoutId);
+    io && io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
     const {
-      left: a,
-      top: d,
-      width: u,
-      height: p
-    } = t.getBoundingClientRect();
-    if (l || e(), !u || !p)
+      left,
+      top,
+      width,
+      height
+    } = element.getBoundingClientRect();
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
       return;
-    const f = Q(d), h = Q(i.clientWidth - (a + u)), m = Q(i.clientHeight - (d + p)), w = Q(a), v = {
-      rootMargin: -f + "px " + -h + "px " + -m + "px " + -w + "px",
-      threshold: R(0, N(1, c)) || 1
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
     };
-    let y = !0;
-    function A(x) {
-      const b = x[0].intersectionRatio;
-      if (b !== c) {
-        if (!y)
-          return r();
-        b ? r(!1, b) : o = setTimeout(() => {
-          r(!1, 1e-7);
-        }, 100);
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 100);
+        } else {
+          refresh(false, ratio);
+        }
       }
-      y = !1;
+      isFirstUpdate = false;
     }
     try {
-      n = new IntersectionObserver(A, {
-        ...v,
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
         // Handle <iframe>s
-        root: i.ownerDocument
+        root: root.ownerDocument
       });
-    } catch {
-      n = new IntersectionObserver(A, v);
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
     }
-    n.observe(t);
+    io.observe(element);
   }
-  return r(!0), s;
+  refresh(true);
+  return cleanup;
 }
-function ce(t, e, n, o) {
-  o === void 0 && (o = {});
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
   const {
-    ancestorScroll: i = !0,
-    ancestorResize: s = !0,
-    elementResize: r = typeof ResizeObserver == "function",
-    layoutShift: l = typeof IntersectionObserver == "function",
-    animationFrame: c = !1
-  } = o, a = ft(t), d = i || s ? [...a ? J(a) : [], ...J(e)] : [];
-  d.forEach((g) => {
-    i && g.addEventListener("scroll", n, {
-      passive: !0
-    }), s && g.addEventListener("resize", n);
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
   });
-  const u = a && l ? re(a, n) : null;
-  let p = -1, f = null;
-  r && (f = new ResizeObserver((g) => {
-    let [v] = g;
-    v && v.target === a && f && (f.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
-      f && f.observe(e);
-    })), n();
-  }), a && !c && f.observe(a), f.observe(e));
-  let h, m = c ? z(t) : null;
-  c && w();
-  function w() {
-    const g = z(t);
-    m && (g.x !== m.x || g.y !== m.y || g.width !== m.width || g.height !== m.height) && n(), m = g, h = requestAnimationFrame(w);
-  }
-  return n(), () => {
-    d.forEach((g) => {
-      i && g.removeEventListener("scroll", n), s && g.removeEventListener("resize", n);
-    }), u && u(), f && f.disconnect(), f = null, c && cancelAnimationFrame(h);
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          resizeObserver && resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const 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 () => {
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo && cleanupIo();
+    resizeObserver && resizeObserver.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
   };
 }
-const le = (t, e, n) => {
-  const o = /* @__PURE__ */ new Map(), i = {
-    platform: se,
-    ...n
-  }, s = {
-    ...i.platform,
-    _c: o
+const computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
   };
-  return Bt(t, e, {
-    ...i,
-    platform: s
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
   });
-}, ae = `:host{--wj-popup-top: auto;--wj-popup-left: auto;display:flex}.native-popup{position:absolute;isolation:isolate;z-index:999;left:var(--wj-popup-left);top:var(--wj-popup-top)}.native-popup:not(.popup-active){display:none}
-`;
-class fe extends Tt {
+};
+const styles = "/*\n[ WJ Popup ]\n*/\n:host {\n  --wj-popup-top: auto;\n  --wj-popup-left: auto;\n  display: flex;\n}\n\n.native-popup {\n  position: absolute;\n  isolation: isolate;\n  z-index: 999;\n  left: var(--wj-popup-left);\n  top: var(--wj-popup-top);\n}\n\n.native-popup:not(.popup-active) {\n  display: none;\n}";
+class Popup extends WJElement {
   constructor() {
     super();
-    ut(this, "className", "Popup");
-    this._manual = !1;
+    __publicField(this, "className", "Popup");
+    this._manual = false;
   }
-  set manual(n) {
-    this._manual = n;
+  set manual(value) {
+    this._manual = value;
   }
   get manual() {
-    return this.hasAttribute("manual") && (this._manual = !0), this._manual;
+    if (this.hasAttribute("manual"))
+      this._manual = true;
+    return this._manual;
   }
   static get cssStyleSheet() {
-    return ae;
+    return styles;
   }
   static get observedAttributes() {
     return ["active"];
@@ -902,98 +1280,148 @@ class fe extends Tt {
   setupAttributes() {
     this.isShadowRoot = "open";
   }
-  attributeChangedCallback(n, o, i) {
-    n === "active" && (this.hasAttribute(n) ? this.show() : this.hide());
+  attributeChangedCallback(name, old, newName) {
+    if (name === "active") {
+      if (this.hasAttribute(name)) {
+        this.show();
+      } else {
+        this.hide();
+      }
+    }
   }
-  draw(n, o, i) {
-    let s = document.createDocumentFragment(), r = document.createElement("slot");
-    r.setAttribute("name", "anchor");
-    let l = document.createElement("slot");
-    l.setAttribute("name", "arrow");
-    let c = document.createElement("div");
-    c.setAttribute("part", "native"), c.classList.add("native-popup");
-    let a = document.createElement("slot");
-    return c.appendChild(a), c.appendChild(l), s.appendChild(r), s.appendChild(c), this.slotAnchor = r, this.slotArrow = l, this.native = c, s;
+  draw(context, store, params) {
+    let fragment = document.createDocumentFragment();
+    let slotAnchor = document.createElement("slot");
+    slotAnchor.setAttribute("name", "anchor");
+    let slotArrow = document.createElement("slot");
+    slotArrow.setAttribute("name", "arrow");
+    let native = document.createElement("div");
+    native.setAttribute("part", "native");
+    native.classList.add("native-popup");
+    let slot = document.createElement("slot");
+    native.appendChild(slot);
+    native.appendChild(slotArrow);
+    fragment.appendChild(slotAnchor);
+    fragment.appendChild(native);
+    this.slotAnchor = slotAnchor;
+    this.slotArrow = slotArrow;
+    this.native = native;
+    return fragment;
   }
-  afterDraw(n, o, i) {
+  afterDraw(context, store, params) {
     this.setAnchor();
   }
   setAnchor() {
-    if (this.slotAnchor && typeof this.anchor == "string") {
-      const n = this.getRootNode();
-      this.anchorEl = n.getElementById(this.anchor);
-    } else
-      this.slotAnchor instanceof HTMLSlotElement && (this.anchorEl = this.slotAnchor.assignedElements({ flatten: !0 })[0]);
-    U.addListener(this.anchorEl, "click", null, (n) => {
-      this.hasAttribute("disabled") || this.showHide();
-    }, { stopPropagation: !0 }), document.addEventListener("click", (n) => {
-      n.composedPath().some((i) => i === this) || this.hasAttribute("active") && this.removeAttribute("active");
+    if (this.slotAnchor && typeof this.anchor === "string") {
+      const root = this.getRootNode();
+      this.anchorEl = root.getElementById(this.anchor);
+    } else if (this.slotAnchor instanceof HTMLSlotElement) {
+      this.anchorEl = this.slotAnchor.assignedElements({ flatten: true })[0];
+    }
+    event.addListener(this.anchorEl, "click", null, (e) => {
+      if (this.hasAttribute("disabled"))
+        return;
+      this.showHide();
+    }, { stopPropagation: true });
+    document.addEventListener("click", (e) => {
+      let clickToHost = e.composedPath().some((el) => el === this);
+      if (!clickToHost) {
+        if (this.hasAttribute("active"))
+          this.removeAttribute("active");
+      }
     });
   }
   showHide() {
-    this.hasAttribute("active") ? this.removeAttribute("active") : this.setAttribute("active", "");
+    if (this.hasAttribute("active")) {
+      this.removeAttribute("active");
+    } else {
+      this.setAttribute("active", "");
+    }
   }
   reposition() {
-    const n = [];
-    this.offsetCalc = +this.offset || 0, this.slotArrow instanceof HTMLSlotElement && (this.arrow = this.slotArrow.assignedElements({ flatten: !0 })[0], this.arrow && (n.push(
-      jt({
-        element: this.arrow
-      })
-    ), this.offsetCalc = Math.sqrt(2 * this.arrow.offsetWidth ** 2) / 2 + +this.offset)), n.push(
-      $t(this.offsetCalc)
-    ), n.push(
-      Vt()
-    ), this.hasAttribute("size") && n.push(
-      It({
-        apply({ availableWidth: o, availableHeight: i, elements: s }) {
-          Object.assign(s.floating.style, {
-            width: `${s.reference.offsetWidth}px`
-          });
-        }
-      })
-    ), le(this.anchorEl, this.native, {
+    const middleware = [];
+    this.offsetCalc = +this.offset || 0;
+    if (this.slotArrow instanceof HTMLSlotElement) {
+      this.arrow = this.slotArrow.assignedElements({ flatten: true })[0];
+      if (this.arrow) {
+        middleware.push(
+          arrow({
+            element: this.arrow
+          })
+        );
+        this.offsetCalc = Math.sqrt(2 * this.arrow.offsetWidth ** 2) / 2 + +this.offset;
+      }
+    }
+    middleware.push(
+      offset(this.offsetCalc)
+    );
+    middleware.push(
+      flip()
+    );
+    if (this.hasAttribute("size")) {
+      middleware.push(
+        size({
+          apply({ availableWidth, availableHeight, elements }) {
+            Object.assign(elements.floating.style, {
+              width: `${elements.reference.offsetWidth}px`
+            });
+          }
+        })
+      );
+    }
+    computePosition(this.anchorEl, this.native, {
       placement: this.placement || "bottom",
       strategy: "fixed",
-      middleware: n
-    }).then(({ x: o, y: i, middlewareData: s, placement: r, strategy: l }) => {
-      if (this.native.style.setProperty("--wj-popup-left", o + "px"), this.native.style.setProperty("--wj-popup-top", i + "px"), this.native.style.position = l, this.arrow) {
-        const c = this.placement.split("-")[0], a = {
+      middleware
+    }).then(({ x, y, middlewareData, placement, strategy }) => {
+      this.native.style.setProperty("--wj-popup-left", x + "px");
+      this.native.style.setProperty("--wj-popup-top", y + "px");
+      this.native.style.position = strategy;
+      if (this.arrow) {
+        const side = this.placement.split("-")[0];
+        const staticSide = {
           top: "bottom",
           right: "left",
           bottom: "top",
           left: "right"
-        }[c];
-        if (s.arrow) {
-          const { x: d, y: u } = s.arrow;
+        }[side];
+        if (middlewareData.arrow) {
+          const { x: x2, y: y2 } = middlewareData.arrow;
           Object.assign(this.arrow.style, {
-            left: d != null ? `${d}px` : "",
-            top: u != null ? `${u}px` : "",
-            [a]: `${-this.arrow.offsetWidth / 2}px`
+            left: x2 != null ? `${x2}px` : "",
+            top: y2 != null ? `${y2}px` : "",
+            [staticSide]: `${-this.arrow.offsetWidth / 2}px`
           });
         }
       }
-    }), U.dispatchCustomEvent(this, "wj-popup:reposition", {
+    });
+    event.dispatchCustomEvent(this, "wj-popup:reposition", {
       data: { top: "bottom", right: "left", bottom: "top", left: "right" },
       context: this,
       event: this
     });
   }
   show() {
-    U.dispatchCustomEvent(this, "wj-popup:show"), this.native.classList.add("popup-active"), this.cleanup = ce(this.anchorEl, this.native, () => {
+    event.dispatchCustomEvent(this, "wj-popup:show");
+    this.native.classList.add("popup-active");
+    this.cleanup = autoUpdate(this.anchorEl, this.native, () => {
       this.reposition();
     });
   }
   hide() {
-    U.dispatchCustomEvent(this, "wj-popup:hide"), this.native.classList.remove("popup-active"), this.cleanup(), this.cleanup = void 0;
+    event.dispatchCustomEvent(this, "wj-popup:hide");
+    this.native.classList.remove("popup-active");
+    this.cleanup();
+    this.cleanup = void 0;
   }
   onHide() {
     this.removeAttribute("active");
   }
   disconnectedCallback() {
-    U.removeElement(this.anchorEl);
+    event.removeElement(this.anchorEl);
   }
 }
-customElements.get("wj-popup") || window.customElements.define("wj-popup", fe);
+customElements.get("wj-popup") || window.customElements.define("wj-popup", Popup);
 export {
-  fe as Popup
+  Popup
 };