directix 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -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.
@@ -58,7 +58,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 @@ function createVue2Directive(hooks) {
     },
     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 @@ function createVue2Directive(hooks) {
       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 @@ function createVue2Directive(hooks) {
     },
     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 @@ function createVue2Directive(hooks) {
   };
   return directive;
 }
-function normalizeBinding(binding) {
+function normalizeBinding$1(binding) {
   var _a;
   return {
     value: binding.value,
@@ -483,7 +483,7 @@ function capitalizeWord(word) {
   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 @@ const vCapitalcase = defineDirective({
   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 @@ const vCapitalcase = defineDirective({
     }
   },
   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 @@ const vCapitalcase = defineDirective({
     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 @@ function getScrollParent(el) {
 }
 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 @@ const vClickOutside = defineDirective({
     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 @@ const vClickOutside = defineDirective({
     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 @@ const vClickOutside = defineDirective({
     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 @@ const vCopy = defineDirective({
   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 @@ const vCopy = defineDirective({
   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 @@ const vCopy = defineDirective({
     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 @@ function getDefaultEventType(el) {
   }
   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 @@ const vDebounce = defineDirective({
     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 @@ const vDebounce = defineDirective({
   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 @@ function parseTranslate(transform) {
   }
   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 @@ const vDraggable = defineDirective({
   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 @@ const vDraggable = defineDirective({
   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 @@ const vDraggable = defineDirective({
     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 @@ const vFocus = defineDirective({
   },
   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 @@ const vFocus = defineDirective({
   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 @@ const vFocus = defineDirective({
     delete el.__focus;
   }
 });
-function normalizeOptions$n(binding) {
+function normalizeOptions$s(binding) {
   if (typeof binding === "boolean") {
     return { focus: binding, refocus: false };
   }
@@ -1359,7 +1761,181 @@ function isFocusable(el) {
   }
   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 @@ const vHover = defineDirective({
     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 @@ const vHover = defineDirective({
   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 @@ function createGestureHandlers(state, transformManager, closePreview) {
   };
   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 @@ const vImagePreview = defineDirective({
   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 @@ const vImagePreview = defineDirective({
   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 @@ const vImagePreview = defineDirective({
     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 @@ const vInfiniteScroll = defineDirective({
     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 @@ const vInfiniteScroll = defineDirective({
   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 @@ function setupIntersectionObserver(el, state) {
   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 @@ const vIntersect = defineDirective({
     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 @@ const vIntersect = defineDirective({
     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 @@ function unobserve(el) {
     globalObserver.unobserve(el);
   }
 }
-function normalizeOptions$i(binding) {
+function normalizeOptions$n(binding) {
   if (typeof binding === "string") {
     return { src: binding };
   }
@@ -2267,7 +2843,7 @@ const vLazy = defineDirective({
     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 @@ const vLazy = defineDirective({
   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 @@ const vLazy = defineDirective({
     delete el.__lazy;
   }
 });
-function normalizeOptions$h(binding) {
+function normalizeOptions$m(binding) {
   if (typeof binding === "boolean") {
     return { value: binding };
   }
@@ -2374,7 +2950,7 @@ const vLoading = defineDirective({
   },
   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 @@ const vLoading = defineDirective({
   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 @@ function hideLoading(el, state) {
   }
   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 @@ const vLongPress = defineDirective({
     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 @@ const vLongPress = defineDirective({
   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 @@ function transformText$1(text, options) {
   }
   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 @@ const vLowercase = defineDirective({
   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 @@ const vLowercase = defineDirective({
     }
   },
   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 @@ function parseMask(mask, placeholder) {
     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 @@ const vMask = defineDirective({
       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 @@ const vMask = defineDirective({
   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 @@ const vMoney = defineDirective({
     delete el.__money;
   }
 });
-function normalizeOptions$d(binding) {
+function normalizeOptions$i(binding) {
   if (typeof binding === "function") {
     return { handler: binding, childList: true };
   }
@@ -2987,7 +3563,7 @@ const vMutation = defineDirective({
     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 @@ const vMutation = defineDirective({
   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 @@ function configurePermission(config) {
 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 @@ function getState(el) {
 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 @@ const vPermission = defineDirective({
     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 @@ const vResize = defineDirective({
     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 @@ const vResize = defineDirective({
   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 @@ const vResize = defineDirective({
     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 @@ const vRipple = defineDirective({
     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 @@ const vRipple = defineDirective({
   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 @@ const DEFAULT_ALLOWED_TAGS = ["b", "i", "u", "strong", "em", "br", "p", "span",
 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 @@ const vSanitize = defineDirective({
   },
   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 @@ const vSanitize = defineDirective({
   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 @@ function getScrollInfo(container, lastScrollLeft, lastScrollTop) {
     container
   };
 }
-function normalizeOptions$8(binding) {
+function normalizeOptions$b(binding) {
   if (typeof binding === "function") {
     return { handler: binding, passive: true };
   }
@@ -3687,7 +4629,7 @@ const vScroll = defineDirective({
     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 @@ const vScroll = defineDirective({
   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 @@ const vScroll = defineDirective({
   }
 });
 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 @@ const vSticky = defineDirective({
   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 @@ const vSticky = defineDirective({
   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 @@ const vSticky = defineDirective({
     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 @@ const vThrottle = defineDirective({
     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 @@ const vThrottle = defineDirective({
   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 @@ function removeTriggerHandlers(el, state) {
     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 @@ const vTooltip = defineDirective({
   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 @@ const vTooltip = defineDirective({
   },
   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 @@ const vTouch = defineDirective({
   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 @@ const vTouch = defineDirective({
   },
   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 @@ const vTouch = defineDirective({
     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 @@ const vTrim = defineDirective({
   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 @@ const vTrim = defineDirective({
     }
   },
   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 @@ function setupInputElement(el, options) {
     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 @@ const vTruncate = defineDirective({
   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 @@ const vTruncate = defineDirective({
   },
   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 @@ function applyTruncation(el, text, options) {
     }
   }
 }
-function normalizeOptions$2(binding) {
+function normalizeOptions$4(binding) {
   var _a, _b, _c, _d, _e;
   if (typeof binding === "number") {
     return {
@@ -4635,7 +5763,7 @@ function transformText(text, options) {
   }
   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 @@ const vUppercase = defineDirective({
   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 @@ const vUppercase = defineDirective({
     }
   },
   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 @@ const vUppercase = defineDirective({
     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 @@ const vVisible = defineDirective({
   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 @@ const vVisible = defineDirective({
     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 @@ function applyVisibility(el, state, isVisible) {
     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 @@ const allDirectives = {
   resize: vResize,
   mutation: vMutation,
   truncate: vTruncate,
+  ellipsis: vEllipsis,
   uppercase: vUppercase,
   lowercase: vLowercase,
   capitalcase: vCapitalcase,
@@ -4814,7 +6314,13 @@ const allDirectives = {
   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 @@ exports.Directix = Directix;
 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 @@ exports.deepMerge = deepMerge;
 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 @@ exports.mutation = vMutation;
 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 @@ exports.supportsIntersectionObserver = supportsIntersectionObserver;
 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 @@ exports.trim = vTrim;
 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,17 +6459,24 @@ exports.vMoney = vMoney;
 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;
 //# sourceMappingURL=index.cjs.map