directix 1.2.0 → 1.3.0

package/dist/index.iife.js

@@ -1,5 +1,5 @@
 /*!
- * directix v1.2.0
+ * directix v1.3.0
  * A comprehensive, easy-to-use, and high-performance Vue custom directives library supporting both Vue 2 and Vue 3
  * (c) 2021-present saqqdy <https://github.com/saqqdy>
  * Released under the MIT License.
@@ -57,7 +57,7 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 /*!
- * directix v1.2.0
+ * directix v1.3.0
  * A comprehensive, easy-to-use, and high-performance Vue custom directives library supporting both Vue 2 and Vue 3
  * (c) 2021-present saqqdy <https://github.com/saqqdy>
  * Released under the MIT License.
@@ -76,7 +76,7 @@ var __async = (__this, __arguments, generator) => {
       },
       inserted(el, binding, vnode) {
         if (hooks.mounted) {
-          hooks.mounted(el, normalizeBinding(binding), vnode);
+          hooks.mounted(el, normalizeBinding$1(binding), vnode);
         }
       },
       update(el, binding, vnode, oldVnode) {
@@ -84,9 +84,9 @@ var __async = (__this, __arguments, generator) => {
         if (hooks.updated) {
           hooks.updated(
             el,
-            normalizeBinding(binding),
+            normalizeBinding$1(binding),
             vnode,
-            normalizeBinding(__spreadProps(__spreadValues({}, binding), { value: binding.oldValue })),
+            normalizeBinding$1(__spreadProps(__spreadValues({}, binding), { value: binding.oldValue })),
             oldVnode
           );
         }
@@ -99,7 +99,7 @@ var __async = (__this, __arguments, generator) => {
       },
       unbind(el, binding, vnode) {
         if (hooks.unmounted) {
-          hooks.unmounted(el, normalizeBinding(binding), vnode);
+          hooks.unmounted(el, normalizeBinding$1(binding), vnode);
         }
         const state = el.__directix_state__;
         if (state == null ? void 0 : state.cleanup) {
@@ -110,7 +110,7 @@ var __async = (__this, __arguments, generator) => {
     };
     return directive;
   }
-  function normalizeBinding(binding) {
+  function normalizeBinding$1(binding) {
     var _a;
     return {
       value: binding.value,
@@ -483,7 +483,7 @@ var __async = (__this, __arguments, generator) => {
     if (!word) return word;
     return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
   }
-  function normalizeOptions$t(binding) {
+  function normalizeOptions$B(binding) {
     var _a, _b, _c;
     if (binding === void 0 || binding === true) {
       return { every: true, onInput: true };
@@ -501,7 +501,7 @@ var __async = (__this, __arguments, generator) => {
     name: "capitalcase",
     ssr: true,
     mounted(el, binding) {
-      const options = normalizeOptions$t(binding.value);
+      const options = normalizeOptions$B(binding.value);
       if (isInputElement(el)) {
         const cleanup2 = setupTextTransformInput(el, options, (text) => capitalizeText(text, options));
         el.__capitalcaseCleanup = cleanup2;
@@ -510,7 +510,7 @@ var __async = (__this, __arguments, generator) => {
       }
     },
     updated(el, binding) {
-      const options = normalizeOptions$t(binding.value);
+      const options = normalizeOptions$B(binding.value);
       if (isInputElement(el)) {
         if (options.onInput) {
           el.value = capitalizeText(el.value, options);
@@ -525,6 +525,134 @@ var __async = (__this, __arguments, generator) => {
       delete el.__capitalcaseCleanup;
     }
   });
+  const vClickDelay = defineDirective({
+    name: "click-delay",
+    ssr: true,
+    defaults: {
+      delay: 300,
+      disabled: false,
+      pendingClass: "v-click-delay--pending",
+      feedback: true
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$A(binding.value, binding);
+      if (options.disabled) return;
+      const state = {
+        options,
+        handler: createClickHandler(el, options),
+        isPending: false,
+        timeoutId: null
+      };
+      el.__clickDelay = state;
+      el.addEventListener("click", state.handler);
+      el.addEventListener("touchend", state.handler);
+    },
+    updated(el, binding) {
+      const state = el.__clickDelay;
+      if (!state) {
+        const options = normalizeOptions$A(binding.value, binding);
+        if (!options.disabled) {
+          const newState = {
+            options,
+            handler: createClickHandler(el, options),
+            isPending: false,
+            timeoutId: null
+          };
+          el.__clickDelay = newState;
+          el.addEventListener("click", newState.handler);
+          el.addEventListener("touchend", newState.handler);
+        }
+        return;
+      }
+      const newOptions = normalizeOptions$A(binding.value, binding);
+      if (newOptions.disabled && !state.options.disabled) {
+        el.removeEventListener("click", state.handler);
+        el.removeEventListener("touchend", state.handler);
+        if (state.timeoutId) {
+          clearTimeout(state.timeoutId);
+        }
+        removePendingClass(el, state.options);
+        delete el.__clickDelay;
+      } else if (!newOptions.disabled && state.options.disabled) {
+        state.handler = createClickHandler(el, newOptions);
+        state.isPending = false;
+        state.timeoutId = null;
+        el.addEventListener("click", state.handler);
+        el.addEventListener("touchend", state.handler);
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__clickDelay;
+      if (!state) return;
+      el.removeEventListener("click", state.handler);
+      el.removeEventListener("touchend", state.handler);
+      if (state.timeoutId) {
+        clearTimeout(state.timeoutId);
+      }
+      removePendingClass(el, state.options);
+      delete el.__clickDelay;
+    }
+  });
+  function createClickHandler(el, options) {
+    return (event) => {
+      const state = el.__clickDelay;
+      if (!state || state.isPending) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      state.isPending = true;
+      if (options.feedback && options.pendingClass) {
+        el.classList.add(options.pendingClass);
+      }
+      options.handler(event);
+      state.timeoutId = setTimeout(() => {
+        state.isPending = false;
+        state.timeoutId = null;
+        removePendingClass(el, options);
+      }, options.delay);
+    };
+  }
+  function removePendingClass(el, options) {
+    if (options.feedback && options.pendingClass) {
+      el.classList.remove(options.pendingClass);
+    }
+  }
+  function parseTime$1(arg) {
+    if (!arg) return null;
+    if (arg.endsWith("ms")) {
+      return parseInt(arg, 10);
+    }
+    if (arg.endsWith("s")) {
+      return parseFloat(arg) * 1e3;
+    }
+    const num = parseInt(arg, 10);
+    return Number.isNaN(num) ? null : num;
+  }
+  function normalizeOptions$A(binding, directiveBinding) {
+    var _a, _b, _c, _d;
+    const delay = parseTime$1(directiveBinding.arg) || 300;
+    if (typeof binding === "function") {
+      return {
+        handler: binding,
+        delay,
+        disabled: false,
+        pendingClass: "v-click-delay--pending",
+        feedback: true
+      };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-click-delay: handler is required");
+    }
+    return {
+      handler: binding.handler,
+      delay: (_a = binding.delay) != null ? _a : delay,
+      disabled: (_b = binding.disabled) != null ? _b : false,
+      pendingClass: (_c = binding.pendingClass) != null ? _c : "v-click-delay--pending",
+      feedback: (_d = binding.feedback) != null ? _d : true
+    };
+  }
   function isElement(value) {
     return value instanceof Element;
   }
@@ -550,15 +678,15 @@ var __async = (__this, __arguments, generator) => {
   }
   function on(target, event, handler, options = false) {
     if (!isBrowser()) return;
-    const opts = normalizeOptions$s(options);
+    const opts = normalizeOptions$z(options);
     target.addEventListener(event, handler, opts);
   }
   function off(target, event, handler, options = false) {
     if (!isBrowser()) return;
-    const opts = normalizeOptions$s(options);
+    const opts = normalizeOptions$z(options);
     target.removeEventListener(event, handler, opts);
   }
-  function normalizeOptions$s(options) {
+  function normalizeOptions$z(options) {
     if (typeof options === "boolean") {
       return options;
     }
@@ -781,7 +909,7 @@ var __async = (__this, __arguments, generator) => {
       prevent: false
     },
     mounted(el, binding) {
-      const options = normalizeOptions$r(binding.value);
+      const options = normalizeOptions$y(binding.value);
       if (options.disabled) return;
       const state = {
         options,
@@ -816,7 +944,7 @@ var __async = (__this, __arguments, generator) => {
       const state = el.__clickOutside;
       if (!state) return;
       const oldOptions = state.options;
-      const newOptions = normalizeOptions$r(binding.value);
+      const newOptions = normalizeOptions$y(binding.value);
       if (oldOptions.disabled !== newOptions.disabled) {
         if (newOptions.disabled) {
           state.handlers.forEach((handler, eventType) => {
@@ -853,7 +981,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__clickOutside;
     }
   });
-  function normalizeOptions$r(binding) {
+  function normalizeOptions$y(binding) {
     var _a, _b, _c, _d, _e;
     if (typeof binding === "function") {
       return {
@@ -930,7 +1058,7 @@ var __async = (__this, __arguments, generator) => {
     name: "copy",
     ssr: false,
     mounted(el, binding) {
-      const options = normalizeOptions$q(binding.value);
+      const options = normalizeOptions$x(binding.value);
       if (options.disabled) return;
       if (options.title) {
         el.setAttribute("title", options.title);
@@ -966,7 +1094,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__copy;
       if (!state) return;
-      state.options = normalizeOptions$q(binding.value);
+      state.options = normalizeOptions$x(binding.value);
       if (state.options.title) {
         el.setAttribute("title", state.options.title);
       }
@@ -978,12 +1106,142 @@ var __async = (__this, __arguments, generator) => {
       delete el.__copy;
     }
   });
-  function normalizeOptions$q(binding) {
+  function normalizeOptions$x(binding) {
     if (typeof binding === "string") {
       return { value: binding };
     }
     return binding;
   }
+  function parseTargetTime(target) {
+    if (target instanceof Date) {
+      return target.getTime();
+    }
+    if (typeof target === "number") {
+      return target;
+    }
+    return new Date(target).getTime();
+  }
+  function calculateTime(remaining) {
+    const total = Math.max(0, remaining);
+    return {
+      days: Math.floor(total / (1e3 * 60 * 60 * 24)),
+      hours: Math.floor(total % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60)),
+      minutes: Math.floor(total % (1e3 * 60 * 60) / (1e3 * 60)),
+      seconds: Math.floor(total % (1e3 * 60) / 1e3),
+      milliseconds: total % 1e3,
+      total
+    };
+  }
+  function formatTime(time, format) {
+    if (typeof format === "function") {
+      return format(time);
+    }
+    const pad = (n, len = 2) => String(n).padStart(len, "0");
+    const result = format.replace(/dd/gi, pad(time.days)).replace(/hh/gi, pad(time.hours)).replace(/mm/gi, pad(time.minutes)).replace(/ss/gi, pad(time.seconds)).replace(/S{3}/gi, pad(time.milliseconds, 3)).replace(/SS/gi, pad(Math.floor(time.milliseconds / 10))).replace(/S/gi, String(Math.floor(time.milliseconds / 100)));
+    return result;
+  }
+  function normalizeOptions$w(binding) {
+    var _a, _b, _c, _d;
+    if (typeof binding === "object" && binding !== null && "target" in binding) {
+      return {
+        target: binding.target,
+        format: (_a = binding.format) != null ? _a : "hh:mm:ss",
+        onComplete: binding.onComplete,
+        onTick: binding.onTick,
+        interval: (_b = binding.interval) != null ? _b : 1e3,
+        showMilliseconds: (_c = binding.showMilliseconds) != null ? _c : false,
+        autoStart: (_d = binding.autoStart) != null ? _d : true,
+        labels: binding.labels
+      };
+    }
+    return {
+      target: binding,
+      format: "hh:mm:ss",
+      interval: 1e3,
+      showMilliseconds: false,
+      autoStart: true
+    };
+  }
+  const vCountdown = defineDirective({
+    name: "countdown",
+    ssr: true,
+    mounted(el, binding) {
+      const options = normalizeOptions$w(binding.value);
+      const targetTime = parseTargetTime(options.target);
+      const state = {
+        options,
+        targetTime,
+        intervalId: null,
+        paused: false,
+        remaining: 0
+      };
+      el.__countdown = state;
+      if (options.autoStart !== false) {
+        startCountdown(el, state);
+      } else {
+        updateDisplay(el, state);
+      }
+    },
+    updated(el, binding) {
+      const state = el.__countdown;
+      const newOptions = normalizeOptions$w(binding.value);
+      const newTargetTime = parseTargetTime(newOptions.target);
+      if (newTargetTime !== state.targetTime) {
+        state.targetTime = newTargetTime;
+        state.options = newOptions;
+        if (state.intervalId) {
+          clearInterval(state.intervalId);
+          state.intervalId = null;
+        }
+        if (!state.paused) {
+          startCountdown(el, state);
+        }
+      } else {
+        state.options = newOptions;
+      }
+    },
+    unmounted(el) {
+      const state = el.__countdown;
+      if (state == null ? void 0 : state.intervalId) {
+        clearInterval(state.intervalId);
+      }
+      delete el.__countdown;
+    }
+  });
+  function startCountdown(el, state) {
+    const tick = () => {
+      const now = Date.now();
+      state.remaining = state.targetTime - now;
+      if (state.remaining <= 0) {
+        state.remaining = 0;
+        updateDisplay(el, state);
+        stopCountdown(state);
+        if (state.options.onComplete) {
+          state.options.onComplete();
+        }
+        el.dispatchEvent(new CustomEvent("countdown:complete"));
+        return;
+      }
+      updateDisplay(el, state);
+      if (state.options.onTick) {
+        const time = calculateTime(state.remaining);
+        state.options.onTick(time);
+      }
+    };
+    tick();
+    state.intervalId = setInterval(tick, state.options.interval || 1e3);
+  }
+  function stopCountdown(state) {
+    if (state.intervalId) {
+      clearInterval(state.intervalId);
+      state.intervalId = null;
+    }
+  }
+  function updateDisplay(el, state) {
+    const time = calculateTime(state.remaining);
+    const display = formatTime(time, state.options.format || "hh:mm:ss");
+    el.textContent = display;
+  }
   const EVENT_MODIFIERS = [
     "click",
     "input",
@@ -1019,7 +1277,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return "click";
   }
-  function normalizeOptions$p(binding, directiveBinding) {
+  function normalizeOptions$v(binding, directiveBinding) {
     const wait = parseTime(directiveBinding.arg) || 300;
     if (typeof binding === "function") {
       return { handler: binding, wait };
@@ -1036,7 +1294,7 @@ var __async = (__this, __arguments, generator) => {
       trailing: true
     },
     mounted(el, binding) {
-      const options = normalizeOptions$p(binding.value, binding);
+      const options = normalizeOptions$v(binding.value, binding);
       const eventType = getEventTypeFromModifiers(binding.modifiers) || getDefaultEventType(el);
       const debouncedFn = debounce(options.handler, options.wait, {
         leading: options.leading,
@@ -1052,7 +1310,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__debounce;
       if (!state) return;
-      const newOptions = normalizeOptions$p(binding.value, binding);
+      const newOptions = normalizeOptions$v(binding.value, binding);
       if (newOptions.wait !== state.options.wait || newOptions.leading !== state.options.leading || newOptions.trailing !== state.options.trailing) {
         state.debouncedFn.cancel();
         const debouncedFn = debounce(newOptions.handler, newOptions.wait, {
@@ -1106,7 +1364,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return { x: 0, y: 0 };
   }
-  function normalizeOptions$o(binding) {
+  function normalizeOptions$u(binding) {
     var _a, _b, _c;
     if (binding === void 0 || binding === true) {
       return { axis: "both", constrain: false, disabled: false };
@@ -1130,7 +1388,7 @@ var __async = (__this, __arguments, generator) => {
     name: "draggable",
     ssr: false,
     mounted(el, binding) {
-      const options = normalizeOptions$o(binding.value);
+      const options = normalizeOptions$u(binding.value);
       if (options.disabled) return;
       if (getComputedStyle(el).position === "static") {
         el.style.position = "absolute";
@@ -1236,7 +1494,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__draggable;
       if (!state) return;
-      state.options = normalizeOptions$o(binding.value);
+      state.options = normalizeOptions$u(binding.value);
       if (state.options.handle) {
         state.handleEl = el.querySelector(state.options.handle);
       }
@@ -1255,6 +1513,150 @@ var __async = (__this, __arguments, generator) => {
       delete el.__draggable;
     }
   });
+  const vEllipsis = defineDirective({
+    name: "ellipsis",
+    ssr: true,
+    defaults: {
+      lines: 1,
+      ellipsis: "...",
+      expandable: false,
+      titleBehavior: "auto"
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$t(binding.value);
+      applyEllipsis(el, options);
+      const state = {
+        options,
+        originalText: el.textContent || "",
+        clickHandler: null,
+        expanded: false
+      };
+      if (options.expandable) {
+        const handler = () => {
+          if (state.expanded) {
+            applyEllipsis(el, options);
+            state.expanded = false;
+          } else {
+            el.textContent = state.originalText;
+            el.style.webkitLineClamp = "";
+            el.style.display = "";
+            el.style.overflow = "";
+            el.style.cursor = "";
+            state.expanded = true;
+          }
+        };
+        el.addEventListener("click", handler);
+        el.style.cursor = "pointer";
+        state.clickHandler = handler;
+      }
+      if (options.titleBehavior === "always") {
+        el.title = state.originalText;
+      } else if (options.titleBehavior === "auto") {
+        if (isTextTruncated(el)) {
+          el.title = state.originalText;
+        }
+      }
+      el.__ellipsis = state;
+    },
+    updated(el, binding) {
+      const state = el.__ellipsis;
+      if (!state) {
+        const options = normalizeOptions$t(binding.value);
+        applyEllipsis(el, options);
+        return;
+      }
+      const newOptions = normalizeOptions$t(binding.value);
+      const textChanged = el.textContent !== state.originalText;
+      if (textChanged) {
+        state.originalText = el.textContent || "";
+        state.expanded = false;
+      }
+      if (state.options.expandable !== newOptions.expandable) {
+        if (state.clickHandler) {
+          el.removeEventListener("click", state.clickHandler);
+          state.clickHandler = null;
+        }
+        if (newOptions.expandable) {
+          const handler = () => {
+            if (state.expanded) {
+              applyEllipsis(el, newOptions);
+              state.expanded = false;
+            } else {
+              el.textContent = state.originalText;
+              el.style.webkitLineClamp = "";
+              el.style.display = "";
+              el.style.overflow = "";
+              state.expanded = true;
+            }
+          };
+          el.addEventListener("click", handler);
+          el.style.cursor = "pointer";
+          state.clickHandler = handler;
+        } else {
+          el.style.cursor = "";
+        }
+      }
+      state.options = newOptions;
+      if (!state.expanded) {
+        applyEllipsis(el, newOptions);
+      }
+      if (newOptions.titleBehavior === "always") {
+        el.title = state.originalText;
+      } else if (newOptions.titleBehavior === "auto") {
+        el.title = isTextTruncated(el) ? state.originalText : "";
+      } else {
+        el.removeAttribute("title");
+      }
+    },
+    unmounted(el) {
+      const state = el.__ellipsis;
+      if (!state) return;
+      if (state.clickHandler) {
+        el.removeEventListener("click", state.clickHandler);
+      }
+      el.style.removeProperty("-webkit-line-clamp");
+      el.style.removeProperty("-webkit-box-orient");
+      el.style.removeProperty("display");
+      el.style.removeProperty("overflow");
+      el.style.removeProperty("text-overflow");
+      el.style.removeProperty("white-space");
+      el.style.removeProperty("cursor");
+      delete el.__ellipsis;
+    }
+  });
+  function applyEllipsis(el, options) {
+    const lines = options.lines || 1;
+    if (lines === 1) {
+      el.style.overflow = "hidden";
+      el.style.textOverflow = "ellipsis";
+      el.style.whiteSpace = "nowrap";
+    } else {
+      el.style.display = "-webkit-box";
+      el.style.overflow = "hidden";
+      el.style.webkitBoxOrient = "vertical";
+      el.style.webkitLineClamp = String(lines);
+    }
+  }
+  function isTextTruncated(el) {
+    return el.scrollWidth > el.clientWidth || el.scrollHeight > el.clientHeight;
+  }
+  function normalizeOptions$t(binding) {
+    var _a, _b, _c, _d;
+    if (typeof binding === "number") {
+      return {
+        lines: binding,
+        ellipsis: "...",
+        expandable: false,
+        titleBehavior: "auto"
+      };
+    }
+    return {
+      lines: (_a = binding == null ? void 0 : binding.lines) != null ? _a : 1,
+      ellipsis: (_b = binding == null ? void 0 : binding.ellipsis) != null ? _b : "...",
+      expandable: (_c = binding == null ? void 0 : binding.expandable) != null ? _c : false,
+      titleBehavior: (_d = binding == null ? void 0 : binding.titleBehavior) != null ? _d : "auto"
+    };
+  }
   const FOCUSABLE_TAGS = /* @__PURE__ */ new Set(["input", "textarea", "select", "button"]);
   function isEqual(a, b) {
     if (a === b) return true;
@@ -1276,7 +1678,7 @@ var __async = (__this, __arguments, generator) => {
     },
     mounted(el, binding) {
       if (!isBrowser()) return;
-      const options = normalizeOptions$n(binding.value);
+      const options = normalizeOptions$s(binding.value);
       if (!options.focus || !isFocusable(el)) {
         if (options.focus) {
           console.warn("[Directix] v-focus: Element is not focusable");
@@ -1304,7 +1706,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__focus;
       if (!state) return;
-      const newOptions = normalizeOptions$n(binding.value);
+      const newOptions = normalizeOptions$s(binding.value);
       if (newOptions.onFocus !== state.options.onFocus) {
         el.removeEventListener("focus", state.handleFocus);
         state.handleFocus = () => {
@@ -1336,7 +1738,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__focus;
     }
   });
-  function normalizeOptions$n(binding) {
+  function normalizeOptions$s(binding) {
     if (typeof binding === "boolean") {
       return { focus: binding, refocus: false };
     }
@@ -1359,7 +1761,181 @@ var __async = (__this, __arguments, generator) => {
     }
     return false;
   }
-  function normalizeOptions$m(binding) {
+  const KEY_ALIASES = {
+    esc: "escape",
+    space: " ",
+    up: "arrowup",
+    down: "arrowdown",
+    left: "arrowleft",
+    right: "arrowright",
+    enter: "enter",
+    tab: "tab",
+    delete: "delete",
+    backspace: "backspace",
+    insert: "insert",
+    home: "home",
+    end: "end",
+    pagedown: "pagedown",
+    pageup: "pageup",
+    f1: "f1",
+    f2: "f2",
+    f3: "f3",
+    f4: "f4",
+    f5: "f5",
+    f6: "f6",
+    f7: "f7",
+    f8: "f8",
+    f9: "f9",
+    f10: "f10",
+    f11: "f11",
+    f12: "f12"
+  };
+  const MODIFIER_KEYS = /* @__PURE__ */ new Set(["ctrl", "alt", "shift", "meta"]);
+  function normalizeKey(key) {
+    const lowerKey = key.toLowerCase();
+    return KEY_ALIASES[lowerKey] || lowerKey;
+  }
+  function parseHotkeyString(hotkey) {
+    const parts = hotkey.toLowerCase().split(/[+.]/);
+    const modifiers = [];
+    let key = "";
+    for (const part of parts) {
+      if (MODIFIER_KEYS.has(part)) {
+        modifiers.push(part);
+      } else {
+        key = normalizeKey(part);
+      }
+    }
+    return { key, modifiers };
+  }
+  function matchesHotkey(event, entry) {
+    if (normalizeKey(event.key) !== entry.key) return false;
+    const eventModifiers = /* @__PURE__ */ new Set();
+    if (event.ctrlKey) eventModifiers.add("ctrl");
+    if (event.altKey) eventModifiers.add("alt");
+    if (event.shiftKey) eventModifiers.add("shift");
+    if (event.metaKey) eventModifiers.add("meta");
+    if (eventModifiers.size !== entry.modifiers.size) return false;
+    for (const mod of entry.modifiers) {
+      if (!eventModifiers.has(mod)) return false;
+    }
+    return true;
+  }
+  function createEntry(key, modifiers, handler, options = {}) {
+    var _a, _b, _c;
+    return {
+      key: normalizeKey(key),
+      modifiers: new Set(modifiers),
+      handler,
+      prevent: (_a = options.prevent) != null ? _a : true,
+      stop: (_b = options.stop) != null ? _b : true,
+      disabled: (_c = options.disabled) != null ? _c : false
+    };
+  }
+  function normalizeBinding(binding, arg, modifiers) {
+    if (arg) {
+      const argLower = arg.toLowerCase();
+      const argIsModifier = MODIFIER_KEYS.has(argLower);
+      let key;
+      const parsedModifiers = [];
+      if (argIsModifier) {
+        parsedModifiers.push(argLower);
+        for (const mod of Object.keys(modifiers)) {
+          const modLower = mod.toLowerCase();
+          if (MODIFIER_KEYS.has(modLower)) {
+            parsedModifiers.push(modLower);
+          } else {
+            key = normalizeKey(mod);
+          }
+        }
+      } else {
+        const parsed = parseHotkeyString(arg);
+        key = parsed.key;
+        parsedModifiers.push(...parsed.modifiers);
+        for (const mod of Object.keys(modifiers)) {
+          const modLower = mod.toLowerCase();
+          if (MODIFIER_KEYS.has(modLower)) {
+            parsedModifiers.push(modLower);
+          }
+        }
+      }
+      const handler = typeof binding === "function" ? binding : binding.handler;
+      return [createEntry(key, parsedModifiers, handler)];
+    }
+    if (typeof binding === "function") {
+      console.warn('[Directix] v-hotkey: hotkey definition required (use v-hotkey:ctrl.s="handler")');
+      return [];
+    }
+    if (Array.isArray(binding)) {
+      return binding.map(
+        (item) => createEntry(item.key, item.modifiers || [], item.handler, {
+          prevent: item.prevent,
+          stop: item.stop,
+          disabled: item.disabled
+        })
+      );
+    }
+    if (typeof binding === "object" && binding !== null) {
+      if ("handler" in binding && typeof binding.handler === "function") {
+        const def = binding;
+        return [createEntry(def.key, def.modifiers || [], def.handler, def)];
+      }
+      const entries = [];
+      for (const [hotkeyStr, value] of Object.entries(binding)) {
+        const { key, modifiers: parsedModifiers } = parseHotkeyString(hotkeyStr);
+        const handler = typeof value === "function" ? value : value.handler;
+        const options = typeof value === "object" ? value : {};
+        entries.push(createEntry(key, parsedModifiers, handler, options));
+      }
+      return entries;
+    }
+    return [];
+  }
+  function createKeydownHandler(state) {
+    return (event) => {
+      for (const entry of state.entries) {
+        if (entry.disabled) continue;
+        if (!matchesHotkey(event, entry)) continue;
+        if (entry.prevent) event.preventDefault();
+        if (entry.stop) event.stopPropagation();
+        entry.handler(event);
+        return;
+      }
+    };
+  }
+  function setupState$1(el, entries) {
+    if (entries.length === 0) return null;
+    const state = { entries, handler: null };
+    state.handler = createKeydownHandler(state);
+    el.tabIndex = el.tabIndex || -1;
+    el.addEventListener("keydown", state.handler);
+    el.__hotkey = state;
+    return state;
+  }
+  const vHotkey = defineDirective({
+    name: "hotkey",
+    ssr: true,
+    mounted(el, binding) {
+      const entries = normalizeBinding(binding.value, binding.arg, binding.modifiers);
+      setupState$1(el, entries);
+    },
+    updated(el, binding) {
+      const state = el.__hotkey;
+      const newEntries = normalizeBinding(binding.value, binding.arg, binding.modifiers);
+      if (state) {
+        state.entries = newEntries;
+      } else {
+        setupState$1(el, newEntries);
+      }
+    },
+    unmounted(el) {
+      const state = el.__hotkey;
+      if (!state) return;
+      el.removeEventListener("keydown", state.handler);
+      delete el.__hotkey;
+    }
+  });
+  function normalizeOptions$r(binding) {
     if (typeof binding === "function") {
       return { handler: binding, class: "v-hover" };
     }
@@ -1380,7 +1956,7 @@ var __async = (__this, __arguments, generator) => {
       leaveDelay: 0
     },
     mounted(el, binding) {
-      const options = normalizeOptions$m(binding.value);
+      const options = normalizeOptions$r(binding.value);
       if (options.disabled || !isBrowser()) return;
       const state = {
         options,
@@ -1433,7 +2009,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__hover;
       if (!state) return;
-      const newOptions = normalizeOptions$m(binding.value);
+      const newOptions = normalizeOptions$r(binding.value);
       if (newOptions.disabled && !state.options.disabled) {
         el.classList.remove(state.options.class || "v-hover");
       } else if (!newOptions.disabled && state.options.disabled) ;
@@ -1746,7 +2322,7 @@ var __async = (__this, __arguments, generator) => {
     };
     return { handleTouchStart, handleTouchMove, handleTouchEnd, handleMouseDown, handleMouseMove, handleMouseUp, handleWheel };
   }
-  function normalizeOptions$l(binding, el) {
+  function normalizeOptions$q(binding, el) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const elSrc = el.tagName === "IMG" ? el.src : void 0;
     const elPreviewSrc = el.getAttribute("data-preview") || void 0;
@@ -1791,7 +2367,7 @@ var __async = (__this, __arguments, generator) => {
     name: "image-preview",
     ssr: false,
     mounted(el, binding) {
-      const options = normalizeOptions$l(binding.value, el);
+      const options = normalizeOptions$q(binding.value, el);
       const state = {
         options,
         overlay: null,
@@ -1905,7 +2481,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__imagePreview;
       if (!state) return;
-      state.options = normalizeOptions$l(binding.value, el);
+      state.options = normalizeOptions$q(binding.value, el);
       el.style.cursor = state.options.disabled ? "" : "zoom-in";
     },
     unmounted(el) {
@@ -1927,7 +2503,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__imagePreview;
     }
   });
-  function normalizeOptions$k(binding) {
+  function normalizeOptions$p(binding) {
     if (typeof binding === "function") {
       return { handler: binding, distance: 0, throttle: 200, useIntersection: true };
     }
@@ -1953,7 +2529,7 @@ var __async = (__this, __arguments, generator) => {
       throttle: 200
     },
     mounted(el, binding) {
-      const options = normalizeOptions$k(binding.value);
+      const options = normalizeOptions$p(binding.value);
       if (options.disabled || !isBrowser()) return;
       let container;
       if (options.container) {
@@ -1999,7 +2575,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__infiniteScroll;
       if (!state) return;
-      state.options = normalizeOptions$k(binding.value);
+      state.options = normalizeOptions$p(binding.value);
     },
     unmounted(el) {
       const state = el.__infiniteScroll;
@@ -2076,7 +2652,7 @@ var __async = (__this, __arguments, generator) => {
     state.observer.observe(sentinel);
   }
   const STATE_KEY$3 = "__intersect";
-  function normalizeOptions$j(binding) {
+  function normalizeOptions$o(binding) {
     const options = typeof binding === "function" ? { handler: binding } : __spreadValues({}, binding);
     if (options.root !== null && typeof options.root === "object" && "value" in options.root) {
       options.root = options.root.value;
@@ -2118,7 +2694,7 @@ var __async = (__this, __arguments, generator) => {
       threshold: 0
     },
     mounted(el, binding) {
-      const options = normalizeOptions$j(binding.value);
+      const options = normalizeOptions$o(binding.value);
       if (options.disabled || !isBrowser() || !supportsIntersectionObserver()) {
         if (!supportsIntersectionObserver()) {
           console.warn("[Directix] v-intersect: IntersectionObserver not supported");
@@ -2138,7 +2714,7 @@ var __async = (__this, __arguments, generator) => {
       var _a, _b, _c;
       const state = el[STATE_KEY$3];
       if (!state) return;
-      const newOptions = normalizeOptions$j(binding.value);
+      const newOptions = normalizeOptions$o(binding.value);
       const observerOptionsChanged = newOptions.root !== state.options.root || newOptions.rootMargin !== state.options.rootMargin || newOptions.threshold !== state.options.threshold;
       if (newOptions.disabled !== state.options.disabled) {
         if (newOptions.disabled) {
@@ -2252,7 +2828,7 @@ var __async = (__this, __arguments, generator) => {
       globalObserver.unobserve(el);
     }
   }
-  function normalizeOptions$i(binding) {
+  function normalizeOptions$n(binding) {
     if (typeof binding === "string") {
       return { src: binding };
     }
@@ -2267,7 +2843,7 @@ var __async = (__this, __arguments, generator) => {
       disabled: false
     },
     mounted(el, binding) {
-      const options = normalizeOptions$i(binding.value);
+      const options = normalizeOptions$n(binding.value);
       if (options.disabled) return;
       if (!options.src) {
         console.warn("[Directix] v-lazy: No source provided");
@@ -2288,7 +2864,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__lazy;
       if (!state) return;
-      const newOptions = normalizeOptions$i(binding.value);
+      const newOptions = normalizeOptions$n(binding.value);
       if (newOptions.disabled) {
         unobserve(el);
         return;
@@ -2311,7 +2887,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__lazy;
     }
   });
-  function normalizeOptions$h(binding) {
+  function normalizeOptions$m(binding) {
     if (typeof binding === "boolean") {
       return { value: binding };
     }
@@ -2374,7 +2950,7 @@ var __async = (__this, __arguments, generator) => {
     },
     mounted(el, binding) {
       if (!isBrowser()) return;
-      const options = normalizeOptions$h(binding.value);
+      const options = normalizeOptions$m(binding.value);
       if (options.disabled) return;
       const computedStyle = getComputedStyle(el);
       const originalPosition = el.style.position;
@@ -2396,7 +2972,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__loading;
       if (!state) return;
-      const newOptions = normalizeOptions$h(binding.value);
+      const newOptions = normalizeOptions$m(binding.value);
       if (newOptions.disabled) {
         hideLoading(el, state);
         return;
@@ -2441,7 +3017,7 @@ var __async = (__this, __arguments, generator) => {
     }
     el.classList.remove("v-loading--active");
   }
-  function normalizeOptions$g(binding) {
+  function normalizeOptions$l(binding) {
     if (typeof binding === "function") {
       return { handler: binding, duration: 500, distance: 10 };
     }
@@ -2472,7 +3048,7 @@ var __async = (__this, __arguments, generator) => {
       tickInterval: 100
     },
     mounted(el, binding) {
-      const options = normalizeOptions$g(binding.value);
+      const options = normalizeOptions$l(binding.value);
       if (options.disabled || !isBrowser()) return;
       const state = {
         options,
@@ -2572,13 +3148,13 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__longPress;
       if (!state) {
-        const options = normalizeOptions$g(binding.value);
+        const options = normalizeOptions$l(binding.value);
         if (!options.disabled) {
           el.__longPress = null;
         }
         return;
       }
-      state.options = normalizeOptions$g(binding.value);
+      state.options = normalizeOptions$l(binding.value);
     },
     unmounted(el) {
       const state = el.__longPress;
@@ -2607,7 +3183,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return text.toLowerCase();
   }
-  function normalizeOptions$f(binding) {
+  function normalizeOptions$k(binding) {
     var _a, _b;
     if (binding === void 0 || binding === true) {
       return { first: false, onInput: true };
@@ -2624,7 +3200,7 @@ var __async = (__this, __arguments, generator) => {
     name: "lowercase",
     ssr: true,
     mounted(el, binding) {
-      const options = normalizeOptions$f(binding.value);
+      const options = normalizeOptions$k(binding.value);
       if (isInputElement(el)) {
         const cleanup2 = setupTextTransformInput(el, options, (text) => transformText$1(text, options));
         el.__lowercaseCleanup = cleanup2;
@@ -2633,7 +3209,7 @@ var __async = (__this, __arguments, generator) => {
       }
     },
     updated(el, binding) {
-      const options = normalizeOptions$f(binding.value);
+      const options = normalizeOptions$k(binding.value);
       if (isInputElement(el)) {
         if (options.onInput) {
           el.value = transformText$1(el.value, options);
@@ -2661,7 +3237,7 @@ var __async = (__this, __arguments, generator) => {
       return pattern ? { pattern, placeholder, isLiteral: false } : { pattern: new RegExp(`\\${char}`), placeholder: char, isLiteral: true };
     });
   }
-  function normalizeOptions$e(binding) {
+  function normalizeOptions$j(binding) {
     if (typeof binding === "string") return { mask: binding, placeholder: "_", showPlaceholder: true };
     if (!(binding == null ? void 0 : binding.mask)) throw new Error("[Directix] v-mask: mask is required");
     return __spreadValues({ placeholder: "_", showPlaceholder: true, showMaskOnBlur: false, clearIncomplete: false, disabled: false }, binding);
@@ -2726,7 +3302,7 @@ var __async = (__this, __arguments, generator) => {
         console.warn("[Directix] v-mask: directive must be used on input or textarea elements");
         return;
       }
-      const options = normalizeOptions$e(binding.value);
+      const options = normalizeOptions$j(binding.value);
       if (options.disabled || !isBrowser()) return;
       const placeholder = options.placeholder || "_";
       const tokens = parseMask(options.mask, placeholder);
@@ -2768,7 +3344,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el[STATE_KEY$2];
       if (!state) return;
-      state.options = normalizeOptions$e(binding.value);
+      state.options = normalizeOptions$j(binding.value);
       state.tokens = parseMask(state.options.mask, state.placeholder);
     },
     unmounted(el) {
@@ -2957,7 +3533,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__money;
     }
   });
-  function normalizeOptions$d(binding) {
+  function normalizeOptions$i(binding) {
     if (typeof binding === "function") {
       return { handler: binding, childList: true };
     }
@@ -2987,7 +3563,7 @@ var __async = (__this, __arguments, generator) => {
       disabled: false
     },
     mounted(el, binding) {
-      const options = normalizeOptions$d(binding.value);
+      const options = normalizeOptions$i(binding.value);
       if (options.disabled || !isBrowser()) return;
       if (!supportsMutationObserver()) {
         console.warn("[Directix] v-mutation: MutationObserver not supported");
@@ -3014,7 +3590,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__mutation;
       if (!state) return;
-      const newOptions = normalizeOptions$d(binding.value);
+      const newOptions = normalizeOptions$i(binding.value);
       if (newOptions.disabled && !state.options.disabled) {
         if (state.observer) {
           state.observer.disconnect();
@@ -3130,7 +3706,7 @@ var __async = (__this, __arguments, generator) => {
   function getPermissionConfig() {
     return globalConfig;
   }
-  function normalizeOptions$c(binding) {
+  function normalizeOptions$h(binding) {
     if (!binding) {
       throw new Error("[Directix] v-permission: permission value is required");
     }
@@ -3235,7 +3811,7 @@ var __async = (__this, __arguments, generator) => {
   function checkPermission(el, binding) {
     var _a, _b;
     const state = getState(el);
-    state.options = normalizeOptions$c(binding.value);
+    state.options = normalizeOptions$h(binding.value);
     const granted = verifyPermission(state.options);
     (_b = (_a = state.options).onChange) == null ? void 0 : _b.call(_a, granted);
     const action = state.options.action || "remove";
@@ -3265,17 +3841,383 @@ var __async = (__this, __arguments, generator) => {
       cleanup(el);
     }
   });
-  function getResizeInfo(entry) {
-    return {
-      width: entry.contentRect.width,
-      height: entry.contentRect.height,
-      contentRect: entry.contentRect,
-      borderBoxSize: entry.borderBoxSize,
+  const vPrint = defineDirective({
+    name: "print",
+    ssr: true,
+    mounted(el, binding) {
+      const options = normalizeOptions$g(binding.value);
+      const state = {
+        options,
+        clickHandler: null
+      };
+      el.__print = state;
+      if (options.immediate) {
+        setTimeout(() => printElement(el, options), 100);
+        return;
+      }
+      const clickHandler = () => {
+        printElement(el, state.options);
+      };
+      el.addEventListener("click", clickHandler);
+      state.clickHandler = clickHandler;
+      el.style.cursor = "pointer";
+    },
+    updated(el, binding) {
+      const state = el.__print;
+      if (!state) return;
+      const newOptions = normalizeOptions$g(binding.value);
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__print;
+      if (!state) return;
+      if (state.clickHandler) {
+        el.removeEventListener("click", state.clickHandler);
+      }
+      el.style.cursor = "";
+      delete el.__print;
+    }
+  });
+  function normalizeOptions$g(binding) {
+    if (binding === true) {
+      return { immediate: true };
+    }
+    if (binding === false) {
+      return {};
+    }
+    return binding || {};
+  }
+  function printElement(triggerEl, options) {
+    return __async(this, null, function* () {
+      if (options.onBeforePrint) {
+        const result = options.onBeforePrint();
+        if (result === false) return;
+      }
+      const targetEl = options.target ? document.querySelector(options.target) : triggerEl;
+      if (!targetEl) {
+        console.warn("[Directix] v-print: Target element not found");
+        return;
+      }
+      if (options.newWindow) {
+        yield printInNewWindow(targetEl, options);
+      } else {
+        yield printInIframe(targetEl, options);
+      }
+      if (options.onAfterPrint) {
+        options.onAfterPrint();
+      }
+    });
+  }
+  function printInIframe(el, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const iframe = document.createElement("iframe");
+      iframe.style.cssText = "position: absolute; top: -10000px; left: -10000px; width: 0; height: 0; border: none;";
+      document.body.appendChild(iframe);
+      const iframeDoc = iframe.contentDocument || ((_a = iframe.contentWindow) == null ? void 0 : _a.document);
+      if (!iframeDoc) {
+        console.warn("[Directix] v-print: Could not access iframe document");
+        document.body.removeChild(iframe);
+        return;
+      }
+      const content = buildPrintContent(el, options);
+      iframeDoc.open();
+      iframeDoc.write(content);
+      iframeDoc.close();
+      yield waitForImages(iframeDoc);
+      try {
+        (_b = iframe.contentWindow) == null ? void 0 : _b.focus();
+        (_c = iframe.contentWindow) == null ? void 0 : _c.print();
+      } catch (err) {
+        console.error("[Directix] v-print: Print failed", err);
+      }
+      setTimeout(() => {
+        document.body.removeChild(iframe);
+      }, 1e3);
+    });
+  }
+  function printInNewWindow(el, options) {
+    return __async(this, null, function* () {
+      const printWindow = window.open("", "_blank");
+      if (!printWindow) {
+        console.warn("[Directix] v-print: Could not open print window");
+        return;
+      }
+      const content = buildPrintContent(el, options);
+      printWindow.document.open();
+      printWindow.document.write(content);
+      printWindow.document.close();
+      yield waitForImages(printWindow.document);
+      printWindow.focus();
+      printWindow.print();
+      setTimeout(() => {
+        printWindow.close();
+      }, 1e3);
+    });
+  }
+  function buildPrintContent(el, options) {
+    let styles = "";
+    document.querySelectorAll('style, link[rel="stylesheet"]').forEach((styleEl) => {
+      if (styleEl.tagName === "STYLE") {
+        styles += `<style>${styleEl.textContent}</style>`;
+      } else if (styleEl.tagName === "LINK") {
+        const href = styleEl.href;
+        styles += `<link rel="stylesheet" href="${href}">`;
+      }
+    });
+    if (options.cssUrls) {
+      options.cssUrls.forEach((url) => {
+        styles += `<link rel="stylesheet" href="${url}">`;
+      });
+    }
+    if (options.styles) {
+      const customStyles = Array.isArray(options.styles) ? options.styles.join("\n") : options.styles;
+      styles += `<style>${customStyles}</style>`;
+    }
+    styles += `
+		<style>
+			@media print {
+				body { margin: 0; padding: 20px; }
+				${options.printClass ? `.${options.printClass} { page-break-inside: avoid; }` : ""}
+			}
+		</style>
+	`;
+    const title = options.title || document.title || "Print";
+    const content = el.outerHTML;
+    return `<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<title>${title}</title>
+	${styles}
+</head>
+<body>
+	${content}
+</body>
+</html>`;
+  }
+  function waitForImages(doc) {
+    const images = doc.querySelectorAll("img");
+    const promises = [];
+    images.forEach((img) => {
+      if (!img.complete) {
+        promises.push(
+          new Promise((resolve) => {
+            img.onload = () => resolve();
+            img.onerror = () => resolve();
+          })
+        );
+      }
+    });
+    return Promise.all(promises);
+  }
+  const DEFAULT_DISTANCE = 60;
+  const DEFAULT_MAX_DISTANCE = 100;
+  const DEFAULT_SUCCESS_DURATION = 500;
+  const DEFAULT_ERROR_DURATION = 1e3;
+  const DEFAULT_INDICATORS = {
+    idle: "↓",
+    pulling: "↓ Pull",
+    ready: "↓ Release",
+    loading: "⟳ Loading...",
+    success: "✓ Done",
+    error: "✗ Failed"
+  };
+  function normalizeOptions$f(binding) {
+    var _a, _b, _c, _d, _e;
+    if (typeof binding === "function") return { handler: binding };
+    return {
+      handler: binding.handler,
+      distance: (_a = binding.distance) != null ? _a : DEFAULT_DISTANCE,
+      maxDistance: (_b = binding.maxDistance) != null ? _b : DEFAULT_MAX_DISTANCE,
+      disabled: (_c = binding.disabled) != null ? _c : false,
+      indicator: binding.indicator,
+      successDuration: (_d = binding.successDuration) != null ? _d : DEFAULT_SUCCESS_DURATION,
+      errorDuration: (_e = binding.errorDuration) != null ? _e : DEFAULT_ERROR_DURATION,
+      onStateChange: binding.onStateChange
+    };
+  }
+  function createIndicator() {
+    const el = document.createElement("div");
+    el.className = "v-pull-refresh__indicator";
+    el.style.cssText = `
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		height: 60px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		background: #f5f5f5;
+		font-size: 14px;
+		color: #666;
+		z-index: 10;
+		pointer-events: none;
+		opacity: 0;
+		transition: opacity 0.2s ease;
+	`;
+    return el;
+  }
+  function updateIndicator(el, state, options) {
+    var _a;
+    const customIndicator = (_a = options.indicator) == null ? void 0 : _a[state];
+    el.textContent = customIndicator || DEFAULT_INDICATORS[state];
+  }
+  function setState(internal, newState) {
+    var _a, _b;
+    if (internal.state === newState) return;
+    internal.state = newState;
+    updateIndicator(internal.indicatorEl, newState, internal.options);
+    (_b = (_a = internal.options).onStateChange) == null ? void 0 : _b.call(_a, newState);
+  }
+  function applyTransform(internal, distance, showIndicator) {
+    internal.contentEl.style.transform = `translateY(${distance}px)`;
+    internal.indicatorEl.style.opacity = "1";
+    internal.indicatorEl.style.transform = `translateY(${distance}px)`;
+  }
+  function resetPosition(internal) {
+    internal.contentEl.style.transform = "";
+    internal.indicatorEl.style.opacity = "0";
+    setState(internal, "idle");
+  }
+  function triggerRefresh(internal) {
+    return __async(this, null, function* () {
+      setState(internal, "loading");
+      const distance = internal.options.distance;
+      applyTransform(internal, distance);
+      try {
+        yield internal.options.handler();
+        setState(internal, "success");
+        yield sleep(internal.options.successDuration);
+      } catch (e) {
+        setState(internal, "error");
+        yield sleep(internal.options.errorDuration);
+      } finally {
+        resetPosition(internal);
+      }
+    });
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  function createHandlers(internal) {
+    const { contentEl, options } = internal;
+    return {
+      touchStart: (e) => {
+        if (options.disabled || internal.state === "loading") return;
+        if (contentEl.scrollTop > 0) return;
+        internal.pulling = true;
+        internal.startY = e.touches[0].clientY;
+        internal.currentY = internal.startY;
+        setState(internal, "idle");
+      },
+      touchMove: (e) => {
+        if (!internal.pulling || options.disabled || internal.state === "loading") return;
+        internal.currentY = e.touches[0].clientY;
+        const diff = internal.currentY - internal.startY;
+        if (diff <= 0) {
+          if (contentEl.style.transform) {
+            contentEl.style.transition = "";
+            resetPosition(internal);
+          }
+          return;
+        }
+        e.preventDefault();
+        const distance = Math.min(diff * 0.5, options.maxDistance);
+        const progress = distance / options.distance;
+        contentEl.style.transition = "none";
+        applyTransform(internal, distance);
+        setState(internal, progress >= 1 ? "ready" : "pulling");
+      },
+      touchEnd: () => {
+        if (!internal.pulling || options.disabled) return;
+        internal.pulling = false;
+        const diff = internal.currentY - internal.startY;
+        const distance = Math.min(diff * 0.5, options.maxDistance);
+        contentEl.style.transition = "";
+        if (internal.state === "ready" && distance >= options.distance) {
+          triggerRefresh(internal);
+        } else {
+          resetPosition(internal);
+        }
+      }
+    };
+  }
+  function bindEvents$1(el, handlers) {
+    el.addEventListener("touchstart", handlers.touchStart, { passive: false });
+    el.addEventListener("touchmove", handlers.touchMove, { passive: false });
+    el.addEventListener("touchend", handlers.touchEnd, { passive: true });
+  }
+  function unbindEvents$1(el, handlers) {
+    el.removeEventListener("touchstart", handlers.touchStart);
+    el.removeEventListener("touchmove", handlers.touchMove);
+    el.removeEventListener("touchend", handlers.touchEnd);
+  }
+  const vPullRefresh = defineDirective({
+    name: "pull-refresh",
+    ssr: false,
+    mounted(el, binding) {
+      const options = normalizeOptions$f(binding.value);
+      el.style.position = "relative";
+      el.style.overflow = "hidden";
+      el.classList.add("v-pull-refresh");
+      const contentEl = document.createElement("div");
+      contentEl.className = "v-pull-refresh__content";
+      contentEl.style.cssText = "position: relative; height: 100%; overflow-y: auto;";
+      while (el.firstChild) {
+        contentEl.appendChild(el.firstChild);
+      }
+      el.appendChild(contentEl);
+      const indicatorEl = createIndicator();
+      el.insertBefore(indicatorEl, contentEl);
+      const internal = {
+        options,
+        state: "idle",
+        startY: 0,
+        currentY: 0,
+        pulling: false,
+        indicatorEl,
+        contentEl,
+        handlers: null
+      };
+      internal.handlers = createHandlers(internal);
+      el.__pullRefresh = internal;
+      if (!options.disabled) {
+        bindEvents$1(el, internal.handlers);
+      }
+      updateIndicator(indicatorEl, "idle", options);
+    },
+    updated(el, binding) {
+      const internal = el.__pullRefresh;
+      if (!internal) return;
+      const wasDisabled = internal.options.disabled;
+      internal.options = normalizeOptions$f(binding.value);
+      updateIndicator(internal.indicatorEl, internal.state, internal.options);
+      if (internal.options.disabled && !wasDisabled) {
+        unbindEvents$1(el, internal.handlers);
+      } else if (!internal.options.disabled && wasDisabled) {
+        bindEvents$1(el, internal.handlers);
+      }
+    },
+    unmounted(el) {
+      const internal = el.__pullRefresh;
+      if (!internal) return;
+      unbindEvents$1(el, internal.handlers);
+      delete el.__pullRefresh;
+    }
+  });
+  function getResizeInfo(entry) {
+    return {
+      width: entry.contentRect.width,
+      height: entry.contentRect.height,
+      contentRect: entry.contentRect,
+      borderBoxSize: entry.borderBoxSize,
       contentBoxSize: entry.contentBoxSize,
       devicePixelContentBoxSize: entry.devicePixelContentBoxSize
     };
   }
-  function normalizeOptions$b(binding) {
+  function normalizeOptions$e(binding) {
     if (typeof binding === "function") {
       return { handler: binding };
     }
@@ -3324,7 +4266,7 @@ var __async = (__this, __arguments, generator) => {
       debounce: 0
     },
     mounted(el, binding) {
-      const options = normalizeOptions$b(binding.value);
+      const options = normalizeOptions$e(binding.value);
       if (options.disabled || !isBrowser()) return;
       const computedStyle = getComputedStyle(el);
       if (computedStyle.position === "static") {
@@ -3384,7 +4326,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__resize;
       if (!state) return;
-      state.options = normalizeOptions$b(binding.value);
+      state.options = normalizeOptions$e(binding.value);
     },
     unmounted(el) {
       const state = el.__resize;
@@ -3403,7 +4345,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__resizeCleanup;
     }
   });
-  function normalizeOptions$a(binding) {
+  function normalizeOptions$d(binding) {
     if (binding === false) {
       return { disabled: true, color: "currentColor", duration: 600 };
     }
@@ -3480,7 +4422,7 @@ var __async = (__this, __arguments, generator) => {
       finalScale: 2
     },
     mounted(el, binding) {
-      const options = normalizeOptions$a(binding.value);
+      const options = normalizeOptions$d(binding.value);
       if (options.disabled || !isBrowser()) return;
       const computedStyle = getComputedStyle(el);
       if (computedStyle.position === "static") {
@@ -3508,7 +4450,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__ripple;
       if (!state) return;
-      state.options = normalizeOptions$a(binding.value);
+      state.options = normalizeOptions$d(binding.value);
     },
     unmounted(el) {
       const state = el.__ripple;
@@ -3522,7 +4464,7 @@ var __async = (__this, __arguments, generator) => {
   const DEFAULT_ALLOWED_ATTRIBUTES = ["title", "alt", "href", "src"];
   const DANGEROUS_TAGS = ["script", "iframe", "object", "embed", "form", "input", "style", "link", "meta", "base"];
   const DANGEROUS_ATTRIBUTES = ["onclick", "onerror", "onload", "onmouseover", "onfocus", "onblur", "onchange", "onsubmit"];
-  function normalizeOptions$9(binding) {
+  function normalizeOptions$c(binding) {
     if (binding === false) {
       return { disabled: true };
     }
@@ -3613,7 +4555,7 @@ var __async = (__this, __arguments, generator) => {
     },
     mounted(el, binding) {
       if (!isBrowser()) return;
-      const options = normalizeOptions$9(binding.value);
+      const options = normalizeOptions$c(binding.value);
       if (options.disabled) return;
       el.__sanitize = { options };
       const content = el.innerHTML;
@@ -3624,7 +4566,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__sanitize;
       if (!state) return;
-      state.options = normalizeOptions$9(binding.value);
+      state.options = normalizeOptions$c(binding.value);
       if (state.options.disabled || !state.options.sanitizeOnUpdate) return;
       const content = el.innerHTML;
       if (content) {
@@ -3665,7 +4607,7 @@ var __async = (__this, __arguments, generator) => {
       container
     };
   }
-  function normalizeOptions$8(binding) {
+  function normalizeOptions$b(binding) {
     if (typeof binding === "function") {
       return { handler: binding, passive: true };
     }
@@ -3687,7 +4629,7 @@ var __async = (__this, __arguments, generator) => {
       disabled: false
     },
     mounted(el, binding) {
-      const options = normalizeOptions$8(binding.value);
+      const options = normalizeOptions$b(binding.value);
       if (options.disabled || !isBrowser()) return;
       let container;
       if (options.container) {
@@ -3743,7 +4685,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__scroll;
       if (!state) return;
-      state.options = normalizeOptions$8(binding.value);
+      state.options = normalizeOptions$b(binding.value);
     },
     unmounted(el) {
       const state = el.__scroll;
@@ -3756,7 +4698,7 @@ var __async = (__this, __arguments, generator) => {
     }
   });
   const STATE_KEY = "__sticky";
-  function normalizeOptions$7(binding) {
+  function normalizeOptions$a(binding) {
     if (binding === false) return { disabled: true, top: 0, zIndex: 100 };
     if (typeof binding === "number") return { top: binding, zIndex: 100 };
     return __spreadValues({
@@ -3838,7 +4780,7 @@ var __async = (__this, __arguments, generator) => {
     ssr: false,
     defaults: { top: 0, zIndex: 100, stickyClass: "v-sticky--fixed", disabled: false },
     mounted(el, binding) {
-      const options = normalizeOptions$7(binding.value);
+      const options = normalizeOptions$a(binding.value);
       if (options.disabled || !isBrowser()) return;
       const container = getScrollContainer(el, options.container);
       const state = {
@@ -3865,7 +4807,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el[STATE_KEY];
       if (!state) return;
-      state.options = normalizeOptions$7(binding.value);
+      state.options = normalizeOptions$a(binding.value);
       checkSticky(el, state);
     },
     unmounted(el) {
@@ -3880,7 +4822,193 @@ var __async = (__this, __arguments, generator) => {
       delete el[STATE_KEY];
     }
   });
-  function normalizeOptions$6(binding, directiveBinding) {
+  const DEFAULT_THRESHOLD = 30;
+  const DEFAULT_MAX_TIME = 500;
+  const DEFAULT_DIRECTIONS = ["left", "right", "up", "down"];
+  function getSwipeDirection(deltaX, deltaY, allowedDirections) {
+    const absX = Math.abs(deltaX);
+    const absY = Math.abs(deltaY);
+    if (absX > absY) {
+      const direction = deltaX > 0 ? "right" : "left";
+      return allowedDirections.includes(direction) ? direction : null;
+    } else {
+      const direction = deltaY > 0 ? "down" : "up";
+      return allowedDirections.includes(direction) ? direction : null;
+    }
+  }
+  function normalizeOptions$9(binding) {
+    var _a, _b, _c, _d, _e, _f;
+    if (typeof binding === "function") return { handler: binding };
+    return {
+      handler: binding.handler,
+      threshold: (_a = binding.threshold) != null ? _a : DEFAULT_THRESHOLD,
+      maxTime: (_b = binding.maxTime) != null ? _b : DEFAULT_MAX_TIME,
+      directions: (_c = binding.directions) != null ? _c : [...DEFAULT_DIRECTIONS],
+      preventScrollOnSwipe: (_d = binding.preventScrollOnSwipe) != null ? _d : true,
+      disabled: (_e = binding.disabled) != null ? _e : false,
+      mouse: (_f = binding.mouse) != null ? _f : true,
+      onLeft: binding.onLeft,
+      onRight: binding.onRight,
+      onUp: binding.onUp,
+      onDown: binding.onDown
+    };
+  }
+  function triggerSwipe(state, deltaX, deltaY, deltaTime, event, el) {
+    var _a, _b, _c, _d, _e;
+    const { options } = state;
+    if (deltaTime > ((_a = options.maxTime) != null ? _a : DEFAULT_MAX_TIME)) return;
+    const distance = Math.max(Math.abs(deltaX), Math.abs(deltaY));
+    if (distance < ((_b = options.threshold) != null ? _b : DEFAULT_THRESHOLD)) return;
+    const direction = getSwipeDirection(deltaX, deltaY, (_c = options.directions) != null ? _c : DEFAULT_DIRECTIONS);
+    if (!direction) return;
+    if (options.preventScrollOnSwipe && event.cancelable) {
+      event.preventDefault();
+    }
+    (_d = options.handler) == null ? void 0 : _d.call(options, direction, event);
+    const callbacks = {
+      left: options.onLeft,
+      right: options.onRight,
+      up: options.onUp,
+      down: options.onDown
+    };
+    (_e = callbacks[direction]) == null ? void 0 : _e.call(callbacks);
+    el.dispatchEvent(new CustomEvent("swipe", { detail: { direction, deltaX, deltaY, deltaTime } }));
+  }
+  function createSwipeHandler(el, state) {
+    return (clientX, clientY, event) => {
+      const deltaX = clientX - state.startX;
+      const deltaY = clientY - state.startY;
+      const deltaTime = Date.now() - state.startTime;
+      triggerSwipe(state, deltaX, deltaY, deltaTime, event, el);
+    };
+  }
+  function setupState(el, options) {
+    if (options.disabled) return null;
+    el.style.touchAction = "none";
+    el.style.userSelect = "none";
+    const state = {
+      options,
+      startX: 0,
+      startY: 0,
+      startTime: 0,
+      isActive: false,
+      handlers: null
+    };
+    const handleSwipe = createSwipeHandler(el, state);
+    state.handlers = {
+      touchStart: (e) => {
+        if (state.options.disabled) return;
+        state.startX = e.touches[0].clientX;
+        state.startY = e.touches[0].clientY;
+        state.startTime = Date.now();
+        state.isActive = true;
+      },
+      touchMove: (e) => {
+        if (!state.isActive || state.options.disabled) return;
+        if (state.options.preventScrollOnSwipe) {
+          e.preventDefault();
+        }
+      },
+      touchEnd: (e) => {
+        if (!state.isActive || state.options.disabled) return;
+        state.isActive = false;
+        const touch = e.changedTouches[0];
+        handleSwipe(touch.clientX, touch.clientY, e);
+      },
+      mouseDown: (e) => {
+        if (state.options.disabled) return;
+        state.startX = e.clientX;
+        state.startY = e.clientY;
+        state.startTime = Date.now();
+        state.isActive = true;
+      },
+      mouseUp: (e) => {
+        if (!state.isActive || state.options.disabled) return;
+        state.isActive = false;
+        handleSwipe(e.clientX, e.clientY, e);
+      }
+    };
+    return state;
+  }
+  function bindEvents(el, state) {
+    var _a;
+    const { handlers } = state;
+    const enableMouse = (_a = state.options.mouse) != null ? _a : true;
+    el.addEventListener("touchstart", handlers.touchStart, { passive: true });
+    el.addEventListener("touchmove", handlers.touchMove, { passive: false });
+    el.addEventListener("touchend", handlers.touchEnd);
+    el.addEventListener("touchcancel", handlers.touchEnd);
+    if (enableMouse) {
+      el.addEventListener("mousedown", handlers.mouseDown);
+      el.addEventListener("mouseup", handlers.mouseUp);
+      el.addEventListener("mouseleave", handlers.mouseUp);
+    }
+  }
+  function unbindEvents(el, state) {
+    var _a;
+    const { handlers } = state;
+    const enableMouse = (_a = state.options.mouse) != null ? _a : true;
+    el.removeEventListener("touchstart", handlers.touchStart);
+    el.removeEventListener("touchmove", handlers.touchMove);
+    el.removeEventListener("touchend", handlers.touchEnd);
+    el.removeEventListener("touchcancel", handlers.touchEnd);
+    if (enableMouse) {
+      el.removeEventListener("mousedown", handlers.mouseDown);
+      el.removeEventListener("mouseup", handlers.mouseUp);
+      el.removeEventListener("mouseleave", handlers.mouseUp);
+    }
+  }
+  const vSwipe = defineDirective({
+    name: "swipe",
+    ssr: false,
+    mounted(el, binding) {
+      const options = normalizeOptions$9(binding.value);
+      const state = setupState(el, options);
+      if (!state) return;
+      el.__swipe = state;
+      bindEvents(el, state);
+    },
+    updated(el, binding) {
+      var _a, _b;
+      const state = el.__swipe;
+      const newOptions = normalizeOptions$9(binding.value);
+      if (!state) {
+        const newState = setupState(el, newOptions);
+        if (newState) {
+          el.__swipe = newState;
+          bindEvents(el, newState);
+        }
+        return;
+      }
+      const wasDisabled = state.options.disabled;
+      const wasMouseEnabled = (_a = state.options.mouse) != null ? _a : true;
+      const nowMouseEnabled = (_b = newOptions.mouse) != null ? _b : true;
+      state.options = newOptions;
+      if (newOptions.disabled && !wasDisabled) {
+        unbindEvents(el, state);
+      } else if (!newOptions.disabled && wasDisabled) {
+        bindEvents(el, state);
+      } else if (wasMouseEnabled !== nowMouseEnabled) {
+        if (wasMouseEnabled) {
+          el.removeEventListener("mousedown", state.handlers.mouseDown);
+          el.removeEventListener("mouseup", state.handlers.mouseUp);
+          el.removeEventListener("mouseleave", state.handlers.mouseUp);
+        }
+        if (nowMouseEnabled) {
+          el.addEventListener("mousedown", state.handlers.mouseDown);
+          el.addEventListener("mouseup", state.handlers.mouseUp);
+          el.addEventListener("mouseleave", state.handlers.mouseUp);
+        }
+      }
+    },
+    unmounted(el) {
+      const state = el.__swipe;
+      if (!state) return;
+      unbindEvents(el, state);
+      delete el.__swipe;
+    }
+  });
+  function normalizeOptions$8(binding, directiveBinding) {
     const wait = parseTime(directiveBinding.arg) || 300;
     if (typeof binding === "function") {
       return { handler: binding, wait };
@@ -3897,7 +5025,7 @@ var __async = (__this, __arguments, generator) => {
       trailing: true
     },
     mounted(el, binding) {
-      const options = normalizeOptions$6(binding.value, binding);
+      const options = normalizeOptions$8(binding.value, binding);
       const eventType = getEventTypeFromModifiers(binding.modifiers) || getDefaultEventType(el);
       const throttledFn = throttle(options.handler, options.wait, {
         leading: options.leading,
@@ -3913,7 +5041,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__throttle;
       if (!state) return;
-      const newOptions = normalizeOptions$6(binding.value, binding);
+      const newOptions = normalizeOptions$8(binding.value, binding);
       if (newOptions.wait !== state.options.wait || newOptions.leading !== state.options.leading || newOptions.trailing !== state.options.trailing) {
         state.throttledFn.cancel();
         const throttledFn = throttle(newOptions.handler, newOptions.wait, {
@@ -4134,7 +5262,7 @@ var __async = (__this, __arguments, generator) => {
       document.removeEventListener("click", docHide);
     }
   }
-  function normalizeOptions$5(binding) {
+  function normalizeOptions$7(binding) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     if (typeof binding === "string") {
       return { content: binding, placement: "top", trigger: "hover" };
@@ -4172,7 +5300,7 @@ var __async = (__this, __arguments, generator) => {
     name: "tooltip",
     ssr: false,
     mounted(el, binding) {
-      const options = normalizeOptions$5(binding.value);
+      const options = normalizeOptions$7(binding.value);
       if (options.disabled || !options.content) return;
       const state = createState(options);
       el.__tooltip = state;
@@ -4181,7 +5309,7 @@ var __async = (__this, __arguments, generator) => {
     },
     updated(el, binding) {
       const state = el.__tooltip;
-      const newOptions = normalizeOptions$5(binding.value);
+      const newOptions = normalizeOptions$7(binding.value);
       if (!state) {
         if (!newOptions.disabled && newOptions.content) {
           const newState = createState(newOptions);
@@ -4227,7 +5355,7 @@ var __async = (__this, __arguments, generator) => {
     name: "touch",
     ssr: false,
     mounted(el, binding) {
-      const options = normalizeOptions$4(binding.value);
+      const options = normalizeOptions$6(binding.value);
       const state = {
         options,
         startX: 0,
@@ -4388,7 +5516,7 @@ var __async = (__this, __arguments, generator) => {
     },
     updated(el, binding) {
       const state = el.__touch;
-      if (state) state.options = normalizeOptions$4(binding.value);
+      if (state) state.options = normalizeOptions$6(binding.value);
     },
     unmounted(el) {
       const state = el.__touch;
@@ -4405,7 +5533,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__touch;
     }
   });
-  function normalizeOptions$4(binding) {
+  function normalizeOptions$6(binding) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     return {
       swipeThreshold: (_a = binding == null ? void 0 : binding.swipeThreshold) != null ? _a : 30,
@@ -4454,7 +5582,7 @@ var __async = (__this, __arguments, generator) => {
     name: "trim",
     ssr: true,
     mounted(el, binding) {
-      const options = normalizeOptions$3(binding.value);
+      const options = normalizeOptions$5(binding.value);
       if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
         setupInputElement(el, options);
       } else {
@@ -4463,7 +5591,7 @@ var __async = (__this, __arguments, generator) => {
       }
     },
     updated(el, binding) {
-      const options = normalizeOptions$3(binding.value);
+      const options = normalizeOptions$5(binding.value);
       const state = el.__trim;
       if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
         if (state) {
@@ -4521,7 +5649,7 @@ var __async = (__this, __arguments, generator) => {
       performTrim();
     }
   }
-  function normalizeOptions$3(binding) {
+  function normalizeOptions$5(binding) {
     var _a, _b, _c;
     if (binding === void 0 || binding === true) {
       return { position: "both", onInput: true, onBlur: true };
@@ -4561,7 +5689,7 @@ var __async = (__this, __arguments, generator) => {
     name: "truncate",
     ssr: true,
     mounted(el, binding) {
-      const options = normalizeOptions$2(binding.value);
+      const options = normalizeOptions$4(binding.value);
       const text = el.textContent || "";
       const state = {
         originalText: text,
@@ -4572,7 +5700,7 @@ var __async = (__this, __arguments, generator) => {
     },
     updated(el, binding) {
       const state = el.__truncate;
-      const newOptions = normalizeOptions$2(binding.value);
+      const newOptions = normalizeOptions$4(binding.value);
       if (state) {
         const originalText = state.originalText;
         if (JSON.stringify(newOptions) !== JSON.stringify(state.options)) {
@@ -4609,7 +5737,7 @@ var __async = (__this, __arguments, generator) => {
       }
     }
   }
-  function normalizeOptions$2(binding) {
+  function normalizeOptions$4(binding) {
     var _a, _b, _c, _d, _e;
     if (typeof binding === "number") {
       return {
@@ -4635,7 +5763,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return text.toUpperCase();
   }
-  function normalizeOptions$1(binding) {
+  function normalizeOptions$3(binding) {
     var _a, _b;
     if (binding === void 0 || binding === true) {
       return { first: false, onInput: true };
@@ -4652,7 +5780,7 @@ var __async = (__this, __arguments, generator) => {
     name: "uppercase",
     ssr: true,
     mounted(el, binding) {
-      const options = normalizeOptions$1(binding.value);
+      const options = normalizeOptions$3(binding.value);
       if (isInputElement(el)) {
         const cleanup2 = setupTextTransformInput(el, options, (text) => transformText(text, options));
         el.__uppercaseCleanup = cleanup2;
@@ -4661,7 +5789,7 @@ var __async = (__this, __arguments, generator) => {
       }
     },
     updated(el, binding) {
-      const options = normalizeOptions$1(binding.value);
+      const options = normalizeOptions$3(binding.value);
       if (isInputElement(el)) {
         if (options.onInput) {
           el.value = transformText(el.value, options);
@@ -4676,7 +5804,212 @@ var __async = (__this, __arguments, generator) => {
       delete el.__uppercaseCleanup;
     }
   });
-  function normalizeOptions(binding) {
+  function getItemSize(options, index) {
+    if (typeof options.itemSize === "function") {
+      return options.itemSize(index);
+    }
+    return options.itemSize || 50;
+  }
+  function calculateTotalHeight(options) {
+    if (typeof options.itemSize === "function") {
+      let total = 0;
+      for (let i = 0; i < options.items.length; i++) {
+        total += options.itemSize(i);
+      }
+      return total;
+    }
+    return (options.itemSize || 50) * options.items.length;
+  }
+  function calculateVisibleRange(scrollTop, containerHeight, options) {
+    const items = options.items;
+    const itemSize = options.itemSize || 50;
+    const overscan = options.overscan || 3;
+    let startIndex = 0, endIndex = 0, offsetY = 0;
+    if (typeof itemSize === "function") {
+      let currentOffset = 0;
+      for (let i = 0; i < items.length; i++) {
+        const size = itemSize(i);
+        if (currentOffset + size > scrollTop) {
+          startIndex = i;
+          offsetY = currentOffset;
+          break;
+        }
+        currentOffset += size;
+      }
+      endIndex = startIndex;
+      currentOffset = offsetY;
+      while (endIndex < items.length && currentOffset < scrollTop + containerHeight) {
+        currentOffset += itemSize(endIndex);
+        endIndex++;
+      }
+      startIndex = Math.max(0, startIndex - overscan);
+      endIndex = Math.min(items.length, endIndex + overscan);
+      currentOffset = 0;
+      for (let i = 0; i < startIndex; i++) {
+        currentOffset += itemSize(i);
+      }
+      offsetY = currentOffset;
+      return { startIndex, endIndex, offsetY };
+    }
+    startIndex = Math.max(0, Math.floor(scrollTop / itemSize) - overscan);
+    endIndex = Math.min(items.length, Math.ceil((scrollTop + containerHeight) / itemSize) + overscan);
+    offsetY = startIndex * itemSize;
+    return { startIndex, endIndex, offsetY };
+  }
+  function normalizeOptions$2(binding) {
+    var _a, _b, _c, _d;
+    if (Array.isArray(binding)) {
+      return {
+        items: binding,
+        itemSize: 50,
+        height: 400,
+        overscan: 3,
+        keyField: "id"
+      };
+    }
+    return {
+      items: binding.items,
+      itemSize: (_a = binding.itemSize) != null ? _a : 50,
+      height: (_b = binding.height) != null ? _b : 400,
+      overscan: (_c = binding.overscan) != null ? _c : 3,
+      render: binding.render,
+      keyField: (_d = binding.keyField) != null ? _d : "id",
+      onScroll: binding.onScroll,
+      onVisibleChange: binding.onVisibleChange
+    };
+  }
+  function createItemElement(item, index, options) {
+    const el = document.createElement("div");
+    el.className = "v-virtual-list__item";
+    el.dataset.index = String(index);
+    const keyField = options.keyField || "id";
+    if (typeof item === "object" && item !== null && keyField in item) {
+      el.dataset.key = String(item[keyField]);
+    }
+    const height = getItemSize(options, index);
+    el.style.height = `${height}px`;
+    el.style.boxSizing = "border-box";
+    if (options.render) {
+      el.innerHTML = options.render(item, index);
+    } else {
+      el.textContent = typeof item === "object" ? JSON.stringify(item) : String(item);
+    }
+    return el;
+  }
+  const vVirtualList = defineDirective({
+    name: "virtual-list",
+    ssr: false,
+    mounted(el, binding) {
+      const options = normalizeOptions$2(binding.value);
+      el.classList.add("v-virtual-list");
+      el.style.height = typeof options.height === "number" ? `${options.height}px` : options.height;
+      el.style.overflow = "auto";
+      el.style.position = "relative";
+      const contentEl = document.createElement("div");
+      contentEl.className = "v-virtual-list__content";
+      contentEl.style.position = "relative";
+      contentEl.style.height = `${calculateTotalHeight(options)}px`;
+      el.appendChild(contentEl);
+      const visibleEl = document.createElement("div");
+      visibleEl.className = "v-virtual-list__visible";
+      visibleEl.style.position = "absolute";
+      visibleEl.style.top = "0";
+      visibleEl.style.left = "0";
+      visibleEl.style.right = "0";
+      contentEl.appendChild(visibleEl);
+      const state = {
+        options,
+        containerEl: el,
+        contentEl,
+        scrollHandler: null,
+        resizeObserver: null,
+        startIndex: 0,
+        endIndex: 0,
+        visibleItems: []
+      };
+      el.__virtualList = state;
+      const scrollHandler = (_event) => {
+        const scrollTop = el.scrollTop;
+        const containerHeight = el.clientHeight;
+        const { startIndex: startIndex2, endIndex: endIndex2, offsetY: offsetY2 } = calculateVisibleRange(
+          scrollTop,
+          containerHeight,
+          state.options
+        );
+        if (startIndex2 !== state.startIndex || endIndex2 !== state.endIndex) {
+          state.startIndex = startIndex2;
+          state.endIndex = endIndex2;
+          renderVisibleItems(visibleEl, state, offsetY2);
+          if (state.options.onVisibleChange) {
+            state.options.onVisibleChange(startIndex2, endIndex2);
+          }
+        }
+        if (state.options.onScroll) {
+          state.options.onScroll(scrollTop);
+        }
+      };
+      state.scrollHandler = scrollHandler;
+      el.addEventListener("scroll", scrollHandler, { passive: true });
+      const { startIndex, endIndex, offsetY } = calculateVisibleRange(0, el.clientHeight, options);
+      state.startIndex = startIndex;
+      state.endIndex = endIndex;
+      renderVisibleItems(visibleEl, state, offsetY);
+      if (typeof ResizeObserver !== "undefined") {
+        const resizeObserver = new ResizeObserver(() => {
+          scrollHandler(new Event("scroll"));
+        });
+        resizeObserver.observe(el);
+        state.resizeObserver = resizeObserver;
+      }
+    },
+    updated(el, binding) {
+      var _a;
+      const state = el.__virtualList;
+      if (!state) return;
+      const newOptions = normalizeOptions$2(binding.value);
+      state.options = newOptions;
+      if (state.contentEl) {
+        state.contentEl.style.height = `${calculateTotalHeight(newOptions)}px`;
+      }
+      const scrollTop = el.scrollTop;
+      const containerHeight = el.clientHeight;
+      const { startIndex, endIndex, offsetY } = calculateVisibleRange(
+        scrollTop,
+        containerHeight,
+        newOptions
+      );
+      state.startIndex = startIndex;
+      state.endIndex = endIndex;
+      const visibleEl = (_a = state.contentEl) == null ? void 0 : _a.querySelector(".v-virtual-list__visible");
+      if (visibleEl) {
+        renderVisibleItems(visibleEl, state, offsetY);
+      }
+    },
+    unmounted(el) {
+      const state = el.__virtualList;
+      if (!state) return;
+      if (state.scrollHandler) {
+        el.removeEventListener("scroll", state.scrollHandler);
+      }
+      if (state.resizeObserver) {
+        state.resizeObserver.disconnect();
+      }
+      delete el.__virtualList;
+    }
+  });
+  function renderVisibleItems(visibleEl, state, offsetY) {
+    const { options, startIndex, endIndex } = state;
+    visibleEl.style.transform = `translateY(${offsetY}px)`;
+    visibleEl.innerHTML = "";
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = options.items[i];
+      if (item !== void 0) {
+        const itemEl = createItemElement(item, i, options);
+        visibleEl.appendChild(itemEl);
+      }
+    }
+  }
+  function normalizeOptions$1(binding) {
     if (typeof binding === "boolean") {
       return { initial: binding };
     }
@@ -4698,7 +6031,7 @@ var __async = (__this, __arguments, generator) => {
     mounted(el, binding) {
       var _a, _b;
       if (!isBrowser()) return;
-      const options = normalizeOptions(binding.value);
+      const options = normalizeOptions$1(binding.value);
       const originalDisplay = el.style.display;
       const originalVisibility = el.style.visibility;
       const state = {
@@ -4722,7 +6055,7 @@ var __async = (__this, __arguments, generator) => {
       var _a;
       const state = el.__visible;
       if (!state) return;
-      const newOptions = normalizeOptions(binding.value);
+      const newOptions = normalizeOptions$1(binding.value);
       let newVisibility;
       if (typeof binding.value === "boolean") {
         newVisibility = binding.value;
@@ -4783,12 +6116,178 @@ var __async = (__this, __arguments, generator) => {
       state.options.handler(isVisible);
     }
   }
+  function createWatermarkCanvas(options) {
+    var _a;
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("[Directix] v-watermark: Could not get canvas context");
+    }
+    const width = options.width || 300;
+    const height = options.height || 200;
+    const fontSize = options.fontSize || 16;
+    const fontFamily = options.fontFamily || "sans-serif";
+    const fontWeight = options.fontWeight || "normal";
+    const color = options.color || "rgba(128, 128, 128, 0.15)";
+    const rotate = (_a = options.rotate) != null ? _a : -22;
+    canvas.width = width;
+    canvas.height = height;
+    ctx.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
+    ctx.fillStyle = color;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.translate(width / 2, height / 2);
+    ctx.rotate(rotate * Math.PI / 180);
+    const content = Array.isArray(options.content) ? options.content : [options.content];
+    const lineHeight = fontSize * 1.5;
+    const startY = -((content.length - 1) * lineHeight) / 2;
+    content.forEach((text, index) => {
+      ctx.fillText(text, 0, startY + index * lineHeight);
+    });
+    return canvas;
+  }
+  function createWatermarkElement(canvas, options) {
+    var _a;
+    const gap = Array.isArray(options.gap) ? options.gap : [options.gap || 100, options.gap || 100];
+    const zIndex = (_a = options.zIndex) != null ? _a : 9999;
+    const el = document.createElement("div");
+    el.className = "v-watermark";
+    el.style.cssText = `
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		pointer-events: none;
+		z-index: ${zIndex};
+		background-image: url("${canvas.toDataURL()}");
+		background-repeat: repeat;
+		background-position: ${gap[0] / 2}px ${gap[1] / 2}px;
+		background-size: ${canvas.width + gap[0]}px ${canvas.height + gap[1]}px;
+	`;
+    return el;
+  }
+  function normalizeOptions(binding) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (typeof binding === "string") {
+      return { content: binding };
+    }
+    return {
+      content: binding.content,
+      width: (_a = binding.width) != null ? _a : 300,
+      height: (_b = binding.height) != null ? _b : 200,
+      rotate: (_c = binding.rotate) != null ? _c : -22,
+      fontSize: (_d = binding.fontSize) != null ? _d : 16,
+      fontFamily: (_e = binding.fontFamily) != null ? _e : "sans-serif",
+      fontWeight: (_f = binding.fontWeight) != null ? _f : "normal",
+      color: (_g = binding.color) != null ? _g : "rgba(128, 128, 128, 0.15)",
+      gap: (_h = binding.gap) != null ? _h : [100, 100],
+      zIndex: (_i = binding.zIndex) != null ? _i : 9999,
+      disabled: (_j = binding.disabled) != null ? _j : false,
+      protect: (_k = binding.protect) != null ? _k : true
+    };
+  }
+  const vWatermark = defineDirective({
+    name: "watermark",
+    ssr: true,
+    mounted(el, binding) {
+      const options = normalizeOptions(binding.value);
+      const computedStyle = getComputedStyle(el);
+      if (computedStyle.position === "static") {
+        el.style.position = "relative";
+      }
+      const state = {
+        options,
+        watermarkEl: null,
+        observer: null,
+        canvas: null
+      };
+      el.__watermark = state;
+      if (!options.disabled) {
+        applyWatermark(el, state);
+      }
+    },
+    updated(el, binding) {
+      const state = el.__watermark;
+      if (!state) return;
+      const newOptions = normalizeOptions(binding.value);
+      if (newOptions.disabled && !state.options.disabled) {
+        removeWatermark(state);
+      } else if (!newOptions.disabled && state.options.disabled) {
+        state.options = newOptions;
+        applyWatermark(el, state);
+      } else if (!newOptions.disabled) {
+        state.options = newOptions;
+        removeWatermark(state);
+        applyWatermark(el, state);
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__watermark;
+      if (!state) return;
+      removeWatermark(state);
+      delete el.__watermark;
+    }
+  });
+  function applyWatermark(el, state) {
+    const options = state.options;
+    state.canvas = createWatermarkCanvas(options);
+    state.watermarkEl = createWatermarkElement(state.canvas, options);
+    el.appendChild(state.watermarkEl);
+    if (options.protect) {
+      setupProtection(el, state);
+    }
+  }
+  function removeWatermark(state) {
+    if (state.observer) {
+      state.observer.disconnect();
+      state.observer = null;
+    }
+    if (state.watermarkEl && state.watermarkEl.parentNode) {
+      state.watermarkEl.parentNode.removeChild(state.watermarkEl);
+    }
+    state.watermarkEl = null;
+    state.canvas = null;
+  }
+  function setupProtection(el, state) {
+    if (typeof MutationObserver === "undefined") return;
+    state.observer = new MutationObserver((mutations) => {
+      if (!state.watermarkEl || !el.contains(state.watermarkEl)) {
+        if (!state.options.disabled) {
+          state.canvas = createWatermarkCanvas(state.options);
+          state.watermarkEl = createWatermarkElement(state.canvas, state.options);
+          el.appendChild(state.watermarkEl);
+        }
+      }
+      for (const mutation of mutations) {
+        if (mutation.type === "attributes" && mutation.target === state.watermarkEl) {
+          const gap = Array.isArray(state.options.gap) ? state.options.gap : [state.options.gap || 100, state.options.gap || 100];
+          state.watermarkEl.style.display = "block";
+          state.watermarkEl.style.visibility = "visible";
+          state.watermarkEl.style.opacity = "1";
+          if (state.canvas) {
+            state.watermarkEl.style.backgroundImage = `url("${state.canvas.toDataURL()}")`;
+          }
+          state.watermarkEl.style.backgroundSize = `${state.canvas.width + gap[0]}px ${state.canvas.height + gap[1]}px`;
+        }
+      }
+    });
+    state.observer.observe(el, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["style", "class", "hidden"]
+    });
+  }
   const allDirectives = {
     "click-outside": vClickOutside,
+    "click-delay": vClickDelay,
     copy: vCopy,
     debounce: vDebounce,
     throttle: vThrottle,
     focus: vFocus,
+    hotkey: vHotkey,
     lazy: vLazy,
     intersect: vIntersect,
     visible: vVisible,
@@ -4805,6 +6304,7 @@ var __async = (__this, __arguments, generator) => {
     resize: vResize,
     mutation: vMutation,
     truncate: vTruncate,
+    ellipsis: vEllipsis,
     uppercase: vUppercase,
     lowercase: vLowercase,
     capitalcase: vCapitalcase,
@@ -4814,7 +6314,13 @@ var __async = (__this, __arguments, generator) => {
     tooltip: vTooltip,
     draggable: vDraggable,
     touch: vTouch,
-    "image-preview": vImagePreview
+    swipe: vSwipe,
+    "image-preview": vImagePreview,
+    countdown: vCountdown,
+    watermark: vWatermark,
+    print: vPrint,
+    "virtual-list": vVirtualList,
+    "pull-refresh": vPullRefresh
   };
   const install = (app, options = {}) => {
     var _a, _b, _c, _d, _e, _f, _g;
@@ -4859,9 +6365,11 @@ var __async = (__this, __arguments, generator) => {
   exports.addCleanupVue2 = addCleanup$1;
   exports.addCleanupVue3 = addCleanup;
   exports.capitalcase = vCapitalcase;
+  exports.clickDelay = vClickDelay;
   exports.clickOutside = vClickOutside;
   exports.configurePermission = configurePermission;
   exports.copy = vCopy;
+  exports.countdown = vCountdown;
   exports.createVue2Directive = createVue2Directive;
   exports.createVue3Directive = createVue3Directive;
   exports.debounce = vDebounce;
@@ -4871,11 +6379,13 @@ var __async = (__this, __arguments, generator) => {
   exports.defineDirective = defineDirective;
   exports.defineDirectiveGroup = defineDirectiveGroup;
   exports.draggable = vDraggable;
+  exports.ellipsis = vEllipsis;
   exports.focus = vFocus;
   exports.generateId = generateId;
   exports.get = get;
   exports.getPermissionConfig = getPermissionConfig;
   exports.getVueVersion = getVueVersion;
+  exports.hotkey = vHotkey;
   exports.hover = vHover;
   exports.imagePreview = vImagePreview;
   exports.infiniteScroll = vInfiniteScroll;
@@ -4903,6 +6413,8 @@ var __async = (__this, __arguments, generator) => {
   exports.number = vNumber;
   exports.parseTime = parseTime;
   exports.permission = vPermission;
+  exports.print = vPrint;
+  exports.pullRefresh = vPullRefresh;
   exports.resetVueVersion = resetVueVersion;
   exports.resize = vResize;
   exports.ripple = vRipple;
@@ -4916,6 +6428,7 @@ var __async = (__this, __arguments, generator) => {
   exports.supportsMutationObserver = supportsMutationObserver;
   exports.supportsPassive = supportsPassive;
   exports.supportsResizeObserver = supportsResizeObserver;
+  exports.swipe = vSwipe;
   exports.throttle = vThrottle;
   exports.throttleFn = throttle;
   exports.tooltip = vTooltip;
@@ -4924,11 +6437,15 @@ var __async = (__this, __arguments, generator) => {
   exports.truncate = vTruncate;
   exports.uppercase = vUppercase;
   exports.vCapitalcase = vCapitalcase;
+  exports.vClickDelay = vClickDelay;
   exports.vClickOutside = vClickOutside;
   exports.vCopy = vCopy;
+  exports.vCountdown = vCountdown;
   exports.vDebounce = vDebounce;
   exports.vDraggable = vDraggable;
+  exports.vEllipsis = vEllipsis;
   exports.vFocus = vFocus;
+  exports.vHotkey = vHotkey;
   exports.vHover = vHover;
   exports.vImagePreview = vImagePreview;
   exports.vInfiniteScroll = vInfiniteScroll;
@@ -4942,19 +6459,26 @@ var __async = (__this, __arguments, generator) => {
   exports.vMutation = vMutation;
   exports.vNumber = vNumber;
   exports.vPermission = vPermission;
+  exports.vPrint = vPrint;
+  exports.vPullRefresh = vPullRefresh;
   exports.vResize = vResize;
   exports.vRipple = vRipple;
   exports.vSanitize = vSanitize;
   exports.vScroll = vScroll;
   exports.vSticky = vSticky;
+  exports.vSwipe = vSwipe;
   exports.vThrottle = vThrottle;
   exports.vTooltip = vTooltip;
   exports.vTouch = vTouch;
   exports.vTrim = vTrim;
   exports.vTruncate = vTruncate;
   exports.vUppercase = vUppercase;
+  exports.vVirtualList = vVirtualList;
   exports.vVisible = vVisible;
+  exports.vWatermark = vWatermark;
+  exports.virtualList = vVirtualList;
   exports.visible = vVisible;
+  exports.watermark = vWatermark;
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 })(this.Directix = this.Directix || {});
 //# sourceMappingURL=index.iife.js.map