npm - directix - Versions diffs - 1.3.0 → 1.4.0 - Mend

directix 1.3.0 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/index.cjs CHANGED Viewed

@@ -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.
@@ -58,12 +58,13 @@ 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.
  */
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
 function createVue2Directive(hooks) {
   const directive = {
     bind(el, binding, vnode) {
@@ -218,8 +219,8 @@ function getVueVersion() {
     }
   }
   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 +229,19 @@ function getVueVersion() {
   }
   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 +443,7 @@ function transformTextContent(el, transformFn) {
 function isInputElement(el) {
   return el.tagName === "INPUT" || el.tagName === "TEXTAREA";
 }
-const DEFAULT_KEEP_LOWER = [
+const DEFAULT_KEEP_LOWER$1 = [
   "a",
   "an",
   "the",
@@ -461,25 +462,25 @@ const DEFAULT_KEEP_LOWER = [
   "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 +494,7 @@ function normalizeOptions$B(binding) {
   }
   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 +504,20 @@ const vCapitalcase = defineDirective({
   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 +526,15 @@ const vCapitalcase = defineDirective({
     delete el.__capitalcaseCleanup;
   }
 });
-const vClickDelay = defineDirective({
-  name: "click-delay",
-  ssr: true,
-  defaults: {
-    delay: 300,
-    disabled: false,
-    pendingClass: "v-click-delay--pending",
-    feedback: true
-  },
-  mounted(el, binding) {
-    const options = normalizeOptions$A(binding.value, binding);
-    if (options.disabled) return;
-    const state = {
-      options,
-      handler: createClickHandler(el, options),
-      isPending: false,
-      timeoutId: null
-    };
-    el.__clickDelay = state;
-    el.addEventListener("click", state.handler);
-    el.addEventListener("touchend", state.handler);
-  },
-  updated(el, binding) {
-    const state = el.__clickDelay;
-    if (!state) {
-      const options = normalizeOptions$A(binding.value, binding);
-      if (!options.disabled) {
-        const newState = {
-          options,
-          handler: createClickHandler(el, options),
-          isPending: false,
-          timeoutId: null
-        };
-        el.__clickDelay = newState;
-        el.addEventListener("click", newState.handler);
-        el.addEventListener("touchend", newState.handler);
-      }
-      return;
-    }
-    const newOptions = normalizeOptions$A(binding.value, binding);
-    if (newOptions.disabled && !state.options.disabled) {
-      el.removeEventListener("click", state.handler);
-      el.removeEventListener("touchend", state.handler);
-      if (state.timeoutId) {
-        clearTimeout(state.timeoutId);
-      }
-      removePendingClass(el, state.options);
-      delete el.__clickDelay;
-    } else if (!newOptions.disabled && state.options.disabled) {
-      state.handler = createClickHandler(el, newOptions);
-      state.isPending = false;
-      state.timeoutId = null;
-      el.addEventListener("click", state.handler);
-      el.addEventListener("touchend", state.handler);
-    }
-    state.options = newOptions;
-  },
-  unmounted(el) {
-    const state = el.__clickDelay;
-    if (!state) return;
-    el.removeEventListener("click", state.handler);
-    el.removeEventListener("touchend", state.handler);
-    if (state.timeoutId) {
-      clearTimeout(state.timeoutId);
-    }
-    removePendingClass(el, state.options);
-    delete el.__clickDelay;
-  }
-});
-function createClickHandler(el, options) {
-  return (event) => {
-    const state = el.__clickDelay;
-    if (!state || state.isPending) {
-      event.preventDefault();
-      event.stopPropagation();
-      return;
-    }
-    state.isPending = true;
-    if (options.feedback && options.pendingClass) {
-      el.classList.add(options.pendingClass);
-    }
-    options.handler(event);
-    state.timeoutId = setTimeout(() => {
-      state.isPending = false;
-      state.timeoutId = null;
-      removePendingClass(el, options);
-    }, options.delay);
-  };
-}
-function removePendingClass(el, options) {
-  if (options.feedback && options.pendingClass) {
-    el.classList.remove(options.pendingClass);
-  }
+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 +561,15 @@ function getScrollParent(el) {
 }
 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 +579,7 @@ function normalizeOptions$z(options) {
   }
   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 +595,58 @@ function getEventPosition(e) {
     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 +833,171 @@ function parseTime(arg) {
 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 +1007,7 @@ const vClickOutside = defineDirective({
       } 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 +1057,7 @@ function normalizeOptions$y(binding) {
     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 +1073,7 @@ function isValidClick(el, event, options) {
   }
   return true;
 }
-function copyToClipboard(text) {
+function copyToClipboard$1(text) {
   return __async(this, null, function* () {
     if (supportsClipboard()) {
       try {
@@ -1030,10 +1083,10 @@ function copyToClipboard(text) {
         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 +1128,7 @@ const vCopy = defineDirective({
         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 +1165,7 @@ function normalizeOptions$x(binding) {
   }
   return binding;
 }
-function parseTargetTime(target) {
+function parseTargetTime$1(target) {
   if (target instanceof Date) {
     return target.getTime();
   }
@@ -1121,7 +1174,7 @@ function parseTargetTime(target) {
   }
   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 +1185,7 @@ function calculateTime(remaining) {
     total
   };
 }
-function formatTime(time, format) {
+function formatTime$1(time, format) {
   if (typeof format === "function") {
     return format(time);
   }
@@ -1167,7 +1220,7 @@ const vCountdown = defineDirective({
   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 +1238,7 @@ const vCountdown = defineDirective({
   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 +1277,7 @@ function startCountdown(el, state) {
     }
     updateDisplay(el, state);
     if (state.options.onTick) {
-      const time = calculateTime(state.remaining);
+      const time = calculateTime$1(state.remaining);
       state.options.onTick(time);
     }
   };
@@ -1238,45 +1291,10 @@ function stopCountdown(state) {
   }
 }
 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 +1354,7 @@ const vDebounce = defineDirective({
     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 +1367,7 @@ function getBoundary(_el, boundary) {
   }
   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 +1375,7 @@ function getClientCoords(e) {
   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 +1438,15 @@ const vDraggable = defineDirective({
       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 +1461,7 @@ const vDraggable = defineDirective({
       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 +1499,7 @@ const vDraggable = defineDirective({
           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 +1675,7 @@ function normalizeOptions$t(binding) {
     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 +1697,7 @@ const vFocus = defineDirective({
   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 +1765,10 @@ function normalizeOptions$s(binding) {
     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 +1779,7 @@ function isFocusable(el) {
   }
   return false;
 }
-const KEY_ALIASES = {
+const KEY_ALIASES$1 = {
   esc: "escape",
   space: " ",
   up: "arrowup",
@@ -1793,7 +1811,7 @@ const KEY_ALIASES = {
 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 +1826,7 @@ function parseHotkeyString(hotkey) {
   }
   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 +1913,7 @@ function createKeydownHandler(state) {
   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 +1953,61 @@ const vHotkey = defineDirective({
     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 +2019,26 @@ function normalizeOptions$r(binding) {
     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 +2051,54 @@ const vHover = defineDirective({
   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 +2107,15 @@ const vHover = defineDirective({
     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 +2126,7 @@ const DEFAULTS = {
   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 +2309,7 @@ function createGestureHandlers(state, transformManager, closePreview) {
       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 +2330,7 @@ function createGestureHandlers(state, transformManager, closePreview) {
       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 +3099,7 @@ function normalizeOptions$l(binding) {
     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 +3146,7 @@ const vLongPress = defineDirective({
         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 +3186,8 @@ const vLongPress = defineDirective({
       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 +3422,7 @@ const vMask = defineDirective({
     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 +3525,7 @@ function setupNumberInput(el, options, formatFn) {
     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 +3546,14 @@ const vMoney = defineDirective({
     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 +3572,7 @@ const vMoney = defineDirective({
         }
       }
       if (value !== null) {
-        el.textContent = formatMoney(clampValue(value, options), options);
+        el.textContent = formatMoney$1(clampValue(value, options), options);
       }
     }
   },
@@ -3523,7 +3589,7 @@ const vMoney = defineDirective({
         value = binding.value.value;
       }
       if (value !== null) {
-        el.textContent = formatMoney(clampValue(value, options), options);
+        el.textContent = formatMoney$1(clampValue(value, options), options);
       }
     }
   },
@@ -3641,14 +3707,14 @@ const vNumber = defineDirective({
     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 +3735,7 @@ const vNumber = defineDirective({
         }
       }
       if (value !== null) {
-        el.textContent = formatNumber(clampValue(value, options), options);
+        el.textContent = formatNumber$1(clampValue(value, options), options);
       }
     }
   },
@@ -3687,7 +3753,7 @@ const vNumber = defineDirective({
         value = binding.value.value;
       }
       if (value !== null) {
-        el.textContent = formatNumber(clampValue(value, options), options);
+        el.textContent = formatNumber$1(clampValue(value, options), options);
       }
     }
   },
@@ -3698,14 +3764,6 @@ const vNumber = defineDirective({
   }
 });
 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 +3776,14 @@ function normalizeOptions$h(binding) {
   }
   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 +3932,16 @@ function printElement(triggerEl, options) {
       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 +3953,11 @@ function printInIframe(el, options) {
       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 +3969,18 @@ function printInIframe(el, options) {
     }, 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 +3988,7 @@ function printInNewWindow(el, options) {
     }, 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 +4029,7 @@ function buildPrintContent(el, options) {
 </body>
 </html>`;
 }
-function waitForImages(doc) {
+function waitForImages$1(doc) {
   const images = doc.querySelectorAll("img");
   const promises = [];
   images.forEach((img) => {
@@ -4089,16 +4122,16 @@ function triggerRefresh(internal) {
     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 +4857,8 @@ const vSticky = defineDirective({
 });
 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 +4876,7 @@ function normalizeOptions$9(binding) {
     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 +4892,7 @@ function triggerSwipe(state, deltaX, deltaY, deltaTime, event, el) {
   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 +5381,7 @@ const vTooltip = defineDirective({
     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 +5459,7 @@ const vTouch = defineDirective({
       } 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 +5476,7 @@ const vTouch = defineDirective({
       }
       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 +5595,9 @@ function normalizeOptions$6(binding) {
     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 +5608,7 @@ function trimText(text, options) {
       return text.replace(new RegExp(`^${charPattern}+|${charPattern}+$`, "g"), "");
   }
 }
-function escapeRegex(str) {
+function escapeRegex$2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 const vTrim = defineDirective({
@@ -5587,7 +5620,7 @@ const vTrim = defineDirective({
       setupInputElement(el, options);
     } else {
       const text = el.textContent || "";
-      el.textContent = trimText(text, options);
+      el.textContent = trimText$1(text, options);
     }
   },
   updated(el, binding) {
@@ -5599,7 +5632,7 @@ const vTrim = defineDirective({
       }
     } else {
       const text = el.textContent || "";
-      el.textContent = trimText(text, options);
+      el.textContent = trimText$1(text, options);
     }
   },
   unmounted(el) {
@@ -5618,7 +5651,7 @@ function setupInputElement(el, options) {
   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 +5700,7 @@ function normalizeOptions$5(binding) {
     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 +5763,7 @@ function applyTruncation(el, text, options) {
       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 +6149,7 @@ function applyVisibility(el, state, isVisible) {
     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 +6265,7 @@ const vWatermark = defineDirective({
 });
 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 +6288,7 @@ function setupProtection(el, state) {
   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 +6313,2988 @@ function setupProtection(el, state) {
     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 +9379,31 @@ const Directix = {
 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 +9417,54 @@ exports.isString = isString;
 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,7 +9505,5 @@ exports.vUppercase = vUppercase;
 exports.vVirtualList = vVirtualList;
 exports.vVisible = vVisible;
 exports.vWatermark = vWatermark;
-exports.virtualList = vVirtualList;
-exports.visible = vVisible;
-exports.watermark = vWatermark;
+exports.wouldTextTruncate = wouldTextTruncate;
 //# sourceMappingURL=index.cjs.map