directix 1.3.0 → 1.4.0

package/dist/index.iife.js

@@ -1,5 +1,5 @@
 /*!
- * directix v1.3.0
+ * directix v1.4.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,12 +57,12 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 /*!
- * directix v1.3.0
+ * directix v1.4.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.
  */
-(function(exports) {
+(function(exports, vue) {
   "use strict";
   function createVue2Directive(hooks) {
     const directive = {
@@ -218,8 +218,8 @@ var __async = (__this, __arguments, generator) => {
       }
     }
     try {
-      const vue = require("vue");
-      const version = parseVersion(vue == null ? void 0 : vue.version);
+      const vue2 = require("vue");
+      const version = parseVersion(vue2 == null ? void 0 : vue2.version);
       if (version !== null) {
         _vueVersion = version;
         return _vueVersion;
@@ -228,19 +228,19 @@ var __async = (__this, __arguments, generator) => {
     }
     if (typeof window !== "undefined") {
       const win = window;
-      const vue = win.Vue;
-      if (vue == null ? void 0 : vue.version) {
-        const version = parseVersion(vue.version);
+      const vue2 = win.Vue;
+      if (vue2 == null ? void 0 : vue2.version) {
+        const version = parseVersion(vue2.version);
         if (version !== null) {
           _vueVersion = version;
           return _vueVersion;
         }
       }
-      if (typeof (vue == null ? void 0 : vue.observable) === "function") {
+      if (typeof (vue2 == null ? void 0 : vue2.observable) === "function") {
         _vueVersion = 2;
         return _vueVersion;
       }
-      if (typeof (vue == null ? void 0 : vue.createApp) === "function" && typeof (vue == null ? void 0 : vue.observable) !== "function") {
+      if (typeof (vue2 == null ? void 0 : vue2.createApp) === "function" && typeof (vue2 == null ? void 0 : vue2.observable) !== "function") {
         _vueVersion = 3;
         return _vueVersion;
       }
@@ -442,7 +442,7 @@ var __async = (__this, __arguments, generator) => {
   function isInputElement(el) {
     return el.tagName === "INPUT" || el.tagName === "TEXTAREA";
   }
-  const DEFAULT_KEEP_LOWER = [
+  const DEFAULT_KEEP_LOWER$1 = [
     "a",
     "an",
     "the",
@@ -461,25 +461,25 @@ var __async = (__this, __arguments, generator) => {
     "with",
     "as"
   ];
-  function capitalizeText(text, options) {
+  function capitalizeText$1(text, options) {
     if (!text) return text;
-    const { every = true, keepLower = DEFAULT_KEEP_LOWER } = options;
+    const { every = true, keepLower = DEFAULT_KEEP_LOWER$1 } = options;
     if (every) {
       const words = text.toLowerCase().split(/\s+/);
       return words.map((word, index) => {
         if (index === 0) {
-          return capitalizeWord(word);
+          return capitalizeWord$1(word);
         }
         if (keepLower.includes(word.toLowerCase())) {
           return word.toLowerCase();
         }
-        return capitalizeWord(word);
+        return capitalizeWord$1(word);
       }).join(" ");
     } else {
-      return capitalizeWord(text);
+      return capitalizeWord$1(text);
     }
   }
-  function capitalizeWord(word) {
+  function capitalizeWord$1(word) {
     if (!word) return word;
     return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
   }
@@ -493,7 +493,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return {
       every: (_a = binding.every) != null ? _a : true,
-      keepLower: (_b = binding.keepLower) != null ? _b : DEFAULT_KEEP_LOWER,
+      keepLower: (_b = binding.keepLower) != null ? _b : DEFAULT_KEEP_LOWER$1,
       onInput: (_c = binding.onInput) != null ? _c : true
     };
   }
@@ -503,20 +503,20 @@ var __async = (__this, __arguments, generator) => {
     mounted(el, binding) {
       const options = normalizeOptions$B(binding.value);
       if (isInputElement(el)) {
-        const cleanup2 = setupTextTransformInput(el, options, (text) => capitalizeText(text, options));
+        const cleanup2 = setupTextTransformInput(el, options, (text) => capitalizeText$1(text, options));
         el.__capitalcaseCleanup = cleanup2;
       } else {
-        transformTextContent(el, (text) => capitalizeText(text, options));
+        transformTextContent(el, (text) => capitalizeText$1(text, options));
       }
     },
     updated(el, binding) {
       const options = normalizeOptions$B(binding.value);
       if (isInputElement(el)) {
         if (options.onInput) {
-          el.value = capitalizeText(el.value, options);
+          el.value = capitalizeText$1(el.value, options);
         }
       } else {
-        transformTextContent(el, (text) => capitalizeText(text, options));
+        transformTextContent(el, (text) => capitalizeText$1(text, options));
       }
     },
     unmounted(el) {
@@ -525,133 +525,15 @@ 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);
-    }
+  const STATE_PREFIX = "__directix_";
+  function setState$1(el, key, state) {
+    el[STATE_PREFIX + key] = state;
   }
-  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 getState$1(el, key) {
+    return el[STATE_PREFIX + key];
   }
-  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 deleteState(el, key) {
+    delete el[STATE_PREFIX + key];
   }
   function isElement(value) {
     return value instanceof Element;
@@ -678,15 +560,15 @@ var __async = (__this, __arguments, generator) => {
   }
   function on(target, event, handler, options = false) {
     if (!isBrowser()) return;
-    const opts = normalizeOptions$z(options);
+    const opts = normalizeOptions$A(options);
     target.addEventListener(event, handler, opts);
   }
   function off(target, event, handler, options = false) {
     if (!isBrowser()) return;
-    const opts = normalizeOptions$z(options);
+    const opts = normalizeOptions$A(options);
     target.removeEventListener(event, handler, opts);
   }
-  function normalizeOptions$z(options) {
+  function normalizeOptions$A(options) {
     if (typeof options === "boolean") {
       return options;
     }
@@ -696,7 +578,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return capture;
   }
-  function getEventPosition(e) {
+  function getEventPosition$1(e) {
     let clientX = 0, clientY = 0;
     if ("touches" in e && e.touches.length > 0) {
       clientX = e.touches[0].clientX;
@@ -712,6 +594,58 @@ var __async = (__this, __arguments, generator) => {
       clientY
     };
   }
+  function bindEvents$2(target, events, options = false) {
+    Object.entries(events).forEach(([event, handler]) => {
+      target.addEventListener(event, handler, typeof options === "boolean" ? options : normalizeOptionsObject(options));
+    });
+    return () => {
+      Object.entries(events).forEach(([event, handler]) => {
+        target.removeEventListener(event, handler, typeof options === "boolean" ? options : normalizeOptionsObject(options));
+      });
+    };
+  }
+  function normalizeOptionsObject(options) {
+    const { capture = false, passive = false, once = false } = options;
+    if (supportsPassive()) {
+      return { capture, passive, once };
+    }
+    return capture;
+  }
+  const EVENT_MODIFIERS = [
+    "click",
+    "input",
+    "change",
+    "submit",
+    "scroll",
+    "resize",
+    "mouseenter",
+    "mouseleave",
+    "mousemove",
+    "mousedown",
+    "mouseup",
+    "keydown",
+    "keyup",
+    "focus",
+    "blur",
+    "touchstart",
+    "touchmove",
+    "touchend"
+  ];
+  function getEventTypeFromModifiers(modifiers) {
+    for (const modifier of EVENT_MODIFIERS) {
+      if (modifiers[modifier]) {
+        return modifier;
+      }
+    }
+    return null;
+  }
+  function getDefaultEventType(el) {
+    const tagName = el.tagName.toLowerCase();
+    if (tagName === "input" || tagName === "textarea") {
+      return "input";
+    }
+    return "click";
+  }
   function isString(value) {
     return typeof value === "string";
   }
@@ -898,53 +832,171 @@ var __async = (__this, __arguments, generator) => {
   function generateId(prefix = "") {
     return `${prefix}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 9)}`;
   }
-  const vClickOutside = defineDirective({
-    name: "click-outside",
-    ssr: false,
+  const STATE_KEY$5 = "clickDelay";
+  function removePendingClass(el, options) {
+    if (options.feedback && options.pendingClass) {
+      el.classList.remove(options.pendingClass);
+    }
+  }
+  function createClickHandler(el, options) {
+    return (event) => {
+      const state = getState$1(el, STATE_KEY$5);
+      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 normalizeOptions$z(binding, directiveBinding) {
+    var _a, _b, _c, _d;
+    const delay = parseTime(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
+    };
+  }
+  const vClickDelay = defineDirective({
+    name: "click-delay",
+    ssr: true,
     defaults: {
-      capture: true,
-      events: ["click"],
+      delay: 300,
       disabled: false,
-      stop: false,
-      prevent: false
+      pendingClass: "v-click-delay--pending",
+      feedback: true
     },
     mounted(el, binding) {
-      const options = normalizeOptions$y(binding.value);
+      const options = normalizeOptions$z(binding.value, binding);
       if (options.disabled) return;
       const state = {
         options,
-        handlers: /* @__PURE__ */ new Map()
-      };
-      el.__clickOutside = state;
-      const createHandler = (_eventType) => {
-        return (event) => {
-          if (!isValidClick(el, event, options)) {
-            return;
-          }
-          if (options.stop) {
-            event.stopPropagation();
-          }
-          if (options.prevent) {
-            event.preventDefault();
-          }
-          options.handler(event);
-        };
+        handler: createClickHandler(el, options),
+        isPending: false,
+        timeoutId: null
       };
-      options.events.forEach((eventType) => {
-        const handler = createHandler();
-        state.handlers.set(eventType, handler);
-        const listenerOptions = {
-          capture: options.capture,
-          passive: !options.prevent
-        };
-        on(document, eventType, handler, listenerOptions);
-      });
+      setState$1(el, STATE_KEY$5, state);
+      el.addEventListener("click", state.handler);
+      el.addEventListener("touchend", state.handler);
     },
     updated(el, binding) {
-      const state = el.__clickOutside;
-      if (!state) return;
-      const oldOptions = state.options;
-      const newOptions = normalizeOptions$y(binding.value);
+      const state = getState$1(el, STATE_KEY$5);
+      if (!state) {
+        const options = normalizeOptions$z(binding.value, binding);
+        if (!options.disabled) {
+          const newState = {
+            options,
+            handler: createClickHandler(el, options),
+            isPending: false,
+            timeoutId: null
+          };
+          setState$1(el, STATE_KEY$5, newState);
+          el.addEventListener("click", newState.handler);
+          el.addEventListener("touchend", newState.handler);
+        }
+        return;
+      }
+      const newOptions = normalizeOptions$z(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);
+        deleteState(el, STATE_KEY$5);
+      } 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 = getState$1(el, STATE_KEY$5);
+      if (!state) return;
+      el.removeEventListener("click", state.handler);
+      el.removeEventListener("touchend", state.handler);
+      if (state.timeoutId) {
+        clearTimeout(state.timeoutId);
+      }
+      removePendingClass(el, state.options);
+      deleteState(el, STATE_KEY$5);
+    }
+  });
+  const vClickOutside = defineDirective({
+    name: "click-outside",
+    ssr: false,
+    defaults: {
+      capture: true,
+      events: ["click"],
+      disabled: false,
+      stop: false,
+      prevent: false
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$y(binding.value);
+      if (options.disabled) return;
+      const state = {
+        options,
+        handlers: /* @__PURE__ */ new Map()
+      };
+      el.__clickOutside = state;
+      const createHandler = (_eventType) => {
+        return (event) => {
+          if (!isValidClick$1(el, event, options)) {
+            return;
+          }
+          if (options.stop) {
+            event.stopPropagation();
+          }
+          if (options.prevent) {
+            event.preventDefault();
+          }
+          options.handler(event);
+        };
+      };
+      options.events.forEach((eventType) => {
+        const handler = createHandler();
+        state.handlers.set(eventType, handler);
+        const listenerOptions = {
+          capture: options.capture,
+          passive: !options.prevent
+        };
+        on(document, eventType, handler, listenerOptions);
+      });
+    },
+    updated(el, binding) {
+      const state = el.__clickOutside;
+      if (!state) return;
+      const oldOptions = state.options;
+      const newOptions = normalizeOptions$y(binding.value);
       if (oldOptions.disabled !== newOptions.disabled) {
         if (newOptions.disabled) {
           state.handlers.forEach((handler, eventType) => {
@@ -954,7 +1006,7 @@ var __async = (__this, __arguments, generator) => {
         } else {
           const createHandler = (_eventType) => {
             return (event) => {
-              if (!isValidClick(el, event, newOptions)) return;
+              if (!isValidClick$1(el, event, newOptions)) return;
               if (newOptions.stop) event.stopPropagation();
               if (newOptions.prevent) event.preventDefault();
               newOptions.handler(event);
@@ -1004,7 +1056,7 @@ var __async = (__this, __arguments, generator) => {
       prevent: (_e = binding.prevent) != null ? _e : false
     }, binding);
   }
-  function isValidClick(el, event, options) {
+  function isValidClick$1(el, event, options) {
     var _a;
     const target = event.target;
     if (el.contains(target)) {
@@ -1020,7 +1072,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return true;
   }
-  function copyToClipboard(text) {
+  function copyToClipboard$1(text) {
     return __async(this, null, function* () {
       if (supportsClipboard()) {
         try {
@@ -1030,10 +1082,10 @@ var __async = (__this, __arguments, generator) => {
           console.warn("[Directix] Clipboard API failed, falling back to execCommand");
         }
       }
-      return copyWithExecCommand(text);
+      return copyWithExecCommand$1(text);
     });
   }
-  function copyWithExecCommand(text) {
+  function copyWithExecCommand$1(text) {
     const textarea = document.createElement("textarea");
     textarea.value = text;
     textarea.style.cssText = `
@@ -1075,7 +1127,7 @@ var __async = (__this, __arguments, generator) => {
           return;
         }
         try {
-          const success = yield copyToClipboard(text);
+          const success = yield copyToClipboard$1(text);
           if (success) {
             (_b = (_a = state.options).onSuccess) == null ? void 0 : _b.call(_a, text);
             el.dispatchEvent(new CustomEvent("copy:success", { detail: { text } }));
@@ -1112,7 +1164,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return binding;
   }
-  function parseTargetTime(target) {
+  function parseTargetTime$1(target) {
     if (target instanceof Date) {
       return target.getTime();
     }
@@ -1121,7 +1173,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return new Date(target).getTime();
   }
-  function calculateTime(remaining) {
+  function calculateTime$1(remaining) {
     const total = Math.max(0, remaining);
     return {
       days: Math.floor(total / (1e3 * 60 * 60 * 24)),
@@ -1132,7 +1184,7 @@ var __async = (__this, __arguments, generator) => {
       total
     };
   }
-  function formatTime(time, format) {
+  function formatTime$1(time, format) {
     if (typeof format === "function") {
       return format(time);
     }
@@ -1167,7 +1219,7 @@ var __async = (__this, __arguments, generator) => {
     ssr: true,
     mounted(el, binding) {
       const options = normalizeOptions$w(binding.value);
-      const targetTime = parseTargetTime(options.target);
+      const targetTime = parseTargetTime$1(options.target);
       const state = {
         options,
         targetTime,
@@ -1185,7 +1237,7 @@ var __async = (__this, __arguments, generator) => {
     updated(el, binding) {
       const state = el.__countdown;
       const newOptions = normalizeOptions$w(binding.value);
-      const newTargetTime = parseTargetTime(newOptions.target);
+      const newTargetTime = parseTargetTime$1(newOptions.target);
       if (newTargetTime !== state.targetTime) {
         state.targetTime = newTargetTime;
         state.options = newOptions;
@@ -1224,7 +1276,7 @@ var __async = (__this, __arguments, generator) => {
       }
       updateDisplay(el, state);
       if (state.options.onTick) {
-        const time = calculateTime(state.remaining);
+        const time = calculateTime$1(state.remaining);
         state.options.onTick(time);
       }
     };
@@ -1238,45 +1290,10 @@ var __async = (__this, __arguments, generator) => {
     }
   }
   function updateDisplay(el, state) {
-    const time = calculateTime(state.remaining);
-    const display = formatTime(time, state.options.format || "hh:mm:ss");
+    const time = calculateTime$1(state.remaining);
+    const display = formatTime$1(time, state.options.format || "hh:mm:ss");
     el.textContent = display;
   }
-  const EVENT_MODIFIERS = [
-    "click",
-    "input",
-    "change",
-    "submit",
-    "scroll",
-    "resize",
-    "mouseenter",
-    "mouseleave",
-    "mousemove",
-    "mousedown",
-    "mouseup",
-    "keydown",
-    "keyup",
-    "focus",
-    "blur",
-    "touchstart",
-    "touchmove",
-    "touchend"
-  ];
-  function getEventTypeFromModifiers(modifiers) {
-    for (const modifier of EVENT_MODIFIERS) {
-      if (modifiers[modifier]) {
-        return modifier;
-      }
-    }
-    return null;
-  }
-  function getDefaultEventType(el) {
-    const tagName = el.tagName.toLowerCase();
-    if (tagName === "input" || tagName === "textarea") {
-      return "input";
-    }
-    return "click";
-  }
   function normalizeOptions$v(binding, directiveBinding) {
     const wait = parseTime(directiveBinding.arg) || 300;
     if (typeof binding === "function") {
@@ -1336,7 +1353,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__debounce;
     }
   });
-  function getBoundary(_el, boundary) {
+  function getBoundary$1(_el, boundary) {
     var _a, _b;
     if (!boundary) return null;
     if (typeof boundary === "function") {
@@ -1349,7 +1366,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return boundary.getBoundingClientRect();
   }
-  function getClientCoords(e) {
+  function getClientCoords$1(e) {
     if (e.type.startsWith("touch")) {
       const touch = e.touches[0];
       return { clientX: touch.clientX, clientY: touch.clientY };
@@ -1357,7 +1374,7 @@ var __async = (__this, __arguments, generator) => {
     const mouseEvent = e;
     return { clientX: mouseEvent.clientX, clientY: mouseEvent.clientY };
   }
-  function parseTranslate(transform) {
+  function parseTranslate$1(transform) {
     const match = transform.match(/translate\(([-\d.]+)px,\s*([-\d.]+)px\)/);
     if (match) {
       return { x: parseFloat(match[1]), y: parseFloat(match[2]) };
@@ -1420,15 +1437,15 @@ var __async = (__this, __arguments, generator) => {
         if (e.type === "touchstart") {
           e.preventDefault();
         }
-        const { clientX, clientY } = getClientCoords(e);
+        const { clientX, clientY } = getClientCoords$1(e);
         state.isDragging = true;
         state.startX = clientX;
         state.startY = clientY;
-        const { x, y } = parseTranslate(el.style.transform);
+        const { x, y } = parseTranslate$1(el.style.transform);
         state.offsetX = x;
         state.offsetY = y;
         if (state.options.constrain || state.options.boundary) {
-          const boundary = state.options.boundary ? getBoundary(el, state.options.boundary) : (_a = el.parentElement) == null ? void 0 : _a.getBoundingClientRect();
+          const boundary = state.options.boundary ? getBoundary$1(el, state.options.boundary) : (_a = el.parentElement) == null ? void 0 : _a.getBoundingClientRect();
           if (boundary) {
             const elRect = el.getBoundingClientRect();
             state.initialLeft = elRect.left - boundary.left;
@@ -1443,7 +1460,7 @@ var __async = (__this, __arguments, generator) => {
         state.moveHandler = (moveEvent) => {
           var _a2, _b2;
           if (!state.isDragging) return;
-          const { clientX: moveX, clientY: moveY } = getClientCoords(moveEvent);
+          const { clientX: moveX, clientY: moveY } = getClientCoords$1(moveEvent);
           let deltaX = moveX - state.startX, deltaY = moveY - state.startY;
           if (state.options.axis === "x") {
             deltaY = 0;
@@ -1481,7 +1498,7 @@ var __async = (__this, __arguments, generator) => {
             document.removeEventListener("mouseup", state.endHandler);
             document.removeEventListener("touchend", state.endHandler);
           }
-          const { x: finalX, y: finalY } = parseTranslate(el.style.transform);
+          const { x: finalX, y: finalY } = parseTranslate$1(el.style.transform);
           (_b2 = (_a2 = state.options).onEnd) == null ? void 0 : _b2.call(_a2, { x: finalX, y: finalY }, new MouseEvent("mouseup"));
         };
         document.addEventListener("mousemove", state.moveHandler);
@@ -1657,7 +1674,7 @@ var __async = (__this, __arguments, generator) => {
       titleBehavior: (_d = binding == null ? void 0 : binding.titleBehavior) != null ? _d : "auto"
     };
   }
-  const FOCUSABLE_TAGS = /* @__PURE__ */ new Set(["input", "textarea", "select", "button"]);
+  const FOCUSABLE_TAGS$1 = /* @__PURE__ */ new Set(["input", "textarea", "select", "button"]);
   function isEqual(a, b) {
     if (a === b) return true;
     if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
@@ -1679,7 +1696,7 @@ var __async = (__this, __arguments, generator) => {
     mounted(el, binding) {
       if (!isBrowser()) return;
       const options = normalizeOptions$s(binding.value);
-      if (!options.focus || !isFocusable(el)) {
+      if (!options.focus || !isFocusable$1(el)) {
         if (options.focus) {
           console.warn("[Directix] v-focus: Element is not focusable");
         }
@@ -1747,10 +1764,10 @@ var __async = (__this, __arguments, generator) => {
       refocus: false
     }, binding);
   }
-  function isFocusable(el) {
+  function isFocusable$1(el) {
     if (!isBrowser()) return false;
     const tagName = el.tagName.toLowerCase();
-    if (FOCUSABLE_TAGS.has(tagName)) {
+    if (FOCUSABLE_TAGS$1.has(tagName)) {
       return !el.disabled;
     }
     if (el.isContentEditable) return true;
@@ -1761,7 +1778,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return false;
   }
-  const KEY_ALIASES = {
+  const KEY_ALIASES$1 = {
     esc: "escape",
     space: " ",
     up: "arrowup",
@@ -1793,7 +1810,7 @@ var __async = (__this, __arguments, generator) => {
   const MODIFIER_KEYS = /* @__PURE__ */ new Set(["ctrl", "alt", "shift", "meta"]);
   function normalizeKey(key) {
     const lowerKey = key.toLowerCase();
-    return KEY_ALIASES[lowerKey] || lowerKey;
+    return KEY_ALIASES$1[lowerKey] || lowerKey;
   }
   function parseHotkeyString(hotkey) {
     const parts = hotkey.toLowerCase().split(/[+.]/);
@@ -1808,7 +1825,7 @@ var __async = (__this, __arguments, generator) => {
     }
     return { key, modifiers };
   }
-  function matchesHotkey(event, entry) {
+  function matchesHotkey$1(event, entry) {
     if (normalizeKey(event.key) !== entry.key) return false;
     const eventModifiers = /* @__PURE__ */ new Set();
     if (event.ctrlKey) eventModifiers.add("ctrl");
@@ -1895,7 +1912,7 @@ var __async = (__this, __arguments, generator) => {
     return (event) => {
       for (const entry of state.entries) {
         if (entry.disabled) continue;
-        if (!matchesHotkey(event, entry)) continue;
+        if (!matchesHotkey$1(event, entry)) continue;
         if (entry.prevent) event.preventDefault();
         if (entry.stop) event.stopPropagation();
         entry.handler(event);
@@ -1935,6 +1952,61 @@ var __async = (__this, __arguments, generator) => {
       delete el.__hotkey;
     }
   });
+  function useTimer() {
+    const timeouts = /* @__PURE__ */ new Set();
+    const intervals = /* @__PURE__ */ new Set();
+    return {
+      /**
+       * Set a timeout (tracked for cleanup)
+       */
+      setTimeout(fn, delay) {
+        const id = setTimeout(() => {
+          timeouts.delete(id);
+          fn();
+        }, delay);
+        timeouts.add(id);
+        return id;
+      },
+      /**
+       * Clear a specific timeout
+       */
+      clearTimeout(id) {
+        clearTimeout(id);
+        timeouts.delete(id);
+      },
+      /**
+       * Set an interval (tracked for cleanup)
+       */
+      setInterval(fn, delay) {
+        const id = setInterval(fn, delay);
+        intervals.add(id);
+        return id;
+      },
+      /**
+       * Clear a specific interval
+       */
+      clearInterval(id) {
+        clearInterval(id);
+        intervals.delete(id);
+      },
+      /**
+       * Clear all tracked timers
+       */
+      clearAll() {
+        timeouts.forEach((id) => clearTimeout(id));
+        intervals.forEach((id) => clearInterval(id));
+        timeouts.clear();
+        intervals.clear();
+      },
+      /**
+       * Check if there are any active timers
+       */
+      hasActive() {
+        return timeouts.size > 0 || intervals.size > 0;
+      }
+    };
+  }
+  const STATE_KEY$4 = "hover";
   function normalizeOptions$r(binding) {
     if (typeof binding === "function") {
       return { handler: binding, class: "v-hover" };
@@ -1946,6 +2018,26 @@ var __async = (__this, __arguments, generator) => {
       leaveDelay: 0
     }, binding);
   }
+  function applyHoverState(el, state, e) {
+    var _a, _b;
+    const { options } = state;
+    if (options.class) {
+      el.classList.add(options.class);
+    }
+    el.dispatchEvent(new CustomEvent("hover:enter", { detail: { event: e } }));
+    (_a = options.onEnter) == null ? void 0 : _a.call(options, e);
+    (_b = options.handler) == null ? void 0 : _b.call(options, true, e);
+  }
+  function applyLeaveState(el, state, e) {
+    var _a, _b;
+    const { options } = state;
+    if (options.class) {
+      el.classList.remove(options.class);
+    }
+    el.dispatchEvent(new CustomEvent("hover:leave", { detail: { event: e } }));
+    (_a = options.onLeave) == null ? void 0 : _a.call(options, e);
+    (_b = options.handler) == null ? void 0 : _b.call(options, false, e);
+  }
   const vHover = defineDirective({
     name: "hover",
     ssr: false,
@@ -1958,56 +2050,54 @@ var __async = (__this, __arguments, generator) => {
     mounted(el, binding) {
       const options = normalizeOptions$r(binding.value);
       if (options.disabled || !isBrowser()) return;
+      const timer = useTimer();
+      let isHovering = false;
       const state = {
         options,
         isHovering: false,
-        enterTimerId: null,
-        leaveTimerId: null,
-        enterHandler: () => {
-        },
-        leaveHandler: () => {
-        }
+        timer,
+        cleanup: null
       };
-      state.enterHandler = (e) => {
+      const enterHandler = (e) => {
         const event = e;
-        if (state.leaveTimerId) {
-          clearTimeout(state.leaveTimerId);
-          state.leaveTimerId = null;
-        }
-        if (state.isHovering) return;
+        timer.clearAll();
+        if (isHovering) return;
         if (options.enterDelay && options.enterDelay > 0) {
-          state.enterTimerId = setTimeout(() => {
+          timer.setTimeout(() => {
+            isHovering = true;
             state.isHovering = true;
             applyHoverState(el, state, event);
           }, options.enterDelay);
         } else {
+          isHovering = true;
           state.isHovering = true;
           applyHoverState(el, state, event);
         }
       };
-      state.leaveHandler = (e) => {
+      const leaveHandler = (e) => {
         const event = e;
-        if (state.enterTimerId) {
-          clearTimeout(state.enterTimerId);
-          state.enterTimerId = null;
-        }
-        if (!state.isHovering) return;
+        timer.clearAll();
+        if (!isHovering) return;
         if (options.leaveDelay && options.leaveDelay > 0) {
-          state.leaveTimerId = setTimeout(() => {
+          timer.setTimeout(() => {
+            isHovering = false;
             state.isHovering = false;
             applyLeaveState(el, state, event);
           }, options.leaveDelay);
         } else {
+          isHovering = false;
           state.isHovering = false;
           applyLeaveState(el, state, event);
         }
       };
-      el.__hover = state;
-      on(el, "mouseenter", state.enterHandler);
-      on(el, "mouseleave", state.leaveHandler);
+      state.cleanup = bindEvents$2(el, {
+        mouseenter: enterHandler,
+        mouseleave: leaveHandler
+      });
+      setState$1(el, STATE_KEY$4, state);
     },
     updated(el, binding) {
-      const state = el.__hover;
+      const state = getState$1(el, STATE_KEY$4);
       if (!state) return;
       const newOptions = normalizeOptions$r(binding.value);
       if (newOptions.disabled && !state.options.disabled) {
@@ -2016,40 +2106,15 @@ var __async = (__this, __arguments, generator) => {
       state.options = newOptions;
     },
     unmounted(el) {
-      const state = el.__hover;
+      var _a;
+      const state = getState$1(el, STATE_KEY$4);
       if (!state) return;
-      if (state.enterTimerId) {
-        clearTimeout(state.enterTimerId);
-      }
-      if (state.leaveTimerId) {
-        clearTimeout(state.leaveTimerId);
-      }
-      off(el, "mouseenter", state.enterHandler);
-      off(el, "mouseleave", state.leaveHandler);
+      state.timer.clearAll();
+      (_a = state.cleanup) == null ? void 0 : _a.call(state);
       el.classList.remove(state.options.class || "v-hover");
-      delete el.__hover;
+      deleteState(el, STATE_KEY$4);
     }
   });
-  function applyHoverState(el, state, e) {
-    var _a, _b;
-    const { options } = state;
-    if (options.class) {
-      el.classList.add(options.class);
-    }
-    el.dispatchEvent(new CustomEvent("hover:enter", { detail: { event: e } }));
-    (_a = options.onEnter) == null ? void 0 : _a.call(options, e);
-    (_b = options.handler) == null ? void 0 : _b.call(options, true, e);
-  }
-  function applyLeaveState(el, state, e) {
-    var _a, _b;
-    const { options } = state;
-    if (options.class) {
-      el.classList.remove(options.class);
-    }
-    el.dispatchEvent(new CustomEvent("hover:leave", { detail: { event: e } }));
-    (_a = options.onLeave) == null ? void 0 : _a.call(options, e);
-    (_b = options.handler) == null ? void 0 : _b.call(options, false, e);
-  }
   const DEFAULTS = {
     minScale: 0.5,
     maxScale: 5,
@@ -2060,7 +2125,7 @@ var __async = (__this, __arguments, generator) => {
     zoomIndicatorDuration: 1500
   };
   let globalZIndex = 9999;
-  function getDistance$2(x1, y1, x2, y2) {
+  function getDistance$3(x1, y1, x2, y2) {
     return Math.sqrt(__pow(x2 - x1, 2) + __pow(y2 - y1, 2));
   }
   function clamp(value, min, max) {
@@ -2243,7 +2308,7 @@ var __async = (__this, __arguments, generator) => {
         gesture.swipeStartY = e.touches[0].clientY;
       } else if (e.touches.length === 2 && options.enablePinchZoom !== false) {
         gesture.isDragging = false;
-        gesture.startDistance = getDistance$2(
+        gesture.startDistance = getDistance$3(
           e.touches[0].clientX,
           e.touches[0].clientY,
           e.touches[1].clientX,
@@ -2264,7 +2329,7 @@ var __async = (__this, __arguments, generator) => {
         transform.translateY = constrained.y;
         updateTransform(false);
       } else if (e.touches.length === 2 && options.enablePinchZoom !== false) {
-        const currentDistance = getDistance$2(
+        const currentDistance = getDistance$3(
           e.touches[0].clientX,
           e.touches[0].clientY,
           e.touches[1].clientX,
@@ -3033,7 +3098,7 @@ var __async = (__this, __arguments, generator) => {
       tickInterval: 100
     }, binding);
   }
-  function getDistance$1(p1, p2) {
+  function getDistance$2(p1, p2) {
     return Math.sqrt(__pow(p2.x - p1.x, 2) + __pow(p2.y - p1.y, 2));
   }
   const vLongPress = defineDirective({
@@ -3080,7 +3145,7 @@ var __async = (__this, __arguments, generator) => {
           clearInterval(state.tickTimerId);
           state.tickTimerId = null;
         }
-        const pos = getEventPosition(event);
+        const pos = getEventPosition$1(event);
         state.startPos = { x: pos.x, y: pos.y };
         state.startTime = Date.now();
         (_a = options.onStart) == null ? void 0 : _a.call(options, event);
@@ -3120,8 +3185,8 @@ var __async = (__this, __arguments, generator) => {
         var _a;
         if (!state.timerId) return;
         const event = e;
-        const pos = getEventPosition(event);
-        const distance = getDistance$1(state.startPos, { x: pos.x, y: pos.y });
+        const pos = getEventPosition$1(event);
+        const distance = getDistance$2(state.startPos, { x: pos.x, y: pos.y });
         if (distance > (options.distance || 10)) {
           if (state.timerId) {
             clearTimeout(state.timerId);
@@ -3356,7 +3421,7 @@ var __async = (__this, __arguments, generator) => {
       delete el[STATE_KEY$2];
     }
   });
-  function formatNumber(value, options) {
+  function formatNumber$1(value, options) {
     const { precision = 0, separator = ",", decimal = ".", prefix = "", suffix = "" } = options;
     const fixed = value.toFixed(precision);
     const [intPart, decPart] = fixed.split(".");
@@ -3459,7 +3524,7 @@ var __async = (__this, __arguments, generator) => {
       el.removeEventListener("blur", onBlur);
     };
   }
-  function formatMoney(value, options) {
+  function formatMoney$1(value, options) {
     const { precision = 2, separator = ",", decimal = ".", symbol = "$", symbolPosition = "before" } = options;
     const fixed = value.toFixed(precision);
     const [intPart, decPart] = fixed.split(".");
@@ -3480,14 +3545,14 @@ var __async = (__this, __arguments, generator) => {
       if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
         const { symbol = "$", symbolPosition = "before" } = options;
         const prefix = symbolPosition === "before" ? symbol : "";
-        const cleanup2 = setupNumberInput(el, __spreadProps(__spreadValues({}, options), { prefix }), formatMoney);
+        const cleanup2 = setupNumberInput(el, __spreadProps(__spreadValues({}, options), { prefix }), formatMoney$1);
         el.__money = { options, cleanup: cleanup2 };
         requestAnimationFrame(() => {
           const inputEl = el;
           if (inputEl.value) {
             const num = parseToNumber(inputEl.value, options.decimal || ".");
             if (num !== null) {
-              const formatted = formatMoney(clampValue(num, options), options);
+              const formatted = formatMoney$1(clampValue(num, options), options);
               if (formatted !== inputEl.value) {
                 inputEl.value = formatted;
                 inputEl.dispatchEvent(new Event("input", { bubbles: true }));
@@ -3506,7 +3571,7 @@ var __async = (__this, __arguments, generator) => {
           }
         }
         if (value !== null) {
-          el.textContent = formatMoney(clampValue(value, options), options);
+          el.textContent = formatMoney$1(clampValue(value, options), options);
         }
       }
     },
@@ -3523,7 +3588,7 @@ var __async = (__this, __arguments, generator) => {
           value = binding.value.value;
         }
         if (value !== null) {
-          el.textContent = formatMoney(clampValue(value, options), options);
+          el.textContent = formatMoney$1(clampValue(value, options), options);
         }
       }
     },
@@ -3641,14 +3706,14 @@ var __async = (__this, __arguments, generator) => {
       var _a, _b;
       const options = typeof binding.value === "number" ? { precision: binding.value } : (_a = binding.value) != null ? _a : {};
       if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
-        const cleanup2 = setupNumberInput(el, options, formatNumber);
+        const cleanup2 = setupNumberInput(el, options, formatNumber$1);
         el.__number = { options, cleanup: cleanup2 };
         requestAnimationFrame(() => {
           const inputEl = el;
           if (inputEl.value) {
             const num = parseToNumber(inputEl.value, options.decimal || ".");
             if (num !== null) {
-              const formatted = formatNumber(clampValue(num, options), options);
+              const formatted = formatNumber$1(clampValue(num, options), options);
               if (formatted !== inputEl.value) {
                 inputEl.value = formatted;
                 inputEl.dispatchEvent(new Event("input", { bubbles: true }));
@@ -3669,7 +3734,7 @@ var __async = (__this, __arguments, generator) => {
           }
         }
         if (value !== null) {
-          el.textContent = formatNumber(clampValue(value, options), options);
+          el.textContent = formatNumber$1(clampValue(value, options), options);
         }
       }
     },
@@ -3687,7 +3752,7 @@ var __async = (__this, __arguments, generator) => {
           value = binding.value.value;
         }
         if (value !== null) {
-          el.textContent = formatNumber(clampValue(value, options), options);
+          el.textContent = formatNumber$1(clampValue(value, options), options);
         }
       }
     },
@@ -3698,14 +3763,6 @@ var __async = (__this, __arguments, generator) => {
     }
   });
   const STATE_KEY$1 = "__permission";
-  const WILDCARD = "*";
-  let globalConfig = null;
-  function configurePermission(config) {
-    globalConfig = config;
-  }
-  function getPermissionConfig() {
-    return globalConfig;
-  }
   function normalizeOptions$h(binding) {
     if (!binding) {
       throw new Error("[Directix] v-permission: permission value is required");
@@ -3718,39 +3775,14 @@ var __async = (__this, __arguments, generator) => {
     }
     return binding;
   }
-  function hasPermission(required, permissions) {
-    return permissions.includes(WILDCARD) || permissions.includes(required);
-  }
   function verifyPermission(options) {
-    var _a;
     if (options.check) {
       return options.check(options.value, options.mode || "some");
     }
-    if (!globalConfig) {
+    {
       console.warn("[Directix] v-permission: No permission config provided");
       return true;
     }
-    const permissions = globalConfig.getPermissions();
-    const roles = ((_a = globalConfig.getRoles) == null ? void 0 : _a.call(globalConfig)) || [];
-    const roleMap = globalConfig.roleMap || {};
-    const required = Array.isArray(options.value) ? options.value : [options.value];
-    const mode = options.mode || "some";
-    function checkSingle(value) {
-      if (value in roleMap) {
-        return roles.includes(value);
-      }
-      if (hasPermission(value, permissions)) {
-        return true;
-      }
-      for (const role of roles) {
-        const rolePermissions = roleMap[role] || [];
-        if (hasPermission(value, rolePermissions)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    return mode === "every" ? required.every(checkSingle) : required.some(checkSingle);
   }
   function handleDenied(el, action, state) {
     var _a, _b;
@@ -3899,16 +3931,16 @@ var __async = (__this, __arguments, generator) => {
         return;
       }
       if (options.newWindow) {
-        yield printInNewWindow(targetEl, options);
+        yield printInNewWindow$1(targetEl, options);
       } else {
-        yield printInIframe(targetEl, options);
+        yield printInIframe$1(targetEl, options);
       }
       if (options.onAfterPrint) {
         options.onAfterPrint();
       }
     });
   }
-  function printInIframe(el, options) {
+  function printInIframe$1(el, options) {
     return __async(this, null, function* () {
       var _a, _b, _c;
       const iframe = document.createElement("iframe");
@@ -3920,11 +3952,11 @@ var __async = (__this, __arguments, generator) => {
         document.body.removeChild(iframe);
         return;
       }
-      const content = buildPrintContent(el, options);
+      const content = buildPrintContent$1(el, options);
       iframeDoc.open();
       iframeDoc.write(content);
       iframeDoc.close();
-      yield waitForImages(iframeDoc);
+      yield waitForImages$1(iframeDoc);
       try {
         (_b = iframe.contentWindow) == null ? void 0 : _b.focus();
         (_c = iframe.contentWindow) == null ? void 0 : _c.print();
@@ -3936,18 +3968,18 @@ var __async = (__this, __arguments, generator) => {
       }, 1e3);
     });
   }
-  function printInNewWindow(el, options) {
+  function printInNewWindow$1(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);
+      const content = buildPrintContent$1(el, options);
       printWindow.document.open();
       printWindow.document.write(content);
       printWindow.document.close();
-      yield waitForImages(printWindow.document);
+      yield waitForImages$1(printWindow.document);
       printWindow.focus();
       printWindow.print();
       setTimeout(() => {
@@ -3955,7 +3987,7 @@ var __async = (__this, __arguments, generator) => {
       }, 1e3);
     });
   }
-  function buildPrintContent(el, options) {
+  function buildPrintContent$1(el, options) {
     let styles = "";
     document.querySelectorAll('style, link[rel="stylesheet"]').forEach((styleEl) => {
       if (styleEl.tagName === "STYLE") {
@@ -3996,7 +4028,7 @@ var __async = (__this, __arguments, generator) => {
 </body>
 </html>`;
   }
-  function waitForImages(doc) {
+  function waitForImages$1(doc) {
     const images = doc.querySelectorAll("img");
     const promises = [];
     images.forEach((img) => {
@@ -4089,16 +4121,16 @@ var __async = (__this, __arguments, generator) => {
       try {
         yield internal.options.handler();
         setState(internal, "success");
-        yield sleep(internal.options.successDuration);
+        yield sleep$1(internal.options.successDuration);
       } catch (e) {
         setState(internal, "error");
-        yield sleep(internal.options.errorDuration);
+        yield sleep$1(internal.options.errorDuration);
       } finally {
         resetPosition(internal);
       }
     });
   }
-  function sleep(ms) {
+  function sleep$1(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   function createHandlers(internal) {
@@ -4824,8 +4856,8 @@ var __async = (__this, __arguments, generator) => {
   });
   const DEFAULT_THRESHOLD = 30;
   const DEFAULT_MAX_TIME = 500;
-  const DEFAULT_DIRECTIONS = ["left", "right", "up", "down"];
-  function getSwipeDirection(deltaX, deltaY, allowedDirections) {
+  const DEFAULT_DIRECTIONS$1 = ["left", "right", "up", "down"];
+  function getSwipeDirection$1(deltaX, deltaY, allowedDirections) {
     const absX = Math.abs(deltaX);
     const absY = Math.abs(deltaY);
     if (absX > absY) {
@@ -4843,7 +4875,7 @@ var __async = (__this, __arguments, generator) => {
       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],
+      directions: (_c = binding.directions) != null ? _c : [...DEFAULT_DIRECTIONS$1],
       preventScrollOnSwipe: (_d = binding.preventScrollOnSwipe) != null ? _d : true,
       disabled: (_e = binding.disabled) != null ? _e : false,
       mouse: (_f = binding.mouse) != null ? _f : true,
@@ -4859,7 +4891,7 @@ var __async = (__this, __arguments, generator) => {
     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);
+    const direction = getSwipeDirection$1(deltaX, deltaY, (_c = options.directions) != null ? _c : DEFAULT_DIRECTIONS$1);
     if (!direction) return;
     if (options.preventScrollOnSwipe && event.cancelable) {
       event.preventDefault();
@@ -5348,7 +5380,7 @@ var __async = (__this, __arguments, generator) => {
       delete el.__tooltip;
     }
   });
-  const getDistance = (x1, y1, x2, y2) => Math.sqrt(__pow(x2 - x1, 2) + __pow(y2 - y1, 2));
+  const getDistance$1 = (x1, y1, x2, y2) => Math.sqrt(__pow(x2 - x1, 2) + __pow(y2 - y1, 2));
   const getAngle = (x1, y1, x2, y2) => Math.atan2(y2 - y1, x2 - x1) * 180 / Math.PI;
   const MOUSE_IGNORE_DURATION = 400;
   const vTouch = defineDirective({
@@ -5426,7 +5458,7 @@ var __async = (__this, __arguments, generator) => {
         } else if (e.touches.length === 2) {
           clearLongPressTimer();
           const [t1, t2] = e.touches;
-          state.startDistance = getDistance(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
+          state.startDistance = getDistance$1(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
           state.startAngle = getAngle(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
           state.lastScale = 1;
           state.lastAngle = 0;
@@ -5443,7 +5475,7 @@ var __async = (__this, __arguments, generator) => {
         }
         if (e.touches.length === 2) {
           const [t1, t2] = e.touches;
-          const currentDistance = getDistance(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
+          const currentDistance = getDistance$1(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
           const currentAngle = getAngle(t1.clientX, t1.clientY, t2.clientX, t2.clientY);
           if (state.options.enablePinch && state.options.onPinch) {
             const scale = currentDistance / state.startDistance;
@@ -5562,9 +5594,9 @@ var __async = (__this, __arguments, generator) => {
       onTouchEnd: binding == null ? void 0 : binding.onTouchEnd
     };
   }
-  function trimText(text, options) {
+  function trimText$1(text, options) {
     const { position = "both", chars } = options;
-    const charPattern = chars ? `[\\s${escapeRegex(chars)}]` : "\\s";
+    const charPattern = chars ? `[\\s${escapeRegex$2(chars)}]` : "\\s";
     switch (position) {
       case "start":
         return text.replace(new RegExp(`^${charPattern}+`, "g"), "");
@@ -5575,7 +5607,7 @@ var __async = (__this, __arguments, generator) => {
         return text.replace(new RegExp(`^${charPattern}+|${charPattern}+$`, "g"), "");
     }
   }
-  function escapeRegex(str) {
+  function escapeRegex$2(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
   const vTrim = defineDirective({
@@ -5587,7 +5619,7 @@ var __async = (__this, __arguments, generator) => {
         setupInputElement(el, options);
       } else {
         const text = el.textContent || "";
-        el.textContent = trimText(text, options);
+        el.textContent = trimText$1(text, options);
       }
     },
     updated(el, binding) {
@@ -5599,7 +5631,7 @@ var __async = (__this, __arguments, generator) => {
         }
       } else {
         const text = el.textContent || "";
-        el.textContent = trimText(text, options);
+        el.textContent = trimText$1(text, options);
       }
     },
     unmounted(el) {
@@ -5618,7 +5650,7 @@ var __async = (__this, __arguments, generator) => {
     el.__trim = state;
     const performTrim = () => {
       const originalValue = el.value;
-      const trimmed = trimText(originalValue, options);
+      const trimmed = trimText$1(originalValue, options);
       if (originalValue !== trimmed) {
         el.value = trimmed;
         el.dispatchEvent(new Event("input", { bubbles: true }));
@@ -5667,7 +5699,7 @@ var __async = (__this, __arguments, generator) => {
       chars: binding.chars
     };
   }
-  function truncateText(text, options) {
+  function truncateText$1(text, options) {
     const { length = 100, position = "end", ellipsis = "..." } = options;
     if (text.length <= length) {
       return text;
@@ -5730,7 +5762,7 @@ var __async = (__this, __arguments, generator) => {
         el.setAttribute("title", text);
       }
     } else {
-      const truncated = truncateText(text, options);
+      const truncated = truncateText$1(text, options);
       el.textContent = truncated;
       if (showTitle && text && text !== truncated) {
         el.setAttribute("title", text);
@@ -6116,7 +6148,7 @@ var __async = (__this, __arguments, generator) => {
       state.options.handler(isVisible);
     }
   }
-  function createWatermarkCanvas(options) {
+  function createWatermarkCanvas$1(options) {
     var _a;
     const canvas = document.createElement("canvas");
     const ctx = canvas.getContext("2d");
@@ -6232,7 +6264,7 @@ var __async = (__this, __arguments, generator) => {
   });
   function applyWatermark(el, state) {
     const options = state.options;
-    state.canvas = createWatermarkCanvas(options);
+    state.canvas = createWatermarkCanvas$1(options);
     state.watermarkEl = createWatermarkElement(state.canvas, options);
     el.appendChild(state.watermarkEl);
     if (options.protect) {
@@ -6255,7 +6287,7 @@ var __async = (__this, __arguments, generator) => {
     state.observer = new MutationObserver((mutations) => {
       if (!state.watermarkEl || !el.contains(state.watermarkEl)) {
         if (!state.options.disabled) {
-          state.canvas = createWatermarkCanvas(state.options);
+          state.canvas = createWatermarkCanvas$1(state.options);
           state.watermarkEl = createWatermarkElement(state.canvas, state.options);
           el.appendChild(state.watermarkEl);
         }
@@ -6280,6 +6312,2988 @@ var __async = (__this, __arguments, generator) => {
       attributeFilter: ["style", "class", "hidden"]
     });
   }
+  const DEFAULT_KEEP_LOWER = [
+    "a",
+    "an",
+    "the",
+    "and",
+    "but",
+    "or",
+    "for",
+    "nor",
+    "on",
+    "at",
+    "to",
+    "from",
+    "by",
+    "in",
+    "of",
+    "with",
+    "as"
+  ];
+  function capitalizeWord(word) {
+    if (!word) return word;
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }
+  function capitalizeText(text, options = {}) {
+    if (!text) return text;
+    const { every = true, keepLower = DEFAULT_KEEP_LOWER } = options;
+    if (every) {
+      const words = text.toLowerCase().split(/\s+/);
+      return words.map((word, index) => {
+        if (index === 0) {
+          return capitalizeWord(word);
+        }
+        if (keepLower.includes(word.toLowerCase())) {
+          return word.toLowerCase();
+        }
+        return capitalizeWord(word);
+      }).join(" ");
+    } else {
+      return capitalizeWord(text);
+    }
+  }
+  function useCapitalcase(options) {
+    const {
+      text,
+      every = true,
+      keepLower = DEFAULT_KEEP_LOWER
+    } = options;
+    const original = vue.ref(vue.unref(text));
+    const capitalized = vue.ref("");
+    function calculate() {
+      const textValue = vue.unref(text);
+      const everyValue = vue.unref(every);
+      const keepLowerValue = vue.unref(keepLower);
+      original.value = textValue;
+      capitalized.value = capitalizeText(textValue, {
+        every: everyValue,
+        keepLower: keepLowerValue
+      });
+    }
+    vue.watch(
+      () => [vue.unref(text), vue.unref(every), vue.unref(keepLower)],
+      () => calculate(),
+      { immediate: true }
+    );
+    return {
+      capitalized,
+      original
+    };
+  }
+  function createCapitalizer(options = {}) {
+    return (text) => capitalizeText(text, options);
+  }
+  function useClickDelay(options) {
+    const {
+      handler,
+      delay = 300,
+      disabled = false
+    } = options;
+    const isPending = vue.ref(false);
+    let timeoutId = null;
+    const getDelay = () => vue.unref(delay);
+    const getDisabled = () => vue.unref(disabled);
+    function click(event) {
+      if (getDisabled() || isPending.value) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      isPending.value = true;
+      handler(event);
+      timeoutId = setTimeout(() => {
+        isPending.value = false;
+        timeoutId = null;
+      }, getDelay());
+    }
+    function reset() {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      isPending.value = false;
+    }
+    function cancel() {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    }
+    vue.onUnmounted(() => {
+      cancel();
+    });
+    return {
+      isPending,
+      click,
+      reset,
+      cancel
+    };
+  }
+  function createDelayedClick(handler, delay = 300) {
+    let isPending = false;
+    return (event) => {
+      if (isPending) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      isPending = true;
+      handler(event);
+      setTimeout(() => {
+        isPending = false;
+      }, delay);
+    };
+  }
+  function isValidClick(el, event, exclude) {
+    const target = event.target;
+    if (el.contains(target)) {
+      return false;
+    }
+    if (exclude == null ? void 0 : exclude.length) {
+      for (const item of exclude) {
+        const excludeEl = typeof item === "function" ? item() : vue.unref(item);
+        const resolved = typeof excludeEl === "string" ? getElement(excludeEl) : excludeEl;
+        if (resolved && (resolved === target || resolved.contains(target))) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  function useClickOutside(options) {
+    const {
+      handler,
+      exclude = [],
+      capture = true,
+      events = ["click"],
+      stop = false,
+      prevent = false
+    } = options;
+    let currentElement = null;
+    const handlers = /* @__PURE__ */ new Map();
+    function createEventHandler(_eventType) {
+      return (event) => {
+        if (!currentElement) return;
+        if (!isValidClick(currentElement, event, exclude)) {
+          return;
+        }
+        if (stop) {
+          event.stopPropagation();
+        }
+        if (prevent) {
+          event.preventDefault();
+        }
+        handler(event);
+      };
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      events.forEach((eventType) => {
+        const eventHandler = createEventHandler();
+        handlers.set(eventType, eventHandler);
+        document.addEventListener(eventType, eventHandler, {
+          capture,
+          passive: !prevent
+        });
+      });
+      return unbind;
+    }
+    function unbind() {
+      handlers.forEach((eventHandler, eventType) => {
+        document.removeEventListener(eventType, eventHandler, { capture });
+      });
+      handlers.clear();
+      currentElement = null;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      bind
+    };
+  }
+  function copyToClipboard(text) {
+    return __async(this, null, function* () {
+      if (supportsClipboard()) {
+        try {
+          yield navigator.clipboard.writeText(text);
+          return true;
+        } catch (e) {
+          console.warn("[Directix] Clipboard API failed, falling back to execCommand");
+        }
+      }
+      return copyWithExecCommand(text);
+    });
+  }
+  function copyWithExecCommand(text) {
+    if (!isBrowser()) return false;
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.style.cssText = `
+    position: fixed;
+    top: -9999px;
+    left: -9999px;
+    opacity: 0;
+    pointer-events: none;
+  `;
+    document.body.appendChild(textarea);
+    try {
+      textarea.select();
+      textarea.setSelectionRange(0, textarea.value.length);
+      return document.execCommand("copy");
+    } catch (e) {
+      return false;
+    } finally {
+      document.body.removeChild(textarea);
+    }
+  }
+  function useCopy(options = {}) {
+    const {
+      source,
+      onSuccess,
+      onError,
+      copiedTimeout = 1500
+    } = options;
+    const copied = vue.ref(false);
+    const error = vue.ref(null);
+    const isSupported = supportsClipboard() || isBrowser();
+    let timeoutId = null;
+    function copy(text) {
+      return __async(this, null, function* () {
+        const value = text != null ? text : vue.unref(source);
+        if (!value) {
+          console.warn("[Directix] useCopy: No text to copy");
+          return false;
+        }
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+        error.value = null;
+        try {
+          const success = yield copyToClipboard(value);
+          if (success) {
+            copied.value = true;
+            onSuccess == null ? void 0 : onSuccess(value);
+            timeoutId = setTimeout(() => {
+              copied.value = false;
+              timeoutId = null;
+            }, copiedTimeout);
+            return true;
+          } else {
+            throw new Error("Copy failed");
+          }
+        } catch (err) {
+          const copyError = err;
+          error.value = copyError;
+          copied.value = false;
+          onError == null ? void 0 : onError(copyError);
+          return false;
+        }
+      });
+    }
+    return {
+      copy,
+      copied: vue.readonly(copied),
+      error: vue.readonly(error),
+      isSupported
+    };
+  }
+  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 useCountdown(options) {
+    const {
+      target,
+      format = "hh:mm:ss",
+      onComplete,
+      onTick,
+      interval = 1e3,
+      autoStart = true
+    } = options;
+    const time = vue.ref(calculateTime(0));
+    const formatted = vue.ref("");
+    const running = vue.ref(false);
+    const paused = vue.ref(false);
+    const completed = vue.ref(false);
+    let intervalId = null, targetTime = 0, remainingWhenPaused = 0;
+    const getInterval = () => vue.unref(interval);
+    const getFormat = () => vue.unref(format);
+    function update() {
+      const now = Date.now();
+      const remaining = targetTime - now;
+      if (remaining <= 0) {
+        time.value = calculateTime(0);
+        formatted.value = formatTime(time.value, getFormat());
+        completed.value = true;
+        running.value = false;
+        stop();
+        if (onComplete) {
+          onComplete();
+        }
+        return;
+      }
+      time.value = calculateTime(remaining);
+      formatted.value = formatTime(time.value, getFormat());
+      if (onTick) {
+        onTick(time.value);
+      }
+    }
+    function start() {
+      if (running.value) return;
+      targetTime = parseTargetTime(vue.unref(target));
+      running.value = true;
+      paused.value = false;
+      completed.value = false;
+      update();
+      intervalId = setInterval(update, getInterval());
+    }
+    function stop() {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      running.value = false;
+    }
+    function pause() {
+      if (!running.value) return;
+      remainingWhenPaused = targetTime - Date.now();
+      stop();
+      paused.value = true;
+    }
+    function resume() {
+      if (running.value || !paused.value) return;
+      targetTime = Date.now() + remainingWhenPaused;
+      running.value = true;
+      paused.value = false;
+      update();
+      intervalId = setInterval(update, getInterval());
+    }
+    function reset() {
+      stop();
+      paused.value = false;
+      completed.value = false;
+      remainingWhenPaused = 0;
+      time.value = calculateTime(0);
+      formatted.value = formatTime(time.value, getFormat());
+    }
+    vue.watch(
+      () => vue.unref(target),
+      (newTarget) => {
+        if (running.value) {
+          targetTime = parseTargetTime(newTarget);
+        }
+      }
+    );
+    if (vue.unref(autoStart)) {
+      start();
+    }
+    vue.onUnmounted(() => {
+      stop();
+    });
+    return {
+      time,
+      formatted,
+      running,
+      paused,
+      completed,
+      start,
+      pause,
+      resume,
+      reset
+    };
+  }
+  function useDebounce(options) {
+    const {
+      handler,
+      wait = 300,
+      leading = false,
+      trailing = true
+    } = options;
+    let timerId = null, lastArgs = null, lastThis = null;
+    const invokeFunc = () => {
+      if (lastArgs) {
+        handler.apply(lastThis, lastArgs);
+        lastArgs = null;
+        lastThis = null;
+      }
+    };
+    const getWait = () => vue.unref(wait);
+    const getLeading = () => vue.unref(leading);
+    const getTrailing = () => vue.unref(trailing);
+    function run(...args) {
+      lastArgs = args;
+      lastThis = this;
+      if (timerId) {
+        clearTimeout(timerId);
+      }
+      if (getLeading() && !timerId) {
+        invokeFunc();
+      }
+      timerId = setTimeout(() => {
+        if (getTrailing()) {
+          invokeFunc();
+        }
+        timerId = null;
+      }, getWait());
+    }
+    function cancel() {
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      lastArgs = null;
+      lastThis = null;
+    }
+    function flush() {
+      if (timerId) {
+        clearTimeout(timerId);
+        invokeFunc();
+        timerId = null;
+      }
+    }
+    function pending() {
+      return timerId !== null;
+    }
+    vue.onUnmounted(() => {
+      cancel();
+    });
+    return {
+      run,
+      cancel,
+      flush,
+      pending
+    };
+  }
+  function debounceFn(fn, wait = 300, options) {
+    return debounce(fn, wait, options);
+  }
+  function getBoundary(boundary) {
+    var _a, _b;
+    if (!boundary) return null;
+    if (typeof boundary === "function") {
+      const boundaryEl = boundary();
+      return (_a = boundaryEl == null ? void 0 : boundaryEl.getBoundingClientRect()) != null ? _a : null;
+    }
+    if (typeof boundary === "string") {
+      const boundaryEl = document.querySelector(boundary);
+      return (_b = boundaryEl == null ? void 0 : boundaryEl.getBoundingClientRect()) != null ? _b : null;
+    }
+    return boundary.getBoundingClientRect();
+  }
+  function getClientCoords(e) {
+    if (e.type.startsWith("touch")) {
+      const touch = e.touches[0] || e.changedTouches[0];
+      return { clientX: touch.clientX, clientY: touch.clientY };
+    }
+    const mouseEvent = e;
+    return { clientX: mouseEvent.clientX, clientY: mouseEvent.clientY };
+  }
+  function parseTranslate(transform) {
+    const match = transform.match(/translate\(([-\d.]+)px,\s*([-\d.]+)px\)/);
+    if (match) {
+      return { x: parseFloat(match[1]), y: parseFloat(match[2]) };
+    }
+    return { x: 0, y: 0 };
+  }
+  function useDraggable(options = {}) {
+    const {
+      axis = "both",
+      constrain = false,
+      boundary,
+      handle,
+      grid,
+      disabled = false,
+      onStart,
+      onDrag,
+      onEnd
+    } = options;
+    const position = vue.ref({ x: 0, y: 0 });
+    const isDragging = vue.ref(false);
+    let currentElement = null, handleEl = null, startX = 0, startY = 0, offsetX = 0, offsetY = 0, initialLeft = 0, initialTop = 0, boundaryWidth = 0, boundaryHeight = 0, elWidth = 0, elHeight = 0;
+    function startDrag(e) {
+      var _a;
+      if (vue.unref(disabled)) return;
+      e.preventDefault();
+      const { clientX, clientY } = getClientCoords(e);
+      isDragging.value = true;
+      startX = clientX;
+      startY = clientY;
+      const { x, y } = parseTranslate(currentElement.style.transform);
+      offsetX = x;
+      offsetY = y;
+      if (vue.unref(constrain) || boundary) {
+        const boundaryRect = boundary ? getBoundary(boundary) : (_a = currentElement.parentElement) == null ? void 0 : _a.getBoundingClientRect();
+        if (boundaryRect) {
+          const elRect = currentElement.getBoundingClientRect();
+          initialLeft = elRect.left - boundaryRect.left;
+          initialTop = elRect.top - boundaryRect.top;
+          boundaryWidth = boundaryRect.width;
+          boundaryHeight = boundaryRect.height;
+          elWidth = elRect.width;
+          elHeight = elRect.height;
+        }
+      }
+      currentElement.classList.add("v-draggable--dragging");
+      document.addEventListener("mousemove", handleDrag);
+      document.addEventListener("mouseup", endDrag);
+      document.addEventListener("touchmove", handleDrag, { passive: false });
+      document.addEventListener("touchend", endDrag);
+      onStart == null ? void 0 : onStart({ x: offsetX, y: offsetY }, e);
+    }
+    function handleDrag(e) {
+      if (!isDragging.value || vue.unref(disabled)) return;
+      e.preventDefault();
+      const { clientX, clientY } = getClientCoords(e);
+      let deltaX = clientX - startX, deltaY = clientY - startY, newX = offsetX + deltaX, newY = offsetY + deltaY;
+      const currentAxis = vue.unref(axis);
+      if (currentAxis === "x") {
+        deltaY = 0;
+      } else if (currentAxis === "y") {
+        deltaX = 0;
+      }
+      const currentGrid = vue.unref(grid);
+      if (currentGrid) {
+        deltaX = Math.round(deltaX / currentGrid[0]) * currentGrid[0];
+        deltaY = Math.round(deltaY / currentGrid[1]) * currentGrid[1];
+      }
+      if (vue.unref(constrain) || boundary) {
+        const newLeft = initialLeft + deltaX;
+        const newTop = initialTop + deltaY;
+        const maxLeft = boundaryWidth - elWidth;
+        const maxTop = boundaryHeight - elHeight;
+        const constrainedLeft = Math.max(0, Math.min(newLeft, maxLeft));
+        const constrainedTop = Math.max(0, Math.min(newTop, maxTop));
+        newX = offsetX + (constrainedLeft - initialLeft);
+        newY = offsetY + (constrainedTop - initialTop);
+      }
+      currentElement.style.transform = `translate(${newX}px, ${newY}px)`;
+      position.value = { x: newX, y: newY };
+      onDrag == null ? void 0 : onDrag({ x: newX, y: newY }, e);
+    }
+    function endDrag(e) {
+      if (!isDragging.value) return;
+      isDragging.value = false;
+      currentElement == null ? void 0 : currentElement.classList.remove("v-draggable--dragging");
+      document.removeEventListener("mousemove", handleDrag);
+      document.removeEventListener("mouseup", endDrag);
+      document.removeEventListener("touchmove", handleDrag);
+      document.removeEventListener("touchend", endDrag);
+      onEnd == null ? void 0 : onEnd(__spreadValues({}, position.value), e);
+    }
+    function reset() {
+      if (currentElement) {
+        currentElement.style.transform = "translate(0px, 0px)";
+        position.value = { x: 0, y: 0 };
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      if (getComputedStyle(element).position === "static") {
+        element.style.position = "absolute";
+      }
+      handleEl = handle ? element.querySelector(handle) : null;
+      const target = handleEl || element;
+      target.addEventListener("mousedown", startDrag);
+      target.addEventListener("touchstart", startDrag, { passive: false });
+      return unbind;
+    }
+    function unbind() {
+      if (currentElement) {
+        const target = handleEl || currentElement;
+        target.removeEventListener("mousedown", startDrag);
+        target.removeEventListener("touchstart", startDrag);
+      }
+      currentElement = null;
+      handleEl = null;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      position: vue.readonly(position),
+      isDragging: vue.readonly(isDragging),
+      reset,
+      bind
+    };
+  }
+  function measureTextWidth(text, fontSize = 14, fontFamily = "sans-serif") {
+    if (typeof document === "undefined") return text.length * 8;
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return text.length * 8;
+    ctx.font = `${fontSize}px ${fontFamily}`;
+    return ctx.measureText(text).width;
+  }
+  function truncateToWidth(text, maxWidth, ellipsis = "...", fontSize = 14, fontFamily = "sans-serif") {
+    if (maxWidth <= 0) return text;
+    const textWidth = measureTextWidth(text, fontSize, fontFamily);
+    if (textWidth <= maxWidth) return text;
+    const ellipsisWidth = measureTextWidth(ellipsis, fontSize, fontFamily);
+    const availableWidth = maxWidth - ellipsisWidth;
+    if (availableWidth <= 0) return ellipsis;
+    let low = 0, high = text.length;
+    while (low < high) {
+      const mid = Math.floor((low + high + 1) / 2);
+      const truncatedText = text.slice(0, mid);
+      const truncatedWidth = measureTextWidth(truncatedText, fontSize, fontFamily);
+      if (truncatedWidth <= availableWidth) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return text.slice(0, low) + ellipsis;
+  }
+  function truncateToLines(text, lines, ellipsis = "...") {
+    if (lines <= 0) return "";
+    const avgCharsPerLine = 80;
+    const maxChars = lines * avgCharsPerLine;
+    if (text.length <= maxChars) return text;
+    return text.slice(0, maxChars - ellipsis.length) + ellipsis;
+  }
+  function useEllipsis(options) {
+    const {
+      text,
+      lines = 1,
+      ellipsis = "...",
+      maxWidth = 0
+    } = options;
+    const original = vue.ref(vue.unref(text));
+    const truncated = vue.ref("");
+    const isTruncated = vue.ref(false);
+    function calculate() {
+      const textValue = vue.unref(text);
+      const linesValue = vue.unref(lines);
+      const ellipsisValue = vue.unref(ellipsis);
+      const maxWidthValue = vue.unref(maxWidth);
+      original.value = textValue;
+      if (!textValue) {
+        truncated.value = "";
+        isTruncated.value = false;
+        return;
+      }
+      if (maxWidthValue > 0) {
+        const result = truncateToWidth(textValue, maxWidthValue, ellipsisValue);
+        truncated.value = result;
+        isTruncated.value = result !== textValue;
+      } else if (linesValue > 1) {
+        const result = truncateToLines(textValue, linesValue, ellipsisValue);
+        truncated.value = result;
+        isTruncated.value = result !== textValue;
+      } else {
+        truncated.value = textValue;
+        isTruncated.value = false;
+      }
+    }
+    function calculateForWidth(width) {
+      const textValue = vue.unref(text);
+      const ellipsisValue = vue.unref(ellipsis);
+      if (!textValue || width <= 0) return textValue || "";
+      return truncateToWidth(textValue, width, ellipsisValue);
+    }
+    function wouldTruncate(width) {
+      const textValue = vue.unref(text);
+      if (!textValue || width <= 0) return false;
+      const textWidth = measureTextWidth(textValue);
+      return textWidth > width;
+    }
+    vue.watch(
+      () => [vue.unref(text), vue.unref(lines), vue.unref(ellipsis), vue.unref(maxWidth)],
+      () => calculate(),
+      { immediate: true }
+    );
+    vue.onUnmounted(() => {
+    });
+    return {
+      truncated,
+      isTruncated,
+      original,
+      calculateForWidth,
+      wouldTruncate
+    };
+  }
+  function truncateText(text, maxLength, ellipsis = "...") {
+    if (!text || text.length <= maxLength) return text;
+    return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+  }
+  function wouldTextTruncate(text, containerWidth, fontSize = 14) {
+    return measureTextWidth(text, fontSize) > containerWidth;
+  }
+  const FOCUSABLE_TAGS = /* @__PURE__ */ new Set(["input", "textarea", "select", "button"]);
+  function isFocusable(el) {
+    if (!isBrowser()) return false;
+    const tagName = el.tagName.toLowerCase();
+    if (FOCUSABLE_TAGS.has(tagName)) {
+      return !el.disabled;
+    }
+    if (el.isContentEditable) return true;
+    const tabindex = el.getAttribute("tabindex");
+    if (tabindex != null) return tabindex !== "-1";
+    if (tagName === "a" || tagName === "area") {
+      return el.hasAttribute("href");
+    }
+    return false;
+  }
+  function useFocus(options = {}) {
+    const { onFocus, onBlur } = options;
+    const isFocused = vue.ref(false);
+    let currentElement = null, focusHandler = null, blurHandler = null;
+    function focus() {
+      if (currentElement && isFocusable(currentElement)) {
+        currentElement.focus();
+      }
+    }
+    function blur() {
+      if (currentElement) {
+        currentElement.blur();
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      focusHandler = (e) => {
+        isFocused.value = true;
+        onFocus == null ? void 0 : onFocus(e);
+      };
+      blurHandler = (e) => {
+        isFocused.value = false;
+        onBlur == null ? void 0 : onBlur(e);
+      };
+      element.addEventListener("focus", focusHandler);
+      element.addEventListener("blur", blurHandler);
+      isFocused.value = document.activeElement === element;
+      return unbind;
+    }
+    function unbind() {
+      if (currentElement) {
+        if (focusHandler) {
+          currentElement.removeEventListener("focus", focusHandler);
+        }
+        if (blurHandler) {
+          currentElement.removeEventListener("blur", blurHandler);
+        }
+      }
+      currentElement = null;
+      focusHandler = null;
+      blurHandler = null;
+      isFocused.value = false;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      isFocused: vue.readonly(isFocused),
+      focus,
+      blur,
+      bind
+    };
+  }
+  const KEY_ALIASES = {
+    esc: "Escape",
+    space: " ",
+    up: "ArrowUp",
+    down: "ArrowDown",
+    left: "ArrowLeft",
+    right: "ArrowRight",
+    enter: "Enter",
+    tab: "Tab",
+    backspace: "Backspace",
+    delete: "Delete",
+    insert: "Insert",
+    home: "Home",
+    end: "End",
+    pageup: "PageUp",
+    pagedown: "PageDown",
+    plus: "+",
+    minus: "-"
+  };
+  const MODIFIERS = /* @__PURE__ */ new Set(["ctrl", "alt", "shift", "meta"]);
+  function parseHotkey(hotkey) {
+    const parts = hotkey.toLowerCase().split("+").map((p) => p.trim());
+    const modifiers = /* @__PURE__ */ new Set();
+    let key = "";
+    for (const part of parts) {
+      if (MODIFIERS.has(part)) {
+        modifiers.add(part);
+      } else {
+        key = KEY_ALIASES[part] || part;
+      }
+    }
+    return { key, modifiers };
+  }
+  function matchesHotkey(event, definition) {
+    if (definition.modifiers.has("ctrl") !== (event.ctrlKey || event.metaKey)) return false;
+    if (definition.modifiers.has("alt") !== event.altKey) return false;
+    if (definition.modifiers.has("shift") !== event.shiftKey) return false;
+    if (definition.modifiers.has("meta") !== event.metaKey) return false;
+    const eventKey = event.key;
+    const targetKey = definition.key;
+    return eventKey.toLowerCase() === targetKey.toLowerCase();
+  }
+  function useHotkey(options = {}) {
+    const {
+      hotkey,
+      hotkeys = [],
+      target,
+      enabled: initialEnabled = true
+    } = options;
+    const enabled = vue.ref(vue.unref(initialEnabled));
+    const hotkeyMap = /* @__PURE__ */ new Map();
+    let currentTarget = null, keydownHandler = null, keyupHandler = null;
+    if (hotkey) {
+      addHotkey(hotkey);
+    }
+    hotkeys.forEach(addHotkey);
+    function addHotkey(def) {
+      const parsed = parseHotkey(def.key);
+      const key = parsed.key.toLowerCase();
+      if (!hotkeyMap.has(key)) {
+        hotkeyMap.set(key, []);
+      }
+      hotkeyMap.get(key).push(def);
+    }
+    function removeHotkey(key) {
+      hotkeyMap.delete(key.toLowerCase());
+    }
+    function clearHotkeys() {
+      hotkeyMap.clear();
+    }
+    function handleKeyEvent(event, isKeyup) {
+      if (!enabled.value) return;
+      const key = event.key.toLowerCase();
+      const definitions = hotkeyMap.get(key);
+      if (!definitions) return;
+      for (const def of definitions) {
+        if (vue.unref(def.disabled)) continue;
+        if (!!def.keyup !== isKeyup) continue;
+        const parsed = parseHotkey(def.key);
+        if (matchesHotkey(event, parsed)) {
+          if (def.prevent !== false) {
+            event.preventDefault();
+          }
+          if (def.stop) {
+            event.stopPropagation();
+          }
+          def.handler(event);
+          break;
+        }
+      }
+    }
+    function bind() {
+      if (!isBrowser()) return;
+      unbind();
+      currentTarget = target ? vue.unref(target) : document;
+      keydownHandler = (e) => handleKeyEvent(e, false);
+      keyupHandler = (e) => handleKeyEvent(e, true);
+      currentTarget == null ? void 0 : currentTarget.addEventListener("keydown", keydownHandler);
+      currentTarget == null ? void 0 : currentTarget.addEventListener("keyup", keyupHandler);
+    }
+    function unbind() {
+      if (currentTarget) {
+        if (keydownHandler) {
+          currentTarget.removeEventListener("keydown", keydownHandler);
+        }
+        if (keyupHandler) {
+          currentTarget.removeEventListener("keyup", keyupHandler);
+        }
+      }
+      currentTarget = null;
+      keydownHandler = null;
+      keyupHandler = null;
+    }
+    function enable() {
+      enabled.value = true;
+    }
+    function disable() {
+      enabled.value = false;
+    }
+    function toggle() {
+      enabled.value = !enabled.value;
+    }
+    vue.watch(enabled, (newEnabled) => {
+      if (newEnabled) {
+        bind();
+      } else {
+        unbind();
+      }
+    });
+    if (target && typeof target === "object" && "value" in target) {
+      vue.watch(target, () => {
+        if (enabled.value) {
+          bind();
+        }
+      });
+    }
+    if (enabled.value) {
+      bind();
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      enabled,
+      enable,
+      disable,
+      toggle,
+      add: addHotkey,
+      remove: removeHotkey,
+      clear: clearHotkeys
+    };
+  }
+  function useHover(options = {}) {
+    const {
+      onEnter,
+      onLeave,
+      class: hoverClass,
+      enterDelay = 0,
+      leaveDelay = 0
+    } = options;
+    const isHovering = vue.ref(false);
+    let enterTimerId = null, leaveTimerId = null, currentElement = null;
+    function clearTimers() {
+      if (enterTimerId) {
+        clearTimeout(enterTimerId);
+        enterTimerId = null;
+      }
+      if (leaveTimerId) {
+        clearTimeout(leaveTimerId);
+        leaveTimerId = null;
+      }
+    }
+    function handleMouseEnter(event) {
+      if (leaveTimerId) {
+        clearTimeout(leaveTimerId);
+        leaveTimerId = null;
+      }
+      if (isHovering.value) return;
+      const delay = vue.unref(enterDelay);
+      if (delay && delay > 0) {
+        enterTimerId = setTimeout(() => {
+          isHovering.value = true;
+          applyHoverState2();
+          onEnter == null ? void 0 : onEnter(event);
+          enterTimerId = null;
+        }, delay);
+      } else {
+        isHovering.value = true;
+        applyHoverState2();
+        onEnter == null ? void 0 : onEnter(event);
+      }
+    }
+    function handleMouseLeave(event) {
+      if (enterTimerId) {
+        clearTimeout(enterTimerId);
+        enterTimerId = null;
+      }
+      if (!isHovering.value) return;
+      const delay = vue.unref(leaveDelay);
+      if (delay && delay > 0) {
+        leaveTimerId = setTimeout(() => {
+          isHovering.value = false;
+          removeHoverState();
+          onLeave == null ? void 0 : onLeave(event);
+          leaveTimerId = null;
+        }, delay);
+      } else {
+        isHovering.value = false;
+        removeHoverState();
+        onLeave == null ? void 0 : onLeave(event);
+      }
+    }
+    function applyHoverState2() {
+      if (currentElement && hoverClass) {
+        currentElement.classList.add(hoverClass);
+      }
+    }
+    function removeHoverState() {
+      if (currentElement && hoverClass) {
+        currentElement.classList.remove(hoverClass);
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      currentElement = element;
+      element.addEventListener("mouseenter", handleMouseEnter);
+      element.addEventListener("mouseleave", handleMouseLeave);
+      return () => {
+        element.removeEventListener("mouseenter", handleMouseEnter);
+        element.removeEventListener("mouseleave", handleMouseLeave);
+        clearTimers();
+        removeHoverState();
+        currentElement = null;
+      };
+    }
+    vue.onUnmounted(() => {
+      clearTimers();
+      removeHoverState();
+    });
+    return {
+      isHovering,
+      bind
+    };
+  }
+  function useImagePreview(options = {}) {
+    const {
+      src: initialSrc,
+      closeOnClickOutside = true,
+      closeOnEsc = true,
+      showCloseButton = true,
+      onOpen,
+      onClose
+    } = options;
+    const isOpen = vue.ref(false);
+    const currentSrc = vue.ref("");
+    let currentElement = null, overlay = null, clickHandler = null, keydownHandler = null;
+    function createOverlay2() {
+      const div = document.createElement("div");
+      div.className = "v-image-preview";
+      div.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      z-index: 9999;
+      background: rgba(0, 0, 0, 0.9);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      cursor: zoom-out;
+    `;
+      return div;
+    }
+    function open(src) {
+      if (!isBrowser()) return;
+      const imageSrc = src || (initialSrc && typeof initialSrc === "object" ? initialSrc.value : initialSrc);
+      if (!imageSrc && !currentElement) return;
+      const finalSrc = imageSrc || currentElement.src;
+      currentSrc.value = finalSrc;
+      overlay = createOverlay2();
+      const img = document.createElement("img");
+      img.src = finalSrc;
+      img.style.cssText = `
+      max-width: 90%;
+      max-height: 90%;
+      object-fit: contain;
+      cursor: default;
+    `;
+      if (showCloseButton) {
+        const closeBtn = document.createElement("button");
+        closeBtn.className = "v-image-preview__close";
+        closeBtn.innerHTML = "&times;";
+        closeBtn.style.cssText = `
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        width: 40px;
+        height: 40px;
+        border: none;
+        background: rgba(255, 255, 255, 0.2);
+        color: white;
+        font-size: 24px;
+        cursor: pointer;
+        border-radius: 50%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      `;
+        closeBtn.addEventListener("click", (e) => {
+          e.stopPropagation();
+          close();
+        });
+        overlay.appendChild(closeBtn);
+      }
+      overlay.appendChild(img);
+      document.body.appendChild(overlay);
+      if (closeOnClickOutside) {
+        clickHandler = close;
+        overlay.addEventListener("click", clickHandler);
+      }
+      if (closeOnEsc) {
+        keydownHandler = (e) => {
+          if (e.key === "Escape") {
+            close();
+          }
+        };
+        document.addEventListener("keydown", keydownHandler);
+      }
+      isOpen.value = true;
+      onOpen == null ? void 0 : onOpen();
+    }
+    function close() {
+      if (overlay) {
+        overlay.remove();
+        overlay = null;
+      }
+      if (clickHandler) {
+        document.removeEventListener("click", clickHandler);
+        clickHandler = null;
+      }
+      if (keydownHandler) {
+        document.removeEventListener("keydown", keydownHandler);
+        keydownHandler = null;
+      }
+      isOpen.value = false;
+      currentSrc.value = "";
+      onClose == null ? void 0 : onClose();
+    }
+    function handleElementClick() {
+      if (currentElement) {
+        open(currentElement.src);
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      element.style.cursor = "zoom-in";
+      element.addEventListener("click", handleElementClick);
+      return unbind;
+    }
+    function unbind() {
+      if (currentElement) {
+        currentElement.style.cursor = "";
+        currentElement.removeEventListener("click", handleElementClick);
+      }
+      currentElement = null;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+      close();
+    });
+    return {
+      isOpen: vue.readonly(isOpen),
+      currentSrc: vue.readonly(currentSrc),
+      open,
+      close,
+      bind
+    };
+  }
+  function useIntersect(options = {}) {
+    const {
+      handler,
+      onEnter,
+      onLeave,
+      onChange,
+      root = null,
+      rootMargin = "0px",
+      threshold = 0,
+      once = false
+    } = options;
+    const isIntersecting = vue.ref(false);
+    const ratio = vue.ref(0);
+    let observer = null, hasTriggeredOnce = false;
+    function createObserver2() {
+      if (!isBrowser() || !supportsIntersectionObserver()) {
+        console.warn("[Directix] useIntersect: IntersectionObserver not supported");
+        return null;
+      }
+      return new IntersectionObserver(
+        (entries) => {
+          for (const entry of entries) {
+            if (once && hasTriggeredOnce) continue;
+            const intersecting = entry.isIntersecting;
+            isIntersecting.value = intersecting;
+            ratio.value = entry.intersectionRatio;
+            handler == null ? void 0 : handler(entry, observer);
+            onChange == null ? void 0 : onChange(intersecting, entry);
+            if (intersecting) {
+              onEnter == null ? void 0 : onEnter(entry, observer);
+              if (once) hasTriggeredOnce = true;
+            } else {
+              onLeave == null ? void 0 : onLeave(entry, observer);
+            }
+          }
+        },
+        {
+          root: vue.unref(root),
+          rootMargin,
+          threshold
+        }
+      );
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      stop();
+      observer = createObserver2();
+      if (observer) {
+        observer.observe(element);
+      }
+      return stop;
+    }
+    function stop() {
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+      isIntersecting.value = false;
+      ratio.value = 0;
+    }
+    vue.onUnmounted(() => {
+      stop();
+    });
+    return {
+      isIntersecting: vue.readonly(isIntersecting),
+      ratio: vue.readonly(ratio),
+      bind,
+      stop
+    };
+  }
+  function getEventPosition(e) {
+    if ("touches" in e && e.touches.length > 0) {
+      return {
+        x: e.touches[0].clientX,
+        y: e.touches[0].clientY
+      };
+    }
+    if ("clientX" in e) {
+      return {
+        x: e.clientX,
+        y: e.clientY
+      };
+    }
+    return { x: 0, y: 0 };
+  }
+  function getDistance(p1, p2) {
+    return Math.sqrt(__pow(p2.x - p1.x, 2) + __pow(p2.y - p1.y, 2));
+  }
+  function useLongPress(options = {}) {
+    const {
+      duration = 500,
+      distance = 10,
+      onStart,
+      onTrigger,
+      onCancel,
+      onTick,
+      tickInterval = 100,
+      prevent = true
+    } = options;
+    const isPressing = vue.ref(false);
+    let timerId = null, tickTimerId = null, startPos = { x: 0, y: 0 }, startPosSet = false;
+    function start(event) {
+      if (!isBrowser()) return;
+      if (prevent) {
+        event.preventDefault();
+      }
+      clearTimers();
+      startPos = getEventPosition(event);
+      startPosSet = true;
+      isPressing.value = true;
+      onStart == null ? void 0 : onStart(event);
+      if (onTick) {
+        let remaining = vue.unref(duration);
+        tickTimerId = setInterval(() => {
+          remaining -= tickInterval;
+          onTick == null ? void 0 : onTick(Math.max(0, remaining));
+        }, tickInterval);
+      }
+      timerId = setTimeout(() => {
+        clearTimers();
+        isPressing.value = false;
+        onTrigger == null ? void 0 : onTrigger(event);
+      }, vue.unref(duration));
+    }
+    function stop(event) {
+      if (!isPressing.value) return;
+      clearTimers();
+      startPosSet = false;
+      isPressing.value = false;
+      onCancel == null ? void 0 : onCancel(event);
+    }
+    function handleMove(event) {
+      if (!isPressing.value || !startPosSet) return;
+      const pos = getEventPosition(event);
+      const dist = getDistance(startPos, pos);
+      if (dist > vue.unref(distance)) {
+        stop(event);
+      }
+    }
+    function clearTimers() {
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      if (tickTimerId) {
+        clearInterval(tickTimerId);
+        tickTimerId = null;
+      }
+    }
+    function bind(element) {
+      element.addEventListener("mousedown", start);
+      element.addEventListener("mouseup", stop);
+      element.addEventListener("mouseleave", stop);
+      element.addEventListener("mousemove", handleMove);
+      element.addEventListener("touchstart", start, { passive: !prevent });
+      element.addEventListener("touchend", stop);
+      element.addEventListener("touchcancel", stop);
+      element.addEventListener("touchmove", handleMove, { passive: true });
+      return () => {
+        element.removeEventListener("mousedown", start);
+        element.removeEventListener("mouseup", stop);
+        element.removeEventListener("mouseleave", stop);
+        element.removeEventListener("mousemove", handleMove);
+        element.removeEventListener("touchstart", start);
+        element.removeEventListener("touchend", stop);
+        element.removeEventListener("touchcancel", stop);
+        element.removeEventListener("touchmove", handleMove);
+        clearTimers();
+      };
+    }
+    vue.onUnmounted(() => {
+      clearTimers();
+    });
+    return {
+      isPressing,
+      start,
+      stop,
+      bind
+    };
+  }
+  function lowercaseText(text, firstOnly = false) {
+    if (!text) return text;
+    if (firstOnly) {
+      return text.charAt(0).toLowerCase() + text.slice(1);
+    }
+    return text.toLowerCase();
+  }
+  function useLowercase(options) {
+    const {
+      text,
+      first = false
+    } = options;
+    const original = vue.ref(vue.unref(text));
+    const transformed = vue.ref("");
+    function calculate() {
+      const textValue = vue.unref(text);
+      const firstValue = vue.unref(first);
+      original.value = textValue;
+      transformed.value = lowercaseText(textValue, firstValue);
+    }
+    vue.watch(
+      () => [vue.unref(text), vue.unref(first)],
+      () => calculate(),
+      { immediate: true }
+    );
+    return {
+      transformed,
+      original
+    };
+  }
+  function createLowercaser(first = false) {
+    return (text) => lowercaseText(text, first);
+  }
+  function formatMoney(value, options = {}) {
+    const {
+      precision = 2,
+      separator = ",",
+      decimal = ".",
+      symbol = "$",
+      symbolPosition = "before"
+    } = options;
+    const fixed = value.toFixed(precision);
+    const [intPart, decPart] = fixed.split(".");
+    const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    let result = formattedInt;
+    if (precision > 0 && decPart) {
+      result += decimal + decPart;
+    }
+    return symbolPosition === "before" ? symbol + result : result + symbol;
+  }
+  function parseMoney(formatted, options = {}) {
+    const { decimal = ".", symbol = "$" } = options;
+    let cleaned = formatted.replace(new RegExp(`[${symbol}\\s]`, "g"), "");
+    if (decimal !== ".") {
+      cleaned = cleaned.replace(/,/g, "");
+      cleaned = cleaned.replace(new RegExp(`\\${decimal}`, "g"), ".");
+    } else {
+      cleaned = cleaned.replace(/,/g, "");
+    }
+    return parseFloat(cleaned) || 0;
+  }
+  function useMoney(options) {
+    const {
+      value,
+      symbol = "$",
+      symbolPosition = "before",
+      precision = 2,
+      separator = ",",
+      decimal = "."
+    } = options;
+    const valueRef = vue.ref(vue.unref(value));
+    function getFormatOptions() {
+      return {
+        precision: vue.unref(precision),
+        separator: vue.unref(separator),
+        decimal: vue.unref(decimal),
+        symbol: vue.unref(symbol),
+        symbolPosition: vue.unref(symbolPosition)
+      };
+    }
+    const formatted = vue.computed(() => {
+      return formatMoney(valueRef.value, getFormatOptions());
+    });
+    function parse(formattedString) {
+      return parseMoney(formattedString, {
+        decimal: vue.unref(decimal),
+        symbol: vue.unref(symbol)
+      });
+    }
+    vue.watch(
+      () => vue.unref(value),
+      (newValue) => {
+        valueRef.value = newValue;
+      }
+    );
+    return {
+      value: valueRef,
+      formatted,
+      parse
+    };
+  }
+  function createMoneyFormatter(options = {}) {
+    return (value) => formatMoney(value, options);
+  }
+  function formatNumber(value, options = {}) {
+    const {
+      precision = 0,
+      separator = ",",
+      decimal = ".",
+      prefix = "",
+      suffix = ""
+    } = options;
+    const fixed = value.toFixed(precision);
+    const [intPart, decPart] = fixed.split(".");
+    const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    let result = formattedInt;
+    if (precision > 0 && decPart) {
+      result += decimal + decPart;
+    }
+    return prefix + result + suffix;
+  }
+  function parseNumber(formatted, options = {}) {
+    const { decimal = ".", prefix = "", suffix = "" } = options;
+    let cleaned = formatted.replace(new RegExp(`^${escapeRegex$1(prefix)}`), "").replace(new RegExp(`${escapeRegex$1(suffix)}$`), "").replace(/\s/g, "");
+    if (decimal !== ".") {
+      cleaned = cleaned.replace(/,/g, "");
+      cleaned = cleaned.replace(new RegExp(`\\${decimal}`, "g"), ".");
+    } else {
+      cleaned = cleaned.replace(/,/g, "");
+    }
+    return parseFloat(cleaned) || 0;
+  }
+  function escapeRegex$1(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function useNumber(options) {
+    const {
+      value,
+      precision = 0,
+      separator = ",",
+      decimal = ".",
+      prefix = "",
+      suffix = ""
+    } = options;
+    const valueRef = vue.ref(vue.unref(value));
+    function getFormatOptions() {
+      return {
+        precision: vue.unref(precision),
+        separator: vue.unref(separator),
+        decimal: vue.unref(decimal),
+        prefix: vue.unref(prefix),
+        suffix: vue.unref(suffix)
+      };
+    }
+    const formatted = vue.computed(() => {
+      return formatNumber(valueRef.value, getFormatOptions());
+    });
+    function parse(formattedString) {
+      return parseNumber(formattedString, {
+        decimal: vue.unref(decimal),
+        prefix: vue.unref(prefix),
+        suffix: vue.unref(suffix)
+      });
+    }
+    vue.watch(
+      () => vue.unref(value),
+      (newValue) => {
+        valueRef.value = newValue;
+      }
+    );
+    return {
+      value: valueRef,
+      formatted,
+      parse
+    };
+  }
+  function createNumberFormatter(options = {}) {
+    return (value) => formatNumber(value, options);
+  }
+  const WILDCARD = "*";
+  function hasPermission(required, permissions) {
+    return permissions.includes(WILDCARD) || permissions.includes(required);
+  }
+  function usePermission(options) {
+    const {
+      value,
+      mode = "some",
+      check,
+      getPermissions,
+      getRoles,
+      roleMap = {}
+    } = options;
+    const granted = vue.ref(false);
+    function verifyPermission2() {
+      if (check) {
+        return check(vue.unref(value), vue.unref(mode));
+      }
+      if (!getPermissions) {
+        console.warn("[Directix] usePermission: getPermissions function is required");
+        return true;
+      }
+      const permissions = getPermissions();
+      const roles = (getRoles == null ? void 0 : getRoles()) || [];
+      const required = Array.isArray(vue.unref(value)) ? vue.unref(value) : [vue.unref(value)];
+      const currentMode = vue.unref(mode);
+      function checkSingle(perm) {
+        if (perm in roleMap) {
+          return roles.includes(perm);
+        }
+        if (hasPermission(perm, permissions)) {
+          return true;
+        }
+        for (const role of roles) {
+          const rolePermissions = roleMap[role] || [];
+          if (hasPermission(perm, rolePermissions)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return currentMode === "every" ? required.every(checkSingle) : required.some(checkSingle);
+    }
+    function recheck() {
+      granted.value = verifyPermission2();
+    }
+    vue.watch(
+      () => vue.unref(value),
+      () => recheck(),
+      { immediate: true }
+    );
+    if (typeof mode === "object" && "value" in mode) {
+      vue.watch(mode, () => recheck());
+    }
+    return {
+      granted: vue.readonly(granted),
+      recheck
+    };
+  }
+  function createPermissionChecker(config) {
+    const { getPermissions, getRoles, roleMap = {} } = config;
+    return (value, mode = "some") => {
+      const permissions = getPermissions();
+      const roles = (getRoles == null ? void 0 : getRoles()) || [];
+      const required = Array.isArray(value) ? value : [value];
+      function checkSingle(perm) {
+        if (perm in roleMap) {
+          return roles.includes(perm);
+        }
+        if (hasPermission(perm, permissions)) {
+          return true;
+        }
+        for (const role of roles) {
+          const rolePermissions = roleMap[role] || [];
+          if (hasPermission(perm, rolePermissions)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return mode === "every" ? required.every(checkSingle) : required.some(checkSingle);
+    };
+  }
+  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);
+  }
+  function buildPrintContent(el, options) {
+    let styles = "";
+    if (typeof document !== "undefined") {
+      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}">`;
+        }
+      });
+    }
+    options.cssUrls.forEach((url) => {
+      styles += `<link rel="stylesheet" href="${url}">`;
+    });
+    if (options.styles) {
+      styles += `<style>${options.styles}</style>`;
+    }
+    styles += `
+		<style>
+			@media print {
+				body { margin: 0; padding: 20px; }
+				${options.printClass ? `.${options.printClass} { page-break-inside: avoid; }` : ""}
+			}
+		</style>
+	`;
+    const title = options.title || (typeof document !== "undefined" ? 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 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] usePrint: 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] usePrint: 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] usePrint: 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 usePrint(options = {}) {
+    const {
+      title,
+      styles,
+      cssUrls = [],
+      onBeforePrint,
+      onAfterPrint,
+      newWindow = false,
+      printClass
+    } = options;
+    const isPrinting = vue.ref(false);
+    function print(target) {
+      return __async(this, null, function* () {
+        if (onBeforePrint) {
+          const result = onBeforePrint();
+          if (result === false) return;
+        }
+        isPrinting.value = true;
+        try {
+          let targetEl = null;
+          if (typeof target === "string") {
+            targetEl = document.querySelector(target);
+          } else if (target instanceof HTMLElement) {
+            targetEl = target;
+          } else {
+            targetEl = document.body;
+          }
+          if (!targetEl) {
+            console.warn("[Directix] usePrint: Target element not found");
+            return;
+          }
+          const printOptions = {
+            title: vue.unref(title) || "",
+            styles: Array.isArray(vue.unref(styles)) ? vue.unref(styles).join("\n") : vue.unref(styles) || "",
+            cssUrls: vue.unref(cssUrls) || [],
+            printClass: vue.unref(printClass)
+          };
+          if (vue.unref(newWindow)) {
+            yield printInNewWindow(targetEl, printOptions);
+          } else {
+            yield printInIframe(targetEl, printOptions);
+          }
+          if (onAfterPrint) {
+            onAfterPrint();
+          }
+        } finally {
+          isPrinting.value = false;
+        }
+      });
+    }
+    function printPage() {
+      return __async(this, null, function* () {
+        yield print();
+      });
+    }
+    vue.onUnmounted(() => {
+    });
+    return {
+      isPrinting,
+      print,
+      printPage
+    };
+  }
+  function quickPrint(_0) {
+    return __async(this, arguments, function* (target, options = {}) {
+      const { print } = usePrint(options);
+      yield print(target);
+    });
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  function usePullRefresh(options) {
+    const {
+      handler,
+      distance = 60,
+      maxDistance = 100,
+      disabled = false,
+      successDuration = 500,
+      errorDuration = 1e3
+    } = options;
+    const state = vue.ref("idle");
+    const distanceValue = vue.ref(0);
+    const isPulling = vue.ref(false);
+    const containerRef = vue.ref(null);
+    let startY = 0, currentY = 0;
+    const getDistance2 = () => vue.unref(distance);
+    const getMaxDistance = () => vue.unref(maxDistance);
+    const getDisabled = () => vue.unref(disabled);
+    const getSuccessDuration = () => vue.unref(successDuration);
+    const getErrorDuration = () => vue.unref(errorDuration);
+    function reset() {
+      state.value = "idle";
+      distanceValue.value = 0;
+      isPulling.value = false;
+    }
+    function refresh() {
+      return __async(this, null, function* () {
+        state.value = "loading";
+        try {
+          yield handler();
+          state.value = "success";
+          yield sleep(getSuccessDuration());
+        } catch (e) {
+          state.value = "error";
+          yield sleep(getErrorDuration());
+        } finally {
+          reset();
+        }
+      });
+    }
+    function touchstart(e) {
+      if (getDisabled() || state.value === "loading") return;
+      const container = containerRef.value;
+      if (container && container.scrollTop > 0) return;
+      isPulling.value = true;
+      startY = e.touches[0].clientY;
+      currentY = startY;
+      state.value = "idle";
+    }
+    function touchmove(e) {
+      if (!isPulling.value || getDisabled() || state.value === "loading") return;
+      currentY = e.touches[0].clientY;
+      const diff = currentY - startY;
+      if (diff <= 0) {
+        distanceValue.value = 0;
+        state.value = "idle";
+        return;
+      }
+      e.preventDefault();
+      const calculatedDistance = Math.min(diff * 0.5, getMaxDistance());
+      distanceValue.value = calculatedDistance;
+      const progress = calculatedDistance / getDistance2();
+      state.value = progress >= 1 ? "ready" : "pulling";
+    }
+    function touchend() {
+      if (!isPulling.value || getDisabled()) return;
+      isPulling.value = false;
+      if (state.value === "ready" && distanceValue.value >= getDistance2()) {
+        refresh();
+      } else {
+        distanceValue.value = 0;
+        reset();
+      }
+    }
+    vue.onUnmounted(() => {
+      reset();
+    });
+    return {
+      state,
+      distance: distanceValue,
+      isPulling,
+      events: {
+        touchstart,
+        touchmove,
+        touchend
+      },
+      containerRef,
+      refresh
+    };
+  }
+  function useResize(options = {}) {
+    const {
+      debounce: debounce2 = 0,
+      box = "content-box",
+      onResize
+    } = options;
+    const width = vue.ref(0);
+    const height = vue.ref(0);
+    let observer = null, debounceTimer = null, fallbackIframe = null;
+    function handleResize(entry) {
+      const currentDebounce = vue.unref(debounce2);
+      function doUpdate() {
+        width.value = entry.contentRect.width;
+        height.value = entry.contentRect.height;
+        onResize == null ? void 0 : onResize({
+          width: entry.contentRect.width,
+          height: entry.contentRect.height,
+          contentRect: entry.contentRect
+        });
+      }
+      if (currentDebounce && currentDebounce > 0) {
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(doUpdate, currentDebounce);
+      } else {
+        doUpdate();
+      }
+    }
+    function createObserver2() {
+      if (!isBrowser()) return;
+      if (supportsResizeObserver()) {
+        observer = new ResizeObserver((entries) => {
+          for (const entry of entries) {
+            handleResize(entry);
+          }
+        });
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      stop();
+      const rect = element.getBoundingClientRect();
+      width.value = rect.width;
+      height.value = rect.height;
+      if (supportsResizeObserver()) {
+        createObserver2();
+        observer == null ? void 0 : observer.observe(element, { box });
+      } else {
+        fallbackIframe = document.createElement("iframe");
+        fallbackIframe.style.cssText = `
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        border: none;
+        pointer-events: none;
+        opacity: 0;
+      `;
+        const computedStyle = getComputedStyle(element);
+        if (computedStyle.position === "static") {
+          element.style.position = "relative";
+        }
+        element.appendChild(fallbackIframe);
+        const iWindow = fallbackIframe.contentWindow;
+        if (iWindow) {
+          iWindow.addEventListener("resize", () => {
+            const rect2 = element.getBoundingClientRect();
+            handleResize({
+              contentRect: rect2
+            });
+          });
+        }
+      }
+      return stop;
+    }
+    function stop() {
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+      if (fallbackIframe) {
+        fallbackIframe.remove();
+        fallbackIframe = null;
+      }
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+    }
+    vue.onUnmounted(() => {
+      stop();
+    });
+    return {
+      width: vue.readonly(width),
+      height: vue.readonly(height),
+      bind,
+      stop
+    };
+  }
+  function getScrollInfoFromContainer(container, lastScrollLeft, lastScrollTop) {
+    let scrollLeft = 0, scrollTop = 0, scrollLeftMax = 0, scrollTopMax = 0;
+    if (container === window) {
+      scrollLeft = window.scrollX || document.documentElement.scrollLeft;
+      scrollTop = window.scrollY || document.documentElement.scrollTop;
+      scrollLeftMax = document.documentElement.scrollWidth - window.innerWidth;
+      scrollTopMax = document.documentElement.scrollHeight - window.innerHeight;
+    } else {
+      const el = container;
+      scrollLeft = el.scrollLeft;
+      scrollTop = el.scrollTop;
+      scrollLeftMax = el.scrollWidth - el.clientWidth;
+      scrollTopMax = el.scrollHeight - el.clientHeight;
+    }
+    const progressX = scrollLeftMax > 0 ? scrollLeft / scrollLeftMax : 0;
+    const progressY = scrollTopMax > 0 ? scrollTop / scrollTopMax : 0;
+    const directionX = scrollLeft !== lastScrollLeft ? scrollLeft > lastScrollLeft ? 1 : -1 : 0;
+    const directionY = scrollTop !== lastScrollTop ? scrollTop > lastScrollTop ? 1 : -1 : 0;
+    return {
+      scrollLeft,
+      scrollTop,
+      scrollLeftMax,
+      scrollTopMax,
+      progressX,
+      progressY,
+      directionX,
+      directionY
+    };
+  }
+  function useScroll(options = {}) {
+    const { throttle: throttle2 = 0, passive = true } = options;
+    const scrollLeft = vue.ref(0);
+    const scrollTop = vue.ref(0);
+    const progressX = vue.ref(0);
+    const progressY = vue.ref(0);
+    const directionX = vue.ref(0);
+    const directionY = vue.ref(0);
+    const isScrolling = vue.ref(false);
+    let container = null, lastScrollLeft = 0, lastScrollTop = 0, scrollHandler = null, throttleTimer = null, scrollTimeout = null;
+    const info = vue.computed(() => ({
+      scrollLeft: scrollLeft.value,
+      scrollTop: scrollTop.value,
+      scrollLeftMax: 0,
+      scrollTopMax: 0,
+      progressX: progressX.value,
+      progressY: progressY.value,
+      directionX: directionX.value,
+      directionY: directionY.value
+    }));
+    function updateScrollInfo(_e) {
+      if (!container) return;
+      const currentThrottle = vue.unref(throttle2);
+      function doUpdate() {
+        const scrollInfo = getScrollInfoFromContainer(container, lastScrollLeft, lastScrollTop);
+        scrollLeft.value = scrollInfo.scrollLeft;
+        scrollTop.value = scrollInfo.scrollTop;
+        progressX.value = scrollInfo.progressX;
+        progressY.value = scrollInfo.progressY;
+        directionX.value = scrollInfo.directionX;
+        directionY.value = scrollInfo.directionY;
+        lastScrollLeft = scrollInfo.scrollLeft;
+        lastScrollTop = scrollInfo.scrollTop;
+        isScrolling.value = true;
+        if (scrollTimeout) {
+          clearTimeout(scrollTimeout);
+        }
+        scrollTimeout = setTimeout(() => {
+          isScrolling.value = false;
+        }, 150);
+      }
+      if (currentThrottle && currentThrottle > 0) {
+        if (!throttleTimer) {
+          throttleTimer = setTimeout(() => {
+            doUpdate();
+            throttleTimer = null;
+          }, currentThrottle);
+        }
+      } else {
+        doUpdate();
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      stop();
+      if (element) {
+        container = element;
+      } else {
+        container = window;
+      }
+      const initialInfo = getScrollInfoFromContainer(container, 0, 0);
+      scrollLeft.value = initialInfo.scrollLeft;
+      scrollTop.value = initialInfo.scrollTop;
+      progressX.value = initialInfo.progressX;
+      progressY.value = initialInfo.progressY;
+      lastScrollLeft = initialInfo.scrollLeft;
+      lastScrollTop = initialInfo.scrollTop;
+      scrollHandler = updateScrollInfo;
+      container.addEventListener("scroll", scrollHandler, { passive });
+      return stop;
+    }
+    function stop() {
+      if (container && scrollHandler) {
+        container.removeEventListener("scroll", scrollHandler);
+      }
+      if (throttleTimer) {
+        clearTimeout(throttleTimer);
+        throttleTimer = null;
+      }
+      if (scrollTimeout) {
+        clearTimeout(scrollTimeout);
+        scrollTimeout = null;
+      }
+      container = null;
+      scrollHandler = null;
+    }
+    function scrollTo(opts) {
+      if (!container) return;
+      const { top, left, behavior = "smooth" } = opts;
+      if (container === window) {
+        window.scrollTo({
+          top,
+          left,
+          behavior
+        });
+      } else {
+        const el = container;
+        if (top !== void 0) el.scrollTop = top;
+        if (left !== void 0) el.scrollLeft = left;
+      }
+    }
+    vue.onUnmounted(() => {
+      stop();
+    });
+    return {
+      scrollLeft: vue.readonly(scrollLeft),
+      scrollTop: vue.readonly(scrollTop),
+      progressX: vue.readonly(progressX),
+      progressY: vue.readonly(progressY),
+      directionX: vue.readonly(directionX),
+      directionY: vue.readonly(directionY),
+      isScrolling: vue.readonly(isScrolling),
+      info: vue.readonly(info),
+      bind,
+      stop,
+      scrollTo
+    };
+  }
+  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 useSwipe(options = {}) {
+    const {
+      handler,
+      threshold = 30,
+      maxTime = 500,
+      directions = DEFAULT_DIRECTIONS,
+      preventScrollOnSwipe = true,
+      mouse = true,
+      onLeft,
+      onRight,
+      onUp,
+      onDown
+    } = options;
+    const direction = vue.ref(null);
+    const lengthX = vue.ref(0);
+    const lengthY = vue.ref(0);
+    const isSwiping = vue.ref(false);
+    let currentElement = null, startX = 0, startY = 0, startTime = 0;
+    function triggerSwipe2(deltaX, deltaY, deltaTime, event) {
+      var _a;
+      const currentThreshold = vue.unref(threshold);
+      const currentMaxTime = vue.unref(maxTime);
+      if (deltaTime > currentMaxTime) return;
+      const distance = Math.max(Math.abs(deltaX), Math.abs(deltaY));
+      if (distance < currentThreshold) return;
+      const swipeDirection = getSwipeDirection(deltaX, deltaY, directions);
+      if (!swipeDirection) return;
+      direction.value = swipeDirection;
+      lengthX.value = deltaX;
+      lengthY.value = deltaY;
+      if (preventScrollOnSwipe && event.cancelable) {
+        event.preventDefault();
+      }
+      handler == null ? void 0 : handler(swipeDirection, event);
+      const callbacks = {
+        left: onLeft,
+        right: onRight,
+        up: onUp,
+        down: onDown
+      };
+      (_a = callbacks[swipeDirection]) == null ? void 0 : _a.call(callbacks);
+      currentElement == null ? void 0 : currentElement.dispatchEvent(new CustomEvent("swipe", {
+        detail: { direction: swipeDirection, deltaX, deltaY, deltaTime }
+      }));
+    }
+    function handleStart(clientX, clientY) {
+      startX = clientX;
+      startY = clientY;
+      startTime = Date.now();
+      isSwiping.value = true;
+      direction.value = null;
+      lengthX.value = 0;
+      lengthY.value = 0;
+    }
+    function handleEnd(clientX, clientY, event) {
+      if (!isSwiping.value) return;
+      isSwiping.value = false;
+      const deltaX = clientX - startX;
+      const deltaY = clientY - startY;
+      const deltaTime = Date.now() - startTime;
+      triggerSwipe2(deltaX, deltaY, deltaTime, event);
+    }
+    function touchStart(e) {
+      handleStart(e.touches[0].clientX, e.touches[0].clientY);
+    }
+    function touchMove(e) {
+      if (!isSwiping.value || !preventScrollOnSwipe) return;
+      e.preventDefault();
+    }
+    function touchEnd(e) {
+      const touch = e.changedTouches[0];
+      handleEnd(touch.clientX, touch.clientY, e);
+    }
+    function mouseDown(e) {
+      handleStart(e.clientX, e.clientY);
+    }
+    function mouseUp(e) {
+      handleEnd(e.clientX, e.clientY, e);
+    }
+    function mouseLeave(e) {
+      if (isSwiping.value) {
+        handleEnd(e.clientX, e.clientY, e);
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      element.style.touchAction = "none";
+      element.style.userSelect = "none";
+      element.addEventListener("touchstart", touchStart, { passive: true });
+      element.addEventListener("touchmove", touchMove, { passive: false });
+      element.addEventListener("touchend", touchEnd);
+      element.addEventListener("touchcancel", touchEnd);
+      if (vue.unref(mouse)) {
+        element.addEventListener("mousedown", mouseDown);
+        element.addEventListener("mouseup", mouseUp);
+        element.addEventListener("mouseleave", mouseLeave);
+      }
+      return unbind;
+    }
+    function unbind() {
+      if (!currentElement) return;
+      currentElement.removeEventListener("touchstart", touchStart);
+      currentElement.removeEventListener("touchmove", touchMove);
+      currentElement.removeEventListener("touchend", touchEnd);
+      currentElement.removeEventListener("touchcancel", touchEnd);
+      if (vue.unref(mouse)) {
+        currentElement.removeEventListener("mousedown", mouseDown);
+        currentElement.removeEventListener("mouseup", mouseUp);
+        currentElement.removeEventListener("mouseleave", mouseLeave);
+      }
+      currentElement = null;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      direction: vue.readonly(direction),
+      lengthX: vue.readonly(lengthX),
+      lengthY: vue.readonly(lengthY),
+      isSwiping: vue.readonly(isSwiping),
+      bind
+    };
+  }
+  function useThrottle(options) {
+    const {
+      handler,
+      wait = 300,
+      leading = true,
+      trailing = true
+    } = options;
+    let timerId = null, lastArgs = null, lastThis = null, lastCallTime = 0;
+    const getWait = () => vue.unref(wait);
+    const getLeading = () => vue.unref(leading);
+    const getTrailing = () => vue.unref(trailing);
+    const invokeFunc = () => {
+      if (lastArgs) {
+        handler.apply(lastThis, lastArgs);
+        lastArgs = null;
+        lastThis = null;
+      }
+    };
+    function run(...args) {
+      const now = Date.now();
+      const currentWait = getWait();
+      if (!lastCallTime && !getLeading()) {
+        lastCallTime = now;
+      }
+      const remaining = currentWait - (now - lastCallTime);
+      lastArgs = args;
+      lastThis = this;
+      if (remaining <= 0 || remaining > currentWait) {
+        if (timerId) {
+          clearTimeout(timerId);
+          timerId = null;
+        }
+        lastCallTime = now;
+        invokeFunc();
+      } else if (!timerId && getTrailing()) {
+        timerId = setTimeout(() => {
+          lastCallTime = getLeading() ? Date.now() : 0;
+          timerId = null;
+          invokeFunc();
+        }, remaining);
+      }
+    }
+    function cancel() {
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      lastCallTime = 0;
+      lastArgs = null;
+      lastThis = null;
+    }
+    vue.onUnmounted(() => {
+      cancel();
+    });
+    return {
+      run,
+      cancel
+    };
+  }
+  function throttleFn(fn, wait = 300, options) {
+    return throttle(fn, wait, options);
+  }
+  function useTouch(options = {}) {
+    const {
+      onSwipe,
+      onSwipeLeft,
+      onSwipeRight,
+      onSwipeUp,
+      onSwipeDown,
+      onPinch,
+      onRotate,
+      onTap,
+      onLongPress,
+      swipeThreshold = 30,
+      longPressDuration = 500,
+      tapDuration = 250,
+      disabled = false
+    } = options;
+    const gesture = vue.ref(null);
+    let currentElement = null, startX = 0, startY = 0, startTime = 0, longPressTimer = null, initialPinchDistance = 0, initialAngle = 0;
+    function getTouchCenter(touches) {
+      let x = 0, y = 0;
+      for (let i = 0; i < touches.length; i++) {
+        x += touches[i].clientX;
+        y += touches[i].clientY;
+      }
+      return { x: x / touches.length, y: y / touches.length };
+    }
+    function getDistance2(touch1, touch2) {
+      const dx = touch1.clientX - touch2.clientX;
+      const dy = touch1.clientY - touch2.clientY;
+      return Math.sqrt(dx * dx + dy * dy);
+    }
+    function getAngle2(touch1, touch2) {
+      return Math.atan2(touch2.clientY - touch1.clientY, touch2.clientX - touch1.clientX) * (180 / Math.PI);
+    }
+    function handleTouchStart(e) {
+      if (vue.unref(disabled)) return;
+      startTime = Date.now();
+      gesture.value = null;
+      if (e.touches.length === 1) {
+        startX = e.touches[0].clientX;
+        startY = e.touches[0].clientY;
+        if (onLongPress) {
+          longPressTimer = setTimeout(() => {
+            gesture.value = "longPress";
+            onLongPress({
+              type: "longPress",
+              center: { x: startX, y: startY },
+              event: e
+            });
+          }, longPressDuration);
+        }
+      } else if (e.touches.length === 2) {
+        initialPinchDistance = getDistance2(e.touches[0], e.touches[1]);
+        initialAngle = getAngle2(e.touches[0], e.touches[1]);
+      }
+    }
+    function handleTouchMove(e) {
+      if (vue.unref(disabled)) return;
+      if (longPressTimer) {
+        clearTimeout(longPressTimer);
+        longPressTimer = null;
+      }
+      if (e.touches.length === 2 && (onPinch || onRotate)) {
+        const currentDistance = getDistance2(e.touches[0], e.touches[1]);
+        const currentAngle = getAngle2(e.touches[0], e.touches[1]);
+        if (onPinch && initialPinchDistance > 0) {
+          const scale = currentDistance / initialPinchDistance;
+          gesture.value = "pinch";
+          onPinch({
+            type: "pinch",
+            scale,
+            center: getTouchCenter(e.touches),
+            event: e
+          });
+        }
+        if (onRotate) {
+          const rotation = currentAngle - initialAngle;
+          gesture.value = "rotate";
+          onRotate({
+            type: "rotate",
+            rotation,
+            center: getTouchCenter(e.touches),
+            event: e
+          });
+        }
+      }
+    }
+    function handleTouchEnd(e) {
+      if (vue.unref(disabled)) return;
+      if (longPressTimer) {
+        clearTimeout(longPressTimer);
+        longPressTimer = null;
+      }
+      const duration = Date.now() - startTime;
+      if (e.changedTouches.length === 1) {
+        const endX = e.changedTouches[0].clientX;
+        const endY = e.changedTouches[0].clientY;
+        const deltaX = endX - startX;
+        const deltaY = endY - startY;
+        const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+        if (distance >= swipeThreshold) {
+          gesture.value = "swipe";
+          let direction;
+          if (Math.abs(deltaX) > Math.abs(deltaY)) {
+            direction = deltaX > 0 ? "right" : "left";
+          } else {
+            direction = deltaY > 0 ? "down" : "up";
+          }
+          const event = {
+            type: "swipe",
+            direction,
+            distance,
+            angle: Math.atan2(deltaY, deltaX) * (180 / Math.PI),
+            center: { x: endX, y: endY },
+            event: e
+          };
+          onSwipe == null ? void 0 : onSwipe(event);
+          switch (direction) {
+            case "left":
+              onSwipeLeft == null ? void 0 : onSwipeLeft(event);
+              break;
+            case "right":
+              onSwipeRight == null ? void 0 : onSwipeRight(event);
+              break;
+            case "up":
+              onSwipeUp == null ? void 0 : onSwipeUp(event);
+              break;
+            case "down":
+              onSwipeDown == null ? void 0 : onSwipeDown(event);
+              break;
+          }
+        } else if (distance < 10 && duration < tapDuration && onTap) {
+          gesture.value = "tap";
+          onTap({
+            type: "tap",
+            center: { x: endX, y: endY },
+            event: e
+          });
+        }
+      }
+      gesture.value = null;
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      element.addEventListener("touchstart", handleTouchStart, { passive: true });
+      element.addEventListener("touchmove", handleTouchMove, { passive: true });
+      element.addEventListener("touchend", handleTouchEnd);
+      element.addEventListener("touchcancel", handleTouchEnd);
+      return unbind;
+    }
+    function unbind() {
+      if (currentElement) {
+        currentElement.removeEventListener("touchstart", handleTouchStart);
+        currentElement.removeEventListener("touchmove", handleTouchMove);
+        currentElement.removeEventListener("touchend", handleTouchEnd);
+        currentElement.removeEventListener("touchcancel", handleTouchEnd);
+      }
+      if (longPressTimer) {
+        clearTimeout(longPressTimer);
+        longPressTimer = null;
+      }
+      currentElement = null;
+      gesture.value = null;
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      gesture: vue.readonly(gesture),
+      bind
+    };
+  }
+  function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function trimText(text, position = "both", chars) {
+    const charPattern = chars ? `[\\s${escapeRegex(chars)}]` : "\\s";
+    switch (position) {
+      case "start":
+        return text.replace(new RegExp(`^${charPattern}+`, "g"), "");
+      case "end":
+        return text.replace(new RegExp(`${charPattern}+$`, "g"), "");
+      case "both":
+      default:
+        return text.replace(new RegExp(`^${charPattern}+|${charPattern}+$`, "g"), "");
+    }
+  }
+  function useTrim(options) {
+    const {
+      text,
+      position = "both",
+      chars
+    } = options;
+    const original = vue.ref(vue.unref(text));
+    const trimmed = vue.ref("");
+    const wasTrimmed = vue.ref(false);
+    function calculate() {
+      const textValue = vue.unref(text);
+      const positionValue = vue.unref(position);
+      const charsValue = vue.unref(chars);
+      original.value = textValue;
+      trimmed.value = trimText(textValue, positionValue, charsValue);
+      wasTrimmed.value = trimmed.value !== textValue;
+    }
+    vue.watch(
+      () => [vue.unref(text), vue.unref(position), vue.unref(chars)],
+      () => calculate(),
+      { immediate: true }
+    );
+    return {
+      trimmed,
+      original,
+      wasTrimmed
+    };
+  }
+  function createTrimmer(position = "both", chars) {
+    return (text) => trimText(text, position, chars);
+  }
+  function uppercaseText(text, firstOnly = false) {
+    if (!text) return text;
+    if (firstOnly) {
+      return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    return text.toUpperCase();
+  }
+  function useUppercase(options) {
+    const {
+      text,
+      first = false
+    } = options;
+    const original = vue.ref(vue.unref(text));
+    const transformed = vue.ref("");
+    function calculate() {
+      const textValue = vue.unref(text);
+      const firstValue = vue.unref(first);
+      original.value = textValue;
+      transformed.value = uppercaseText(textValue, firstValue);
+    }
+    vue.watch(
+      () => [vue.unref(text), vue.unref(first)],
+      () => calculate(),
+      { immediate: true }
+    );
+    return {
+      transformed,
+      original
+    };
+  }
+  function createUppercaser(first = false) {
+    return (text) => uppercaseText(text, first);
+  }
+  function useVirtualList(options) {
+    const {
+      items,
+      itemSize = 50,
+      height = 400,
+      overscan = 3,
+      keyField: _keyField = "id"
+    } = options;
+    const containerRef = vue.ref(null);
+    const scrollTop = vue.ref(0);
+    const startIndex = vue.ref(0);
+    const endIndex = vue.ref(0);
+    const getItems = () => vue.unref(items);
+    const getItemSizeValue = () => vue.unref(itemSize);
+    const getHeight = () => vue.unref(height);
+    const getOverscan = () => vue.unref(overscan);
+    const totalHeight = vue.computed(() => {
+      const itemsList = getItems();
+      const size = getItemSizeValue();
+      if (typeof size === "function") {
+        let total = 0;
+        for (let i = 0; i < itemsList.length; i++) {
+          total += size(i);
+        }
+        return total;
+      }
+      return size * itemsList.length;
+    });
+    function calculateVisibleRange2() {
+      const itemsList = getItems();
+      const size = getItemSizeValue();
+      const containerHeight = getHeight();
+      const overscanValue = getOverscan();
+      const currentScrollTop = scrollTop.value;
+      let start = 0, end = 0, offsetY = 0;
+      if (typeof size === "function") {
+        let currentOffset = 0;
+        for (let i = 0; i < itemsList.length; i++) {
+          const itemHeight = size(i);
+          if (currentOffset + itemHeight > currentScrollTop) {
+            start = i;
+            offsetY = currentOffset;
+            break;
+          }
+          currentOffset += itemHeight;
+        }
+        end = start;
+        currentOffset = offsetY;
+        while (end < itemsList.length && currentOffset < currentScrollTop + containerHeight) {
+          currentOffset += size(end);
+          end++;
+        }
+        start = Math.max(0, start - overscanValue);
+        end = Math.min(itemsList.length, end + overscanValue);
+        currentOffset = 0;
+        for (let i = 0; i < start; i++) {
+          currentOffset += size(i);
+        }
+        offsetY = currentOffset;
+      } else {
+        start = Math.max(0, Math.floor(currentScrollTop / size) - overscanValue);
+        end = Math.min(itemsList.length, Math.ceil((currentScrollTop + containerHeight) / size) + overscanValue);
+        offsetY = start * size;
+      }
+      return { start, end, offsetY };
+    }
+    const visibleItems = vue.computed(() => {
+      const itemsList = getItems();
+      const size = getItemSizeValue();
+      const { start, end, offsetY } = calculateVisibleRange2();
+      startIndex.value = start;
+      endIndex.value = end;
+      const result = [];
+      let currentOffset = offsetY;
+      for (let i = start; i < end; i++) {
+        const item = itemsList[i];
+        if (item !== void 0) {
+          const itemHeight = typeof size === "function" ? size(i) : size;
+          result.push({
+            item,
+            index: i,
+            style: {
+              position: "absolute",
+              top: `${currentOffset}px`,
+              height: `${itemHeight}px`,
+              width: "100%"
+            }
+          });
+          currentOffset += itemHeight;
+        }
+      }
+      return result;
+    });
+    const listStyle = vue.computed(() => ({
+      height: `${getHeight()}px`,
+      overflow: "auto",
+      position: "relative"
+    }));
+    function handleScroll(event) {
+      const target = event.target;
+      scrollTop.value = target.scrollTop;
+    }
+    function scrollToIndex(index) {
+      if (!containerRef.value) return;
+      const size = getItemSizeValue();
+      const itemsList = getItems();
+      if (typeof size === "function") {
+        let offset = 0;
+        for (let i = 0; i < Math.min(index, itemsList.length); i++) {
+          offset += size(i);
+        }
+        containerRef.value.scrollTop = offset;
+      } else {
+        containerRef.value.scrollTop = index * size;
+      }
+    }
+    function scrollTo(position) {
+      if (!containerRef.value) return;
+      containerRef.value.scrollTop = position;
+    }
+    vue.onMounted(() => {
+      if (containerRef.value) {
+        containerRef.value.addEventListener("scroll", handleScroll, { passive: true });
+      }
+    });
+    vue.onUnmounted(() => {
+      if (containerRef.value) {
+        containerRef.value.removeEventListener("scroll", handleScroll);
+      }
+    });
+    return {
+      visibleItems,
+      totalHeight,
+      scrollTop,
+      startIndex,
+      endIndex,
+      scrollToIndex,
+      scrollTo,
+      containerRef,
+      listStyle
+    };
+  }
+  function useVisible(options = {}) {
+    const {
+      initial = true,
+      useHidden = false,
+      onChange
+    } = options;
+    const visible = vue.ref(vue.unref(initial));
+    let currentElement = null, originalDisplay = "", originalVisibility = "";
+    function show() {
+      visible.value = true;
+    }
+    function hide() {
+      visible.value = false;
+    }
+    function toggle() {
+      visible.value = !visible.value;
+    }
+    function applyVisibility2(isVisible) {
+      if (!currentElement) return;
+      if (isVisible) {
+        currentElement.classList.remove("v-hidden");
+        currentElement.classList.add("v-visible");
+        if (useHidden) {
+          currentElement.style.visibility = originalVisibility || "visible";
+        } else {
+          currentElement.style.display = originalDisplay;
+        }
+      } else {
+        currentElement.classList.remove("v-visible");
+        currentElement.classList.add("v-hidden");
+        if (useHidden) {
+          currentElement.style.visibility = "hidden";
+        } else {
+          currentElement.style.display = "none";
+        }
+      }
+    }
+    function bind(element) {
+      if (!isBrowser()) return () => {
+      };
+      unbind();
+      currentElement = element;
+      originalDisplay = element.style.display;
+      originalVisibility = element.style.visibility;
+      applyVisibility2(visible.value);
+      return unbind;
+    }
+    function unbind() {
+      if (currentElement) {
+        currentElement.style.display = originalDisplay;
+        currentElement.style.visibility = originalVisibility;
+        currentElement.classList.remove("v-hidden", "v-visible");
+      }
+      currentElement = null;
+    }
+    vue.watch(visible, (newValue, oldValue) => {
+      if (newValue !== oldValue) {
+        applyVisibility2(newValue);
+        onChange == null ? void 0 : onChange(newValue);
+      }
+    });
+    if (typeof initial === "object" && "value" in initial) {
+      vue.watch(initial, (newValue) => {
+        visible.value = newValue;
+      });
+    }
+    vue.onUnmounted(() => {
+      unbind();
+    });
+    return {
+      visible,
+      show,
+      hide,
+      toggle,
+      bind
+    };
+  }
+  function createWatermarkCanvas(options) {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("[Directix] useWatermark: Could not get canvas context");
+    }
+    const {
+      content,
+      width,
+      height,
+      fontSize,
+      fontFamily,
+      fontWeight,
+      color,
+      rotate
+    } = options;
+    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 contentArray = Array.isArray(content) ? content : [content];
+    const lineHeight = fontSize * 1.5;
+    const startY = -((contentArray.length - 1) * lineHeight) / 2;
+    contentArray.forEach((text, index) => {
+      ctx.fillText(text, 0, startY + index * lineHeight);
+    });
+    return canvas;
+  }
+  function useWatermark(options) {
+    const {
+      content,
+      width = 300,
+      height = 200,
+      rotate = -22,
+      fontSize = 16,
+      fontFamily = "sans-serif",
+      fontWeight = "normal",
+      color = "rgba(128, 128, 128, 0.15)",
+      gap = [100, 100],
+      zIndex = 9999,
+      disabled = false,
+      protect: _protect = true
+    } = options;
+    const canvas = vue.ref(null);
+    const dataUrl = vue.ref("");
+    const disabledRef = vue.ref(vue.unref(disabled));
+    function generate() {
+      const contentValue = vue.unref(content);
+      const widthValue = vue.unref(width);
+      const heightValue = vue.unref(height);
+      const rotateValue = vue.unref(rotate);
+      const fontSizeValue = vue.unref(fontSize);
+      const fontFamilyValue = vue.unref(fontFamily);
+      const fontWeightValue = vue.unref(fontWeight);
+      const colorValue = vue.unref(color);
+      canvas.value = createWatermarkCanvas({
+        content: contentValue,
+        width: widthValue,
+        height: heightValue,
+        fontSize: fontSizeValue,
+        fontFamily: fontFamilyValue,
+        fontWeight: fontWeightValue,
+        color: colorValue,
+        rotate: rotateValue
+      });
+      dataUrl.value = canvas.value.toDataURL();
+    }
+    const style = vue.ref({
+      position: "absolute",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      zIndex: vue.unref(zIndex),
+      backgroundImage: "",
+      backgroundRepeat: "repeat",
+      backgroundPosition: "0 0",
+      backgroundSize: ""
+    });
+    function updateStyle() {
+      const gapValue = vue.unref(gap);
+      const zIndexValue = vue.unref(zIndex);
+      const gapArray = Array.isArray(gapValue) ? gapValue : [gapValue, gapValue];
+      const widthValue = vue.unref(width);
+      const heightValue = vue.unref(height);
+      style.value = __spreadProps(__spreadValues({}, style.value), {
+        zIndex: zIndexValue,
+        backgroundImage: `url("${dataUrl.value}")`,
+        backgroundPosition: `${gapArray[0] / 2}px ${gapArray[1] / 2}px`,
+        backgroundSize: `${widthValue + gapArray[0]}px ${heightValue + gapArray[1]}px`
+      });
+    }
+    function update(newOptions) {
+      Object.assign(options, newOptions);
+      generate();
+      updateStyle();
+    }
+    function enable() {
+      disabledRef.value = false;
+    }
+    function disable() {
+      disabledRef.value = true;
+    }
+    vue.watch(
+      () => [
+        vue.unref(content),
+        vue.unref(width),
+        vue.unref(height),
+        vue.unref(rotate),
+        vue.unref(fontSize),
+        vue.unref(fontFamily),
+        vue.unref(fontWeight),
+        vue.unref(color),
+        vue.unref(gap),
+        vue.unref(zIndex)
+      ],
+      () => {
+        generate();
+        updateStyle();
+      },
+      { immediate: true }
+    );
+    vue.watch(disabledRef, (isDisabled) => {
+      style.value.display = isDisabled ? "none" : "block";
+    });
+    if (vue.unref(disabled)) {
+      style.value.display = "none";
+    }
+    vue.onUnmounted(() => {
+    });
+    return {
+      canvas,
+      dataUrl,
+      style,
+      disabled: disabledRef,
+      update,
+      enable,
+      disable
+    };
+  }
+  function createWatermarkUrl(content, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const canvas = createWatermarkCanvas({
+      content,
+      width: (_a = options.width) != null ? _a : 300,
+      height: (_b = options.height) != null ? _b : 200,
+      fontSize: (_c = options.fontSize) != null ? _c : 16,
+      fontFamily: "sans-serif",
+      fontWeight: "normal",
+      color: (_d = options.color) != null ? _d : "rgba(128, 128, 128, 0.15)",
+      rotate: (_e = options.rotate) != null ? _e : -22
+    });
+    return canvas.toDataURL();
+  }
   const allDirectives = {
     "click-outside": vClickOutside,
     "click-delay": vClickDelay,
@@ -6364,32 +9378,31 @@ var __async = (__this, __arguments, generator) => {
   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.calculateTime = calculateTime;
+  exports.capitalizeText = capitalizeText;
+  exports.capitalizeWord = capitalizeWord;
+  exports.createCapitalizer = createCapitalizer;
+  exports.createDelayedClick = createDelayedClick;
+  exports.createLowercaser = createLowercaser;
+  exports.createMoneyFormatter = createMoneyFormatter;
+  exports.createNumberFormatter = createNumberFormatter;
+  exports.createPermissionChecker = createPermissionChecker;
+  exports.createTrimmer = createTrimmer;
+  exports.createUppercaser = createUppercaser;
   exports.createVue2Directive = createVue2Directive;
   exports.createVue3Directive = createVue3Directive;
-  exports.debounce = vDebounce;
-  exports.debounceFn = debounce;
+  exports.createWatermarkUrl = createWatermarkUrl;
+  exports.debounceFn = debounceFn;
   exports.deepClone = deepClone;
   exports.deepMerge = deepMerge;
   exports.defineDirective = defineDirective;
   exports.defineDirectiveGroup = defineDirectiveGroup;
-  exports.draggable = vDraggable;
-  exports.ellipsis = vEllipsis;
-  exports.focus = vFocus;
+  exports.formatMoney = formatMoney;
+  exports.formatNumber = formatNumber;
+  exports.formatTime = formatTime;
   exports.generateId = generateId;
   exports.get = get;
-  exports.getPermissionConfig = getPermissionConfig;
   exports.getVueVersion = getVueVersion;
-  exports.hotkey = vHotkey;
-  exports.hover = vHover;
-  exports.imagePreview = vImagePreview;
-  exports.infiniteScroll = vInfiniteScroll;
-  exports.intersect = vIntersect;
   exports.isArray = isArray;
   exports.isBoolean = isBoolean;
   exports.isBrowser = isBrowser;
@@ -6403,39 +9416,54 @@ var __async = (__this, __arguments, generator) => {
   exports.isVue2 = isVue2;
   exports.isVue27 = isVue27;
   exports.isVue3 = isVue3;
-  exports.lazy = vLazy;
-  exports.loading = vLoading;
-  exports.longPress = vLongPress;
-  exports.lowercase = vLowercase;
-  exports.mask = vMask;
-  exports.money = vMoney;
-  exports.mutation = vMutation;
-  exports.number = vNumber;
+  exports.lowercaseText = lowercaseText;
+  exports.parseMoney = parseMoney;
+  exports.parseNumber = parseNumber;
+  exports.parseTargetTime = parseTargetTime;
   exports.parseTime = parseTime;
-  exports.permission = vPermission;
-  exports.print = vPrint;
-  exports.pullRefresh = vPullRefresh;
+  exports.quickPrint = quickPrint;
   exports.resetVueVersion = resetVueVersion;
-  exports.resize = vResize;
-  exports.ripple = vRipple;
-  exports.sanitize = vSanitize;
-  exports.scroll = vScroll;
   exports.set = set;
   exports.setVueVersion = setVueVersion;
-  exports.sticky = vSticky;
   exports.supportsClipboard = supportsClipboard;
   exports.supportsIntersectionObserver = supportsIntersectionObserver;
   exports.supportsMutationObserver = supportsMutationObserver;
   exports.supportsPassive = supportsPassive;
   exports.supportsResizeObserver = supportsResizeObserver;
-  exports.swipe = vSwipe;
-  exports.throttle = vThrottle;
-  exports.throttleFn = throttle;
-  exports.tooltip = vTooltip;
-  exports.touch = vTouch;
-  exports.trim = vTrim;
-  exports.truncate = vTruncate;
-  exports.uppercase = vUppercase;
+  exports.throttleFn = throttleFn;
+  exports.trimText = trimText;
+  exports.truncateText = truncateText;
+  exports.uppercaseText = uppercaseText;
+  exports.useCapitalcase = useCapitalcase;
+  exports.useClickDelay = useClickDelay;
+  exports.useClickOutside = useClickOutside;
+  exports.useCopy = useCopy;
+  exports.useCountdown = useCountdown;
+  exports.useDebounce = useDebounce;
+  exports.useDraggable = useDraggable;
+  exports.useEllipsis = useEllipsis;
+  exports.useFocus = useFocus;
+  exports.useHotkey = useHotkey;
+  exports.useHover = useHover;
+  exports.useImagePreview = useImagePreview;
+  exports.useIntersect = useIntersect;
+  exports.useLongPress = useLongPress;
+  exports.useLowercase = useLowercase;
+  exports.useMoney = useMoney;
+  exports.useNumber = useNumber;
+  exports.usePermission = usePermission;
+  exports.usePrint = usePrint;
+  exports.usePullRefresh = usePullRefresh;
+  exports.useResize = useResize;
+  exports.useScroll = useScroll;
+  exports.useSwipe = useSwipe;
+  exports.useThrottle = useThrottle;
+  exports.useTouch = useTouch;
+  exports.useTrim = useTrim;
+  exports.useUppercase = useUppercase;
+  exports.useVirtualList = useVirtualList;
+  exports.useVisible = useVisible;
+  exports.useWatermark = useWatermark;
   exports.vCapitalcase = vCapitalcase;
   exports.vClickDelay = vClickDelay;
   exports.vClickOutside = vClickOutside;
@@ -6476,9 +9504,7 @@ var __async = (__this, __arguments, generator) => {
   exports.vVirtualList = vVirtualList;
   exports.vVisible = vVisible;
   exports.vWatermark = vWatermark;
-  exports.virtualList = vVirtualList;
-  exports.visible = vVisible;
-  exports.watermark = vWatermark;
+  exports.wouldTextTruncate = wouldTextTruncate;
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-})(this.Directix = this.Directix || {});
+})(this.Directix = this.Directix || {}, Vue);
 //# sourceMappingURL=index.iife.js.map