@element-plus/nightly 0.0.20250429 → 0.0.20250430

package/dist/index.full.js

@@ -1,4 +1,4 @@
-/*! Element Plus v0.0.20250429 */
+/*! Element Plus v0.0.20250430 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
@@ -81,99 +81,121 @@
     return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
   };
 
-  var __defProp$9 = Object.defineProperty;
-  var __defProps$6 = Object.defineProperties;
-  var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
-  var __hasOwnProp$b = Object.prototype.hasOwnProperty;
-  var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$9 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp$b.call(b, prop))
-        __defNormalProp$9(a, prop, b[prop]);
-    if (__getOwnPropSymbols$b)
-      for (var prop of __getOwnPropSymbols$b(b)) {
-        if (__propIsEnum$b.call(b, prop))
-          __defNormalProp$9(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
   function computedEager(fn, options) {
     var _a;
     const result = vue.shallowRef();
     vue.watchEffect(() => {
       result.value = fn();
-    }, __spreadProps$6(__spreadValues$9({}, options), {
+    }, {
+      ...options,
       flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
-    }));
+    });
     return vue.readonly(result);
   }
 
-  var _a;
-  const isClient = typeof window !== "undefined";
+  function tryOnScopeDispose(fn) {
+    if (vue.getCurrentScope()) {
+      vue.onScopeDispose(fn);
+      return true;
+    }
+    return false;
+  }
+
+  function toValue(r) {
+    return typeof r === "function" ? r() : vue.unref(r);
+  }
+
+  const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+  typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
   const isDef = (val) => typeof val !== "undefined";
-  const isString$2 = (val) => typeof val === "string";
+  const notNullish = (val) => val != null;
+  const toString$1 = Object.prototype.toString;
+  const isObject$2 = (val) => toString$1.call(val) === "[object Object]";
   const noop$1 = () => {
   };
-  const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
-
-  function resolveUnref(r) {
-    return typeof r === "function" ? r() : vue.unref(r);
+  const isIOS = /* @__PURE__ */ getIsIOS();
+  function getIsIOS() {
+    var _a, _b;
+    return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
   }
 
   function createFilterWrapper(filter, fn) {
     function wrapper(...args) {
-      filter(() => fn.apply(this, args), { fn, thisArg: this, args });
+      return new Promise((resolve, reject) => {
+        Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+      });
     }
     return wrapper;
   }
   function debounceFilter(ms, options = {}) {
     let timer;
     let maxTimer;
+    let lastRejector = noop$1;
+    const _clearTimeout = (timer2) => {
+      clearTimeout(timer2);
+      lastRejector();
+      lastRejector = noop$1;
+    };
     const filter = (invoke) => {
-      const duration = resolveUnref(ms);
-      const maxDuration = resolveUnref(options.maxWait);
+      const duration = toValue(ms);
+      const maxDuration = toValue(options.maxWait);
       if (timer)
-        clearTimeout(timer);
+        _clearTimeout(timer);
       if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
         if (maxTimer) {
-          clearTimeout(maxTimer);
+          _clearTimeout(maxTimer);
           maxTimer = null;
         }
-        return invoke();
+        return Promise.resolve(invoke());
       }
-      if (maxDuration && !maxTimer) {
-        maxTimer = setTimeout(() => {
-          if (timer)
-            clearTimeout(timer);
+      return new Promise((resolve, reject) => {
+        lastRejector = options.rejectOnCancel ? reject : resolve;
+        if (maxDuration && !maxTimer) {
+          maxTimer = setTimeout(() => {
+            if (timer)
+              _clearTimeout(timer);
+            maxTimer = null;
+            resolve(invoke());
+          }, maxDuration);
+        }
+        timer = setTimeout(() => {
+          if (maxTimer)
+            _clearTimeout(maxTimer);
           maxTimer = null;
-          invoke();
-        }, maxDuration);
-      }
-      timer = setTimeout(() => {
-        if (maxTimer)
-          clearTimeout(maxTimer);
-        maxTimer = null;
-        invoke();
-      }, duration);
+          resolve(invoke());
+        }, duration);
+      });
     };
     return filter;
   }
-  function throttleFilter(ms, trailing = true, leading = true) {
+  function throttleFilter(...args) {
     let lastExec = 0;
     let timer;
     let isLeading = true;
+    let lastRejector = noop$1;
+    let lastValue;
+    let ms;
+    let trailing;
+    let leading;
+    let rejectOnCancel;
+    if (!vue.isRef(args[0]) && typeof args[0] === "object")
+      ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
+    else
+      [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
     const clear = () => {
       if (timer) {
         clearTimeout(timer);
         timer = void 0;
+        lastRejector();
+        lastRejector = noop$1;
       }
     };
-    const filter = (invoke) => {
-      const duration = resolveUnref(ms);
+    const filter = (_invoke) => {
+      const duration = toValue(ms);
       const elapsed = Date.now() - lastExec;
+      const invoke = () => {
+        return lastValue = _invoke();
+      };
       clear();
       if (duration <= 0) {
         lastExec = Date.now();
@@ -183,38 +205,35 @@
         lastExec = Date.now();
         invoke();
       } else if (trailing) {
-        timer = setTimeout(() => {
-          lastExec = Date.now();
-          isLeading = true;
-          clear();
-          invoke();
-        }, duration);
+        lastValue = new Promise((resolve, reject) => {
+          lastRejector = rejectOnCancel ? reject : resolve;
+          timer = setTimeout(() => {
+            lastExec = Date.now();
+            isLeading = true;
+            resolve(invoke());
+            clear();
+          }, Math.max(0, duration - elapsed));
+        });
       }
       if (!leading && !timer)
         timer = setTimeout(() => isLeading = true, duration);
       isLeading = false;
+      return lastValue;
     };
     return filter;
   }
-  function identity$1(arg) {
-    return arg;
-  }
-
-  function tryOnScopeDispose(fn) {
-    if (vue.getCurrentScope()) {
-      vue.onScopeDispose(fn);
-      return true;
-    }
-    return false;
+  function getLifeCycleTarget(target) {
+    return target || vue.getCurrentInstance();
   }
 
   function useDebounceFn(fn, ms = 200, options = {}) {
-    return createFilterWrapper(debounceFilter(ms, options), fn);
+    return createFilterWrapper(
+      debounceFilter(ms, options),
+      fn
+    );
   }
 
   function refDebounced(value, ms = 200, options = {}) {
-    if (ms <= 0)
-      return value;
     const debounced = vue.ref(value.value);
     const updater = useDebounceFn(() => {
       debounced.value = value.value;
@@ -223,13 +242,17 @@
     return debounced;
   }
 
-  function useThrottleFn(fn, ms = 200, trailing = false, leading = true) {
-    return createFilterWrapper(throttleFilter(ms, trailing, leading), fn);
+  function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+    return createFilterWrapper(
+      throttleFilter(ms, trailing, leading, rejectOnCancel),
+      fn
+    );
   }
 
-  function tryOnMounted(fn, sync = true) {
-    if (vue.getCurrentInstance())
-      vue.onMounted(fn);
+  function tryOnMounted(fn, sync = true, target) {
+    const instance = getLifeCycleTarget();
+    if (instance)
+      vue.onMounted(fn, target);
     else if (sync)
       fn();
     else
@@ -259,7 +282,7 @@
         isPending.value = false;
         timer = null;
         cb(...args);
-      }, resolveUnref(interval));
+      }, toValue(interval));
     }
     if (immediate) {
       isPending.value = true;
@@ -268,7 +291,7 @@
     }
     tryOnScopeDispose(stop);
     return {
-      isPending,
+      isPending: vue.readonly(isPending),
       start,
       stop
     };
@@ -276,7 +299,7 @@
 
   function unrefElement(elRef) {
     var _a;
-    const plain = resolveUnref(elRef);
+    const plain = toValue(elRef);
     return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
   }
 
@@ -285,28 +308,45 @@
 
   function useEventListener(...args) {
     let target;
-    let event;
-    let listener;
+    let events;
+    let listeners;
     let options;
-    if (isString$2(args[0])) {
-      [event, listener, options] = args;
+    if (typeof args[0] === "string" || Array.isArray(args[0])) {
+      [events, listeners, options] = args;
       target = defaultWindow;
     } else {
-      [target, event, listener, options] = args;
+      [target, events, listeners, options] = args;
     }
     if (!target)
       return noop$1;
-    let cleanup = noop$1;
-    const stopWatch = vue.watch(() => unrefElement(target), (el) => {
-      cleanup();
-      if (!el)
-        return;
-      el.addEventListener(event, listener, options);
-      cleanup = () => {
-        el.removeEventListener(event, listener, options);
-        cleanup = noop$1;
-      };
-    }, { immediate: true, flush: "post" });
+    if (!Array.isArray(events))
+      events = [events];
+    if (!Array.isArray(listeners))
+      listeners = [listeners];
+    const cleanups = [];
+    const cleanup = () => {
+      cleanups.forEach((fn) => fn());
+      cleanups.length = 0;
+    };
+    const register = (el, event, listener, options2) => {
+      el.addEventListener(event, listener, options2);
+      return () => el.removeEventListener(event, listener, options2);
+    };
+    const stopWatch = vue.watch(
+      () => [unrefElement(target), toValue(options)],
+      ([el, options2]) => {
+        cleanup();
+        if (!el)
+          return;
+        const optionsClone = isObject$2(options2) ? { ...options2 } : options2;
+        cleanups.push(
+          ...events.flatMap((event) => {
+            return listeners.map((listener) => register(el, event, listener, optionsClone));
+          })
+        );
+      },
+      { immediate: true, flush: "post" }
+    );
     const stop = () => {
       stopWatch();
       cleanup();
@@ -315,24 +355,36 @@
     return stop;
   }
 
+  let _iOSWorkaround = false;
   function onClickOutside(target, handler, options = {}) {
-    const { window = defaultWindow, ignore, capture = true, detectIframe = false } = options;
+    const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
     if (!window)
-      return;
-    const shouldListen = vue.ref(true);
-    let fallback;
+      return noop$1;
+    if (isIOS && !_iOSWorkaround) {
+      _iOSWorkaround = true;
+      Array.from(window.document.body.children).forEach((el) => el.addEventListener("click", noop$1));
+      window.document.documentElement.addEventListener("click", noop$1);
+    }
+    let shouldListen = true;
+    const shouldIgnore = (event) => {
+      return ignore.some((target2) => {
+        if (typeof target2 === "string") {
+          return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
+        } else {
+          const el = unrefElement(target2);
+          return el && (event.target === el || event.composedPath().includes(el));
+        }
+      });
+    };
     const listener = (event) => {
-      window.clearTimeout(fallback);
       const el = unrefElement(target);
-      const composedPath = event.composedPath();
-      if (!el || el === event.target || composedPath.includes(el) || !shouldListen.value)
+      if (!el || el === event.target || event.composedPath().includes(el))
+        return;
+      if (event.detail === 0)
+        shouldListen = !shouldIgnore(event);
+      if (!shouldListen) {
+        shouldListen = true;
         return;
-      if (ignore && ignore.length > 0) {
-        if (ignore.some((target2) => {
-          const el2 = unrefElement(target2);
-          return el2 && (event.target === el2 || composedPath.includes(el2));
-        }))
-          return;
       }
       handler(event);
     };
@@ -340,74 +392,205 @@
       useEventListener(window, "click", listener, { passive: true, capture }),
       useEventListener(window, "pointerdown", (e) => {
         const el = unrefElement(target);
-        shouldListen.value = !!el && !e.composedPath().includes(el);
-      }, { passive: true }),
-      useEventListener(window, "pointerup", (e) => {
-        if (e.button === 0) {
-          const path = e.composedPath();
-          e.composedPath = () => path;
-          fallback = window.setTimeout(() => listener(e), 50);
-        }
+        shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
       }, { passive: true }),
       detectIframe && useEventListener(window, "blur", (event) => {
-        var _a;
-        const el = unrefElement(target);
-        if (((_a = document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(document.activeElement)))
-          handler(event);
+        setTimeout(() => {
+          var _a;
+          const el = unrefElement(target);
+          if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement))) {
+            handler(event);
+          }
+        }, 0);
       })
     ].filter(Boolean);
     const stop = () => cleanup.forEach((fn) => fn());
     return stop;
   }
 
-  function useActiveElement(options = {}) {
-    const { window = defaultWindow } = options;
-    const counter = vue.ref(0);
-    if (window) {
-      useEventListener(window, "blur", () => counter.value += 1, true);
-      useEventListener(window, "focus", () => counter.value += 1, true);
+  function useMounted() {
+    const isMounted = vue.ref(false);
+    const instance = vue.getCurrentInstance();
+    if (instance) {
+      vue.onMounted(() => {
+        isMounted.value = true;
+      }, instance);
     }
+    return isMounted;
+  }
+
+  function useSupported(callback) {
+    const isMounted = useMounted();
     return vue.computed(() => {
-      counter.value;
-      return window == null ? void 0 : window.document.activeElement;
+      isMounted.value;
+      return Boolean(callback());
     });
   }
 
-  function useSupported(callback, sync = false) {
-    const isSupported = vue.ref();
-    const update = () => isSupported.value = Boolean(callback());
-    update();
-    tryOnMounted(update, sync);
-    return isSupported;
+  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 = toValue(target);
+      const items = (Array.isArray(value) ? value : [value]).map(unrefElement).filter(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 = () => {
+      cleanup();
+      stopWatch();
+    };
+    tryOnScopeDispose(stop);
+    return {
+      isSupported,
+      stop,
+      takeRecords
+    };
   }
 
-  const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-  const globalKey = "__vueuse_ssr_handlers__";
-  _global[globalKey] = _global[globalKey] || {};
-  _global[globalKey];
+  function useActiveElement(options = {}) {
+    var _a;
+    const {
+      window = defaultWindow,
+      deep = true,
+      triggerOnRemoval = false
+    } = options;
+    const document = (_a = options.document) != null ? _a : window == null ? void 0 : window.document;
+    const getDeepActiveElement = () => {
+      var _a2;
+      let element = document == null ? void 0 : document.activeElement;
+      if (deep) {
+        while (element == null ? void 0 : element.shadowRoot)
+          element = (_a2 = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a2.activeElement;
+      }
+      return element;
+    };
+    const activeElement = vue.ref();
+    const trigger = () => {
+      activeElement.value = getDeepActiveElement();
+    };
+    if (window) {
+      useEventListener(window, "blur", (event) => {
+        if (event.relatedTarget !== null)
+          return;
+        trigger();
+      }, true);
+      useEventListener(window, "focus", trigger, true);
+    }
+    if (triggerOnRemoval) {
+      useMutationObserver(document, (mutations) => {
+        mutations.filter((m) => m.removedNodes.length).map((n) => Array.from(n.removedNodes)).flat().forEach((node) => {
+          if (node === activeElement.value)
+            trigger();
+        });
+      }, {
+        childList: true,
+        subtree: true
+      });
+    }
+    trigger();
+    return activeElement;
+  }
 
-  function useCssVar(prop, target, { window = defaultWindow, initialValue = "" } = {}) {
+  function useMediaQuery(query, options = {}) {
+    const { window = defaultWindow } = options;
+    const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
+    let mediaQuery;
+    const matches = vue.ref(false);
+    const handler = (event) => {
+      matches.value = event.matches;
+    };
+    const cleanup = () => {
+      if (!mediaQuery)
+        return;
+      if ("removeEventListener" in mediaQuery)
+        mediaQuery.removeEventListener("change", handler);
+      else
+        mediaQuery.removeListener(handler);
+    };
+    const stopWatch = vue.watchEffect(() => {
+      if (!isSupported.value)
+        return;
+      cleanup();
+      mediaQuery = window.matchMedia(toValue(query));
+      if ("addEventListener" in mediaQuery)
+        mediaQuery.addEventListener("change", handler);
+      else
+        mediaQuery.addListener(handler);
+      matches.value = mediaQuery.matches;
+    });
+    tryOnScopeDispose(() => {
+      stopWatch();
+      cleanup();
+      mediaQuery = void 0;
+    });
+    return matches;
+  }
+
+  function cloneFnJSON(source) {
+    return JSON.parse(JSON.stringify(source));
+  }
+
+  function useCssVar(prop, target, options = {}) {
+    const { window = defaultWindow, initialValue = "", observe = false } = options;
     const variable = vue.ref(initialValue);
     const elRef = vue.computed(() => {
       var _a;
       return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
     });
-    vue.watch([elRef, () => resolveUnref(prop)], ([el, prop2]) => {
+    function updateCssVar() {
       var _a;
+      const key = toValue(prop);
+      const el = toValue(elRef);
       if (el && window) {
-        const value = (_a = window.getComputedStyle(el).getPropertyValue(prop2)) == null ? void 0 : _a.trim();
+        const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();
         variable.value = value || initialValue;
       }
-    }, { immediate: true });
-    vue.watch(variable, (val) => {
-      var _a;
-      if ((_a = elRef.value) == null ? void 0 : _a.style)
-        elRef.value.style.setProperty(resolveUnref(prop), val);
-    });
+    }
+    if (observe) {
+      useMutationObserver(elRef, updateCssVar, {
+        attributeFilter: ["style", "class"],
+        window
+      });
+    }
+    vue.watch(
+      [elRef, () => toValue(prop)],
+      updateCssVar,
+      { immediate: true }
+    );
+    vue.watch(
+      variable,
+      (val) => {
+        var _a;
+        if ((_a = elRef.value) == null ? void 0 : _a.style)
+          elRef.value.style.setProperty(toValue(prop), val);
+      }
+    );
     return variable;
   }
 
-  function useDocumentVisibility({ document = defaultDocument } = {}) {
+  function useDocumentVisibility(options = {}) {
+    const { document = defaultDocument } = options;
     if (!document)
       return vue.ref("visible");
     const visibility = vue.ref(document.visibilityState);
@@ -417,23 +600,8 @@
     return visibility;
   }
 
-  var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
-  var __hasOwnProp$f = Object.prototype.hasOwnProperty;
-  var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-  var __objRest$2 = (source, exclude) => {
-    var target = {};
-    for (var prop in source)
-      if (__hasOwnProp$f.call(source, prop) && exclude.indexOf(prop) < 0)
-        target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols$f)
-      for (var prop of __getOwnPropSymbols$f(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum$f.call(source, prop))
-          target[prop] = source[prop];
-      }
-    return target;
-  };
   function useResizeObserver(target, callback, options = {}) {
-    const _a = options, { window = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
+    const { window = defaultWindow, ...observerOptions } = options;
     let observer;
     const isSupported = useSupported(() => window && "ResizeObserver" in window);
     const cleanup = () => {
@@ -442,13 +610,19 @@
         observer = void 0;
       }
     };
-    const stopWatch = vue.watch(() => unrefElement(target), (el) => {
-      cleanup();
-      if (isSupported.value && window && el) {
-        observer = new ResizeObserver(callback);
-        observer.observe(el, observerOptions);
-      }
-    }, { immediate: true, flush: "post" });
+    const targets = vue.computed(() => Array.isArray(target) ? target.map((el) => unrefElement(el)) : [unrefElement(target)]);
+    const stopWatch = vue.watch(
+      targets,
+      (els) => {
+        cleanup();
+        if (isSupported.value && window) {
+          observer = new ResizeObserver(callback);
+          for (const _el of els)
+            _el && observer.observe(_el, observerOptions);
+        }
+      },
+      { immediate: true, flush: "post" }
+    );
     const stop = () => {
       cleanup();
       stopWatch();
@@ -502,8 +676,11 @@
     }
     useResizeObserver(target, update);
     vue.watch(() => unrefElement(target), (ele) => !ele && update());
+    useMutationObserver(target, update, {
+      attributeFilter: ["style", "class"]
+    });
     if (windowScroll)
-      useEventListener("scroll", update, { passive: true });
+      useEventListener("scroll", update, { capture: true, passive: true });
     if (windowResize)
       useEventListener("resize", update, { passive: true });
     tryOnMounted(() => {
@@ -523,111 +700,15 @@
     };
   }
 
-  var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-  var __objRest$1 = (source, exclude) => {
-    var target = {};
-    for (var prop in source)
-      if (__hasOwnProp$7.call(source, prop) && exclude.indexOf(prop) < 0)
-        target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols$7)
-      for (var prop of __getOwnPropSymbols$7(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum$7.call(source, prop))
-          target[prop] = source[prop];
-      }
-    return target;
-  };
-  function useMutationObserver(target, callback, options = {}) {
-    const _a = options, { window = defaultWindow } = _a, mutationOptions = __objRest$1(_a, ["window"]);
-    let observer;
-    const isSupported = useSupported(() => window && "MutationObserver" in window);
-    const cleanup = () => {
-      if (observer) {
-        observer.disconnect();
-        observer = void 0;
-      }
-    };
-    const stopWatch = vue.watch(() => unrefElement(target), (el) => {
-      cleanup();
-      if (isSupported.value && window && el) {
-        observer = new MutationObserver(callback);
-        observer.observe(el, mutationOptions);
-      }
-    }, { immediate: true });
-    const stop = () => {
-      cleanup();
-      stopWatch();
-    };
-    tryOnScopeDispose(stop);
-    return {
-      isSupported,
-      stop
-    };
-  }
-
-  var SwipeDirection;
-  (function(SwipeDirection2) {
-    SwipeDirection2["UP"] = "UP";
-    SwipeDirection2["RIGHT"] = "RIGHT";
-    SwipeDirection2["DOWN"] = "DOWN";
-    SwipeDirection2["LEFT"] = "LEFT";
-    SwipeDirection2["NONE"] = "NONE";
-  })(SwipeDirection || (SwipeDirection = {}));
-
-  var __defProp = Object.defineProperty;
-  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    if (__getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(b)) {
-        if (__propIsEnum.call(b, prop))
-          __defNormalProp(a, prop, b[prop]);
-      }
-    return a;
-  };
-  const _TransitionPresets = {
-    easeInSine: [0.12, 0, 0.39, 0],
-    easeOutSine: [0.61, 1, 0.88, 1],
-    easeInOutSine: [0.37, 0, 0.63, 1],
-    easeInQuad: [0.11, 0, 0.5, 0],
-    easeOutQuad: [0.5, 1, 0.89, 1],
-    easeInOutQuad: [0.45, 0, 0.55, 1],
-    easeInCubic: [0.32, 0, 0.67, 0],
-    easeOutCubic: [0.33, 1, 0.68, 1],
-    easeInOutCubic: [0.65, 0, 0.35, 1],
-    easeInQuart: [0.5, 0, 0.75, 0],
-    easeOutQuart: [0.25, 1, 0.5, 1],
-    easeInOutQuart: [0.76, 0, 0.24, 1],
-    easeInQuint: [0.64, 0, 0.78, 0],
-    easeOutQuint: [0.22, 1, 0.36, 1],
-    easeInOutQuint: [0.83, 0, 0.17, 1],
-    easeInExpo: [0.7, 0, 0.84, 0],
-    easeOutExpo: [0.16, 1, 0.3, 1],
-    easeInOutExpo: [0.87, 0, 0.13, 1],
-    easeInCirc: [0.55, 0, 1, 0.45],
-    easeOutCirc: [0, 0.55, 0.45, 1],
-    easeInOutCirc: [0.85, 0, 0.15, 1],
-    easeInBack: [0.36, 0, 0.66, -0.56],
-    easeOutBack: [0.34, 1.56, 0.64, 1],
-    easeInOutBack: [0.68, -0.6, 0.32, 1.6]
-  };
-  __spreadValues({
-    linear: identity$1
-  }, _TransitionPresets);
-
   function useVModel(props, key, emit, options = {}) {
     var _a, _b, _c;
     const {
+      clone = false,
       passive = false,
       eventName,
       deep = false,
-      defaultValue
+      defaultValue,
+      shouldEmit
     } = options;
     const vm = vue.getCurrentInstance();
     const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
@@ -637,17 +718,39 @@
         key = "modelValue";
       }
     }
-    event = eventName || event || `update:${key.toString()}`;
-    const getValue = () => isDef(props[key]) ? props[key] : defaultValue;
+    event = event || `update:${key.toString()}`;
+    const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
+    const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+    const triggerEmit = (value) => {
+      if (shouldEmit) {
+        if (shouldEmit(value))
+          _emit(event, value);
+      } else {
+        _emit(event, value);
+      }
+    };
     if (passive) {
-      const proxy = vue.ref(getValue());
-      vue.watch(() => props[key], (v) => proxy.value = v);
-      vue.watch(proxy, (v) => {
-        if (v !== props[key] || deep)
-          _emit(event, v);
-      }, {
-        deep
-      });
+      const initialValue = getValue();
+      const proxy = vue.ref(initialValue);
+      let isUpdating = false;
+      vue.watch(
+        () => props[key],
+        (v) => {
+          if (!isUpdating) {
+            isUpdating = true;
+            proxy.value = cloneFn(v);
+            vue.nextTick(() => isUpdating = false);
+          }
+        }
+      );
+      vue.watch(
+        proxy,
+        (v) => {
+          if (!isUpdating && (v !== props[key] || deep))
+            triggerEmit(v);
+        },
+        { deep }
+      );
       return proxy;
     } else {
       return vue.computed({
@@ -655,13 +758,14 @@
           return getValue();
         },
         set(value) {
-          _emit(event, value);
+          triggerEmit(value);
         }
       });
     }
   }
 
-  function useWindowFocus({ window = defaultWindow } = {}) {
+  function useWindowFocus(options = {}) {
+    const { window = defaultWindow } = options;
     if (!window)
       return vue.ref(false);
     const focused = vue.ref(window.document.hasFocus());
@@ -677,23 +781,31 @@
   function useWindowSize(options = {}) {
     const {
       window = defaultWindow,
-      initialWidth = Infinity,
-      initialHeight = Infinity,
-      listenOrientation = true
+      initialWidth = Number.POSITIVE_INFINITY,
+      initialHeight = Number.POSITIVE_INFINITY,
+      listenOrientation = true,
+      includeScrollbar = true
     } = options;
     const width = vue.ref(initialWidth);
     const height = vue.ref(initialHeight);
     const update = () => {
       if (window) {
-        width.value = window.innerWidth;
-        height.value = window.innerHeight;
+        if (includeScrollbar) {
+          width.value = window.innerWidth;
+          height.value = window.innerHeight;
+        } else {
+          width.value = window.document.documentElement.clientWidth;
+          height.value = window.document.documentElement.clientHeight;
+        }
       }
     };
     update();
     tryOnMounted(update);
     useEventListener("resize", update, { passive: true });
-    if (listenOrientation)
-      useEventListener("orientationchange", update, { passive: true });
+    if (listenOrientation) {
+      const matches = useMediaQuery("(orientation: portrait)");
+      vue.watch(matches, () => update());
+    }
     return { width, height };
   }
 
@@ -11610,7 +11722,7 @@
 
   const ElConfigProvider = withInstall(ConfigProvider);
 
-  const version$1 = "0.0.20250429";
+  const version$1 = "0.0.20250430";
 
   const makeInstaller = (components = []) => {
     const install = (app, options) => {