@vueuse/components 12.2.0 → 12.3.0

package/index.cjs

@@ -24,7 +24,7 @@ const defaultWindow = shared.isClient ? window : void 0;
 
 function unrefElement(elRef) {
   var _a;
-  const plain = shared.toValue(elRef);
+  const plain = vue.toValue(elRef);
   return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
 }
 
@@ -41,10 +41,8 @@ function useEventListener(...args) {
   }
   if (!target)
     return shared.noop;
-  if (!Array.isArray(events))
-    events = [events];
-  if (!Array.isArray(listeners))
-    listeners = [listeners];
+  events = shared.toArray(events);
+  listeners = shared.toArray(listeners);
   const cleanups = [];
   const cleanup = () => {
     cleanups.forEach((fn) => fn());
@@ -55,7 +53,7 @@ function useEventListener(...args) {
     return () => el.removeEventListener(event, listener, options2);
   };
   const stopWatch = vue.watch(
-    () => [unrefElement(target), shared.toValue(options)],
+    () => [unrefElement(target), vue.toValue(options)],
     ([el, options2]) => {
       cleanup();
       if (!el)
@@ -89,7 +87,7 @@ function onClickOutside(target, handler, options = {}) {
   }
   let shouldListen = true;
   const shouldIgnore = (event) => {
-    return shared.toValue(ignore).some((target2) => {
+    return vue.toValue(ignore).some((target2) => {
       if (typeof target2 === "string") {
         return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
       } else {
@@ -99,11 +97,11 @@ function onClickOutside(target, handler, options = {}) {
     });
   };
   function hasMultipleRoots(target2) {
-    const vm = shared.toValue(target2);
+    const vm = vue.toValue(target2);
     return vm && vm.$.subTree.shapeFlag === 16;
   }
   function checkMultipleRoots(target2, event) {
-    const vm = shared.toValue(target2);
+    const vm = vue.toValue(target2);
     const children = vm.$.subTree && vm.$.subTree.children;
     if (children == null || !Array.isArray(children))
       return false;
@@ -207,7 +205,7 @@ function onKeyStroke(...args) {
   } = options;
   const predicate = createKeyPredicate(key);
   const listener = (e) => {
-    if (e.repeat && shared.toValue(dedupe))
+    if (e.repeat && vue.toValue(dedupe))
       return;
     if (predicate(e))
       handler(e);
@@ -458,7 +456,7 @@ function useMediaQuery(query, options = {}) {
   const stopWatch = vue.watchEffect(() => {
     if (ssrSupport.value) {
       ssrSupport.value = !isSupported.value;
-      const queryStrings = shared.toValue(query).split(",");
+      const queryStrings = vue.toValue(query).split(",");
       matches.value = queryStrings.some((queryString) => {
         const not = queryString.includes("not all");
         const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
@@ -477,7 +475,7 @@ function useMediaQuery(query, options = {}) {
     if (!isSupported.value)
       return;
     cleanup();
-    mediaQuery = window.matchMedia(shared.toValue(query));
+    mediaQuery = window.matchMedia(vue.toValue(query));
     if ("addEventListener" in mediaQuery)
       mediaQuery.addEventListener("change", handler);
     else
@@ -564,7 +562,7 @@ function useStorage(key, defaults, storage, options = {}) {
   }
   if (!storage)
     return data;
-  const rawInit = shared.toValue(defaults);
+  const rawInit = vue.toValue(defaults);
   const type = guessSerializerType(rawInit);
   const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];
   const { pause: pauseWatch, resume: resumeWatch } = shared.pausableWatch(
@@ -877,7 +875,7 @@ const UseDraggable = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
     const disabled = vue.computed(() => !!props.disabled);
     const storageValue = props.storageKey && core.useStorage(
       props.storageKey,
-      shared.toValue(props.initialValue) || { x: 0, y: 0 },
+      vue.toValue(props.initialValue) || { x: 0, y: 0 },
       core.isClient ? props.storageType === "session" ? sessionStorage : localStorage : void 0
     );
     const initialValue = storageValue || props.initialValue || { x: 0, y: 0 };
@@ -917,10 +915,222 @@ const UseElementBounding = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
   }
 });
 
+function useMutationObserver(target, callback, options = {}) {
+  const { window = defaultWindow, ...mutationOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window && "MutationObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const targets = vue.computed(() => {
+    const value = vue.toValue(target);
+    const items = shared.toArray(value).map(unrefElement).filter(shared.notNullish);
+    return new Set(items);
+  });
+  const stopWatch = vue.watch(
+    () => targets.value,
+    (targets2) => {
+      cleanup();
+      if (isSupported.value && targets2.size) {
+        observer = new MutationObserver(callback);
+        targets2.forEach((el) => observer.observe(el, mutationOptions));
+      }
+    },
+    { immediate: true, flush: "post" }
+  );
+  const takeRecords = () => {
+    return observer == null ? void 0 : observer.takeRecords();
+  };
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  shared.tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop,
+    takeRecords
+  };
+}
+
+function useResizeObserver(target, callback, options = {}) {
+  const { window = defaultWindow, ...observerOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window && "ResizeObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const targets = vue.computed(() => {
+    const _targets = vue.toValue(target);
+    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+  });
+  const stopWatch = vue.watch(
+    targets,
+    (els) => {
+      cleanup();
+      if (isSupported.value && window) {
+        observer = new ResizeObserver(callback);
+        for (const _el of els) {
+          if (_el)
+            observer.observe(_el, observerOptions);
+        }
+      }
+    },
+    { immediate: true, flush: "post" }
+  );
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  shared.tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+function useElementBounding(target, options = {}) {
+  const {
+    reset = true,
+    windowResize = true,
+    windowScroll = true,
+    immediate = true,
+    updateTiming = "sync"
+  } = options;
+  const height = vue.ref(0);
+  const bottom = vue.ref(0);
+  const left = vue.ref(0);
+  const right = vue.ref(0);
+  const top = vue.ref(0);
+  const width = vue.ref(0);
+  const x = vue.ref(0);
+  const y = vue.ref(0);
+  function recalculate() {
+    const el = unrefElement(target);
+    if (!el) {
+      if (reset) {
+        height.value = 0;
+        bottom.value = 0;
+        left.value = 0;
+        right.value = 0;
+        top.value = 0;
+        width.value = 0;
+        x.value = 0;
+        y.value = 0;
+      }
+      return;
+    }
+    const rect = el.getBoundingClientRect();
+    height.value = rect.height;
+    bottom.value = rect.bottom;
+    left.value = rect.left;
+    right.value = rect.right;
+    top.value = rect.top;
+    width.value = rect.width;
+    x.value = rect.x;
+    y.value = rect.y;
+  }
+  function update() {
+    if (updateTiming === "sync")
+      recalculate();
+    else if (updateTiming === "next-frame")
+      requestAnimationFrame(() => recalculate());
+  }
+  useResizeObserver(target, update);
+  vue.watch(() => unrefElement(target), (ele) => !ele && update());
+  useMutationObserver(target, update, {
+    attributeFilter: ["style", "class"]
+  });
+  if (windowScroll)
+    useEventListener("scroll", update, { capture: true, passive: true });
+  if (windowResize)
+    useEventListener("resize", update, { passive: true });
+  shared.tryOnMounted(() => {
+    if (immediate)
+      update();
+  });
+  return {
+    height,
+    bottom,
+    left,
+    right,
+    top,
+    width,
+    x,
+    y,
+    update
+  };
+}
+
+const vElementBounding = {
+  mounted(el, binding) {
+    const [handler, options] = typeof binding.value === "function" ? [binding.value, {}] : binding.value;
+    const {
+      height,
+      bottom,
+      left,
+      right,
+      top,
+      width,
+      x,
+      y
+    } = useElementBounding(el, options);
+    vue.watch([height, bottom, left, right, top, width, x, y], () => handler({ height, bottom, left, right, top, width, x, y }));
+  }
+};
+
+function onElementRemoval(target, callback, options = {}) {
+  const {
+    window = defaultWindow,
+    document = window == null ? void 0 : window.document,
+    flush = "sync"
+  } = options;
+  if (!window || !document)
+    return shared.noop;
+  let stopFn;
+  const cleanupAndUpdate = (fn) => {
+    stopFn == null ? void 0 : stopFn();
+    stopFn = fn;
+  };
+  const stopWatch = vue.watchEffect(() => {
+    const el = unrefElement(target);
+    if (el) {
+      const { stop } = useMutationObserver(
+        document,
+        (mutationsList) => {
+          const targetRemoved = mutationsList.map((mutation) => [...mutation.removedNodes]).flat().some((node) => node === el || node.contains(el));
+          if (targetRemoved) {
+            callback(mutationsList);
+          }
+        },
+        {
+          window,
+          childList: true,
+          subtree: true
+        }
+      );
+      cleanupAndUpdate(stop);
+    }
+  }, { flush });
+  const stopHandle = () => {
+    stopWatch();
+    cleanupAndUpdate();
+  };
+  shared.tryOnScopeDispose(stopHandle);
+  return stopHandle;
+}
+
 function useElementHover(el, options = {}) {
   const {
     delayEnter = 0,
     delayLeave = 0,
+    triggerOnRemoval = false,
     window = defaultWindow
   } = options;
   const isHovered = vue.ref(false);
@@ -940,6 +1150,12 @@ function useElementHover(el, options = {}) {
     return isHovered;
   useEventListener(el, "mouseenter", () => toggle(true), { passive: true });
   useEventListener(el, "mouseleave", () => toggle(false), { passive: true });
+  if (triggerOnRemoval) {
+    onElementRemoval(
+      vue.computed(() => unrefElement(el)),
+      () => toggle(false)
+    );
+  }
   return isHovered;
 }
 
@@ -970,45 +1186,6 @@ const UseElementSize = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
   }
 });
 
-function useResizeObserver(target, callback, options = {}) {
-  const { window = defaultWindow, ...observerOptions } = options;
-  let observer;
-  const isSupported = useSupported(() => window && "ResizeObserver" in window);
-  const cleanup = () => {
-    if (observer) {
-      observer.disconnect();
-      observer = void 0;
-    }
-  };
-  const targets = vue.computed(() => {
-    const _targets = shared.toValue(target);
-    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
-  });
-  const stopWatch = vue.watch(
-    targets,
-    (els) => {
-      cleanup();
-      if (isSupported.value && window) {
-        observer = new ResizeObserver(callback);
-        for (const _el of els) {
-          if (_el)
-            observer.observe(_el, observerOptions);
-        }
-      }
-    },
-    { immediate: true, flush: "post" }
-  );
-  const stop = () => {
-    cleanup();
-    stopWatch();
-  };
-  shared.tryOnScopeDispose(stop);
-  return {
-    isSupported,
-    stop
-  };
-}
-
 function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
   const { window = defaultWindow, box = "content-box" } = options;
   const isSVG = vue.computed(() => {
@@ -1030,7 +1207,7 @@ function useElementSize(target, initialSize = { width: 0, height: 0 }, options =
         }
       } else {
         if (boxSize) {
-          const formatBoxSize = Array.isArray(boxSize) ? boxSize : [boxSize];
+          const formatBoxSize = shared.toArray(boxSize);
           width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
           height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
         } else {
@@ -1101,8 +1278,8 @@ function useIntersectionObserver(target, callback, options = {}) {
   } = options;
   const isSupported = useSupported(() => window && "IntersectionObserver" in window);
   const targets = vue.computed(() => {
-    const _target = shared.toValue(target);
-    return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(shared.notNullish);
+    const _target = vue.toValue(target);
+    return shared.toArray(_target).map(unrefElement).filter(shared.notNullish);
   });
   let cleanup = shared.noop;
   const isActive = vue.ref(immediate);
@@ -1175,7 +1352,7 @@ function useElementVisibility(element, options = {}) {
       root: scrollTarget,
       window,
       threshold,
-      rootMargin: shared.toValue(rootMargin)
+      rootMargin: vue.toValue(rootMargin)
     }
   );
   return elementIsVisible;
@@ -1341,7 +1518,7 @@ async function loadImage(options) {
 }
 function useImage(options, asyncStateOptions = {}) {
   const state = useAsyncState(
-    () => loadImage(shared.toValue(options)),
+    () => loadImage(vue.toValue(options)),
     void 0,
     {
       resetOnExecute: true,
@@ -1349,7 +1526,7 @@ function useImage(options, asyncStateOptions = {}) {
     }
   );
   vue.watch(
-    () => shared.toValue(options),
+    () => vue.toValue(options),
     () => state.execute(asyncStateOptions.delay),
     { deep: true }
   );
@@ -1442,13 +1619,13 @@ function useScroll(element, options = {}) {
     var _a, _b, _c, _d;
     if (!window)
       return;
-    const _element = shared.toValue(element);
+    const _element = vue.toValue(element);
     if (!_element)
       return;
     (_c = _element instanceof Document ? window.document.body : _element) == null ? void 0 : _c.scrollTo({
-      top: (_a = shared.toValue(_y)) != null ? _a : y.value,
-      left: (_b = shared.toValue(_x)) != null ? _b : x.value,
-      behavior: shared.toValue(behavior)
+      top: (_a = vue.toValue(_y)) != null ? _a : y.value,
+      left: (_b = vue.toValue(_x)) != null ? _b : x.value,
+      behavior: vue.toValue(behavior)
     });
     const scrollContainer = ((_d = _element == null ? void 0 : _element.document) == null ? void 0 : _d.documentElement) || (_element == null ? void 0 : _element.documentElement) || _element;
     if (x != null)
@@ -1534,7 +1711,7 @@ function useScroll(element, options = {}) {
   );
   shared.tryOnMounted(() => {
     try {
-      const _element = shared.toValue(element);
+      const _element = vue.toValue(element);
       if (!_element)
         return;
       setArrivedState(_element);
@@ -1555,7 +1732,7 @@ function useScroll(element, options = {}) {
     arrivedState,
     directions,
     measure() {
-      const _element = shared.toValue(element);
+      const _element = vue.toValue(element);
       if (window && _element)
         setArrivedState(_element);
     }
@@ -1582,7 +1759,7 @@ function useInfiniteScroll(element, onLoadMore, options = {}) {
   const promise = vue.ref();
   const isLoading = vue.computed(() => !!promise.value);
   const observedElement = vue.computed(() => {
-    return resolveElement(shared.toValue(element));
+    return resolveElement(vue.toValue(element));
   });
   const isElementVisible = useElementVisibility(observedElement);
   function checkAndLoad() {
@@ -1660,6 +1837,156 @@ const UseMouseInElement = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
   }
 });
 
+const UseMouseBuiltinExtractors = {
+  page: (event) => [event.pageX, event.pageY],
+  client: (event) => [event.clientX, event.clientY],
+  screen: (event) => [event.screenX, event.screenY],
+  movement: (event) => event instanceof Touch ? null : [event.movementX, event.movementY]
+};
+function useMouse(options = {}) {
+  const {
+    type = "page",
+    touch = true,
+    resetOnTouchEnds = false,
+    initialValue = { x: 0, y: 0 },
+    window = defaultWindow,
+    target = window,
+    scroll = true,
+    eventFilter
+  } = options;
+  let _prevMouseEvent = null;
+  let _prevScrollX = 0;
+  let _prevScrollY = 0;
+  const x = vue.ref(initialValue.x);
+  const y = vue.ref(initialValue.y);
+  const sourceType = vue.ref(null);
+  const extractor = typeof type === "function" ? type : UseMouseBuiltinExtractors[type];
+  const mouseHandler = (event) => {
+    const result = extractor(event);
+    _prevMouseEvent = event;
+    if (result) {
+      [x.value, y.value] = result;
+      sourceType.value = "mouse";
+    }
+    if (window) {
+      _prevScrollX = window.scrollX;
+      _prevScrollY = window.scrollY;
+    }
+  };
+  const touchHandler = (event) => {
+    if (event.touches.length > 0) {
+      const result = extractor(event.touches[0]);
+      if (result) {
+        [x.value, y.value] = result;
+        sourceType.value = "touch";
+      }
+    }
+  };
+  const scrollHandler = () => {
+    if (!_prevMouseEvent || !window)
+      return;
+    const pos = extractor(_prevMouseEvent);
+    if (_prevMouseEvent instanceof MouseEvent && pos) {
+      x.value = pos[0] + window.scrollX - _prevScrollX;
+      y.value = pos[1] + window.scrollY - _prevScrollY;
+    }
+  };
+  const reset = () => {
+    x.value = initialValue.x;
+    y.value = initialValue.y;
+  };
+  const mouseHandlerWrapper = eventFilter ? (event) => eventFilter(() => mouseHandler(event), {}) : (event) => mouseHandler(event);
+  const touchHandlerWrapper = eventFilter ? (event) => eventFilter(() => touchHandler(event), {}) : (event) => touchHandler(event);
+  const scrollHandlerWrapper = eventFilter ? () => eventFilter(() => scrollHandler(), {}) : () => scrollHandler();
+  if (target) {
+    const listenerOptions = { passive: true };
+    useEventListener(target, ["mousemove", "dragover"], mouseHandlerWrapper, listenerOptions);
+    if (touch && type !== "movement") {
+      useEventListener(target, ["touchstart", "touchmove"], touchHandlerWrapper, listenerOptions);
+      if (resetOnTouchEnds)
+        useEventListener(target, "touchend", reset, listenerOptions);
+    }
+    if (scroll && type === "page")
+      useEventListener(window, "scroll", scrollHandlerWrapper, { passive: true });
+  }
+  return {
+    x,
+    y,
+    sourceType
+  };
+}
+
+function useMouseInElement(target, options = {}) {
+  const {
+    handleOutside = true,
+    window = defaultWindow
+  } = options;
+  const type = options.type || "page";
+  const { x, y, sourceType } = useMouse(options);
+  const targetRef = vue.ref(target != null ? target : window == null ? void 0 : window.document.body);
+  const elementX = vue.ref(0);
+  const elementY = vue.ref(0);
+  const elementPositionX = vue.ref(0);
+  const elementPositionY = vue.ref(0);
+  const elementHeight = vue.ref(0);
+  const elementWidth = vue.ref(0);
+  const isOutside = vue.ref(true);
+  let stop = () => {
+  };
+  if (window) {
+    stop = vue.watch(
+      [targetRef, x, y],
+      () => {
+        const el = unrefElement(targetRef);
+        if (!el || !(el instanceof Element))
+          return;
+        const {
+          left,
+          top,
+          width,
+          height
+        } = el.getBoundingClientRect();
+        elementPositionX.value = left + (type === "page" ? window.pageXOffset : 0);
+        elementPositionY.value = top + (type === "page" ? window.pageYOffset : 0);
+        elementHeight.value = height;
+        elementWidth.value = width;
+        const elX = x.value - elementPositionX.value;
+        const elY = y.value - elementPositionY.value;
+        isOutside.value = width === 0 || height === 0 || elX < 0 || elY < 0 || elX > width || elY > height;
+        if (handleOutside || !isOutside.value) {
+          elementX.value = elX;
+          elementY.value = elY;
+        }
+      },
+      { immediate: true }
+    );
+    useEventListener(document, "mouseleave", () => {
+      isOutside.value = true;
+    });
+  }
+  return {
+    x,
+    y,
+    sourceType,
+    elementX,
+    elementY,
+    elementPositionX,
+    elementPositionY,
+    elementHeight,
+    elementWidth,
+    isOutside,
+    stop
+  };
+}
+
+const vMouseInElement = {
+  mounted(el, binding) {
+    const [handler, options] = typeof binding.value === "function" ? [binding.value, {}] : binding.value;
+    const state = shared.reactiveOmit(vue.reactive(useMouseInElement(el, options)), "stop");
+    vue.watch(state, (val) => handler(val));
+  }
+};
+
 const UseMousePressed = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
   name: "UseMousePressed",
   props: ["touch", "initialValue", "as"],
@@ -1898,47 +2225,6 @@ const vResizeObserver = {
   }
 };
 
-function useMutationObserver(target, callback, options = {}) {
-  const { window = defaultWindow, ...mutationOptions } = options;
-  let observer;
-  const isSupported = useSupported(() => window && "MutationObserver" in window);
-  const cleanup = () => {
-    if (observer) {
-      observer.disconnect();
-      observer = void 0;
-    }
-  };
-  const targets = vue.computed(() => {
-    const value = shared.toValue(target);
-    const items = (Array.isArray(value) ? value : [value]).map(unrefElement).filter(shared.notNullish);
-    return new Set(items);
-  });
-  const stopWatch = vue.watch(
-    () => targets.value,
-    (targets2) => {
-      cleanup();
-      if (isSupported.value && targets2.size) {
-        observer = new MutationObserver(callback);
-        targets2.forEach((el) => observer.observe(el, mutationOptions));
-      }
-    },
-    { immediate: true, flush: "post" }
-  );
-  const takeRecords = () => {
-    return observer == null ? void 0 : observer.takeRecords();
-  };
-  const stop = () => {
-    stopWatch();
-    cleanup();
-  };
-  shared.tryOnScopeDispose(stop);
-  return {
-    isSupported,
-    stop,
-    takeRecords
-  };
-}
-
 function useCssVar(prop, target, options = {}) {
   const { window = defaultWindow, initialValue, observe = false } = options;
   const variable = vue.ref(initialValue);
@@ -1948,8 +2234,8 @@ function useCssVar(prop, target, options = {}) {
   });
   function updateCssVar() {
     var _a;
-    const key = shared.toValue(prop);
-    const el = shared.toValue(elRef);
+    const key = vue.toValue(prop);
+    const el = vue.toValue(elRef);
     if (el && window && key) {
       const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();
       variable.value = value || initialValue;
@@ -1962,7 +2248,7 @@ function useCssVar(prop, target, options = {}) {
     });
   }
   vue.watch(
-    [elRef, () => shared.toValue(prop)],
+    [elRef, () => vue.toValue(prop)],
     (_, old) => {
       if (old[0] && old[1])
         old[0].style.removeProperty(old[1]);
@@ -1974,7 +2260,7 @@ function useCssVar(prop, target, options = {}) {
     variable,
     (val) => {
       var _a;
-      const raw_prop = shared.toValue(prop);
+      const raw_prop = vue.toValue(prop);
       if (((_a = elRef.value) == null ? void 0 : _a.style) && raw_prop) {
         if (val == null)
           elRef.value.style.removeProperty(raw_prop);
@@ -2118,7 +2404,7 @@ function useScrollLock(element, initialState = false) {
   let stopTouchMoveListener = null;
   let initialOverflow = "";
   vue.watch(shared.toRef(element), (el) => {
-    const target = resolveElement(shared.toValue(el));
+    const target = resolveElement(vue.toValue(el));
     if (target) {
       const ele = target;
       if (!elInitialOverflow.get(ele))
@@ -2134,7 +2420,7 @@ function useScrollLock(element, initialState = false) {
     immediate: true
   });
   const lock = () => {
-    const el = resolveElement(shared.toValue(element));
+    const el = resolveElement(vue.toValue(element));
     if (!el || isLocked.value)
       return;
     if (shared.isIOS) {
@@ -2151,7 +2437,7 @@ function useScrollLock(element, initialState = false) {
     isLocked.value = true;
   };
   const unlock = () => {
-    const el = resolveElement(shared.toValue(element));
+    const el = resolveElement(vue.toValue(element));
     if (!el || !isLocked.value)
       return;
     if (shared.isIOS)
@@ -2302,11 +2588,13 @@ exports.UseWindowFocus = UseWindowFocus;
 exports.UseWindowSize = UseWindowSize;
 exports.VOnClickOutside = vOnClickOutside;
 exports.VOnLongPress = vOnLongPress;
+exports.vElementBounding = vElementBounding;
 exports.vElementHover = vElementHover;
 exports.vElementSize = vElementSize;
 exports.vElementVisibility = vElementVisibility;
 exports.vInfiniteScroll = vInfiniteScroll;
 exports.vIntersectionObserver = vIntersectionObserver;
+exports.vMouseInElement = vMouseInElement;
 exports.vOnClickOutside = vOnClickOutside;
 exports.vOnKeyStroke = vOnKeyStroke;
 exports.vOnLongPress = vOnLongPress;