@evance/evance-ui 1.0.32 → 1.0.33

package/dist/cjs/EvOverlay.vue_vue_type_script_setup_true_lang-CvYioTZj.cjs

@@ -1,1714 +0,0 @@
-"use strict";
-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);
-/*! Evance UI v1.0.32 | MIT License */
-const vue = require("vue");
-const dimensions = require("./dimensions-DTdSalhE.cjs");
-const props = require("./props-DdqDoPkT.cjs");
-const helpers = require("./helpers-CV_nBQd8.cjs");
-const isFunctions = require("./is-functions-f1MIqAiq.cjs");
-const events = require("./events-KJonLG5b.cjs");
-const components = require("./components-2AZAM_Nt.cjs");
-const toggleScope = require("./toggleScope-CclKSVzg.cjs");
-const scroll = require("./scroll-PagdwptF.cjs");
-const units = require("./units-9qEF239I.cjs");
-const anchor = require("./anchor-CAKDrmsF.cjs");
-const animate = require("./animate-IDPEYw3Z.cjs");
-const component = require("./component-HNi67mmR.cjs");
-const EvTransition = require("./EvTransition-YZzsn8kI.cjs");
-const modelProxy = require("./modelProxy-CjKneVB_.cjs");
-const teleport = require("./teleport-C4GRO6Pf.cjs");
-const stack = require("./stack-BDag9o-Q.cjs");
-const router = require("./router-wfgEM6Rq.cjs");
-const locale = require("./locale-BcOX0Jg4.cjs");
-const handlers = /* @__PURE__ */ new WeakMap();
-function bindProps(el, props2) {
-  Object.keys(props2).forEach((k) => {
-    var _a;
-    if (isFunctions.isOn(k)) {
-      const name = events.eventName(k);
-      const handler = handlers.get(el);
-      if (props2[k] == null) {
-        handler == null ? void 0 : handler.forEach((v) => {
-          const [n, fn] = v;
-          if (n === name) {
-            el.removeEventListener(name, fn);
-            handler.delete(v);
-          }
-        });
-      } else if (!handler || !((_a = [...handler]) == null ? void 0 : _a.some((v) => v[0] === name && v[1] === props2[k]))) {
-        el.addEventListener(name, props2[k]);
-        const _handler = handler || /* @__PURE__ */ new Set();
-        _handler.add([name, props2[k]]);
-        if (!handlers.has(el)) {
-          handlers.set(el, _handler);
-        }
-      }
-    } else {
-      if (props2[k] == null) {
-        el.removeAttribute(k);
-      } else {
-        el.setAttribute(k, props2[k]);
-      }
-    }
-  });
-}
-function unbindProps(el, props2) {
-  Object.keys(props2).forEach((k) => {
-    if (isFunctions.isOn(k)) {
-      const name = events.eventName(k);
-      const handler = handlers.get(el);
-      handler == null ? void 0 : handler.forEach((v) => {
-        const [n, fn] = v;
-        if (n === name) {
-          el.removeEventListener(name, fn);
-          handler.delete(v);
-        }
-      });
-    } else {
-      el.removeAttribute(k);
-    }
-  });
-}
-const axes = ["x", "y"];
-class Rect {
-  constructor(x, y, width, height) {
-    this.x = x;
-    this.y = y;
-    this.width = width;
-    this.height = height;
-  }
-  get top() {
-    return this.y;
-  }
-  get bottom() {
-    return this.y + this.height;
-  }
-  get left() {
-    return this.x;
-  }
-  get right() {
-    return this.x + this.width;
-  }
-  /**
-   * ## Add Offset
-   * @param offset
-   */
-  addOffset(offset) {
-    const rect = Rect.fromRect(this);
-    rect.x += offset.x;
-    rect.y += offset.y;
-    return rect;
-  }
-  /**
-   * ## From Element
-   * @param el
-   * @param beforeTransforms
-   */
-  static fromElement(el, beforeTransforms = false) {
-    if (!beforeTransforms) {
-      return Rect.fromRect(el.getBoundingClientRect());
-    }
-    return adjustedBoundingRect(el);
-  }
-  /**
-   * ## From Rect
-   * Kind of replicates DOMRect.fromRect()
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMRect/fromRect_static
-   * @param rect
-   */
-  static fromRect(rect) {
-    return new Rect(rect.x, rect.y, rect.width, rect.height);
-  }
-  /**
-   * ## Get Overflow
-   * Returns the overflow margins based on a second Rect.
-   * @param b
-   */
-  getOverflow(b) {
-    return {
-      top: Math.max(0, b.top - this.top),
-      right: Math.max(0, this.right - b.right),
-      bottom: Math.max(0, this.bottom - b.bottom),
-      left: Math.max(0, b.left - this.left)
-    };
-  }
-}
-function adjustedBoundingRect(el) {
-  const rect = el.getBoundingClientRect();
-  const style = getComputedStyle(el);
-  const tx = style.transform;
-  if (tx) {
-    let ta, sx, sy, dx, dy;
-    if (tx.startsWith("matrix3d(")) {
-      ta = tx.slice(9, -1).split(/, /);
-      sx = +ta[0];
-      sy = +ta[5];
-      dx = +ta[12];
-      dy = +ta[13];
-    } else if (tx.startsWith("matrix(")) {
-      ta = tx.slice(7, -1).split(/, /);
-      sx = +ta[0];
-      sy = +ta[3];
-      dx = +ta[4];
-      dy = +ta[5];
-    } else {
-      return Rect.fromRect(rect);
-    }
-    const to = style.transformOrigin;
-    const x = rect.x - dx - (1 - sx) * parseFloat(to);
-    const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(" ") + 1));
-    const w = sx ? rect.width / sx : el.offsetWidth + 1;
-    const h = sy ? rect.height / sy : el.offsetHeight + 1;
-    return new Rect(x, y, w, h);
-  } else {
-    return Rect.fromRect(rect);
-  }
-}
-function getTargetRect(target) {
-  if (Array.isArray(target)) {
-    return new Rect(target[0], target[1], 0, 0);
-  } else {
-    return target.getBoundingClientRect();
-  }
-}
-function isFixedPosition(el) {
-  while (el) {
-    if (window.getComputedStyle(el).position === "fixed") {
-      return true;
-    }
-    el = el.offsetParent;
-  }
-  return false;
-}
-function toFixedPosition(style, isRtl = false) {
-  Object.assign(style, {
-    position: "fixed",
-    top: 0,
-    [isRtl ? "right" : "left"]: 0
-  });
-}
-const makeDelayOpenCloseProps = props.propsFactory(
-  {
-    closeDelay: [Number, String],
-    openDelay: [Number, String]
-  },
-  "delay"
-);
-function useDelayOpenClose(props2, callback) {
-  const delays = {};
-  const createDelay = (prop) => {
-    return () => {
-      const isOpening = prop === "openDelay";
-      if (delays.closeDelay) {
-        window.clearTimeout(delays.closeDelay);
-      }
-      if (delays.openDelay) {
-        window.clearTimeout(delays.openDelay);
-      }
-      return new Promise((resolve) => {
-        const duration = parseInt((props2[prop] ?? 0).toString(), 10);
-        delays[prop] = window.setTimeout(() => {
-          callback == null ? void 0 : callback(isOpening);
-          resolve(isOpening);
-        }, duration);
-      });
-    };
-  };
-  return {
-    delayClose: createDelay("closeDelay"),
-    delayOpen: createDelay("openDelay")
-  };
-}
-const EvMenuSymbol = Symbol.for("ev:menu");
-const makeActivatorProps = props.propsFactory(
-  {
-    activator: [String, Object],
-    activatorProps: {
-      type: Object,
-      default: () => ({})
-    },
-    openOnClick: {
-      type: Boolean,
-      default: void 0
-    },
-    openOnHover: Boolean,
-    openOnFocus: {
-      type: Boolean,
-      default: void 0
-    },
-    closeOnContentClick: Boolean,
-    ...makeDelayOpenCloseProps()
-  },
-  "EvOverlay/activator"
-);
-function useActivator(props2, isActive, isTopOfStack) {
-  return new Activator(props2, isActive, isTopOfStack);
-}
-class Activator {
-  constructor(props2, isActive, isTopOfStack) {
-    __publicField(this, "activatorEl", vue.ref());
-    __publicField(this, "activatorEvents");
-    __publicField(this, "activatorRef", vue.ref());
-    __publicField(this, "availableEvents");
-    __publicField(this, "component");
-    __publicField(this, "contentEvents");
-    __publicField(this, "delayClose");
-    __publicField(this, "delayOpen");
-    __publicField(this, "openOnClick");
-    __publicField(this, "openOnFocus");
-    __publicField(this, "veilEvents");
-    __publicField(this, "isHovered", false);
-    __publicField(this, "isFocused", false);
-    __publicField(this, "firstEnter", true);
-    __publicField(this, "watcher");
-    __publicField(this, "scope");
-    this.props = props2;
-    this.isActive = isActive;
-    this.isTopOfStack = isTopOfStack;
-    this.component = components.getCurrentComponent("Activator");
-    this.openOnFocus = vue.computed(
-      () => props2.openOnFocus || props2.openOnFocus == null && props2.openOnHover
-    );
-    this.openOnClick = vue.computed(
-      () => props2.openOnClick || props2.openOnClick == null && !props2.openOnHover && !this.openOnFocus.value
-    );
-    const { delayOpen, delayClose } = this.createDelayFunctions();
-    this.delayOpen = delayOpen;
-    this.delayClose = delayClose;
-    this.availableEvents = this.getAvailableEvents();
-    this.activatorEvents = this.createActivatorEvents();
-    this.contentEvents = this.createContentEvents();
-    this.veilEvents = this.createVeilEvents();
-    this.watchIsTopOfStack();
-    this.watchActivatorEl();
-    this.watchActivatorProp();
-  }
-  /**
-   * ## Create Activator Events
-   * Returns a computed set of partially available events.
-   * @private
-   */
-  createActivatorEvents() {
-    return vue.computed(() => {
-      const events2 = {};
-      if (this.isOpenOnClick()) {
-        events2.onClick = this.availableEvents.onClick;
-      }
-      if (this.isOpenOnHover()) {
-        events2.onMouseenter = this.availableEvents.onMouseenter;
-        events2.onMouseleave = this.availableEvents.onMouseleave;
-      }
-      if (this.isOpenOnFocus()) {
-        events2.onFocus = this.availableEvents.onFocus;
-        events2.onBlur = this.availableEvents.onBlur;
-      }
-      return events2;
-    });
-  }
-  /**
-   * ## Create Content Events
-   * @private
-   */
-  createContentEvents() {
-    return vue.computed(() => {
-      const events2 = {};
-      if (this.isOpenOnHover()) {
-        events2.onMouseenter = () => {
-          this.isHovered = true;
-          this.delayOpen();
-        };
-        events2.onMouseleave = () => {
-          this.isHovered = false;
-          this.delayClose();
-        };
-      }
-      if (this.isOpenOnFocus()) {
-        events2.onFocusin = () => {
-          this.isFocused = true;
-          this.delayOpen();
-        };
-        events2.onFocusout = () => {
-          this.isFocused = false;
-          this.delayClose();
-        };
-      }
-      if (this.isCloseOnContentClick()) {
-        const menu = vue.inject(EvMenuSymbol, null);
-        events2.onClick = () => {
-          this.isActive.value = false;
-          menu == null ? void 0 : menu.closeParents();
-        };
-      }
-      return events2;
-    });
-  }
-  /**
-   * ## Create Delay Functions
-   * @private
-   */
-  createDelayFunctions() {
-    return useDelayOpenClose(this.props, (value) => {
-      const canOpenHover = this.props.openOnHover && this.isHovered;
-      const canOpenFocus = this.openOnFocus.value && this.isFocused;
-      if (value === (canOpenHover || canOpenFocus) && !(this.props.openOnHover && this.isActive.value && !this.isTopOfStack.value)) {
-        if (this.isActive.value !== value) {
-          this.firstEnter = true;
-        }
-        this.isActive.value = value;
-      }
-    });
-  }
-  /**
-   * ## Create Veil Events
-   * @private
-   */
-  createVeilEvents() {
-    return vue.computed(() => {
-      const events2 = {};
-      if (this.isOpenOnHover()) {
-        events2.onMouseenter = () => {
-          if (this.firstEnter) {
-            this.isHovered = true;
-            this.firstEnter = false;
-            this.delayOpen();
-          }
-        };
-        events2.onMouseleave = () => {
-          this.isHovered = false;
-          this.delayClose();
-        };
-      }
-      return events2;
-    });
-  }
-  /**
-   *
-   * @param selector
-   * @private
-   */
-  getActivatorEl(selector = this.props.activator) {
-    var _a, _b, _c;
-    let activator;
-    if (selector) {
-      if (selector === "parent") {
-        let el = (_c = (_b = (_a = this.component) == null ? void 0 : _a.proxy) == null ? void 0 : _b.$el) == null ? void 0 : _c.parentNode;
-        while (el.hasAttribute("data-no-activator")) {
-          el = el.parentNode;
-        }
-        activator = el;
-      } else if (typeof selector === "string") {
-        activator = document.querySelector(selector);
-      } else if ("$el" in selector) {
-        activator = selector.$el;
-      } else {
-        activator = selector;
-      }
-    }
-    return this.setActivatorEl(activator);
-  }
-  /**
-   * ## Get Available Events
-   */
-  getAvailableEvents() {
-    return {
-      onBlur: this.onBlur.bind(this),
-      onClick: this.onClick.bind(this),
-      onFocus: this.onFocus.bind(this),
-      onMouseenter: this.onMouseenter.bind(this),
-      onMouseleave: this.onMouseleave.bind(this)
-    };
-  }
-  /**
-   * ## Is Close on Content Click?
-   * Should we close overlays when the content of the overlay is clicked.
-   * For example, when a menu item is clicked.
-   */
-  isCloseOnContentClick() {
-    return this.props.closeOnContentClick;
-  }
-  /**
-   * ## Is Open On Click?
-   */
-  isOpenOnClick() {
-    return this.openOnClick.value;
-  }
-  /**
-   * ## Is Open on Hover?
-   */
-  isOpenOnHover() {
-    return this.props.openOnHover;
-  }
-  /**
-   * ## Is Open on Focus?
-   */
-  isOpenOnFocus() {
-    return this.openOnFocus.value;
-  }
-  /**
-   * ## On Blur
-   * @param e
-   */
-  onBlur(e) {
-    e.stopPropagation();
-    this.isFocused = false;
-    this.delayClose();
-  }
-  /**
-   * ## On Click
-   * @param e
-   */
-  onClick(e) {
-    e.stopPropagation();
-    this.activatorEl.value = e.currentTarget || e.target;
-    this.isActive.value = !this.isActive.value;
-  }
-  /**
-   * ## On Focus
-   * @param e
-   */
-  onFocus(e) {
-    if (helpers.Browser.supportsFocusVisible && !e.target.matches(":focus-visible")) {
-      return;
-    }
-    e.stopPropagation();
-    this.isFocused = true;
-    this.activatorEl.value = e.currentTarget || e.target;
-    this.delayOpen();
-  }
-  /**
-   * ## On Mouse Enter (Hover)
-   * @param e
-   */
-  onMouseenter(e) {
-    var _a;
-    if ((_a = e.sourceCapabilities) == null ? void 0 : _a.firesTouchEvents) {
-      return;
-    }
-    this.isHovered = true;
-    this.activatorEl.value = e.currentTarget || e.target;
-    this.delayOpen();
-  }
-  /**
-   * ## On Mouse Leave
-   * @param e
-   */
-  onMouseleave(e) {
-    this.isHovered = false;
-    this.delayClose();
-  }
-  /**
-   * ## Set Activator Element
-   * @param activator
-   */
-  setActivatorEl(activator) {
-    this.activatorEl.value = (activator == null ? void 0 : activator.nodeType) === Node.ELEMENT_NODE ? activator : void 0;
-    return this.activatorEl.value;
-  }
-  /**
-   * ## Watch Activator Prop
-   * @private
-   */
-  watchActivatorProp() {
-    vue.watch(
-      () => !!this.props.activator,
-      (value) => {
-        if (value && helpers.Browser.hasWindow) {
-          this.scope = vue.effectScope();
-          this.scope.run(() => {
-            this.watcher = new ActivatorWatcher(this);
-          });
-        } else if (this.scope) {
-          this.scope.stop();
-        }
-      },
-      { flush: "post", immediate: true }
-    );
-    vue.onScopeDispose(() => {
-      var _a;
-      (_a = this.scope) == null ? void 0 : _a.stop();
-      if (this.watcher) {
-        this.watcher = void 0;
-      }
-    });
-  }
-  /**
-   * ## Watch for changes in `activatorEl`
-   * @private
-   */
-  watchActivatorEl() {
-    vue.watchEffect(() => {
-      if (!this.activatorRef.value) {
-        return;
-      }
-      vue.nextTick(() => {
-        this.activatorEl.value = helpers.refElement(this.activatorRef.value);
-      });
-    });
-  }
-  /**
-   * ## Watch for changes in `isTopOfStack`.
-   * @private
-   */
-  watchIsTopOfStack() {
-    vue.watch(this.isTopOfStack, (value) => {
-      if (value && (this.isOpenOnHover() && !this.isHovered && (!this.isOpenOnFocus() || !this.isFocused) || this.isOpenOnFocus() && !this.isFocused && (!this.isOpenOnHover() || !this.isHovered))) {
-        this.isActive.value = false;
-      }
-    });
-  }
-}
-class ActivatorWatcher {
-  constructor(activator) {
-    this.activator = activator;
-    this.watchActivator();
-  }
-  addActivatorPropsEventListeners(el = this.activator.getActivatorEl(), activatorProps = this.activator.props.activatorProps) {
-    if (!el) {
-      return;
-    }
-    bindProps(
-      el,
-      vue.mergeProps(this.activator.activatorEvents.value, activatorProps)
-    );
-  }
-  removeActivatorPropsEventListeners(el = this.activator.getActivatorEl(), activatorProps = this.activator.props.activatorProps) {
-    if (!el) {
-      return;
-    }
-    unbindProps(
-      el,
-      vue.mergeProps(this.activator.activatorEvents.value, activatorProps)
-    );
-  }
-  watchActivator() {
-    vue.watch(
-      () => this.activator.props.activator,
-      (value, oldValue) => {
-        if (oldValue && value !== oldValue) {
-          const activator = this.activator.getActivatorEl(oldValue);
-          activator && this.removeActivatorPropsEventListeners(activator);
-        }
-        if (value) {
-          vue.nextTick(() => this.addActivatorPropsEventListeners());
-        }
-      },
-      { immediate: true }
-    );
-    vue.watch(
-      () => this.activator.props.activatorProps,
-      () => {
-        this.addActivatorPropsEventListeners();
-      }
-    );
-    vue.onScopeDispose(() => {
-      this.removeActivatorPropsEventListeners();
-    });
-  }
-}
-function connectedPositionStrategy(data, props2, contentStyles) {
-  const manager = new ConnectedPosition(data, props2, contentStyles);
-  return {
-    updatePosition: manager.updatePosition.bind(manager)
-  };
-}
-class ConnectedPosition {
-  constructor(data, props2, contentStyles) {
-    __publicField(this, "contentScrollParents");
-    __publicField(this, "contentRect");
-    __publicField(this, "maxHeight");
-    __publicField(this, "maxWidth");
-    __publicField(this, "minHeight");
-    __publicField(this, "minWidth");
-    __publicField(this, "observe", false);
-    __publicField(this, "observer");
-    __publicField(this, "offset");
-    __publicField(this, "preferredPosition");
-    __publicField(this, "preferredOrigin");
-    __publicField(this, "targetRect");
-    __publicField(this, "viewportRect");
-    __publicField(this, "viewportMargin", 12);
-    __publicField(this, "zoneCalculator");
-    this.data = data;
-    this.props = props2;
-    this.contentStyles = contentStyles;
-    this.resolveFixedActivator();
-    this.minWidth = this.computedNumericProp("minWidth");
-    this.maxWidth = this.computedNumericProp("maxWidth");
-    this.minHeight = this.computedNumericProp("minHeight");
-    this.maxHeight = this.computedNumericProp("maxHeight");
-    this.offset = this.computedOffset();
-    this.zoneCalculator = new ZoneCalculator();
-    this.calculatePreferences();
-    this.addResizeObserver();
-    this.watch();
-  }
-  /**
-   * ## Add Resize Observer
-   *
-   * Watch for changes to the size and element of the activator as well as the overlay content.
-   *
-   * @private
-   */
-  addResizeObserver() {
-    this.observe = false;
-    this.observer = new ResizeObserver(() => {
-      if (this.observe) {
-        this.updatePosition();
-      }
-    });
-    vue.watch(
-      [this.data.activatorEl, this.data.contentEl],
-      ([newActivatorEl, newContentEl], [oldActivatorEl, oldContentEl]) => {
-        var _a, _b, _c, _d;
-        if (oldActivatorEl) {
-          (_a = this.observer) == null ? void 0 : _a.unobserve(oldActivatorEl);
-        }
-        if (newActivatorEl) {
-          (_b = this.observer) == null ? void 0 : _b.observe(newActivatorEl);
-        }
-        if (oldContentEl) {
-          (_c = this.observer) == null ? void 0 : _c.unobserve(oldContentEl);
-        }
-        if (newContentEl) {
-          (_d = this.observer) == null ? void 0 : _d.observe(newContentEl);
-        }
-      },
-      {
-        immediate: true
-      }
-    );
-    vue.onScopeDispose(() => {
-      var _a;
-      (_a = this.observer) == null ? void 0 : _a.disconnect();
-    });
-  }
-  /**
-   * ## Calculate Preferences (for position and origin anchor points)
-   * @private
-   */
-  calculatePreferences() {
-    const { preferredPosition, preferredOrigin } = helpers.destructComputed(() => {
-      const position = anchor.Anchor.fromSelector(
-        this.props.position,
-        this.data.isRtl.value
-      );
-      let origin;
-      if (this.props.origin === "overlap") {
-        origin = position;
-      } else if (this.props.origin === "auto") {
-        origin = position.flipSide();
-      } else {
-        origin = anchor.Anchor.fromSelector(
-          this.props.origin,
-          this.data.isRtl.value
-        );
-      }
-      if (position.side === origin.side && position.alignment === origin.flipAlignment().alignment) {
-        return {
-          preferredPosition: position.flipCorner(),
-          preferredOrigin: origin.flipCorner()
-        };
-      } else {
-        return {
-          preferredPosition: position,
-          preferredOrigin: origin
-        };
-      }
-    });
-    this.preferredPosition = preferredPosition;
-    this.preferredOrigin = preferredOrigin;
-  }
-  /**
-   * ## Computed Numeric Prop
-   * @param key
-   * @private
-   */
-  computedNumericProp(key) {
-    return vue.computed(() => {
-      const value = parseFloat(
-        this.props[key]
-      );
-      return isNaN(value) ? Infinity : value;
-    });
-  }
-  /**
-   * ## Computed Offset
-   *
-   * Returns an array, with the following indexes:
-   * - `0` - represents `side` offset.
-   * - `1` - represents `alignment` offset.
-   *
-   * @private
-   */
-  computedOffset() {
-    return vue.computed(() => {
-      if (Array.isArray(this.props.offset)) {
-        return this.props.offset;
-      }
-      if (typeof this.props.offset === "string") {
-        const offset = this.props.offset.split(" ").map(parseFloat);
-        if (offset.length < 2) {
-          offset.push(0);
-        }
-        return offset;
-      }
-      return isFunctions.isNumber(this.props.offset) ? [this.props.offset, 0] : [0, 0];
-    });
-  }
-  /**
-   * # Get Content Rect
-   *
-   * Returns a Rect adjusted for the original elements position, whilst accommodating RTL direction.
-   */
-  getContentRect() {
-    const el = this.data.contentEl.value;
-    const isRtl = this.data.isRtl.value;
-    const rect = Rect.fromElement(el, true);
-    if (isRtl) {
-      rect.x += parseFloat(el.style.right || 0);
-    } else {
-      rect.x -= parseFloat(el.style.left || 0);
-    }
-    rect.y -= parseFloat(el.style.top || 0);
-    return rect;
-  }
-  /**
-   * ## Get Content Scroll Parents
-   * @private
-   */
-  getContentScrollParents() {
-    const scrollParents = scroll.getScrollParents(this.data.contentEl.value);
-    const contentEl = this.data.contentEl.value;
-    if (!scrollParents.length) {
-      scrollParents.push(document.documentElement);
-      if (!(contentEl.style.top && contentEl.style.left)) {
-        this.contentRect.x -= parseFloat(
-          document.documentElement.style.getPropertyValue(
-            "--ev-body-scroll-x"
-          ) || "0"
-        );
-        this.contentRect.y -= parseFloat(
-          document.documentElement.style.getPropertyValue(
-            "--ev-body-scroll-y"
-          ) || "0"
-        );
-      }
-    }
-    return scrollParents;
-  }
-  /**
-   * ## Get Viewport Rect
-   *
-   * Calculates the viewport viewable area for the content taking into account the viewport margins.
-   * i.e. how close are we allowed to place content to the edges of the viewport?
-   *
-   * @private
-   */
-  getViewportRect() {
-    const viewportRect = this.contentScrollParents.reduce(
-      (currentRect, el) => {
-        const elRect = Rect.fromElement(el);
-        const isDocEl = el === document.documentElement;
-        const scrollRect = new Rect(
-          isDocEl ? 0 : elRect.x,
-          isDocEl ? 0 : elRect.y,
-          el.clientWidth,
-          el.clientHeight
-        );
-        if (!currentRect) {
-          return scrollRect;
-        }
-        return new Rect(
-          Math.max(currentRect.left, scrollRect.left),
-          Math.max(currentRect.top, scrollRect.top),
-          Math.min(currentRect.right, scrollRect.right) - Math.max(currentRect.left, scrollRect.left),
-          Math.min(currentRect.bottom, scrollRect.bottom) - Math.max(currentRect.top, scrollRect.top)
-        );
-      },
-      void 0
-    );
-    viewportRect.x += this.viewportMargin;
-    viewportRect.y += this.viewportMargin;
-    viewportRect.width -= this.viewportMargin * 2;
-    viewportRect.height -= this.viewportMargin * 2;
-    return viewportRect;
-  }
-  /**
-   * ## Resolve Fixed Activator
-   * @private
-   */
-  resolveFixedActivator() {
-    const isActivatorFixed = isFixedPosition(this.data.activatorEl.value);
-    if (isActivatorFixed) {
-      toFixedPosition(this.contentStyles.value, this.data.isRtl.value);
-    }
-  }
-  /**
-   * ## Update Position
-   */
-  updatePosition() {
-    var _a;
-    this.observe = false;
-    requestAnimationFrame(() => {
-      requestAnimationFrame(() => this.observe = true);
-    });
-    if (!this.data.activatorEl.value || !this.data.contentEl.value) {
-      return;
-    }
-    this.targetRect = Rect.fromElement(this.data.activatorEl.value);
-    this.contentRect = this.getContentRect();
-    this.contentScrollParents = this.getContentScrollParents();
-    this.viewportRect = this.getViewportRect();
-    const zones = this.zoneCalculator.getAvailable(
-      this.targetRect,
-      this.viewportRect,
-      this.offset.value,
-      this.contentRect
-    );
-    const placement = {
-      position: this.preferredPosition.value,
-      origin: this.preferredOrigin.value
-    };
-    if (placement.position.side === "auto") {
-      const autoZone = this.getAutoZone(placement.position, zones);
-      placement.position = autoZone.position;
-      placement.origin = placement.position.flipSide();
-    }
-    const zone = placement.position.side === "center" ? this.getCenterZone(zones) : this.getBestZone(placement.position, zones);
-    placement.position = zone.position;
-    placement.origin = placement.position.flipSide();
-    let { x, y } = zone.rect;
-    if (placement.position.side === "center") {
-      y = zone.rect.y + (zone.rect.height - this.contentRect.height) / 2;
-      x = zone.rect.x + (zone.rect.width - this.contentRect.width) / 2;
-    } else {
-      if (placement.position.side === "top") {
-        y = zone.rect.bottom - this.contentRect.height;
-      } else if (placement.position.side === "left") {
-        x = zone.rect.right - this.contentRect.width;
-      }
-      if (placement.position.alignment !== "start") {
-        const divider = placement.position.alignment === "center" ? 2 : 1;
-        if (placement.position.axis === "x") {
-          y = this.targetRect.y + (this.targetRect.height - this.contentRect.height) / divider;
-        } else {
-          x = this.targetRect.x + (this.targetRect.width - this.contentRect.width) / divider;
-        }
-      }
-    }
-    if (y < this.viewportRect.y) {
-      y = this.viewportRect.y;
-    }
-    if (x < this.viewportRect.x) {
-      x = this.viewportRect.x;
-    }
-    Object.assign(this.contentStyles.value, {
-      "--ev-overlay-position": placement.position.toCssValue(),
-      transformOrigin: placement.origin.toCssValue(),
-      top: units.toWebUnit(units.pixelRound(y)),
-      left: units.toWebUnit(units.pixelRound(x)),
-      minWidth: units.toWebUnit(
-        placement.position.axis === "y" ? Math.min(this.minWidth.value, this.targetRect.width) : this.minWidth.value
-      ),
-      maxWidth: units.toWebUnit(
-        units.pixelCeil(
-          helpers.clamp(
-            zone.rect.width,
-            this.minWidth.value === Infinity ? 0 : this.minWidth.value,
-            this.maxWidth.value
-          )
-        )
-      ),
-      maxHeight: units.toWebUnit(
-        units.pixelCeil(
-          helpers.clamp(
-            zone.rect.height,
-            this.minHeight.value === Infinity ? 0 : this.minHeight.value,
-            this.maxHeight.value
-          )
-        )
-      )
-    });
-    (_a = this.data.contentEl.value) == null ? void 0 : _a.setAttribute(
-      "data-position",
-      placement.position.toString()
-    );
-    return {
-      zoneRect: zone.rect,
-      contentRect: this.contentRect
-    };
-  }
-  getAutoZone(position, zones) {
-    const matches = zones.filter((zone) => {
-      if (zone.position.side === "center") {
-        return false;
-      }
-      return position.alignment === "auto" || zone.position.alignment === position.alignment;
-    });
-    return matches[0];
-  }
-  /**
-   * ## Get Best Zone
-   * Returns the zone that fits the content, or the zone with the largest available area.
-   * @param position
-   * @param zones
-   * @private
-   */
-  getBestZone(position, zones) {
-    const positions = [
-      position,
-      position.centerAlign(),
-      position.flipSide(),
-      position.flipSide().centerAlign(),
-      position.flipCorner(),
-      position.flipCorner().centerAlign(),
-      position.flipCorner().flipSide(),
-      position.flipCorner().flipSide().centerAlign()
-    ];
-    for (const newPosition of positions) {
-      const zone = zones.find((zone2) => {
-        return zone2.position.toString() === newPosition.toString();
-      });
-      if (zone == null ? void 0 : zone.isFitsContent) {
-        return zone;
-      }
-    }
-    for (const newPosition of positions) {
-      const zone = zones.find((zone2) => {
-        return zone2.position.toString() === newPosition.toString();
-      });
-      if (!zone) {
-        continue;
-      }
-      const dimension = newPosition.axis === "x" ? "width" : "height";
-      if (zone.available[dimension] >= 0) {
-        return zone;
-      }
-    }
-    return this.getAutoZone(position, zones);
-  }
-  /**
-   * ## Get Center Zone
-   * Returns the zone for centering content in the viewport, which is basically the whole viewport.
-   * @param zones
-   * @private
-   */
-  getCenterZone(zones) {
-    return zones.find((zone) => {
-      return zone.position.side === "center" && zone.position.alignment === "center";
-    });
-  }
-  /**
-   * ## Watch
-   *
-   * Watch for changes that affect position calculations.
-   *
-   * @private
-   */
-  watch() {
-    vue.watch(
-      () => {
-        var _a, _b;
-        return [
-          (_a = this.preferredPosition) == null ? void 0 : _a.value,
-          (_b = this.preferredOrigin) == null ? void 0 : _b.value,
-          this.props.offset,
-          this.props.minWidth,
-          this.props.minHeight,
-          this.props.maxWidth,
-          this.props.maxHeight
-        ];
-      },
-      () => this.updatePosition()
-    );
-    vue.nextTick(() => {
-      const result = this.updatePosition();
-      if (!result) {
-        return;
-      }
-    });
-  }
-}
-class Zone {
-  constructor(position, rect, content) {
-    __publicField(this, "available");
-    __publicField(this, "isFitsContent");
-    this.position = position;
-    this.rect = rect;
-    this.content = content;
-    this.available = {
-      width: this.rect.width - content.width,
-      height: this.rect.height - content.height
-    };
-    this.isFitsContent = this.rect.width >= content.width && this.rect.height >= content.height;
-  }
-  get availableArea() {
-    return this.available.width * this.available.height;
-  }
-}
-class ZoneCalculator {
-  /**
-   * ## Get Available
-   *
-   * Returns all available zones around the target.
-   *
-   * @param target
-   * @param viewport
-   * @param offset
-   * @param content
-   */
-  getAvailable(target, viewport, offset, content) {
-    const [offsetSide, offsetAlign] = offset;
-    const sides = {
-      top: {
-        y: viewport.top,
-        height: target.top - viewport.top - offsetSide,
-        align: "x"
-      },
-      bottom: {
-        y: target.bottom + offsetSide,
-        height: viewport.bottom - target.bottom - offsetSide,
-        align: "x"
-      },
-      left: {
-        x: viewport.left,
-        width: target.left - viewport.left - offsetSide,
-        align: "y"
-      },
-      right: {
-        x: target.right + offsetSide,
-        width: viewport.right - target.right - offsetSide,
-        align: "y"
-      },
-      center: { x: viewport.left, width: viewport.width, align: "y" }
-    };
-    const alignments = {
-      x: {
-        center: { x: viewport.left, width: viewport.width },
-        start: {
-          x: target.left + offsetAlign,
-          width: viewport.width - target.left - offsetAlign
-        },
-        end: {
-          x: viewport.left,
-          width: target.right - viewport.left - offsetAlign
-        }
-      },
-      y: {
-        center: { y: viewport.top, height: viewport.height },
-        start: {
-          y: target.top + offsetAlign,
-          height: viewport.bottom - target.top - offsetAlign
-        },
-        end: {
-          y: viewport.top,
-          height: target.bottom - viewport.top - offsetAlign
-        }
-      }
-    };
-    const zones = [];
-    for (const [side, sideAttrs] of Object.entries(sides)) {
-      for (const [align, alignAttrs] of Object.entries(
-        alignments[sideAttrs.align]
-      )) {
-        const anchor$1 = new anchor.Anchor(
-          side,
-          align
-        );
-        const rectProps = Object.assign(
-          {
-            width: 0,
-            height: 0,
-            x: 0,
-            y: 0
-          },
-          sideAttrs,
-          alignAttrs
-        );
-        const rect = Rect.fromRect(rectProps);
-        zones.push(new Zone(anchor$1, rect, content));
-      }
-    }
-    zones.sort((zoneA, zoneB) => {
-      return zoneB.availableArea - zoneA.availableArea;
-    });
-    return zones;
-  }
-}
-function staticPositionStrategy(data, props2, contentStyles) {
-}
-const positionStrategies = {
-  static: staticPositionStrategy,
-  // specific viewport position, usually centered
-  connected: connectedPositionStrategy
-  // connected to a certain element
-};
-const makePositionStrategyProps = props.propsFactory(
-  {
-    positionStrategy: {
-      type: [String, Function],
-      default: "connected",
-      validator: (value) => typeof value === "function" || value in positionStrategies
-    },
-    position: {
-      type: String,
-      default: "auto"
-    },
-    origin: {
-      type: String,
-      default: "auto"
-    },
-    offset: [Number, String, Array]
-  },
-  "EvOverlay/position"
-);
-function usePositionStrategies(props2, data) {
-  const contentStyles = vue.ref({});
-  const updatePosition = vue.ref();
-  function onResize(e) {
-    var _a;
-    (_a = updatePosition.value) == null ? void 0 : _a.call(updatePosition, e);
-  }
-  if (helpers.Browser.hasWindow) {
-    toggleScope.useToggleScope(
-      () => {
-        return !!(data.isActive.value && props2.positionStrategy);
-      },
-      (reset) => {
-        var _a;
-        vue.watch(() => props2.positionStrategy, reset);
-        vue.onScopeDispose(() => {
-          updatePosition.value = void 0;
-        });
-        let positionStrategyFn;
-        if (isFunctions.isFunction(props2.positionStrategy)) {
-          positionStrategyFn = props2.positionStrategy;
-        } else {
-          positionStrategyFn = positionStrategies[props2.positionStrategy];
-        }
-        updatePosition.value = (_a = positionStrategyFn(
-          data,
-          props2,
-          contentStyles
-        )) == null ? void 0 : _a.updatePosition;
-      }
-    );
-    window.addEventListener("resize", onResize, { passive: true });
-    vue.onScopeDispose(() => {
-      window.removeEventListener("resize", onResize);
-      updatePosition.value = void 0;
-    });
-  }
-  return {
-    contentStyles,
-    updatePosition
-  };
-}
-function blockScrollStrategy(data, props2) {
-  var _a, _b;
-  const offsetParent = (_a = data.containerEl.value) == null ? void 0 : _a.offsetParent;
-  const scrollElements = [
-    .../* @__PURE__ */ new Set([
-      ...scroll.getScrollParents(
-        data.activatorEl.value,
-        props2.contained ? offsetParent : void 0
-      ),
-      ...scroll.getScrollParents(
-        data.contentEl.value,
-        props2.contained ? offsetParent : void 0
-      )
-    ])
-  ].filter((el) => !el.classList.contains("ev-overlay-scroll-blocked"));
-  const scrollbarWidth = window.innerWidth - document.documentElement.offsetWidth;
-  const scrollableParent = ((el) => scroll.hasScrollbar(el) && el)(
-    offsetParent || document.documentElement
-  );
-  if (scrollableParent) {
-    (_b = data.containerEl.value) == null ? void 0 : _b.classList.add("ev-overlay--scroll-blocked");
-  }
-  scrollElements.forEach((el, i) => {
-    el.style.setProperty(
-      "--ev-body-scroll-x",
-      units.toWebUnit(-el.scrollLeft) ?? null
-    );
-    el.style.setProperty(
-      "--ev-body-scroll-y",
-      units.toWebUnit(-el.scrollTop) ?? null
-    );
-    if (el !== document.documentElement) {
-      el.style.setProperty(
-        "--ev-scrollbar-offset",
-        units.toWebUnit(scrollbarWidth) ?? null
-      );
-    }
-    el.classList.add("ev-overlay-scroll-blocked");
-  });
-  vue.onScopeDispose(() => {
-    var _a2;
-    scrollElements.forEach((el, i) => {
-      const x = parseFloat(
-        el.style.getPropertyValue("--ev-body-scroll-x")
-      );
-      const y = parseFloat(
-        el.style.getPropertyValue("--ev-body-scroll-y")
-      );
-      el.style.removeProperty("--ev-body-scroll-x");
-      el.style.removeProperty("--ev-body-scroll-y");
-      el.style.removeProperty("--ev-scrollbar-offset");
-      el.classList.remove("ev-overlay-scroll-blocked");
-      el.scrollLeft = -x;
-      el.scrollTop = -y;
-    });
-    if (scrollableParent) {
-      (_a2 = data.containerEl.value) == null ? void 0 : _a2.classList.remove(
-        "ev-overlay--scroll-blocked"
-      );
-    }
-  });
-}
-function closeScrollStrategy(data) {
-  function onScroll(e) {
-    data.isActive.value = false;
-  }
-  events.addScrollEventListener(
-    data.activatorEl.value ?? data.contentEl.value,
-    onScroll
-  );
-}
-function repositionScrollStrategy(data, props2, scope) {
-  let slow = false;
-  let raf = -1;
-  let ric = -1;
-  function update(e) {
-    animate.requestNewFrame(() => {
-      var _a, _b;
-      const start = performance.now();
-      (_b = (_a = data.updatePosition).value) == null ? void 0 : _b.call(_a, e);
-      const time = performance.now() - start;
-      slow = time / (1e3 / 60) > 2;
-    });
-  }
-  ric = (typeof requestIdleCallback === "undefined" ? (cb) => cb() : requestIdleCallback)(() => {
-    scope.run(() => {
-      events.addScrollEventListener(
-        data.activatorEl.value ?? data.contentEl.value,
-        (e) => {
-          if (slow) {
-            cancelAnimationFrame(raf);
-            raf = requestAnimationFrame(() => {
-              raf = requestAnimationFrame(() => {
-                update(e);
-              });
-            });
-          } else {
-            update(e);
-          }
-        }
-      );
-    });
-  });
-  vue.onScopeDispose(() => {
-    typeof cancelIdleCallback !== "undefined" && cancelIdleCallback(ric);
-    cancelAnimationFrame(raf);
-  });
-}
-const scrollStrategies = {
-  none: null,
-  close: closeScrollStrategy,
-  block: blockScrollStrategy,
-  reposition: repositionScrollStrategy
-};
-const makeScrollStrategyProps = props.propsFactory(
-  {
-    scrollStrategy: {
-      type: [String, Function],
-      default: "block",
-      validator: (val) => typeof val === "function" || val in scrollStrategies
-    }
-  },
-  "EvOverlay/scroll"
-);
-function useScrollStrategies(props2, data) {
-  if (!helpers.Browser.hasWindow) {
-    return;
-  }
-  let scope;
-  vue.watchEffect(async () => {
-    scope == null ? void 0 : scope.stop();
-    if (!(data.isActive.value && props2.scrollStrategy)) {
-      return;
-    }
-    scope = vue.effectScope();
-    await vue.nextTick();
-    scope.active && scope.run(() => {
-      var _a;
-      if (typeof props2.scrollStrategy === "function") {
-        props2.scrollStrategy(data, props2, scope);
-      } else {
-        (_a = scrollStrategies[props2.scrollStrategy]) == null ? void 0 : _a.call(
-          scrollStrategies,
-          data,
-          props2,
-          scope
-        );
-      }
-    });
-  });
-  vue.onScopeDispose(() => {
-    scope == null ? void 0 : scope.stop();
-  });
-}
-const makeEvOverlayProps = props.propsFactory(
-  {
-    absolute: Boolean,
-    attach: [Boolean, String, Object],
-    closeOnBack: {
-      type: Boolean,
-      default: true
-    },
-    contained: Boolean,
-    contentClass: null,
-    contentProps: null,
-    disabled: Boolean,
-    modelValue: [Boolean, Object],
-    persistent: Boolean,
-    veil: {
-      type: Boolean,
-      default: true
-    },
-    zIndex: {
-      type: [Number, String],
-      default: 2e3
-    },
-    ...makeActivatorProps(),
-    ...dimensions.makeDimensionsProps(),
-    ...makePositionStrategyProps(),
-    ...makeScrollStrategyProps(),
-    ...EvTransition.makeEvTransitionProps(),
-    ...component.makeComponentProps()
-  },
-  "EvOverlay"
-);
-/*!
-  * vue-router v4.2.4
-  * (c) 2023 Eduardo San Martin Morote
-  * @license MIT
-  */
-var NavigationType;
-(function(NavigationType2) {
-  NavigationType2["pop"] = "pop";
-  NavigationType2["push"] = "push";
-})(NavigationType || (NavigationType = {}));
-var NavigationDirection;
-(function(NavigationDirection2) {
-  NavigationDirection2["back"] = "back";
-  NavigationDirection2["forward"] = "forward";
-  NavigationDirection2["unknown"] = "";
-})(NavigationDirection || (NavigationDirection = {}));
-Symbol(process.env.NODE_ENV !== "production" ? "navigation failure" : "");
-var NavigationFailureType;
-(function(NavigationFailureType2) {
-  NavigationFailureType2[NavigationFailureType2["aborted"] = 4] = "aborted";
-  NavigationFailureType2[NavigationFailureType2["cancelled"] = 8] = "cancelled";
-  NavigationFailureType2[NavigationFailureType2["duplicated"] = 16] = "duplicated";
-})(NavigationFailureType || (NavigationFailureType = {}));
-Symbol(process.env.NODE_ENV !== "production" ? "router view location matched" : "");
-Symbol(process.env.NODE_ENV !== "production" ? "router view depth" : "");
-const routerKey = Symbol(process.env.NODE_ENV !== "production" ? "router" : "");
-Symbol(process.env.NODE_ENV !== "production" ? "route location" : "");
-Symbol(process.env.NODE_ENV !== "production" ? "router view location" : "");
-function useRouter() {
-  return vue.inject(routerKey);
-}
-function useScopeId() {
-  const component2 = components.getCurrentComponent("useScopeId");
-  const scopeId = component2.vnode.scopeId;
-  return {
-    scopeId: scopeId ? { [scopeId]: "" } : void 0
-  };
-}
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  ...{
-    inheritAttrs: false
-  },
-  __name: "EvOverlay",
-  props: {
-    disableGlobalStack: Boolean,
-    ...makeEvOverlayProps()
-  },
-  emits: [
-    "click:outside",
-    "update:modelValue",
-    "enter",
-    "afterEnter",
-    "beforeLeave",
-    "leave",
-    "afterLeave"
-  ],
-  setup(__props, { expose: __expose, emit }) {
-    const props2 = __props;
-    const attrs = vue.useAttrs();
-    const slots = vue.useSlots();
-    const router$1 = useRouter();
-    const model = modelProxy.useModelProxy(props2, "modelValue");
-    const containerEl = vue.ref(void 0);
-    const contentEl = vue.ref(void 0);
-    const contentTransition = EvTransition.useEvTransition(props2);
-    const dimensions$1 = dimensions.useDimensions(props2);
-    const { scopeId } = useScopeId();
-    const isActiveContent = vue.computed({
-      get: () => model.value,
-      set: (value) => {
-        if (!(value && props2.disabled)) {
-          model.value = value;
-        }
-      }
-    });
-    const { isTopGlobal, isTopLocal, stackStyles } = stack.useStack(
-      isActiveContent,
-      vue.toRef(props2, "zIndex"),
-      props2.disableGlobalStack
-    );
-    const {
-      activatorEl,
-      activatorRef,
-      activatorEvents,
-      contentEvents,
-      veilEvents
-    } = useActivator(props2, isActiveContent, isTopLocal);
-    const teleportTarget = teleport.useTeleport(
-      vue.computed(() => {
-        return props2.attach || props2.contained;
-      })
-    );
-    const { rtlClasses, isRtl } = locale.useRtl();
-    const { contentStyles, updatePosition } = usePositionStrategies(props2, {
-      isRtl,
-      contentEl,
-      activatorEl,
-      isActive: isActiveContent
-    });
-    useScrollStrategies(props2, {
-      containerEl,
-      contentEl,
-      activatorEl,
-      isActive: isActiveContent,
-      updatePosition
-    });
-    __expose({
-      activatorEl,
-      contentEl,
-      isTopGlobal,
-      isTopLocal,
-      updatePosition
-    });
-    vue.watch(
-      () => props2.disabled,
-      (value) => {
-        if (value) {
-          isActiveContent.value = false;
-        }
-      }
-    );
-    const isActiveVeil = vue.computed(() => {
-      return isActiveContent.value && !!props2.veil;
-    });
-    const isActiveTeleport = vue.shallowRef(false);
-    vue.watch(isActiveContent, () => {
-      isActiveTeleport.value = true;
-    });
-    function clickOutsideCondition() {
-      return isActiveContent.value && isTopGlobal.value;
-    }
-    function dismiss(focusActivator = false) {
-      var _a, _b;
-      if (props2.persistent) {
-        animate.clickBlockedAnimation(contentEl.value);
-        return;
-      }
-      isActiveContent.value = false;
-      if (focusActivator && ((_a = contentEl.value) == null ? void 0 : _a.contains(document.activeElement))) {
-        (_b = activatorEl.value) == null ? void 0 : _b.focus();
-      }
-    }
-    function onEnter(el) {
-      if (!el.dataset.enter) {
-        el.dataset.enter = "true";
-        return;
-      }
-      emit("enter");
-    }
-    function onAfterEnter(el) {
-      if (!el.dataset.afterEnter) {
-        el.dataset.afterEnter = "true";
-        return;
-      }
-      emit("afterEnter");
-    }
-    function onBeforeLeave() {
-      emit("beforeLeave");
-    }
-    function onLeave() {
-      emit("leave");
-    }
-    function onAfterLeave() {
-      isActiveTeleport.value = false;
-      emit("afterLeave");
-    }
-    const clickOutsideDirectiveArgs = {
-      handler: onClickOutside,
-      condition: clickOutsideCondition,
-      include: () => [activatorEl.value]
-    };
-    function onClickOutside(e) {
-      emit("click:outside", e);
-      dismiss(false);
-    }
-    function onKeydown(e) {
-      if (e.key === "Escape" && isTopGlobal.value) {
-        dismiss(true);
-      }
-    }
-    vue.watch(
-      isActiveContent,
-      (active) => {
-        if (active) {
-          window.addEventListener("keydown", onKeydown);
-        } else {
-          window.removeEventListener("keydown", onKeydown);
-        }
-      },
-      { immediate: true }
-    );
-    toggleScope.useToggleScope(
-      () => props2.closeOnBack,
-      () => {
-        router.useBackButton(router$1, (next) => {
-          if (isTopGlobal.value && isActiveContent.value) {
-            next(false);
-            dismiss(false);
-          } else {
-            next();
-          }
-        });
-      }
-    );
-    const top = vue.ref();
-    vue.watch(
-      () => isActiveContent.value && (props2.absolute || props2.contained) && teleportTarget.value == null,
-      (value) => {
-        if (value) {
-          const scrollParent = scroll.getScrollParent(containerEl.value);
-          if (scrollParent && scrollParent !== document.scrollingElement) {
-            top.value = scrollParent.scrollTop;
-          }
-        }
-      }
-    );
-    const activatorSlot = () => {
-      var _a;
-      return (_a = slots.activator) == null ? void 0 : _a.call(slots, {
-        isActive: isActiveContent.value,
-        props: vue.mergeProps(
-          { ref: activatorRef },
-          activatorEvents.value,
-          props2.activatorProps
-        )
-      });
-    };
-    const contentAttributes = vue.mergeProps(contentEvents.value, props2.contentProps);
-    const overlayAttributes = {
-      ...scopeId,
-      ...attrs
-    };
-    return (_ctx, _cache) => {
-      const _directive_click_outside = vue.resolveDirective("click-outside");
-      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
-        vue.createVNode(activatorSlot),
-        isActiveTeleport.value ? (vue.openBlock(), vue.createBlock(vue.Teleport, {
-          key: 0,
-          disabled: !vue.unref(teleportTarget),
-          to: vue.unref(teleportTarget)
-        }, [
-          vue.createElementVNode("div", vue.mergeProps({
-            ref_key: "containerEl",
-            ref: containerEl,
-            class: [
-              "ev-overlay",
-              {
-                "is-active": isActiveContent.value
-              },
-              vue.unref(rtlClasses),
-              props2.class
-            ],
-            style: [
-              vue.unref(stackStyles),
-              {
-                top: vue.unref(units.toWebUnit)(top.value)
-              },
-              props2.style
-            ]
-          }, overlayAttributes), [
-            vue.createVNode(vue.Transition, {
-              appear: "",
-              name: "transition-fade"
-            }, {
-              default: vue.withCtx(() => [
-                isActiveVeil.value ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
-                  key: 0,
-                  class: "ev-overlay--veil"
-                }, vue.unref(veilEvents)), null, 16)) : vue.createCommentVNode("", true)
-              ]),
-              _: 1
-            }),
-            vue.createVNode(vue.unref(EvTransition.EvTransition), {
-              appear: "",
-              transition: vue.unref(contentTransition),
-              target: vue.unref(activatorEl),
-              onEnter,
-              onAfterEnter,
-              onBeforeLeave,
-              onLeave,
-              onAfterLeave
-            }, {
-              default: vue.withCtx(() => [
-                vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
-                  ref_key: "contentEl",
-                  ref: contentEl,
-                  class: ["ev-overlay--content", [props2.contentClass]],
-                  style: [vue.unref(dimensions$1), vue.unref(contentStyles)]
-                }, vue.unref(contentAttributes)), [
-                  vue.renderSlot(_ctx.$slots, "default")
-                ], 16)), [
-                  [vue.vShow, isActiveContent.value],
-                  [_directive_click_outside, clickOutsideDirectiveArgs]
-                ])
-              ]),
-              _: 3
-            }, 8, ["transition", "target"])
-          ], 16)
-        ], 8, ["disabled", "to"])) : vue.createCommentVNode("", true)
-      ], 64);
-    };
-  }
-});
-exports.EvMenuSymbol = EvMenuSymbol;
-exports.Rect = Rect;
-exports._sfc_main = _sfc_main;
-exports.adjustedBoundingRect = adjustedBoundingRect;
-exports.axes = axes;
-exports.bindProps = bindProps;
-exports.getTargetRect = getTargetRect;
-exports.isFixedPosition = isFixedPosition;
-exports.makeActivatorProps = makeActivatorProps;
-exports.makeEvOverlayProps = makeEvOverlayProps;
-exports.makePositionStrategyProps = makePositionStrategyProps;
-exports.makeScrollStrategyProps = makeScrollStrategyProps;
-exports.toFixedPosition = toFixedPosition;
-exports.unbindProps = unbindProps;
-exports.useActivator = useActivator;
-exports.usePositionStrategies = usePositionStrategies;
-exports.useScrollStrategies = useScrollStrategies;
-//# sourceMappingURL=EvOverlay.vue_vue_type_script_setup_true_lang-CvYioTZj.cjs.map