wj-elements 0.0.3 → 0.0.5

package/dist/wj-popup.js

@@ -1,1278 +1,902 @@
-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";
+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 G } from "./wj-element.js";
 import "./wj-store.js";
-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 = {
+const N = Math.min, R = Math.max, Z = Math.round, Q = Math.floor, B = (t) => ({
+  x: t,
+  y: t
+}), Pt = {
   left: "right",
   right: "left",
   bottom: "top",
   top: "bottom"
-};
-const oppositeAlignmentMap = {
+}, St = {
   start: "end",
   end: "start"
 };
-function clamp(start, value, end) {
-  return max(start, min(value, end));
+function Dt(t, e, n) {
+  return R(t, N(e, n));
 }
-function evaluate(value, param) {
-  return typeof value === "function" ? value(param) : value;
+function U(t, e) {
+  return typeof t == "function" ? t(e) : t;
 }
-function getSide(placement) {
-  return placement.split("-")[0];
+function j(t) {
+  return t.split("-")[0];
 }
-function getAlignment(placement) {
-  return placement.split("-")[1];
+function _(t) {
+  return t.split("-")[1];
 }
-function getOppositeAxis(axis) {
-  return axis === "x" ? "y" : "x";
+function kt(t) {
+  return t === "x" ? "y" : "x";
 }
-function getAxisLength(axis) {
-  return axis === "y" ? "height" : "width";
+function rt(t) {
+  return t === "y" ? "height" : "width";
 }
-function getSideAxis(placement) {
-  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+function nt(t) {
+  return ["top", "bottom"].includes(j(t)) ? "y" : "x";
 }
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
+function ct(t) {
+  return kt(nt(t));
 }
-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 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 getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+function Mt(t) {
+  const e = tt(t);
+  return [st(t), e, st(e)];
 }
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+function st(t) {
+  return t.replace(/start|end/g, (e) => St[e]);
 }
-function getSideList(side, isStart, rtl) {
-  const lr = ["left", "right"];
-  const rl = ["right", "left"];
-  const tb = ["top", "bottom"];
-  const bt = ["bottom", "top"];
-  switch (side) {
+function Ft(t, e, n) {
+  const o = ["left", "right"], i = ["right", "left"], s = ["top", "bottom"], r = ["bottom", "top"];
+  switch (t) {
     case "top":
     case "bottom":
-      if (rtl)
-        return isStart ? rl : lr;
-      return isStart ? lr : rl;
+      return n ? e ? i : o : e ? o : i;
     case "left":
     case "right":
-      return isStart ? tb : bt;
+      return e ? s : r;
     default:
       return [];
   }
 }
-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 Ht(t, e, n, o) {
+  const i = _(t);
+  let s = Ft(j(t), n === "start", o);
+  return i && (s = s.map((r) => r + "-" + i), e && (s = s.concat(s.map(st)))), s;
 }
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+function tt(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => Pt[e]);
 }
-function expandPaddingObject(padding) {
+function Nt(t) {
   return {
     top: 0,
     right: 0,
     bottom: 0,
     left: 0,
-    ...padding
+    ...t
   };
 }
-function getPaddingObject(padding) {
-  return typeof padding !== "number" ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
+function gt(t) {
+  return typeof t != "number" ? Nt(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
   };
 }
-function rectToClientRect(rect) {
+function et(t) {
   return {
-    ...rect,
-    top: rect.y,
-    left: rect.x,
-    right: rect.x + rect.width,
-    bottom: rect.y + rect.height
+    ...t,
+    top: t.y,
+    left: t.x,
+    right: t.x + t.width,
+    bottom: t.y + t.height
   };
 }
-function computeCoordsFromPlacement(_ref, placement, rtl) {
+function ht(t, e, n) {
   let {
-    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) {
+    reference: o,
+    floating: i
+  } = t;
+  const s = nt(e), r = ct(e), l = rt(r), c = j(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) {
     case "top":
-      coords = {
-        x: commonX,
-        y: reference.y - floating.height
+      f = {
+        x: d,
+        y: o.y - i.height
       };
       break;
     case "bottom":
-      coords = {
-        x: commonX,
-        y: reference.y + reference.height
+      f = {
+        x: d,
+        y: o.y + o.height
       };
       break;
     case "right":
-      coords = {
-        x: reference.x + reference.width,
-        y: commonY
+      f = {
+        x: o.x + o.width,
+        y: u
       };
       break;
     case "left":
-      coords = {
-        x: reference.x - floating.width,
-        y: commonY
+      f = {
+        x: o.x - i.width,
+        y: u
       };
       break;
     default:
-      coords = {
-        x: reference.x,
-        y: reference.y
+      f = {
+        x: o.x,
+        y: o.y
       };
   }
-  switch (getAlignment(placement)) {
+  switch (_(e)) {
     case "start":
-      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      f[r] -= p * (n && a ? -1 : 1);
       break;
     case "end":
-      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      f[r] += p * (n && a ? -1 : 1);
       break;
   }
-  return coords;
+  return f;
 }
-const computePosition$1 = async (reference, floating, config) => {
+const Bt = async (t, e, n) => {
   const {
-    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];
+    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++) {
     const {
-      x: nextX,
-      y: nextY,
-      data,
-      reset
-    } = await fn({
-      x,
+      name: w,
+      fn: g
+    } = l[m], {
+      x: v,
       y,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform: platform2,
+      data: A,
+      reset: x
+    } = await g({
+      x: d,
+      y: u,
+      initialPlacement: o,
+      placement: p,
+      strategy: i,
+      middlewareData: f,
+      rects: a,
+      platform: r,
       elements: {
-        reference,
-        floating
+        reference: t,
+        floating: e
       }
     });
-    x = nextX != null ? nextX : x;
-    y = nextY != null ? nextY : y;
-    middlewareData = {
-      ...middlewareData,
-      [name]: {
-        ...middlewareData[name],
-        ...data
+    if (d = v ?? d, u = y ?? u, f = {
+      ...f,
+      [w]: {
+        ...f[w],
+        ...A
       }
-    };
-    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;
+    }, 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;
       continue;
     }
   }
   return {
-    x,
-    y,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
+    x: d,
+    y: u,
+    placement: p,
+    strategy: i,
+    middlewareData: f
   };
 };
-async function detectOverflow(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
+async function wt(t, e) {
+  var n;
+  e === void 0 && (e = {});
   const {
-    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: 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
+  } = U(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: 1,
     y: 1
   } : {
     x: 1,
     y: 1
-  };
-  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
-    rect,
-    offsetParent,
-    strategy
-  }) : rect);
+  }, x = et(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect: v,
+    offsetParent: y,
+    strategy: c
+  }) : v);
   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
+    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
   };
 }
-const arrow = (options) => ({
+const Vt = (t) => ({
   name: "arrow",
-  options,
-  async fn(state) {
-    const {
-      x,
-      y,
-      placement,
-      rects,
-      platform: platform2,
-      elements,
-      middlewareData
-    } = state;
+  options: t,
+  async fn(e) {
     const {
-      element,
-      padding = 0
-    } = evaluate(options, state) || {};
-    if (element == null) {
+      x: n,
+      y: o,
+      placement: i,
+      rects: s,
+      platform: r,
+      elements: l,
+      middlewareData: c
+    } = e, {
+      element: a,
+      padding: d = 0
+    } = U(t, e) || {};
+    if (a == null)
       return {};
-    }
-    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;
+    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, H = E / 2 - m[h] / 2 - 1, Y = N(u[g], H), X = N(u[v], H), 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;
     return {
-      [axis]: coords[axis] + alignmentOffset,
+      [f]: p[f] + W,
       data: {
-        [axis]: offset2,
-        centerOffset: center - offset2 - alignmentOffset,
-        ...shouldAddOffset && {
-          alignmentOffset
+        [f]: S,
+        centerOffset: C - S - W,
+        ...D && {
+          alignmentOffset: W
         }
       },
-      reset: shouldAddOffset
+      reset: D
     };
   }
-});
-const flip = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
+}), jt = function(t) {
+  return t === void 0 && (t = {}), {
     name: "flip",
-    options,
-    async fn(state) {
-      var _middlewareData$arrow, _middlewareData$flip;
+    options: t,
+    async fn(e) {
+      var n, o;
       const {
-        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) {
+        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
+      } = U(t, e);
+      if ((n = s.arrow) != null && n.alignmentOffset)
         return {};
+      const g = j(i), v = j(l) === l, y = await (c.isRTL == null ? void 0 : c.isRTL(a.floating)), A = p || (v || !m ? [tt(l)] : Mt(l));
+      !p && h !== "none" && A.push(...Ht(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]]);
       }
-      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) {
+      if (P = [...P, {
+        placement: i,
+        overflows: E
+      }], !E.every((L) => L <= 0)) {
+        var H, Y;
+        const L = (((H = s.flip) == null ? void 0 : H.index) || 0) + 1, q = x[L];
+        if (q)
           return {
             data: {
-              index: nextIndex,
-              overflows: overflowsData
+              index: L,
+              overflows: P
             },
             reset: {
-              placement: nextPlacement
+              placement: q
             }
           };
-        }
-        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) {
+        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) {
             case "bestFit": {
-              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;
-              }
+              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);
               break;
             }
             case "initialPlacement":
-              resetPlacement = initialPlacement;
+              C = l;
               break;
           }
-        }
-        if (placement !== resetPlacement) {
+        if (i !== C)
           return {
             reset: {
-              placement: resetPlacement
+              placement: C
             }
           };
-        }
       }
       return {};
     }
   };
 };
-async function convertValueToCoords(state, options) {
+async function zt(t, e) {
   const {
-    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);
+    placement: n,
+    platform: o,
+    elements: i
+  } = t, s = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = j(n), l = _(n), c = nt(n) === "y", a = ["left", "top"].includes(r) ? -1 : 1, d = s && c ? -1 : 1, u = U(e, t);
   let {
-    mainAxis,
-    crossAxis,
-    alignmentAxis
-  } = typeof rawValue === "number" ? {
-    mainAxis: rawValue,
+    mainAxis: p,
+    crossAxis: f,
+    alignmentAxis: h
+  } = typeof u == "number" ? {
+    mainAxis: u,
     crossAxis: 0,
     alignmentAxis: null
   } : {
     mainAxis: 0,
     crossAxis: 0,
     alignmentAxis: null,
-    ...rawValue
+    ...u
   };
-  if (alignment && typeof alignmentAxis === "number") {
-    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
-  }
-  return isVertical ? {
-    x: crossAxis * crossAxisMulti,
-    y: mainAxis * mainAxisMulti
+  return l && typeof h == "number" && (f = l === "end" ? h * -1 : h), c ? {
+    x: f * d,
+    y: p * a
   } : {
-    x: mainAxis * mainAxisMulti,
-    y: crossAxis * crossAxisMulti
+    x: p * a,
+    y: f * d
   };
 }
-const offset = function(options) {
-  if (options === void 0) {
-    options = 0;
-  }
-  return {
+const It = function(t) {
+  return t === void 0 && (t = 0), {
     name: "offset",
-    options,
-    async fn(state) {
+    options: t,
+    async fn(e) {
       const {
-        x,
-        y
-      } = state;
-      const diffCoords = await convertValueToCoords(state, options);
+        x: n,
+        y: o
+      } = e, i = await zt(e, t);
       return {
-        x: x + diffCoords.x,
-        y: y + diffCoords.y,
-        data: diffCoords
+        x: n + i.x,
+        y: o + i.y,
+        data: i
       };
     }
   };
-};
-const size = function(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
+}, $t = function(t) {
+  return t === void 0 && (t = {}), {
     name: "size",
-    options,
-    async fn(state) {
-      const {
-        placement,
-        rects,
-        platform: platform2,
-        elements
-      } = state;
+    options: t,
+    async fn(e) {
       const {
-        apply = () => {
+        placement: n,
+        rects: o,
+        platform: i,
+        elements: s
+      } = e, {
+        apply: r = () => {
         },
-        ...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";
+        ...l
+      } = U(t, e), c = await wt(e, l), a = j(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;
       } else {
-        widthSide = side;
-        heightSide = alignment === "end" ? "top" : "bottom";
+        const b = f - c.top - c.bottom;
+        y = d || v ? N(w, b) : b;
       }
-      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;
+      if (v && !d) {
+        const b = R(c.left, 0), E = R(c.right, 0), P = R(c.top, 0), H = R(c.bottom, 0);
+        u ? A = p - 2 * (b !== 0 || E !== 0 ? b + E : R(c.left, c.right)) : y = f - 2 * (P !== 0 || H !== 0 ? P + H : R(c.top, c.bottom));
       }
-      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
+      await r({
+        ...e,
+        availableWidth: A,
+        availableHeight: y
       });
-      const nextDimensions = await platform2.getDimensions(elements.floating);
-      if (width !== nextDimensions.width || height !== nextDimensions.height) {
-        return {
-          reset: {
-            rects: true
-          }
-        };
-      }
-      return {};
+      const x = await i.getDimensions(s.floating);
+      return p !== x.width || f !== x.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
     }
   };
 };
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || "").toLowerCase();
-  }
-  return "#document";
+function V(t) {
+  return xt(t) ? (t.nodeName || "").toLowerCase() : "#document";
 }
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+function O(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
 }
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+function F(t) {
+  var e;
+  return (e = (xt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
 }
-function isNode(value) {
-  return value instanceof Node || value instanceof getWindow(value).Node;
+function xt(t) {
+  return t instanceof Node || t instanceof O(t).Node;
 }
-function isElement(value) {
-  return value instanceof Element || value instanceof getWindow(value).Element;
+function M(t) {
+  return t instanceof Element || t instanceof O(t).Element;
 }
-function isHTMLElement(value) {
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+function k(t) {
+  return t instanceof HTMLElement || t instanceof O(t).HTMLElement;
 }
-function isShadowRoot(value) {
-  if (typeof ShadowRoot === "undefined") {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+function dt(t) {
+  return typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof O(t).ShadowRoot;
 }
-function isOverflowElement(element) {
+function J(t) {
   const {
-    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);
-    }
+    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(V(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 = $(t);
+  for (; k(e) && !ot(e); ) {
+    if (lt(e))
+      return e;
+    e = $(e);
   }
   return null;
 }
-function isWebKit() {
-  if (typeof CSS === "undefined" || !CSS.supports)
-    return false;
-  return CSS.supports("-webkit-backdrop-filter", "none");
+function at() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
 }
-function isLastTraversableNode(node) {
-  return ["html", "body", "#document"].includes(getNodeName(node));
+function ot(t) {
+  return ["html", "body", "#document"].includes(V(t));
 }
-function getComputedStyle(element) {
-  return getWindow(element).getComputedStyle(element);
+function T(t) {
+  return O(t).getComputedStyle(t);
 }
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.pageXOffset,
-    scrollTop: element.pageYOffset
+function it(t) {
+  return M(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.pageXOffset,
+    scrollTop: t.pageYOffset
   };
 }
-function getParentNode(node) {
-  if (getNodeName(node) === "html") {
-    return node;
-  }
-  const result = (
+function $(t) {
+  if (V(t) === "html")
+    return t;
+  const e = (
     // 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)
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    dt(t) && t.host || // Fallback.
+    F(t)
   );
-  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
+  return dt(e) ? e.host : e;
+}
+function vt(t) {
+  const e = $(t);
+  return ot(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : k(e) && J(e) ? e : vt(e);
+}
+function K(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 || [], J(i) ? i : [], r.frameElement && n ? K(r.frameElement) : []) : e.concat(i, K(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
   };
 }
-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
+function ft(t) {
+  return M(t) ? t : t.contextElement;
+}
+function I(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
   };
 }
-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
+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
   };
 }
-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 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 ? M(o) && (r = I(o)) : r = I(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 && M(o) ? O(o) : o;
+    let h = p.frameElement;
+    for (; h && o && f !== p; ) {
+      const m = I(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 convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+function Kt(t) {
   let {
-    rect,
-    offsetParent,
-    strategy
-  } = _ref;
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  if (offsetParent === documentElement) {
-    return rect;
-  }
-  let scroll = {
+    rect: e,
+    offsetParent: n,
+    strategy: o
+  } = t;
+  const i = k(n), s = F(n);
+  if (n === s)
+    return e;
+  let r = {
     scrollLeft: 0,
     scrollTop: 0
-  };
-  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;
-    }
+  }, l = B(1);
+  const c = B(0);
+  if ((i || !i && o !== "fixed") && ((V(n) !== "body" || J(s)) && (r = it(n)), k(n))) {
+    const a = z(n);
+    l = I(n), c.x = a.x + n.clientLeft, c.y = a.y + n.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
+    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
   };
 }
-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 Ut(t) {
+  return Array.from(t.getClientRects());
+}
+function At(t) {
+  return z(F(t)).left + it(t).scrollLeft;
+}
+function Jt(t) {
+  const e = F(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 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;
-    }
+function Gt(t, e) {
+  const n = O(t), o = F(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);
   }
   return {
-    width,
-    height,
-    x,
-    y
+    width: s,
+    height: r,
+    x: l,
+    y: c
   };
 }
-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;
+function Qt(t, e) {
+  const n = z(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, s = k(t) ? I(t) : B(1), r = t.clientWidth * s.x, l = t.clientHeight * s.y, c = i * s.x, a = o * s.y;
   return {
-    width,
-    height,
-    x,
-    y
+    width: r,
+    height: l,
+    x: c,
+    y: a
   };
 }
-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
+function pt(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = Gt(t, n);
+  else if (e === "document")
+    o = Jt(F(t));
+  else if (M(e))
+    o = Qt(e, n);
+  else {
+    const i = bt(t);
+    o = {
+      ...e,
+      x: e.x - i.x,
+      y: e.y - i.y
     };
   }
-  return rectToClientRect(rect);
+  return et(o);
 }
-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 Et(t, e) {
+  const n = $(t);
+  return n === e || !M(n) || ot(n) ? !1 : T(n).position === "fixed" || Et(n, e);
 }
-function getClippingElementAncestors(element, cache) {
-  const cachedResult = cache.get(element);
-  if (cachedResult) {
-    return cachedResult;
+function Zt(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = K(t, [], !1).filter((l) => M(l) && V(l) !== "body"), i = null;
+  const s = T(t).position === "fixed";
+  let r = s ? $(t) : t;
+  for (; M(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) || J(r) && !c && Et(t, r)) ? o = o.filter((d) => d !== r) : i = l, r = $(r);
   }
-  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;
+  return e.set(t, o), o;
 }
-function getClippingRect(_ref) {
+function te(t) {
   let {
-    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));
+    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));
   return {
-    width: clippingRect.right - clippingRect.left,
-    height: clippingRect.bottom - clippingRect.top,
-    x: clippingRect.left,
-    y: clippingRect.top
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
   };
 }
-function getDimensions(element) {
-  return getCssDimensions(element);
+function ee(t) {
+  return yt(t);
 }
-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 = {
+function ne(t, e, n) {
+  const o = k(e), i = F(e), s = n === "fixed", r = z(t, !0, s, e);
+  let l = {
     scrollLeft: 0,
     scrollTop: 0
   };
-  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);
-    }
-  }
+  const c = B(0);
+  if (o || !o && !s)
+    if ((V(e) !== "body" || J(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));
   return {
-    x: rect.left + scroll.scrollLeft - offsets.x,
-    y: rect.top + scroll.scrollTop - offsets.y,
-    width: rect.width,
-    height: rect.height
+    x: r.left + l.scrollLeft - c.x,
+    y: r.top + l.scrollTop - c.y,
+    width: r.width,
+    height: r.height
   };
 }
-function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
-    return null;
-  }
-  if (polyfill) {
-    return polyfill(element);
-  }
-  return element.offsetParent;
+function mt(t, e) {
+  return !k(t) || T(t).position === "fixed" ? null : e ? e(t) : t.offsetParent;
 }
-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;
+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 && (V(o) === "html" || V(o) === "body" && T(o).position === "static" && !lt(o)) ? n : o || Yt(t) || n;
 }
-const getElementRects = async function(_ref) {
+const oe = async function(t) {
   let {
-    reference,
-    floating,
-    strategy
-  } = _ref;
-  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
-  const getDimensionsFn = this.getDimensions;
+    reference: e,
+    floating: n,
+    strategy: o
+  } = t;
+  const i = this.getOffsetParent || Ct, s = this.getDimensions;
   return {
-    reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
+    reference: ne(e, await i(n), o),
     floating: {
       x: 0,
       y: 0,
-      ...await getDimensionsFn(floating)
+      ...await s(n)
     }
   };
 };
-function isRTL(element) {
-  return getComputedStyle(element).direction === "rtl";
-}
-const platform = {
-  convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement,
-  getClippingRect,
-  getOffsetParent,
-  getElementRects,
-  getClientRects,
-  getDimensions,
-  getScale,
-  isElement,
-  isRTL
+function ie(t) {
+  return T(t).direction === "rtl";
+}
+const se = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Kt,
+  getDocumentElement: F,
+  getClippingRect: te,
+  getOffsetParent: Ct,
+  getElementRects: oe,
+  getClientRects: Ut,
+  getDimensions: ee,
+  getScale: I,
+  isElement: M,
+  isRTL: ie
 };
-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();
+function re(t, e) {
+  let n = null, o;
+  const i = F(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();
     const {
-      left,
-      top,
-      width,
-      height
-    } = element.getBoundingClientRect();
-    if (!skip) {
-      onMove();
-    }
-    if (!width || !height) {
+      left: a,
+      top: d,
+      width: u,
+      height: p
+    } = t.getBoundingClientRect();
+    if (l || e(), !u || !p)
       return;
-    }
-    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
+    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
     };
-    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);
-        }
+    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);
       }
-      isFirstUpdate = false;
+      y = !1;
     }
     try {
-      io = new IntersectionObserver(handleObserve, {
-        ...options,
+      n = new IntersectionObserver(A, {
+        ...v,
         // Handle <iframe>s
-        root: root.ownerDocument
+        root: i.ownerDocument
       });
-    } catch (e) {
-      io = new IntersectionObserver(handleObserve, options);
+    } catch {
+      n = new IntersectionObserver(A, v);
     }
-    io.observe(element);
+    n.observe(t);
   }
-  refresh(true);
-  return cleanup;
+  return r(!0), s;
 }
-function autoUpdate(reference, floating, update, options) {
-  if (options === void 0) {
-    options = {};
-  }
+function ce(t, e, n, o) {
+  o === void 0 && (o = {});
   const {
-    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);
+    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 ? K(a) : [], ...K(e)] : [];
+  d.forEach((g) => {
+    i && g.addEventListener("scroll", n, {
+      passive: !0
+    }), s && g.addEventListener("resize", n);
   });
-  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 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 computePosition = (reference, floating, options) => {
-  const cache = /* @__PURE__ */ new Map();
-  const mergedOptions = {
-    platform,
-    ...options
-  };
-  const platformWithCache = {
-    ...mergedOptions.platform,
-    _c: cache
+const le = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: se,
+    ...n
+  }, s = {
+    ...i.platform,
+    _c: o
   };
-  return computePosition$1(reference, floating, {
-    ...mergedOptions,
-    platform: platformWithCache
+  return Bt(t, e, {
+    ...i,
+    platform: s
   });
-};
-const styles = "/*!\n* direction.scss\n*/\n/* Skeleton Variables */\n/*\n[ Popup ]\n*/\n:host {\n  --wj-popup-top: auto;\n  --wj-popup-left: auto;\n  display: flex;\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.native-popup:not(.popup-active) {\n  display: none;\n}";
-class Popup extends WJElement {
+}, ae = `/*!
+* direction.scss
+*/: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 {
   constructor() {
     super();
-    __publicField(this, "className", "Popup");
-    this._manual = false;
+    ut(this, "className", "Popup");
+    this._manual = !1;
   }
-  set manual(value) {
-    this._manual = value;
+  set manual(n) {
+    this._manual = n;
   }
   get manual() {
-    if (this.hasAttribute("manual"))
-      this._manual = true;
-    return this._manual;
+    return this.hasAttribute("manual") && (this._manual = !0), this._manual;
   }
   static get cssStyleSheet() {
-    return styles;
+    return ae;
   }
   static get observedAttributes() {
     return ["active"];
@@ -1280,145 +904,95 @@ class Popup extends WJElement {
   setupAttributes() {
     this.isShadowRoot = "open";
   }
-  attributeChangedCallback(name, old, newName) {
-    if (name === "active") {
-      if (this.hasAttribute(name)) {
-        this.show();
-      } else {
-        this.hide();
-      }
-    }
+  attributeChangedCallback(n, o, i) {
+    n === "active" && (this.hasAttribute(n) ? this.show() : this.hide());
   }
-  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;
+  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;
   }
-  afterDraw(context, store, params) {
+  afterDraw(n, o, i) {
     this.setAnchor();
   }
   setAnchor() {
-    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) => {
-      console.log("som CLICK");
-      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");
-      }
+    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]);
+    G.addListener(this.anchorEl, "click", null, (n) => {
+      console.log("som CLICK"), !this.hasAttribute("disabled") && this.showHide();
+    }, { stopPropagation: !0 }), document.addEventListener("click", (n) => {
+      n.composedPath().some((i) => i === this) || this.hasAttribute("active") && this.removeAttribute("active");
     });
   }
   showHide() {
-    if (this.hasAttribute("active")) {
-      this.removeAttribute("active");
-    } else {
-      this.setAttribute("active", "");
-      event.addListener(this, "click", "wj:popup-show");
-    }
+    this.hasAttribute("active") ? this.removeAttribute("active") : (this.setAttribute("active", ""), G.addListener(this, "click", "wj:popup-show"));
   }
   reposition() {
-    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, {
+    const n = [];
+    this.offsetCalc = +this.offset || 0, this.slotArrow instanceof HTMLSlotElement && (this.arrow = this.slotArrow.assignedElements({ flatten: !0 })[0], this.arrow && (n.push(
+      Vt({
+        element: this.arrow
+      })
+    ), this.offsetCalc = Math.sqrt(2 * this.arrow.offsetWidth ** 2) / 2 + +this.offset)), n.push(
+      It(this.offsetCalc)
+    ), n.push(
+      jt()
+    ), this.hasAttribute("size") && n.push(
+      $t({
+        apply({ availableWidth: o, availableHeight: i, elements: s }) {
+          Object.assign(s.floating.style, {
+            width: `${s.reference.offsetWidth}px`
+          });
+        }
+      })
+    ), le(this.anchorEl, this.native, {
       placement: this.placement || "bottom",
       strategy: "fixed",
-      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 = {
+      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 = {
           top: "bottom",
           right: "left",
           bottom: "top",
           left: "right"
-        }[side];
-        if (middlewareData.arrow) {
-          const { x: x2, y: y2 } = middlewareData.arrow;
+        }[c];
+        if (s.arrow) {
+          const { x: d, y: u } = s.arrow;
           Object.assign(this.arrow.style, {
-            left: x2 != null ? `${x2}px` : "",
-            top: y2 != null ? `${y2}px` : "",
-            [staticSide]: `${-this.arrow.offsetWidth / 2}px`
+            left: d != null ? `${d}px` : "",
+            top: u != null ? `${u}px` : "",
+            [a]: `${-this.arrow.offsetWidth / 2}px`
           });
         }
       }
-    });
-    event.dispatchCustomEvent(this, "wj-popup:reposition", {
+    }), G.dispatchCustomEvent(this, "wj-popup:reposition", {
       data: { top: "bottom", right: "left", bottom: "top", left: "right" },
       context: this,
       event: this
     });
   }
   show() {
-    this.native.classList.add("popup-active");
-    this.cleanup = autoUpdate(this.anchorEl, this.native, () => {
+    this.native.classList.add("popup-active"), this.cleanup = ce(this.anchorEl, this.native, () => {
       this.reposition();
     });
   }
   hide() {
-    this.native.classList.remove("popup-active");
-    this.cleanup();
-    this.cleanup = void 0;
+    this.native.classList.remove("popup-active"), this.cleanup(), this.cleanup = void 0;
   }
   disconnectedCallback() {
-    event.removeElement(this.anchorEl);
+    G.removeElement(this.anchorEl);
   }
 }
-customElements.get("wj-popup") || window.customElements.define("wj-popup", Popup);
+customElements.get("wj-popup") || window.customElements.define("wj-popup", fe);
 export {
-  Popup
+  fe as Popup
 };