directix 1.0.0-beta.2 → 1.1.0

package/dist/index.iife.js

@@ -0,0 +1,3193 @@
+/*!
+ * directix v1.1.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.
+ */
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+/*!
+ * directix v1.1.0
+ * A comprehensive, easy-to-use, and high-performance Vue custom directives library supporting both Vue 2 and Vue 3
+ * (c) 2021-present saqqdy <https://github.com/saqqdy>
+ * Released under the MIT License.
+ */
+(function(exports) {
+  "use strict";
+  let _vueVersion = null, _isVue2 = null, _isVue27 = null, _isVue3 = null;
+  function parseVersion(version) {
+    if (version.startsWith("2.7")) return 2.7;
+    if (version.startsWith("2")) return 2;
+    if (version.startsWith("3")) return 3;
+    return null;
+  }
+  function getVueVersion() {
+    var _a, _b;
+    if (_vueVersion !== null) return _vueVersion;
+    if (typeof process !== "undefined") {
+      const envVersion = process.env.DIRECTIX_VUE_VERSION;
+      if (envVersion === "2.7") {
+        _vueVersion = 2.7;
+        return _vueVersion;
+      }
+      if (envVersion === "2") {
+        _vueVersion = 2;
+        return _vueVersion;
+      }
+      if (envVersion === "3") {
+        _vueVersion = 3;
+        return _vueVersion;
+      }
+    }
+    try {
+      const vue = require("vue");
+      const version = parseVersion(vue == null ? void 0 : vue.version);
+      if (version !== null) {
+        _vueVersion = version;
+        return _vueVersion;
+      }
+    } catch (e) {
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      const vue = win.Vue;
+      if (vue == null ? void 0 : vue.version) {
+        const version = parseVersion(vue.version);
+        if (version !== null) {
+          _vueVersion = version;
+          return _vueVersion;
+        }
+      }
+      if (typeof (vue == null ? void 0 : vue.observable) === "function") {
+        _vueVersion = 2;
+        return _vueVersion;
+      }
+      if (typeof (vue == null ? void 0 : vue.createApp) === "function" && typeof (vue == null ? void 0 : vue.observable) !== "function") {
+        _vueVersion = 3;
+        return _vueVersion;
+      }
+      const devtools = win.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+      if ((_a = devtools == null ? void 0 : devtools.Vue) == null ? void 0 : _a.version) {
+        const version = parseVersion(devtools.Vue.version);
+        if (version !== null) {
+          _vueVersion = version;
+          return _vueVersion;
+        }
+      }
+      if ((_b = devtools == null ? void 0 : devtools.apps) == null ? void 0 : _b.length) {
+        _vueVersion = 3;
+        return _vueVersion;
+      }
+    }
+    if (_vueVersion === null) {
+      if (typeof window !== "undefined") {
+        console.warn(
+          "[Directix] Unable to detect Vue version, defaulting to Vue 3. Set DIRECTIX_VUE_VERSION=2 or call setVueVersion(2) if using Vue 2."
+        );
+      }
+      _vueVersion = 3;
+    }
+    return _vueVersion;
+  }
+  function setVueVersion(version) {
+    _vueVersion = version;
+    _isVue2 = version === 2 || version === 2.7;
+    _isVue27 = version === 2.7;
+    _isVue3 = version === 3;
+  }
+  function resetVueVersion() {
+    _vueVersion = null;
+    _isVue2 = null;
+    _isVue27 = null;
+    _isVue3 = null;
+  }
+  function isVue2() {
+    if (_isVue2 === null) {
+      const version = getVueVersion();
+      _isVue2 = version === 2 || version === 2.7;
+    }
+    return _isVue2;
+  }
+  function isVue27() {
+    if (_isVue27 === null) {
+      _isVue27 = getVueVersion() === 2.7;
+    }
+    return _isVue27;
+  }
+  function isVue3() {
+    if (_isVue3 === null) {
+      _isVue3 = getVueVersion() === 3;
+    }
+    return _isVue3;
+  }
+  const isBrowser = () => {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+  };
+  const isSSR = () => !isBrowser();
+  const supportsPassive = () => {
+    if (!isBrowser()) return false;
+    let supports = false;
+    try {
+      const options = {
+        get passive() {
+          supports = true;
+          return false;
+        }
+      };
+      window.addEventListener("test", null, options);
+      window.removeEventListener("test", null, options);
+    } catch (e) {
+      supports = false;
+    }
+    return supports;
+  };
+  const supportsIntersectionObserver = () => {
+    return isBrowser() && "IntersectionObserver" in window;
+  };
+  const supportsResizeObserver = () => {
+    return isBrowser() && "ResizeObserver" in window;
+  };
+  const supportsClipboard = () => {
+    return isBrowser() && "clipboard" in navigator;
+  };
+  const supportsMutationObserver = () => {
+    return isBrowser() && "MutationObserver" in window;
+  };
+  function createVue2Directive(hooks) {
+    const directive = {
+      bind(el, binding, vnode) {
+        const state = {
+          value: binding.value,
+          vnode,
+          cleanup: []
+        };
+        el.__directix_state__ = state;
+      },
+      inserted(el, binding, vnode) {
+        if (hooks.mounted) {
+          hooks.mounted(el, normalizeBinding(binding), vnode);
+        }
+      },
+      update(el, binding, vnode, oldVnode) {
+        const state = el.__directix_state__;
+        if (hooks.updated) {
+          hooks.updated(
+            el,
+            normalizeBinding(binding),
+            vnode,
+            normalizeBinding(__spreadProps(__spreadValues({}, binding), { value: binding.oldValue })),
+            oldVnode
+          );
+        }
+        if (state) {
+          state.value = binding.value;
+          state.vnode = vnode;
+        }
+      },
+      componentUpdated(_el, _binding, _vnode, _oldVnode) {
+      },
+      unbind(el, binding, vnode) {
+        if (hooks.unmounted) {
+          hooks.unmounted(el, normalizeBinding(binding), vnode);
+        }
+        const state = el.__directix_state__;
+        if (state == null ? void 0 : state.cleanup) {
+          state.cleanup.forEach((fn) => fn());
+        }
+        delete el.__directix_state__;
+      }
+    };
+    return directive;
+  }
+  function normalizeBinding(binding) {
+    var _a;
+    return {
+      value: binding.value,
+      oldValue: (_a = binding.oldValue) != null ? _a : null,
+      arg: binding.arg,
+      modifiers: binding.modifiers || {},
+      instance: binding.instance || null
+    };
+  }
+  function addCleanup$1(el, fn) {
+    const state = el.__directix_state__;
+    if (state) {
+      state.cleanup.push(fn);
+    }
+  }
+  function createVue3Directive(hooks) {
+    const directive = {
+      created(el, binding, vnode) {
+        const state = {
+          value: binding.value,
+          vnode,
+          cleanup: []
+        };
+        el.__directix_state__ = state;
+      },
+      beforeMount(_el, _binding, _vnode) {
+      },
+      mounted(el, binding, vnode) {
+        if (hooks.mounted) {
+          hooks.mounted(el, normalizeBindingVue3(binding), vnode);
+        }
+      },
+      beforeUpdate(_el, _binding, _vnode, _prevVnode) {
+      },
+      updated(el, binding, vnode, prevVnode) {
+        const state = el.__directix_state__;
+        if (hooks.updated) {
+          hooks.updated(
+            el,
+            normalizeBindingVue3(binding),
+            vnode,
+            normalizeBindingVue3(__spreadProps(__spreadValues({}, binding), { value: binding.oldValue })),
+            prevVnode
+          );
+        }
+        if (state) {
+          state.value = binding.value;
+          state.vnode = vnode;
+        }
+      },
+      beforeUnmount(_el, _binding, _vnode) {
+      },
+      unmounted(el, binding, vnode) {
+        if (hooks.unmounted) {
+          hooks.unmounted(el, normalizeBindingVue3(binding), vnode);
+        }
+        const state = el.__directix_state__;
+        if (state == null ? void 0 : state.cleanup) {
+          state.cleanup.forEach((fn) => fn());
+        }
+        delete el.__directix_state__;
+      }
+    };
+    return directive;
+  }
+  function normalizeBindingVue3(binding) {
+    var _a;
+    return {
+      value: binding.value,
+      oldValue: (_a = binding.oldValue) != null ? _a : null,
+      arg: binding.arg,
+      modifiers: binding.modifiers || {},
+      instance: binding.instance
+    };
+  }
+  function addCleanup(el, fn) {
+    const state = el.__directix_state__;
+    if (state) {
+      state.cleanup.push(fn);
+    }
+  }
+  function defineDirective(definition) {
+    var _b;
+    const _a = definition, { name, version, ssr, defaults } = _a, hooks = __objRest(_a, ["name", "version", "ssr", "defaults"]);
+    if (isSSR() && !ssr) {
+      if (typeof process !== "undefined" && ((_b = process.env) == null ? void 0 : _b.NODE_ENV) !== "test") {
+        console.warn(
+          `[Directix] Directive "${name}" is not compatible with SSR. It will be a no-op on the server side.`
+        );
+      }
+      return createNoOpDirective();
+    }
+    const wrappedHooks = {
+      mounted: hooks.mounted ? (el, binding, vnode) => {
+        hooks.mounted(el, applyDefaults(binding, defaults), vnode);
+      } : void 0,
+      updated: hooks.updated ? (el, binding, vnode, prevBinding, prevVnode) => {
+        hooks.updated(el, applyDefaults(binding, defaults), vnode, prevBinding, prevVnode);
+      } : void 0,
+      unmounted: hooks.unmounted
+    };
+    return createLazyDirective(wrappedHooks);
+  }
+  function createLazyDirective(hooks) {
+    let cachedDirective = null;
+    function getDirective() {
+      if (!cachedDirective) {
+        cachedDirective = getVueVersion() === 2 ? createVue2Directive(hooks) : createVue3Directive(hooks);
+      }
+      return cachedDirective;
+    }
+    function createHook(hookName) {
+      return function(el, binding, vnode, prevVnode) {
+        var _a, _b;
+        (_b = (_a = getDirective())[hookName]) == null ? void 0 : _b.call(_a, el, binding, vnode, prevVnode);
+      };
+    }
+    return {
+      // Vue 2 hooks
+      bind: createHook("bind"),
+      inserted: createHook("inserted"),
+      update: createHook("update"),
+      componentUpdated: createHook("componentUpdated"),
+      unbind: createHook("unbind"),
+      // Vue 3 hooks
+      created: createHook("created"),
+      beforeMount: createHook("beforeMount"),
+      mounted: createHook("mounted"),
+      beforeUpdate: createHook("beforeUpdate"),
+      updated: createHook("updated"),
+      beforeUnmount: createHook("beforeUnmount"),
+      unmounted: createHook("unmounted")
+    };
+  }
+  function applyDefaults(binding, defaults) {
+    if (!defaults) return binding;
+    const value = typeof binding.value === "object" && binding.value !== null ? __spreadValues(__spreadValues({}, defaults), binding.value) : binding.value;
+    return __spreadProps(__spreadValues({}, binding), { value });
+  }
+  function createNoOpDirective() {
+    return {
+      mounted: () => {
+      },
+      updated: () => {
+      },
+      unmounted: () => {
+      }
+    };
+  }
+  function defineDirectiveGroup(name, directives) {
+    return {
+      name,
+      directives,
+      install(app, _options) {
+        Object.entries(directives).forEach(([directiveName, directive]) => {
+          const fullName = `${name}-${directiveName}`;
+          app.directive(fullName, directive);
+        });
+      }
+    };
+  }
+  function isElement(value) {
+    return value instanceof Element;
+  }
+  function getElement(target) {
+    if (!target) return null;
+    if (typeof target === "string") {
+      if (!isBrowser()) return null;
+      return document.querySelector(target);
+    }
+    return isElement(target) ? target : null;
+  }
+  function getScrollParent(el) {
+    if (!isBrowser()) return window;
+    let parent = el.parentElement;
+    while (parent) {
+      const { overflow, overflowX, overflowY } = getComputedStyle(parent);
+      if (/(auto|scroll)/.test(overflow + overflowX + overflowY)) {
+        return parent;
+      }
+      parent = parent.parentElement;
+    }
+    return window;
+  }
+  function on(target, event, handler, options = false) {
+    if (!isBrowser()) return;
+    const opts = normalizeOptions$k(options);
+    target.addEventListener(event, handler, opts);
+  }
+  function off(target, event, handler, options = false) {
+    if (!isBrowser()) return;
+    const opts = normalizeOptions$k(options);
+    target.removeEventListener(event, handler, opts);
+  }
+  function normalizeOptions$k(options) {
+    if (typeof options === "boolean") {
+      return options;
+    }
+    const { capture = false, passive = false, once = false } = options;
+    if (supportsPassive()) {
+      return { capture, passive, once };
+    }
+    return capture;
+  }
+  function getEventPosition(e) {
+    let clientX = 0, clientY = 0;
+    if ("touches" in e && e.touches.length > 0) {
+      clientX = e.touches[0].clientX;
+      clientY = e.touches[0].clientY;
+    } else if ("clientX" in e) {
+      clientX = e.clientX;
+      clientY = e.clientY;
+    }
+    return {
+      x: clientX,
+      y: clientY,
+      clientX,
+      clientY
+    };
+  }
+  function isString(value) {
+    return typeof value === "string";
+  }
+  function isNumber(value) {
+    return typeof value === "number" && !Number.isNaN(value);
+  }
+  function isBoolean(value) {
+    return typeof value === "boolean";
+  }
+  function isFunction(value) {
+    return typeof value === "function";
+  }
+  function isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function isArray(value) {
+    return Array.isArray(value);
+  }
+  function isEmpty(value) {
+    if (value === null || value === void 0) return true;
+    if (isString(value) || isArray(value)) return value.length === 0;
+    if (isObject(value)) return Object.keys(value).length === 0;
+    return false;
+  }
+  function isPromise(value) {
+    return isObject(value) && isFunction(value.then);
+  }
+  function deepClone(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => deepClone(item));
+    }
+    const cloned = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        cloned[key] = deepClone(obj[key]);
+      }
+    }
+    return cloned;
+  }
+  function deepMerge(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+      for (const key in source) {
+        if (isObject(source[key])) {
+          if (!target[key]) {
+            Object.assign(target, { [key]: {} });
+          }
+          deepMerge(
+            target[key],
+            source[key]
+          );
+        } else {
+          Object.assign(target, { [key]: source[key] });
+        }
+      }
+    }
+    return deepMerge(target, ...sources);
+  }
+  function get(obj, path, defaultValue) {
+    const keys = path.split(".");
+    let result = obj;
+    for (const key of keys) {
+      if (result === null || result === void 0) {
+        return defaultValue;
+      }
+      result = result[key];
+    }
+    return result === void 0 ? defaultValue : result;
+  }
+  function set(obj, path, value) {
+    const keys = path.split(".");
+    const lastKey = keys.pop();
+    let current = obj;
+    for (const key of keys) {
+      if (current[key] === void 0) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    current[lastKey] = value;
+  }
+  function debounce(func, wait = 300, options = {}) {
+    let timerId = null, lastArgs = null, lastThis = null;
+    const { leading = false, trailing = true } = options;
+    const invokeFunc = () => {
+      if (lastArgs) {
+        func.apply(lastThis, lastArgs);
+        lastArgs = null;
+        lastThis = null;
+      }
+    };
+    const debounced = function(...args) {
+      lastArgs = args;
+      lastThis = this;
+      if (timerId) {
+        clearTimeout(timerId);
+      }
+      if (leading && !timerId) {
+        invokeFunc();
+      }
+      timerId = setTimeout(() => {
+        if (trailing) {
+          invokeFunc();
+        }
+        timerId = null;
+      }, wait);
+    };
+    debounced.cancel = () => {
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      lastArgs = null;
+      lastThis = null;
+    };
+    debounced.flush = () => {
+      if (timerId) {
+        clearTimeout(timerId);
+        invokeFunc();
+        timerId = null;
+      }
+    };
+    return debounced;
+  }
+  function throttle(func, wait = 300, options = {}) {
+    let timerId = null, lastArgs = null, lastThis = null, lastCallTime = 0;
+    const { leading = true, trailing = true } = options;
+    const invokeFunc = () => {
+      if (lastArgs) {
+        func.apply(lastThis, lastArgs);
+        lastArgs = null;
+        lastThis = null;
+      }
+    };
+    const throttled = function(...args) {
+      const now = Date.now();
+      if (!lastCallTime && !leading) {
+        lastCallTime = now;
+      }
+      const remaining = wait - (now - lastCallTime);
+      lastArgs = args;
+      lastThis = this;
+      if (remaining <= 0 || remaining > wait) {
+        if (timerId) {
+          clearTimeout(timerId);
+          timerId = null;
+        }
+        lastCallTime = now;
+        invokeFunc();
+      } else if (!timerId && trailing) {
+        timerId = setTimeout(() => {
+          lastCallTime = leading ? Date.now() : 0;
+          timerId = null;
+          invokeFunc();
+        }, remaining);
+      }
+    };
+    throttled.cancel = () => {
+      if (timerId) {
+        clearTimeout(timerId);
+        timerId = null;
+      }
+      lastCallTime = 0;
+      lastArgs = null;
+      lastThis = null;
+    };
+    return throttled;
+  }
+  function parseTime(arg) {
+    if (!arg) return null;
+    if (arg.endsWith("ms")) {
+      return Number.parseInt(arg, 10);
+    }
+    if (arg.endsWith("s")) {
+      return Number.parseFloat(arg) * 1e3;
+    }
+    const num = Number.parseInt(arg, 10);
+    return Number.isNaN(num) ? null : num;
+  }
+  function generateId(prefix = "") {
+    return `${prefix}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 9)}`;
+  }
+  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$j(binding.value);
+      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);
+        };
+      };
+      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$j(binding.value);
+      if (oldOptions.disabled !== newOptions.disabled) {
+        if (newOptions.disabled) {
+          state.handlers.forEach((handler, eventType) => {
+            off(document, eventType, handler, { capture: oldOptions.capture });
+          });
+          state.handlers.clear();
+        } else {
+          const createHandler = (_eventType) => {
+            return (event) => {
+              if (!isValidClick(el, event, newOptions)) return;
+              if (newOptions.stop) event.stopPropagation();
+              if (newOptions.prevent) event.preventDefault();
+              newOptions.handler(event);
+            };
+          };
+          newOptions.events.forEach((eventType) => {
+            const handler = createHandler();
+            state.handlers.set(eventType, handler);
+            on(document, eventType, handler, {
+              capture: newOptions.capture,
+              passive: !newOptions.prevent
+            });
+          });
+        }
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__clickOutside;
+      if (!state) return;
+      state.handlers.forEach((handler, eventType) => {
+        off(document, eventType, handler, { capture: state.options.capture });
+      });
+      delete el.__clickOutside;
+    }
+  });
+  function normalizeOptions$j(binding) {
+    var _a, _b, _c, _d, _e;
+    if (typeof binding === "function") {
+      return {
+        handler: binding,
+        capture: true,
+        events: ["click"],
+        disabled: false,
+        stop: false,
+        prevent: false
+      };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-click-outside: handler is required");
+    }
+    return __spreadValues({
+      capture: (_a = binding.capture) != null ? _a : true,
+      events: (_b = binding.events) != null ? _b : ["click"],
+      disabled: (_c = binding.disabled) != null ? _c : false,
+      stop: (_d = binding.stop) != null ? _d : false,
+      prevent: (_e = binding.prevent) != null ? _e : false
+    }, binding);
+  }
+  function isValidClick(el, event, options) {
+    var _a;
+    const target = event.target;
+    if (el.contains(target)) {
+      return false;
+    }
+    if ((_a = options.exclude) == null ? void 0 : _a.length) {
+      for (const exclude of options.exclude) {
+        const excludeEl = typeof exclude === "function" ? exclude() : getElement(exclude);
+        if (excludeEl && (excludeEl === target || excludeEl.contains(target))) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  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) {
+    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);
+    }
+  }
+  const vCopy = defineDirective({
+    name: "copy",
+    ssr: false,
+    mounted(el, binding) {
+      const options = normalizeOptions$i(binding.value);
+      if (options.disabled) return;
+      if (options.title) {
+        el.setAttribute("title", options.title);
+      }
+      const state = {
+        handler: null,
+        options
+      };
+      state.handler = () => __async(null, null, function* () {
+        var _a, _b, _c, _d;
+        const text = state.options.value;
+        if (!text) {
+          console.warn("[Directix] v-copy: No text to copy");
+          return;
+        }
+        try {
+          const success = yield copyToClipboard(text);
+          if (success) {
+            (_b = (_a = state.options).onSuccess) == null ? void 0 : _b.call(_a, text);
+            el.dispatchEvent(new CustomEvent("copy:success", { detail: { text } }));
+          } else {
+            throw new Error("Copy failed");
+          }
+        } catch (err) {
+          const error = err;
+          (_d = (_c = state.options).onError) == null ? void 0 : _d.call(_c, error);
+          el.dispatchEvent(new CustomEvent("copy:error", { detail: { error } }));
+        }
+      });
+      el.addEventListener("click", state.handler);
+      el.__copy = state;
+    },
+    updated(el, binding) {
+      const state = el.__copy;
+      if (!state) return;
+      state.options = normalizeOptions$i(binding.value);
+      if (state.options.title) {
+        el.setAttribute("title", state.options.title);
+      }
+    },
+    unmounted(el) {
+      const state = el.__copy;
+      if (!state) return;
+      el.removeEventListener("click", state.handler);
+      delete el.__copy;
+    }
+  });
+  function normalizeOptions$i(binding) {
+    if (typeof binding === "string") {
+      return { value: binding };
+    }
+    return binding;
+  }
+  const vDebounce = defineDirective({
+    name: "debounce",
+    ssr: true,
+    // SSR safe - event binding is skipped on server
+    defaults: {
+      wait: 300,
+      leading: false,
+      trailing: true
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$h(binding.value, binding);
+      const eventType = getEventTypeFromModifiers$1(binding.modifiers) || getEventType$1(el);
+      const debouncedFn = debounce(options.handler, options.wait, {
+        leading: options.leading,
+        trailing: options.trailing
+      });
+      el.addEventListener(eventType, debouncedFn);
+      el.__debounce = {
+        debouncedFn,
+        eventType,
+        options
+      };
+    },
+    updated(el, binding) {
+      const state = el.__debounce;
+      if (!state) return;
+      const newOptions = normalizeOptions$h(binding.value, binding);
+      if (newOptions.wait !== state.options.wait || newOptions.leading !== state.options.leading || newOptions.trailing !== state.options.trailing) {
+        state.debouncedFn.cancel();
+        const debouncedFn = debounce(newOptions.handler, newOptions.wait, {
+          leading: newOptions.leading,
+          trailing: newOptions.trailing
+        });
+        el.removeEventListener(state.eventType, state.debouncedFn);
+        el.addEventListener(state.eventType, debouncedFn);
+        el.__debounce = {
+          debouncedFn,
+          eventType: state.eventType,
+          options: newOptions
+        };
+      } else if (newOptions.handler !== state.options.handler) {
+        state.options.handler = newOptions.handler;
+      }
+    },
+    unmounted(el) {
+      const state = el.__debounce;
+      if (!state) return;
+      state.debouncedFn.cancel();
+      el.removeEventListener(state.eventType, state.debouncedFn);
+      delete el.__debounce;
+    }
+  });
+  function normalizeOptions$h(binding, directiveBinding) {
+    const wait = parseTime(directiveBinding.arg) || 300;
+    if (typeof binding === "function") {
+      return { handler: binding, wait };
+    }
+    return __spreadProps(__spreadValues({}, binding), { wait: binding.wait || wait });
+  }
+  function getEventType$1(el) {
+    const tagName = el.tagName.toLowerCase();
+    if (tagName === "input" || tagName === "textarea") {
+      return "input";
+    }
+    return "click";
+  }
+  const EVENT_MODIFIERS$1 = [
+    "click",
+    "input",
+    "change",
+    "submit",
+    "scroll",
+    "resize",
+    "mouseenter",
+    "mouseleave",
+    "mousemove",
+    "mousedown",
+    "mouseup",
+    "keydown",
+    "keyup",
+    "focus",
+    "blur",
+    "touchstart",
+    "touchmove",
+    "touchend"
+  ];
+  function getEventTypeFromModifiers$1(modifiers) {
+    for (const modifier of EVENT_MODIFIERS$1) {
+      if (modifiers[modifier]) {
+        return modifier;
+      }
+    }
+    return null;
+  }
+  const vThrottle = defineDirective({
+    name: "throttle",
+    ssr: true,
+    // SSR safe - event binding is skipped on server
+    defaults: {
+      wait: 300,
+      leading: true,
+      trailing: true
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$g(binding.value, binding);
+      const eventType = getEventTypeFromModifiers(binding.modifiers) || getEventType(el);
+      const throttledFn = throttle(options.handler, options.wait, {
+        leading: options.leading,
+        trailing: options.trailing
+      });
+      el.addEventListener(eventType, throttledFn);
+      el.__throttle = {
+        throttledFn,
+        eventType,
+        options
+      };
+    },
+    updated(el, binding) {
+      const state = el.__throttle;
+      if (!state) return;
+      const newOptions = normalizeOptions$g(binding.value, binding);
+      if (newOptions.wait !== state.options.wait || newOptions.leading !== state.options.leading || newOptions.trailing !== state.options.trailing) {
+        state.throttledFn.cancel();
+        const throttledFn = throttle(newOptions.handler, newOptions.wait, {
+          leading: newOptions.leading,
+          trailing: newOptions.trailing
+        });
+        el.removeEventListener(state.eventType, state.throttledFn);
+        el.addEventListener(state.eventType, throttledFn);
+        el.__throttle = {
+          throttledFn,
+          eventType: state.eventType,
+          options: newOptions
+        };
+      } else if (newOptions.handler !== state.options.handler) {
+        state.options.handler = newOptions.handler;
+      }
+    },
+    unmounted(el) {
+      const state = el.__throttle;
+      if (!state) return;
+      state.throttledFn.cancel();
+      el.removeEventListener(state.eventType, state.throttledFn);
+      delete el.__throttle;
+    }
+  });
+  function normalizeOptions$g(binding, directiveBinding) {
+    const wait = parseTime(directiveBinding.arg) || 300;
+    if (typeof binding === "function") {
+      return { handler: binding, wait };
+    }
+    return __spreadProps(__spreadValues({}, binding), { wait: binding.wait || wait });
+  }
+  function getEventType(el) {
+    const tagName = el.tagName.toLowerCase();
+    if (tagName === "input" || tagName === "textarea") {
+      return "input";
+    }
+    return "click";
+  }
+  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;
+  }
+  const FOCUSABLE_TAGS = /* @__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;
+    const objA = a;
+    const objB = b;
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => objA[key] === objB[key]);
+  }
+  const vFocus = defineDirective({
+    name: "focus",
+    ssr: true,
+    // SSR safe - will skip focus on server
+    defaults: {
+      focus: true,
+      refocus: false
+    },
+    mounted(el, binding) {
+      if (!isBrowser()) return;
+      const options = normalizeOptions$f(binding.value);
+      if (!options.focus || !isFocusable(el)) {
+        if (options.focus) {
+          console.warn("[Directix] v-focus: Element is not focusable");
+        }
+        return;
+      }
+      const handleFocus = () => {
+        var _a;
+        return (_a = options.onFocus) == null ? void 0 : _a.call(options, el);
+      };
+      const handleBlur = () => {
+        var _a;
+        return (_a = options.onBlur) == null ? void 0 : _a.call(options, el);
+      };
+      el.addEventListener("focus", handleFocus);
+      el.addEventListener("blur", handleBlur);
+      el.__focus = {
+        options,
+        handleFocus,
+        handleBlur,
+        lastValue: binding.value
+      };
+      el.focus();
+    },
+    updated(el, binding) {
+      const state = el.__focus;
+      if (!state) return;
+      const newOptions = normalizeOptions$f(binding.value);
+      if (newOptions.onFocus !== state.options.onFocus) {
+        el.removeEventListener("focus", state.handleFocus);
+        state.handleFocus = () => {
+          var _a;
+          return (_a = newOptions.onFocus) == null ? void 0 : _a.call(newOptions, el);
+        };
+        el.addEventListener("focus", state.handleFocus);
+      }
+      if (newOptions.onBlur !== state.options.onBlur) {
+        el.removeEventListener("blur", state.handleBlur);
+        state.handleBlur = () => {
+          var _a;
+          return (_a = newOptions.onBlur) == null ? void 0 : _a.call(newOptions, el);
+        };
+        el.addEventListener("blur", state.handleBlur);
+      }
+      const valueChanged = !isEqual(binding.value, state.lastValue);
+      if (newOptions.refocus && newOptions.focus && valueChanged) {
+        el.focus();
+      }
+      state.options = newOptions;
+      state.lastValue = binding.value;
+    },
+    unmounted(el) {
+      const state = el.__focus;
+      if (!state) return;
+      el.removeEventListener("focus", state.handleFocus);
+      el.removeEventListener("blur", state.handleBlur);
+      delete el.__focus;
+    }
+  });
+  function normalizeOptions$f(binding) {
+    if (typeof binding === "boolean") {
+      return { focus: binding, refocus: false };
+    }
+    return __spreadValues({
+      focus: true,
+      refocus: false
+    }, binding);
+  }
+  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;
+  }
+  let globalObserver = null;
+  function getGlobalObserver(preload) {
+    if (globalObserver) return globalObserver;
+    globalObserver = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting) {
+            load(entry.target);
+            globalObserver == null ? void 0 : globalObserver.unobserve(entry.target);
+          }
+        });
+      },
+      {
+        rootMargin: `${preload}px`
+      }
+    );
+    return globalObserver;
+  }
+  function setSrc(el, src) {
+    if (el.tagName === "IMG") {
+      el.src = src;
+    } else {
+      el.style.backgroundImage = `url("${src}")`;
+    }
+  }
+  function setLazyState(el, state) {
+    el.dataset.lazyState = state;
+  }
+  function getLazyState(el) {
+    return el.dataset.lazyState || "pending";
+  }
+  function load(el) {
+    const state = el.__lazy;
+    if (!state || !state.options.src) return;
+    if (state.options.filter && !state.options.filter(state.options.src)) {
+      return;
+    }
+    setLazyState(el, "loading");
+    state.attempt++;
+    el.classList.add("v-lazy--loading");
+    const img = new Image();
+    img.onload = () => {
+      var _a, _b;
+      setSrc(el, state.options.src);
+      setLazyState(el, "loaded");
+      el.classList.remove("v-lazy--loading");
+      el.classList.add("v-lazy--loaded");
+      (_b = (_a = state.options).onLoad) == null ? void 0 : _b.call(_a, el);
+    };
+    img.onerror = () => {
+      var _a, _b;
+      el.classList.remove("v-lazy--loading");
+      if (state.attempt < (state.options.attempt || 1)) {
+        setTimeout(() => load(el), 1e3 * state.attempt);
+        return;
+      }
+      if (state.options.error) {
+        setSrc(el, state.options.error);
+      }
+      setLazyState(el, "error");
+      el.classList.add("v-lazy--error");
+      (_b = (_a = state.options).onError) == null ? void 0 : _b.call(_a, el, new Error("Failed to load image"));
+    };
+    img.src = state.options.src;
+  }
+  function observe(el) {
+    const state = el.__lazy;
+    if (!state) return;
+    if (!supportsIntersectionObserver()) {
+      load(el);
+      return;
+    }
+    if (state.options.observer) {
+      state.observer = state.options.observer;
+      state.observer.observe(el);
+    } else {
+      const observer = getGlobalObserver(state.options.preload || 0);
+      state.observer = observer;
+      observer.observe(el);
+    }
+  }
+  function unobserve(el) {
+    const state = el.__lazy;
+    if (!state) return;
+    if (state.observer) {
+      state.observer.unobserve(el);
+    } else if (globalObserver) {
+      globalObserver.unobserve(el);
+    }
+  }
+  function normalizeOptions$e(binding) {
+    if (typeof binding === "string") {
+      return { src: binding };
+    }
+    return binding || {};
+  }
+  const vLazy = defineDirective({
+    name: "lazy",
+    ssr: false,
+    defaults: {
+      preload: 0,
+      attempt: 1,
+      disabled: false
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$e(binding.value);
+      if (options.disabled) return;
+      if (!options.src) {
+        console.warn("[Directix] v-lazy: No source provided");
+        return;
+      }
+      setLazyState(el, "pending");
+      if (options.placeholder) {
+        setSrc(el, options.placeholder);
+      }
+      el.classList.add("v-lazy");
+      const state = {
+        options,
+        attempt: 0
+      };
+      el.__lazy = state;
+      observe(el);
+    },
+    updated(el, binding) {
+      const state = el.__lazy;
+      if (!state) return;
+      const newOptions = normalizeOptions$e(binding.value);
+      if (newOptions.disabled) {
+        unobserve(el);
+        return;
+      }
+      if (newOptions.src !== state.options.src) {
+        state.options = newOptions;
+        state.attempt = 0;
+        if (getLazyState(el) !== "pending") {
+          setLazyState(el, "pending");
+          el.classList.remove("v-lazy--loaded", "v-lazy--error");
+          if (newOptions.placeholder) {
+            setSrc(el, newOptions.placeholder);
+          }
+          observe(el);
+        }
+      }
+    },
+    unmounted(el) {
+      unobserve(el);
+      delete el.__lazy;
+    }
+  });
+  const STATE_KEY$3 = "__intersect";
+  function normalizeOptions$d(binding) {
+    const options = typeof binding === "function" ? { handler: binding } : __spreadValues({}, binding);
+    if (options.root !== null && typeof options.root === "object" && "value" in options.root) {
+      options.root = options.root.value;
+    }
+    return options;
+  }
+  function createObserverCallback(el, state, options) {
+    return (entries) => {
+      var _a, _b, _c, _d;
+      for (const entry of entries) {
+        if (options.once && state.hasTriggeredOnce) continue;
+        const { isIntersecting } = entry;
+        (_a = options.handler) == null ? void 0 : _a.call(options, entry, state.observer);
+        (_b = options.onChange) == null ? void 0 : _b.call(options, isIntersecting, entry);
+        if (isIntersecting) {
+          (_c = options.onEnter) == null ? void 0 : _c.call(options, entry, state.observer);
+          if (options.once) state.hasTriggeredOnce = true;
+        } else {
+          (_d = options.onLeave) == null ? void 0 : _d.call(options, entry, state.observer);
+        }
+        el.dispatchEvent(new CustomEvent("intersect", { detail: { isIntersecting, entry } }));
+      }
+    };
+  }
+  function createObserver(el, state, options) {
+    return new IntersectionObserver(createObserverCallback(el, state, options), {
+      root: options.root,
+      rootMargin: options.rootMargin,
+      threshold: options.threshold
+    });
+  }
+  const vIntersect = defineDirective({
+    name: "intersect",
+    ssr: false,
+    defaults: {
+      disabled: false,
+      once: false,
+      rootMargin: "0px",
+      threshold: 0
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$d(binding.value);
+      if (options.disabled || !isBrowser() || !supportsIntersectionObserver()) {
+        if (!supportsIntersectionObserver()) {
+          console.warn("[Directix] v-intersect: IntersectionObserver not supported");
+        }
+        return;
+      }
+      const state = {
+        options,
+        observer: null,
+        hasTriggeredOnce: false
+      };
+      state.observer = createObserver(el, state, options);
+      el[STATE_KEY$3] = state;
+      state.observer.observe(el);
+    },
+    updated(el, binding) {
+      var _a, _b, _c;
+      const state = el[STATE_KEY$3];
+      if (!state) return;
+      const newOptions = normalizeOptions$d(binding.value);
+      const observerOptionsChanged = newOptions.root !== state.options.root || newOptions.rootMargin !== state.options.rootMargin || newOptions.threshold !== state.options.threshold;
+      if (newOptions.disabled !== state.options.disabled) {
+        if (newOptions.disabled) {
+          (_a = state.observer) == null ? void 0 : _a.disconnect();
+        } else {
+          (_b = state.observer) == null ? void 0 : _b.observe(el);
+        }
+      }
+      if (observerOptionsChanged) {
+        (_c = state.observer) == null ? void 0 : _c.disconnect();
+        state.observer = createObserver(el, state, newOptions);
+        state.observer.observe(el);
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      var _a;
+      const state = el[STATE_KEY$3];
+      if (!state) return;
+      (_a = state.observer) == null ? void 0 : _a.disconnect();
+      delete el[STATE_KEY$3];
+    }
+  });
+  function normalizeOptions$c(binding) {
+    if (typeof binding === "boolean") {
+      return { initial: binding };
+    }
+    return __spreadValues({
+      initial: true,
+      disabled: false,
+      useHidden: false
+    }, binding);
+  }
+  const vVisible = defineDirective({
+    name: "visible",
+    ssr: true,
+    // SSR safe - will set initial visibility on server
+    defaults: {
+      initial: true,
+      disabled: false,
+      useHidden: false
+    },
+    mounted(el, binding) {
+      var _a, _b;
+      if (!isBrowser()) return;
+      const options = normalizeOptions$c(binding.value);
+      const originalDisplay = el.style.display;
+      const originalVisibility = el.style.visibility;
+      const state = {
+        options,
+        isVisible: (_a = options.initial) != null ? _a : true,
+        originalDisplay,
+        originalVisibility,
+        transitionEndHandler: (e) => {
+          if (e.propertyName === "opacity" || e.propertyName === "visibility") {
+            el.dispatchEvent(new CustomEvent("visible:transition-end", {
+              detail: { isVisible: state.isVisible }
+            }));
+          }
+        }
+      };
+      el.__visible = state;
+      on(el, "transitionend", state.transitionEndHandler);
+      applyVisibility(el, state, (_b = options.initial) != null ? _b : true);
+    },
+    updated(el, binding) {
+      var _a;
+      const state = el.__visible;
+      if (!state) return;
+      const newOptions = normalizeOptions$c(binding.value);
+      let newVisibility;
+      if (typeof binding.value === "boolean") {
+        newVisibility = binding.value;
+      } else {
+        newVisibility = (_a = newOptions.initial) != null ? _a : true;
+      }
+      if (state.isVisible !== newVisibility) {
+        applyVisibility(el, state, newVisibility);
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__visible;
+      if (!state) return;
+      off(el, "transitionend", state.transitionEndHandler);
+      el.style.display = state.originalDisplay;
+      el.style.visibility = state.originalVisibility;
+      delete el.__visible;
+    }
+  });
+  function applyVisibility(el, state, isVisible) {
+    const previousVisibility = state.isVisible;
+    state.isVisible = isVisible;
+    if (isVisible) {
+      el.classList.remove("v-hidden");
+      el.classList.add("v-visible");
+    } else {
+      el.classList.remove("v-visible");
+      el.classList.add("v-hidden");
+    }
+    if (state.options.useHidden) {
+      if (isVisible) {
+        el.style.visibility = state.originalVisibility || "visible";
+      } else {
+        const computedStyle = getComputedStyle(el);
+        const hasTransition = computedStyle.transitionDuration !== "0s";
+        if (hasTransition) {
+          const handleTransitionEnd = (e) => {
+            if (e.target === el && (e.propertyName === "opacity" || e.propertyName === "transform")) {
+              if (!state.isVisible) {
+                el.style.visibility = "hidden";
+              }
+              el.removeEventListener("transitionend", handleTransitionEnd);
+            }
+          };
+          el.addEventListener("transitionend", handleTransitionEnd);
+        } else {
+          el.style.visibility = "hidden";
+        }
+      }
+    } else {
+      el.style.display = isVisible ? state.originalDisplay : "none";
+    }
+    el.dispatchEvent(new CustomEvent("visible:change", {
+      detail: { isVisible, previousVisibility }
+    }));
+    if (state.options.handler && previousVisibility !== isVisible) {
+      state.options.handler(isVisible);
+    }
+  }
+  function normalizeOptions$b(binding) {
+    if (typeof binding === "boolean") {
+      return { value: binding };
+    }
+    return __spreadValues({
+      value: true,
+      loadingClass: "v-loading",
+      spinnerClass: "v-loading__spinner",
+      textClass: "v-loading__text",
+      background: "rgba(255, 255, 255, 0.9)",
+      lock: false,
+      disabled: false
+    }, binding);
+  }
+  const DEFAULT_SPINNER = `
+<svg class="v-loading__circular" viewBox="25 25 50 50">
+  <circle class="v-loading__path" cx="50" cy="50" r="20" fill="none" stroke-width="2" stroke-miterlimit="10"/>
+</svg>
+`;
+  function createLoadingOverlay(options) {
+    const overlay = document.createElement("div");
+    overlay.className = options.loadingClass || "v-loading";
+    overlay.style.cssText = `
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 1000;
+    background: ${options.background || "rgba(255, 255, 255, 0.9)"};
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+  `;
+    const spinnerHtml = options.spinner || DEFAULT_SPINNER;
+    const spinnerContainer = document.createElement("div");
+    spinnerContainer.className = options.spinnerClass || "v-loading__spinner";
+    spinnerContainer.innerHTML = spinnerHtml;
+    overlay.appendChild(spinnerContainer);
+    if (options.text) {
+      const textEl = document.createElement("div");
+      textEl.className = options.textClass || "v-loading__text";
+      textEl.textContent = options.text;
+      overlay.appendChild(textEl);
+    }
+    return overlay;
+  }
+  const vLoading = defineDirective({
+    name: "loading",
+    ssr: true,
+    // SSR safe - will skip DOM manipulation on server
+    defaults: {
+      value: true,
+      loadingClass: "v-loading",
+      spinnerClass: "v-loading__spinner",
+      textClass: "v-loading__text",
+      background: "rgba(255, 255, 255, 0.9)",
+      lock: false,
+      disabled: false
+    },
+    mounted(el, binding) {
+      if (!isBrowser()) return;
+      const options = normalizeOptions$b(binding.value);
+      if (options.disabled) return;
+      const computedStyle = getComputedStyle(el);
+      const originalPosition = el.style.position;
+      const originalOverflow = el.style.overflow;
+      const state = {
+        options,
+        loadingOverlay: null,
+        originalPosition,
+        originalOverflow
+      };
+      el.__loading = state;
+      if (computedStyle.position === "static") {
+        el.style.position = "relative";
+      }
+      if (options.value) {
+        showLoading(el, state);
+      }
+    },
+    updated(el, binding) {
+      const state = el.__loading;
+      if (!state) return;
+      const newOptions = normalizeOptions$b(binding.value);
+      if (newOptions.disabled) {
+        hideLoading(el, state);
+        return;
+      }
+      if (newOptions.value && !state.options.value) {
+        showLoading(el, state);
+      } else if (!newOptions.value && state.options.value) {
+        hideLoading(el, state);
+      }
+      if (state.loadingOverlay && newOptions.text !== state.options.text) {
+        const textEl = state.loadingOverlay.querySelector(`.${state.options.textClass}`);
+        if (textEl) {
+          textEl.textContent = newOptions.text || "";
+        }
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__loading;
+      if (!state) return;
+      hideLoading(el, state);
+      el.style.position = state.originalPosition;
+      el.style.overflow = state.originalOverflow;
+      delete el.__loading;
+    }
+  });
+  function showLoading(el, state) {
+    if (state.loadingOverlay) return;
+    state.loadingOverlay = createLoadingOverlay(state.options);
+    el.appendChild(state.loadingOverlay);
+    if (state.options.lock) {
+      el.style.overflow = "hidden";
+    }
+    el.classList.add("v-loading--active");
+  }
+  function hideLoading(el, state) {
+    if (!state.loadingOverlay) return;
+    state.loadingOverlay.remove();
+    state.loadingOverlay = null;
+    if (state.options.lock) {
+      el.style.overflow = state.originalOverflow;
+    }
+    el.classList.remove("v-loading--active");
+  }
+  function getScrollInfo(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,
+      container
+    };
+  }
+  function normalizeOptions$a(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding, passive: true };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-scroll: handler is required");
+    }
+    return __spreadValues({
+      passive: true,
+      throttle: 0,
+      disabled: false
+    }, binding);
+  }
+  const vScroll = defineDirective({
+    name: "scroll",
+    ssr: false,
+    defaults: {
+      passive: true,
+      throttle: 0,
+      disabled: false
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$a(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      let container;
+      if (options.container) {
+        if (options.container === window) {
+          container = window;
+        } else if (typeof options.container === "string") {
+          const found = document.querySelector(options.container);
+          container = found || getScrollParent(el);
+        } else {
+          container = options.container;
+        }
+      } else {
+        const { overflow, overflowX, overflowY } = getComputedStyle(el);
+        const isSelfScrollable = /(auto|scroll)/.test(overflow + overflowX + overflowY);
+        container = isSelfScrollable ? el : getScrollParent(el);
+      }
+      const state = {
+        options,
+        container,
+        lastScrollLeft: 0,
+        lastScrollTop: 0,
+        throttleTimer: null,
+        pendingEvent: null,
+        scrollHandler: (e) => {
+          if (options.throttle && options.throttle > 0) {
+            state.pendingEvent = e;
+            if (!state.throttleTimer) {
+              state.throttleTimer = setTimeout(() => {
+                if (state.pendingEvent) {
+                  const info = getScrollInfo(container, state.lastScrollLeft, state.lastScrollTop);
+                  state.lastScrollLeft = info.scrollLeft;
+                  state.lastScrollTop = info.scrollTop;
+                  options.handler(state.pendingEvent, info);
+                }
+                state.throttleTimer = null;
+                state.pendingEvent = null;
+              }, options.throttle);
+            }
+          } else {
+            const info = getScrollInfo(container, state.lastScrollLeft, state.lastScrollTop);
+            state.lastScrollLeft = info.scrollLeft;
+            state.lastScrollTop = info.scrollTop;
+            options.handler(e, info);
+          }
+        }
+      };
+      const initialInfo = getScrollInfo(container, 0, 0);
+      state.lastScrollLeft = initialInfo.scrollLeft;
+      state.lastScrollTop = initialInfo.scrollTop;
+      el.__scroll = state;
+      on(container, "scroll", state.scrollHandler, { passive: options.passive });
+    },
+    updated(el, binding) {
+      const state = el.__scroll;
+      if (!state) return;
+      state.options = normalizeOptions$a(binding.value);
+    },
+    unmounted(el) {
+      const state = el.__scroll;
+      if (!state) return;
+      if (state.throttleTimer) {
+        clearTimeout(state.throttleTimer);
+      }
+      off(state.container, "scroll", state.scrollHandler);
+      delete el.__scroll;
+    }
+  });
+  function normalizeOptions$9(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding, distance: 0, throttle: 200, useIntersection: true };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-infinite-scroll: handler is required");
+    }
+    return __spreadValues({
+      distance: 0,
+      disabled: false,
+      loading: false,
+      useIntersection: true,
+      throttle: 200
+    }, binding);
+  }
+  const vInfiniteScroll = defineDirective({
+    name: "infinite-scroll",
+    ssr: false,
+    defaults: {
+      distance: 0,
+      disabled: false,
+      loading: false,
+      useIntersection: true,
+      throttle: 200
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$9(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      let container;
+      if (options.container) {
+        if (typeof options.container === "string") {
+          const found = document.querySelector(options.container);
+          container = found || getScrollParent(el);
+        } else {
+          container = options.container;
+        }
+      } else {
+        container = getScrollParent(el);
+      }
+      const state = {
+        options,
+        container,
+        sentinel: null,
+        observer: null,
+        throttleTimer: null,
+        isLoading: false,
+        scrollHandler: (_e) => __async(null, null, function* () {
+          if (state.isLoading || state.options.disabled || state.options.loading) {
+            return;
+          }
+          if (state.throttleTimer) {
+            return;
+          }
+          state.throttleTimer = setTimeout(() => {
+            state.throttleTimer = null;
+          }, options.throttle);
+          const shouldLoad = checkShouldLoad(container, el, options.distance || 0);
+          if (shouldLoad) {
+            yield triggerLoad(state, el);
+          }
+        })
+      };
+      el.__infiniteScroll = state;
+      if (options.useIntersection && supportsIntersectionObserver()) {
+        setupIntersectionObserver(el, state);
+      } else {
+        on(container, "scroll", state.scrollHandler, { passive: true });
+      }
+    },
+    updated(el, binding) {
+      const state = el.__infiniteScroll;
+      if (!state) return;
+      state.options = normalizeOptions$9(binding.value);
+    },
+    unmounted(el) {
+      const state = el.__infiniteScroll;
+      if (!state) return;
+      if (state.throttleTimer) {
+        clearTimeout(state.throttleTimer);
+      }
+      if (state.observer) {
+        state.observer.disconnect();
+      }
+      if (state.sentinel && state.sentinel.parentNode) {
+        state.sentinel.parentNode.removeChild(state.sentinel);
+      }
+      off(state.container, "scroll", state.scrollHandler);
+      delete el.__infiniteScroll;
+    }
+  });
+  function checkShouldLoad(container, _el, distance) {
+    if (container === window) {
+      const scrollTop2 = window.scrollY || document.documentElement.scrollTop;
+      const scrollHeight2 = document.documentElement.scrollHeight;
+      const clientHeight2 = window.innerHeight;
+      return scrollTop2 + clientHeight2 >= scrollHeight2 - distance;
+    }
+    const el = container;
+    const scrollTop = el.scrollTop;
+    const scrollHeight = el.scrollHeight;
+    const clientHeight = el.clientHeight;
+    return scrollTop + clientHeight >= scrollHeight - distance;
+  }
+  function triggerLoad(state, el) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f;
+      state.isLoading = true;
+      (_b = (_a = state.options).onLoadStart) == null ? void 0 : _b.call(_a);
+      el.classList.add("v-infinite-scroll--loading");
+      try {
+        yield state.options.handler();
+      } catch (err) {
+        (_d = (_c = state.options).onError) == null ? void 0 : _d.call(_c, err);
+      } finally {
+        state.isLoading = false;
+        (_f = (_e = state.options).onLoadEnd) == null ? void 0 : _f.call(_e);
+        el.classList.remove("v-infinite-scroll--loading");
+      }
+    });
+  }
+  function setupIntersectionObserver(el, state) {
+    const sentinel = document.createElement("div");
+    sentinel.className = "v-infinite-scroll__sentinel";
+    sentinel.style.cssText = `
+    height: 1px;
+    width: 100%;
+    clear: both;
+  `;
+    el.appendChild(sentinel);
+    state.sentinel = sentinel;
+    state.observer = new IntersectionObserver(
+      (entries) => __async(null, null, function* () {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            if (!state.isLoading && !state.options.disabled && !state.options.loading) {
+              yield triggerLoad(state, el);
+            }
+          }
+        }
+      }),
+      {
+        root: state.container === window ? null : state.container,
+        rootMargin: `${state.options.distance || 0}px`,
+        threshold: 0
+      }
+    );
+    state.observer.observe(sentinel);
+  }
+  const STATE_KEY$2 = "__sticky";
+  function normalizeOptions$8(binding) {
+    if (binding === false) return { disabled: true, top: 0, zIndex: 100 };
+    if (typeof binding === "number") return { top: binding, zIndex: 100 };
+    return __spreadValues({
+      top: 0,
+      zIndex: 100,
+      stickyClass: "v-sticky--fixed",
+      disabled: false
+    }, binding && typeof binding === "object" ? binding : {});
+  }
+  function parseOffset(value) {
+    if (value === void 0) return "0";
+    return typeof value === "number" ? `${value}px` : value;
+  }
+  function getScrollContainer(el, customContainer) {
+    if (customContainer) {
+      if (typeof customContainer === "string") {
+        return document.querySelector(customContainer) || getScrollParent(el);
+      }
+      return customContainer;
+    }
+    const parent = el.parentElement;
+    if (parent) {
+      const { overflow, overflowX, overflowY } = getComputedStyle(parent);
+      if (/(auto|scroll)/.test(overflow + overflowX + overflowY)) {
+        return parent;
+      }
+    }
+    return getScrollParent(el);
+  }
+  function checkSticky(el, state) {
+    if (state.options.disabled) {
+      unsetSticky(el, state);
+      return;
+    }
+    const topOffset = Number.parseFloat(parseOffset(state.options.top));
+    const containerRect = state.container === window ? { top: 0 } : state.container.getBoundingClientRect();
+    const referenceEl = state.placeholder || el;
+    const rect = referenceEl.getBoundingClientRect();
+    const elementTopRelativeToContainer = rect.top - containerRect.top;
+    const shouldSticky = elementTopRelativeToContainer <= topOffset;
+    if (shouldSticky && !state.isSticky) {
+      setSticky(el, state, topOffset, containerRect.top);
+    } else if (!shouldSticky && state.isSticky) {
+      unsetSticky(el, state);
+    }
+  }
+  function setSticky(el, state, topOffset, containerTop) {
+    var _a, _b, _c;
+    state.isSticky = true;
+    const placeholder = document.createElement("div");
+    placeholder.style.cssText = `width:${el.offsetWidth}px;height:${el.offsetHeight}px`;
+    (_a = el.parentNode) == null ? void 0 : _a.insertBefore(placeholder, el);
+    state.placeholder = placeholder;
+    const fixedTop = state.container === window ? topOffset : containerTop + topOffset;
+    el.style.position = "fixed";
+    el.style.top = `${fixedTop}px`;
+    el.style.zIndex = String(state.options.zIndex || 100);
+    el.style.width = `${el.offsetWidth}px`;
+    if (state.options.bottom !== void 0) {
+      el.style.bottom = parseOffset(state.options.bottom);
+    }
+    state.options.stickyClass && el.classList.add(state.options.stickyClass);
+    el.dispatchEvent(new CustomEvent("sticky:change", { detail: { isSticky: true } }));
+    (_c = (_b = state.options).onChange) == null ? void 0 : _c.call(_b, true);
+  }
+  function unsetSticky(el, state) {
+    var _a, _b, _c, _d;
+    if (!state.isSticky) return;
+    state.isSticky = false;
+    (_b = (_a = state.placeholder) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(state.placeholder);
+    state.placeholder = null;
+    Object.assign(el.style, state.originalStyles);
+    state.options.stickyClass && el.classList.remove(state.options.stickyClass);
+    el.dispatchEvent(new CustomEvent("sticky:change", { detail: { isSticky: false } }));
+    (_d = (_c = state.options).onChange) == null ? void 0 : _d.call(_c, false);
+  }
+  const vSticky = defineDirective({
+    name: "sticky",
+    ssr: false,
+    defaults: { top: 0, zIndex: 100, stickyClass: "v-sticky--fixed", disabled: false },
+    mounted(el, binding) {
+      const options = normalizeOptions$8(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const container = getScrollContainer(el, options.container);
+      const state = {
+        options,
+        placeholder: null,
+        originalStyles: {
+          position: el.style.position,
+          top: el.style.top,
+          bottom: el.style.bottom,
+          zIndex: el.style.zIndex,
+          width: el.style.width
+        },
+        isSticky: false,
+        container,
+        scrollHandler: () => checkSticky(el, state),
+        resizeHandler: () => checkSticky(el, state)
+      };
+      el.classList.add("v-sticky");
+      el[STATE_KEY$2] = state;
+      on(container, "scroll", state.scrollHandler, { passive: true });
+      on(window, "resize", state.resizeHandler, { passive: true });
+      checkSticky(el, state);
+    },
+    updated(el, binding) {
+      const state = el[STATE_KEY$2];
+      if (!state) return;
+      state.options = normalizeOptions$8(binding.value);
+      checkSticky(el, state);
+    },
+    unmounted(el) {
+      var _a, _b;
+      const state = el[STATE_KEY$2];
+      if (!state) return;
+      (_b = (_a = state.placeholder) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(state.placeholder);
+      Object.assign(el.style, state.originalStyles);
+      el.classList.remove("v-sticky", state.options.stickyClass || "v-sticky--fixed");
+      off(state.container, "scroll", state.scrollHandler);
+      off(window, "resize", state.resizeHandler);
+      delete el[STATE_KEY$2];
+    }
+  });
+  function normalizeOptions$7(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding, duration: 500, distance: 10 };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-long-press: handler is required");
+    }
+    return __spreadValues({
+      duration: 500,
+      distance: 10,
+      disabled: false,
+      prevent: true,
+      stop: false,
+      tickInterval: 100
+    }, binding);
+  }
+  function getDistance(p1, p2) {
+    return Math.sqrt(__pow(p2.x - p1.x, 2) + __pow(p2.y - p1.y, 2));
+  }
+  const vLongPress = defineDirective({
+    name: "long-press",
+    ssr: false,
+    defaults: {
+      duration: 500,
+      distance: 10,
+      disabled: false,
+      prevent: true,
+      stop: false,
+      tickInterval: 100
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$7(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const state = {
+        options,
+        timerId: null,
+        tickTimerId: null,
+        startTime: 0,
+        startPos: { x: 0, y: 0 },
+        startHandler: () => {
+        },
+        endHandler: () => {
+        },
+        moveHandler: () => {
+        }
+      };
+      state.startHandler = (e) => {
+        var _a;
+        const event = e;
+        if (options.prevent) {
+          event.preventDefault();
+        }
+        if (options.stop) {
+          event.stopPropagation();
+        }
+        if (state.timerId) {
+          clearTimeout(state.timerId);
+          state.timerId = null;
+        }
+        if (state.tickTimerId) {
+          clearInterval(state.tickTimerId);
+          state.tickTimerId = null;
+        }
+        const pos = getEventPosition(event);
+        state.startPos = { x: pos.x, y: pos.y };
+        state.startTime = Date.now();
+        (_a = options.onStart) == null ? void 0 : _a.call(options, event);
+        if (options.onTick) {
+          let remaining = options.duration;
+          state.tickTimerId = setInterval(() => {
+            var _a2;
+            remaining -= options.tickInterval;
+            (_a2 = options.onTick) == null ? void 0 : _a2.call(options, Math.max(0, remaining));
+          }, options.tickInterval);
+        }
+        state.timerId = setTimeout(() => {
+          if (state.tickTimerId) {
+            clearInterval(state.tickTimerId);
+            state.tickTimerId = null;
+          }
+          options.handler(event);
+        }, options.duration);
+      };
+      state.endHandler = (e) => {
+        var _a;
+        const event = e;
+        if (state.timerId) {
+          clearTimeout(state.timerId);
+          state.timerId = null;
+        }
+        if (state.tickTimerId) {
+          clearInterval(state.tickTimerId);
+          state.tickTimerId = null;
+        }
+        if (state.startTime > 0) {
+          (_a = options.onCancel) == null ? void 0 : _a.call(options, event);
+        }
+        state.startTime = 0;
+      };
+      state.moveHandler = (e) => {
+        var _a;
+        if (!state.timerId) return;
+        const event = e;
+        const pos = getEventPosition(event);
+        const distance = getDistance(state.startPos, { x: pos.x, y: pos.y });
+        if (distance > (options.distance || 10)) {
+          if (state.timerId) {
+            clearTimeout(state.timerId);
+            state.timerId = null;
+          }
+          if (state.tickTimerId) {
+            clearInterval(state.tickTimerId);
+            state.tickTimerId = null;
+          }
+          (_a = options.onCancel) == null ? void 0 : _a.call(options, event);
+          state.startTime = 0;
+        }
+      };
+      el.__longPress = state;
+      on(el, "mousedown", state.startHandler);
+      on(el, "mouseup", state.endHandler);
+      on(el, "mouseleave", state.endHandler);
+      on(el, "mousemove", state.moveHandler);
+      on(el, "touchstart", state.startHandler, { passive: !options.prevent });
+      on(el, "touchend", state.endHandler);
+      on(el, "touchcancel", state.endHandler);
+      on(el, "touchmove", state.moveHandler, { passive: true });
+    },
+    updated(el, binding) {
+      const state = el.__longPress;
+      if (!state) {
+        const options = normalizeOptions$7(binding.value);
+        if (!options.disabled) {
+          el.__longPress = null;
+        }
+        return;
+      }
+      state.options = normalizeOptions$7(binding.value);
+    },
+    unmounted(el) {
+      const state = el.__longPress;
+      if (!state) return;
+      if (state.timerId) {
+        clearTimeout(state.timerId);
+      }
+      if (state.tickTimerId) {
+        clearInterval(state.tickTimerId);
+      }
+      off(el, "mousedown", state.startHandler);
+      off(el, "mouseup", state.endHandler);
+      off(el, "mouseleave", state.endHandler);
+      off(el, "mousemove", state.moveHandler);
+      off(el, "touchstart", state.startHandler);
+      off(el, "touchend", state.endHandler);
+      off(el, "touchcancel", state.endHandler);
+      off(el, "touchmove", state.moveHandler);
+      delete el.__longPress;
+    }
+  });
+  function normalizeOptions$6(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding, class: "v-hover" };
+    }
+    return __spreadValues({
+      class: "v-hover",
+      disabled: false,
+      enterDelay: 0,
+      leaveDelay: 0
+    }, binding);
+  }
+  const vHover = defineDirective({
+    name: "hover",
+    ssr: false,
+    defaults: {
+      class: "v-hover",
+      disabled: false,
+      enterDelay: 0,
+      leaveDelay: 0
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$6(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const state = {
+        options,
+        isHovering: false,
+        enterTimerId: null,
+        leaveTimerId: null,
+        enterHandler: () => {
+        },
+        leaveHandler: () => {
+        }
+      };
+      state.enterHandler = (e) => {
+        const event = e;
+        if (state.leaveTimerId) {
+          clearTimeout(state.leaveTimerId);
+          state.leaveTimerId = null;
+        }
+        if (state.isHovering) return;
+        if (options.enterDelay && options.enterDelay > 0) {
+          state.enterTimerId = setTimeout(() => {
+            state.isHovering = true;
+            applyHoverState(el, state, event);
+          }, options.enterDelay);
+        } else {
+          state.isHovering = true;
+          applyHoverState(el, state, event);
+        }
+      };
+      state.leaveHandler = (e) => {
+        const event = e;
+        if (state.enterTimerId) {
+          clearTimeout(state.enterTimerId);
+          state.enterTimerId = null;
+        }
+        if (!state.isHovering) return;
+        if (options.leaveDelay && options.leaveDelay > 0) {
+          state.leaveTimerId = setTimeout(() => {
+            state.isHovering = false;
+            applyLeaveState(el, state, event);
+          }, options.leaveDelay);
+        } else {
+          state.isHovering = false;
+          applyLeaveState(el, state, event);
+        }
+      };
+      el.__hover = state;
+      on(el, "mouseenter", state.enterHandler);
+      on(el, "mouseleave", state.leaveHandler);
+    },
+    updated(el, binding) {
+      const state = el.__hover;
+      if (!state) return;
+      const newOptions = normalizeOptions$6(binding.value);
+      if (newOptions.disabled && !state.options.disabled) {
+        el.classList.remove(state.options.class || "v-hover");
+      } else if (!newOptions.disabled && state.options.disabled) ;
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__hover;
+      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);
+      el.classList.remove(state.options.class || "v-hover");
+      delete el.__hover;
+    }
+  });
+  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);
+  }
+  function normalizeOptions$5(binding) {
+    if (binding === false) {
+      return { disabled: true, color: "currentColor", duration: 600 };
+    }
+    if (typeof binding === "string") {
+      return { color: binding, duration: 600 };
+    }
+    const base = {
+      color: "currentColor",
+      duration: 600,
+      disabled: false,
+      initialScale: 0,
+      finalScale: 2
+    };
+    return binding && typeof binding === "object" ? __spreadValues(__spreadValues({}, base), binding) : base;
+  }
+  function createRipple(event, el, options) {
+    const rect = el.getBoundingClientRect();
+    const x = event.clientX - rect.left;
+    const y = event.clientY - rect.top;
+    const size = Math.max(rect.width, rect.height) * 2;
+    const ripple = document.createElement("span");
+    ripple.className = "v-ripple__wave";
+    ripple.style.cssText = `
+    position: absolute;
+    border-radius: 50%;
+    pointer-events: none;
+    background-color: ${options.color};
+    width: ${size}px;
+    height: ${size}px;
+    left: ${x - size / 2}px;
+    top: ${y - size / 2}px;
+    transform: scale(${options.initialScale});
+    opacity: 0.3;
+    z-index: 0;
+  `;
+    return ripple;
+  }
+  function animateRipple(ripple, options) {
+    const duration = options.duration || 600;
+    const initialScale = options.initialScale || 0;
+    const finalScale = options.finalScale || 2;
+    if (typeof ripple.animate === "function") {
+      ripple.animate(
+        [
+          { transform: `scale(${initialScale})`, opacity: 0.3 },
+          { transform: `scale(${finalScale})`, opacity: 0 }
+        ],
+        {
+          duration,
+          easing: "ease-out",
+          fill: "forwards"
+        }
+      ).onfinish = () => {
+        ripple.remove();
+      };
+    } else {
+      ripple.style.transition = `transform ${duration}ms ease-out, opacity ${duration}ms ease-out`;
+      String(ripple.offsetHeight);
+      ripple.style.transform = `scale(${finalScale})`;
+      ripple.style.opacity = "0";
+      setTimeout(() => {
+        ripple.remove();
+      }, duration);
+    }
+  }
+  const vRipple = defineDirective({
+    name: "ripple",
+    ssr: false,
+    defaults: {
+      color: "currentColor",
+      duration: 600,
+      disabled: false,
+      initialScale: 0,
+      finalScale: 2
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$5(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const computedStyle = getComputedStyle(el);
+      if (computedStyle.position === "static") {
+        el.style.position = "relative";
+      }
+      if (computedStyle.overflow === "visible") {
+        el.style.overflow = "hidden";
+      }
+      el.classList.add("v-ripple");
+      const state = {
+        options,
+        clickHandler: (e) => {
+          if (state.options.disabled) return;
+          const mouseEvent = e;
+          const ripple = createRipple(mouseEvent, el, state.options);
+          if (ripple) {
+            el.appendChild(ripple);
+            animateRipple(ripple, state.options);
+          }
+        }
+      };
+      el.__ripple = state;
+      on(el, "click", state.clickHandler);
+    },
+    updated(el, binding) {
+      const state = el.__ripple;
+      if (!state) return;
+      state.options = normalizeOptions$5(binding.value);
+    },
+    unmounted(el) {
+      const state = el.__ripple;
+      if (!state) return;
+      off(el, "click", state.clickHandler);
+      el.classList.remove("v-ripple");
+      delete el.__ripple;
+    }
+  });
+  const STATE_KEY$1 = "__mask";
+  const TOKEN_PATTERNS = {
+    "#": /\d/,
+    A: /[A-Za-z]/,
+    N: /[A-Za-z0-9]/,
+    X: /./
+  };
+  function parseMask(mask, placeholder) {
+    return [...mask].map((char) => {
+      const pattern = TOKEN_PATTERNS[char];
+      return pattern ? { pattern, placeholder, isLiteral: false } : { pattern: new RegExp(`\\${char}`), placeholder: char, isLiteral: true };
+    });
+  }
+  function normalizeOptions$4(binding) {
+    if (typeof binding === "string") return { mask: binding, placeholder: "_", showPlaceholder: true };
+    if (!(binding == null ? void 0 : binding.mask)) throw new Error("[Directix] v-mask: mask is required");
+    return __spreadValues({ placeholder: "_", showPlaceholder: true, showMaskOnBlur: false, clearIncomplete: false, disabled: false }, binding);
+  }
+  function isInput(el) {
+    return el.tagName === "INPUT" || el.tagName === "TEXTAREA";
+  }
+  function formatValue(value, tokens, placeholder, showPlaceholder) {
+    let result = "", valueIndex = 0;
+    for (const token of tokens) {
+      if (valueIndex >= value.length) {
+        result += token.isLiteral ? token.placeholder : showPlaceholder ? placeholder : "";
+        continue;
+      }
+      const inputChar = value[valueIndex];
+      if (token.isLiteral) {
+        if (inputChar === token.placeholder) valueIndex++;
+        result += token.placeholder;
+      } else if (token.pattern.test(inputChar)) {
+        result += inputChar;
+        valueIndex++;
+      } else if (inputChar === placeholder) {
+        result += showPlaceholder ? placeholder : "";
+        valueIndex++;
+      } else {
+        valueIndex++;
+      }
+    }
+    return result;
+  }
+  function getRawValue(value, tokens, placeholder) {
+    let raw = "";
+    for (let i = 0; i < value.length && i < tokens.length; i++) {
+      if (!tokens[i].isLiteral && value[i] !== placeholder) {
+        raw += value[i];
+      }
+    }
+    return raw;
+  }
+  function isComplete(value, tokens, placeholder) {
+    for (let i = 0; i < tokens.length; i++) {
+      if (!tokens[i].isLiteral && (i >= value.length || value[i] === placeholder)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getCursorPos(tokens, rawCursorPos) {
+    let pos = rawCursorPos;
+    while (pos < tokens.length && tokens[pos].isLiteral) {
+      pos++;
+    }
+    return Math.min(pos, tokens.length);
+  }
+  const vMask = defineDirective({
+    name: "mask",
+    ssr: false,
+    defaults: { placeholder: "_", showPlaceholder: true, showMaskOnBlur: false, clearIncomplete: false, disabled: false },
+    mounted(el, binding) {
+      var _a;
+      if (!isInput(el)) {
+        console.warn("[Directix] v-mask: directive must be used on input or textarea elements");
+        return;
+      }
+      const options = normalizeOptions$4(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const placeholder = options.placeholder || "_";
+      const tokens = parseMask(options.mask, placeholder);
+      const inputHandler = (e) => {
+        var _a2, _b, _c;
+        const target = e.target;
+        const rawValue = target.value;
+        const cursorPos = target.selectionStart || 0;
+        const formatted = formatValue(rawValue, tokens, placeholder, (_a2 = options.showPlaceholder) != null ? _a2 : true);
+        if (formatted !== rawValue) {
+          target.value = formatted;
+          target.setSelectionRange(getCursorPos(tokens, cursorPos), getCursorPos(tokens, cursorPos));
+          target.dispatchEvent(new Event("input", { bubbles: true }));
+          return;
+        }
+        (_b = options.onChange) == null ? void 0 : _b.call(options, formatted, getRawValue(formatted, tokens, placeholder));
+        if (isComplete(formatted, tokens, placeholder)) {
+          (_c = options.onComplete) == null ? void 0 : _c.call(options, formatted);
+        }
+      };
+      const focusHandler = () => {
+        if (!el.value && options.showPlaceholder) {
+          el.value = formatValue("", tokens, placeholder, true);
+        }
+      };
+      const blurHandler = () => {
+        if (!options.showMaskOnBlur && !isComplete(el.value, tokens, placeholder) && options.clearIncomplete) {
+          el.value = "";
+        }
+      };
+      on(el, "input", inputHandler);
+      on(el, "focus", focusHandler);
+      on(el, "blur", blurHandler);
+      el[STATE_KEY$1] = { options, tokens, placeholder, inputHandler, focusHandler, blurHandler };
+      if (el.value) {
+        el.value = formatValue(el.value, tokens, placeholder, (_a = options.showPlaceholder) != null ? _a : true);
+      }
+    },
+    updated(el, binding) {
+      const state = el[STATE_KEY$1];
+      if (!state) return;
+      state.options = normalizeOptions$4(binding.value);
+      state.tokens = parseMask(state.options.mask, state.placeholder);
+    },
+    unmounted(el) {
+      const state = el[STATE_KEY$1];
+      if (!state) return;
+      off(el, "input", state.inputHandler);
+      off(el, "focus", state.focusHandler);
+      off(el, "blur", state.blurHandler);
+      delete el[STATE_KEY$1];
+    }
+  });
+  const STATE_KEY = "__permission";
+  const WILDCARD = "*";
+  let globalConfig = null;
+  function configurePermission(config) {
+    globalConfig = config;
+  }
+  function getPermissionConfig() {
+    return globalConfig;
+  }
+  function normalizeOptions$3(binding) {
+    if (!binding) {
+      throw new Error("[Directix] v-permission: permission value is required");
+    }
+    if (typeof binding === "string") {
+      return { value: binding };
+    }
+    if (Array.isArray(binding)) {
+      return { value: 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;
+    switch (action) {
+      case "remove":
+        state.parentNode = el.parentNode;
+        state.placeholder = document.createComment("v-permission");
+        (_a = el.parentNode) == null ? void 0 : _a.insertBefore(state.placeholder, el);
+        (_b = el.parentNode) == null ? void 0 : _b.removeChild(el);
+        break;
+      case "disable":
+        state.originalDisabled = el.getAttribute("disabled") || false;
+        el.setAttribute("disabled", "true");
+        el.classList.add("v-permission--disabled");
+        break;
+      case "hide":
+        state.originalDisplay = el.style.display;
+        el.style.display = "none";
+        el.classList.add("v-permission--hidden");
+        break;
+    }
+  }
+  function handleGranted(el, action, state) {
+    switch (action) {
+      case "remove":
+        if (state.placeholder && state.parentNode) {
+          state.parentNode.insertBefore(el, state.placeholder);
+          state.parentNode.removeChild(state.placeholder);
+          state.placeholder = null;
+        }
+        break;
+      case "disable":
+        if (state.originalDisabled === false) {
+          el.removeAttribute("disabled");
+        } else if (state.originalDisabled) {
+          el.setAttribute("disabled", state.originalDisabled);
+        }
+        el.classList.remove("v-permission--disabled");
+        break;
+      case "hide":
+        el.style.display = state.originalDisplay || "";
+        el.classList.remove("v-permission--hidden");
+        break;
+    }
+  }
+  function getState(el) {
+    if (!el[STATE_KEY]) {
+      el[STATE_KEY] = {
+        options: { value: "" },
+        originalDisplay: "",
+        originalDisabled: false,
+        parentNode: null,
+        placeholder: null
+      };
+    }
+    return el[STATE_KEY];
+  }
+  function checkPermission(el, binding) {
+    var _a, _b;
+    const state = getState(el);
+    state.options = normalizeOptions$3(binding.value);
+    const granted = verifyPermission(state.options);
+    (_b = (_a = state.options).onChange) == null ? void 0 : _b.call(_a, granted);
+    const action = state.options.action || "remove";
+    if (granted) {
+      handleGranted(el, action, state);
+    } else {
+      handleDenied(el, action, state);
+    }
+  }
+  function cleanup(el) {
+    const state = el[STATE_KEY];
+    if ((state == null ? void 0 : state.placeholder) && state.parentNode) {
+      state.parentNode.removeChild(state.placeholder);
+    }
+    delete el[STATE_KEY];
+  }
+  const vPermission = defineDirective({
+    name: "permission",
+    ssr: true,
+    mounted(el, binding) {
+      checkPermission(el, binding);
+    },
+    updated(el, binding) {
+      checkPermission(el, binding);
+    },
+    unmounted(el) {
+      cleanup(el);
+    }
+  });
+  const DEFAULT_ALLOWED_TAGS = ["b", "i", "u", "strong", "em", "br", "p", "span", "div"];
+  const DEFAULT_ALLOWED_ATTRIBUTES = ["title", "alt", "href", "src"];
+  const DANGEROUS_TAGS = ["script", "iframe", "object", "embed", "form", "input", "style", "link", "meta", "base"];
+  const DANGEROUS_ATTRIBUTES = ["onclick", "onerror", "onload", "onmouseover", "onfocus", "onblur", "onchange", "onsubmit"];
+  function normalizeOptions$2(binding) {
+    if (binding === false) {
+      return { disabled: true };
+    }
+    if (binding === true) {
+      return {
+        allowedTags: DEFAULT_ALLOWED_TAGS,
+        allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES
+      };
+    }
+    return __spreadValues({
+      allowedTags: DEFAULT_ALLOWED_TAGS,
+      allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES,
+      allowDataUrls: false,
+      allowStyles: false,
+      allowClass: false,
+      allowId: false,
+      disabled: false,
+      sanitizeOnUpdate: true
+    }, binding);
+  }
+  function sanitizeHtml(html, options) {
+    var _a;
+    if (options.handler) {
+      return options.handler(html);
+    }
+    const temp = document.createElement("div");
+    temp.innerHTML = html;
+    for (const tag of DANGEROUS_TAGS) {
+      const elements = temp.getElementsByTagName(tag);
+      while (elements.length > 0) {
+        (_a = elements[0].parentNode) == null ? void 0 : _a.removeChild(elements[0]);
+      }
+    }
+    const processElement = (el) => {
+      var _a2;
+      const tagName = el.tagName.toLowerCase();
+      if (options.allowedTags && !options.allowedTags.includes(tagName)) {
+        const text = document.createTextNode(el.textContent || "");
+        (_a2 = el.parentNode) == null ? void 0 : _a2.replaceChild(text, el);
+        return;
+      }
+      for (const attr of DANGEROUS_ATTRIBUTES) {
+        el.removeAttribute(attr);
+      }
+      const href = el.getAttribute("href");
+      if (href && href.toLowerCase().startsWith("javascript:")) {
+        el.removeAttribute("href");
+      }
+      if (!options.allowDataUrls) {
+        const src = el.getAttribute("src");
+        if (src && src.toLowerCase().startsWith("data:")) {
+          el.removeAttribute("src");
+        }
+      }
+      if (options.allowedAttributes) {
+        const attrs = Array.from(el.attributes);
+        for (const attr of attrs) {
+          const isAllowed = options.allowedAttributes.includes(attr.name.toLowerCase());
+          const isClass = attr.name === "class" && options.allowClass;
+          const isId = attr.name === "id" && options.allowId;
+          const isStyle = attr.name === "style" && options.allowStyles;
+          if (!isAllowed && !isClass && !isId && !isStyle) {
+            el.removeAttribute(attr.name);
+          }
+        }
+      }
+      for (const child of Array.from(el.children)) {
+        processElement(child);
+      }
+    };
+    for (const child of Array.from(temp.children)) {
+      processElement(child);
+    }
+    return temp.innerHTML;
+  }
+  const vSanitize = defineDirective({
+    name: "sanitize",
+    ssr: true,
+    defaults: {
+      allowedTags: DEFAULT_ALLOWED_TAGS,
+      allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES,
+      allowDataUrls: false,
+      allowStyles: false,
+      allowClass: false,
+      allowId: false,
+      disabled: false,
+      sanitizeOnUpdate: true
+    },
+    mounted(el, binding) {
+      if (!isBrowser()) return;
+      const options = normalizeOptions$2(binding.value);
+      if (options.disabled) return;
+      el.__sanitize = { options };
+      const content = el.innerHTML;
+      if (content) {
+        el.innerHTML = sanitizeHtml(content, options);
+      }
+    },
+    updated(el, binding) {
+      const state = el.__sanitize;
+      if (!state) return;
+      state.options = normalizeOptions$2(binding.value);
+      if (state.options.disabled || !state.options.sanitizeOnUpdate) return;
+      const content = el.innerHTML;
+      if (content) {
+        el.innerHTML = sanitizeHtml(content, state.options);
+      }
+    },
+    unmounted(el) {
+      delete el.__sanitize;
+    }
+  });
+  function getResizeInfo(entry) {
+    return {
+      width: entry.contentRect.width,
+      height: entry.contentRect.height,
+      contentRect: entry.contentRect,
+      borderBoxSize: entry.borderBoxSize,
+      contentBoxSize: entry.contentBoxSize,
+      devicePixelContentBoxSize: entry.devicePixelContentBoxSize
+    };
+  }
+  function normalizeOptions$1(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding };
+    }
+    if (!binding) {
+      throw new Error("[Directix] v-resize: handler is required");
+    }
+    return __spreadValues({
+      disabled: false,
+      box: "content-box",
+      debounce: 0
+    }, binding);
+  }
+  function createFallbackResize(el, callback) {
+    const iframe = document.createElement("iframe");
+    iframe.style.cssText = `
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    border: none;
+    pointer-events: none;
+    opacity: 0;
+  `;
+    el.appendChild(iframe);
+    const iWindow = iframe.contentWindow;
+    if (iWindow) {
+      iWindow.addEventListener("resize", callback);
+    }
+    return {
+      iframe,
+      cleanup: () => {
+        if (iWindow) {
+          iWindow.removeEventListener("resize", callback);
+        }
+        iframe.remove();
+      }
+    };
+  }
+  const vResize = defineDirective({
+    name: "resize",
+    ssr: false,
+    defaults: {
+      disabled: false,
+      box: "content-box",
+      debounce: 0
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$1(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      const computedStyle = getComputedStyle(el);
+      if (computedStyle.position === "static") {
+        el.style.position = "relative";
+      }
+      const state = {
+        options,
+        observer: null,
+        debounceTimer: null,
+        pendingEntry: null,
+        fallbackIframe: null,
+        handler: (entry) => {
+          if (options.debounce && options.debounce > 0) {
+            state.pendingEntry = entry;
+            if (!state.debounceTimer) {
+              state.debounceTimer = setTimeout(() => {
+                if (state.pendingEntry) {
+                  options.handler(state.pendingEntry);
+                }
+                state.debounceTimer = null;
+                state.pendingEntry = null;
+              }, options.debounce);
+            }
+          } else {
+            options.handler(entry);
+          }
+        }
+      };
+      el.__resize = state;
+      if (supportsResizeObserver()) {
+        state.observer = new ResizeObserver((entries) => {
+          for (const entry of entries) {
+            state.handler(entry);
+          }
+        });
+        state.observer.observe(el, { box: options.box });
+      } else {
+        console.warn("[Directix] v-resize: ResizeObserver not supported, using fallback");
+        const { iframe, cleanup: cleanup2 } = createFallbackResize(el, () => {
+          const rect = el.getBoundingClientRect();
+          const entry = {
+            target: el,
+            contentRect: rect,
+            borderBoxSize: [],
+            contentBoxSize: [],
+            devicePixelContentBoxSize: []
+          };
+          state.handler(entry);
+          if (options.onFallback) {
+            options.onFallback(getResizeInfo(entry));
+          }
+        });
+        state.fallbackIframe = iframe;
+        el.__resizeCleanup = cleanup2;
+      }
+    },
+    updated(el, binding) {
+      const state = el.__resize;
+      if (!state) return;
+      state.options = normalizeOptions$1(binding.value);
+    },
+    unmounted(el) {
+      const state = el.__resize;
+      if (!state) return;
+      if (state.debounceTimer) {
+        clearTimeout(state.debounceTimer);
+      }
+      if (state.observer) {
+        state.observer.disconnect();
+      }
+      const cleanup2 = el.__resizeCleanup;
+      if (cleanup2) {
+        cleanup2();
+      }
+      delete el.__resize;
+      delete el.__resizeCleanup;
+    }
+  });
+  function normalizeOptions(binding) {
+    if (typeof binding === "function") {
+      return { handler: binding, childList: true };
+    }
+    if (!binding || !binding.handler) {
+      throw new Error("[Directix] v-mutation: handler is required");
+    }
+    return __spreadValues({
+      attributes: false,
+      childList: true,
+      subtree: false,
+      characterData: false,
+      attributeOldValue: false,
+      characterDataOldValue: false,
+      disabled: false
+    }, binding);
+  }
+  const vMutation = defineDirective({
+    name: "mutation",
+    ssr: false,
+    defaults: {
+      attributes: false,
+      childList: true,
+      subtree: false,
+      characterData: false,
+      attributeOldValue: false,
+      characterDataOldValue: false,
+      disabled: false
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions(binding.value);
+      if (options.disabled || !isBrowser()) return;
+      if (!supportsMutationObserver()) {
+        console.warn("[Directix] v-mutation: MutationObserver not supported");
+        return;
+      }
+      const state = {
+        options,
+        observer: null
+      };
+      state.observer = new MutationObserver((mutations, observer) => {
+        options.handler(mutations, observer);
+      });
+      state.observer.observe(el, {
+        attributes: options.attributes,
+        attributeFilter: options.attributeFilter,
+        childList: options.childList,
+        subtree: options.subtree,
+        characterData: options.characterData,
+        attributeOldValue: options.attributeOldValue,
+        characterDataOldValue: options.characterDataOldValue
+      });
+      el.__mutation = state;
+    },
+    updated(el, binding) {
+      const state = el.__mutation;
+      if (!state) return;
+      const newOptions = normalizeOptions(binding.value);
+      if (newOptions.disabled && !state.options.disabled) {
+        if (state.observer) {
+          state.observer.disconnect();
+        }
+      } else if (!newOptions.disabled && state.options.disabled) {
+        if (state.observer) {
+          state.observer.observe(el, {
+            attributes: newOptions.attributes,
+            attributeFilter: newOptions.attributeFilter,
+            childList: newOptions.childList,
+            subtree: newOptions.subtree,
+            characterData: newOptions.characterData,
+            attributeOldValue: newOptions.attributeOldValue,
+            characterDataOldValue: newOptions.characterDataOldValue
+          });
+        }
+      } else if (!newOptions.disabled) {
+        if (newOptions.attributes !== state.options.attributes || newOptions.childList !== state.options.childList || newOptions.subtree !== state.options.subtree || newOptions.characterData !== state.options.characterData) {
+          if (state.observer) {
+            state.observer.disconnect();
+            state.observer.observe(el, {
+              attributes: newOptions.attributes,
+              attributeFilter: newOptions.attributeFilter,
+              childList: newOptions.childList,
+              subtree: newOptions.subtree,
+              characterData: newOptions.characterData,
+              attributeOldValue: newOptions.attributeOldValue,
+              characterDataOldValue: newOptions.characterDataOldValue
+            });
+          }
+        }
+      }
+      state.options = newOptions;
+    },
+    unmounted(el) {
+      const state = el.__mutation;
+      if (!state) return;
+      if (state.observer) {
+        state.observer.disconnect();
+      }
+      delete el.__mutation;
+    }
+  });
+  const allDirectives = {
+    "click-outside": vClickOutside,
+    copy: vCopy,
+    debounce: vDebounce,
+    throttle: vThrottle,
+    focus: vFocus,
+    lazy: vLazy,
+    intersect: vIntersect,
+    visible: vVisible,
+    loading: vLoading,
+    scroll: vScroll,
+    "infinite-scroll": vInfiniteScroll,
+    sticky: vSticky,
+    "long-press": vLongPress,
+    hover: vHover,
+    ripple: vRipple,
+    mask: vMask,
+    permission: vPermission,
+    sanitize: vSanitize,
+    resize: vResize,
+    mutation: vMutation
+  };
+  const install = (app, options = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let vueVersion = null;
+    if (typeof app === "function" && ((_a = app.version) == null ? void 0 : _a.startsWith("2"))) {
+      vueVersion = 2;
+    } else if ((app == null ? void 0 : app.config) && ((_b = app == null ? void 0 : app.version) == null ? void 0 : _b.startsWith("3"))) {
+      vueVersion = 3;
+    } else if (typeof (app == null ? void 0 : app.directive) === "function" && typeof (app == null ? void 0 : app.mixin) === "function" && ((_c = app.version) == null ? void 0 : _c.startsWith("2"))) {
+      vueVersion = 2;
+    } else if (typeof window !== "undefined") {
+      const win = window;
+      if ((_e = (_d = win.Vue) == null ? void 0 : _d.version) == null ? void 0 : _e.startsWith("2")) {
+        vueVersion = 2;
+      } else if ((_g = (_f = win.Vue) == null ? void 0 : _f.version) == null ? void 0 : _g.startsWith("3")) {
+        vueVersion = 3;
+      }
+    }
+    if (vueVersion) {
+      setVueVersion(vueVersion);
+    }
+    const { directives, all = false } = options;
+    if (all || !directives) {
+      Object.entries(allDirectives).forEach(([name, directive]) => {
+        app.directive(name, directive);
+      });
+    } else {
+      directives.forEach((name) => {
+        const directive = allDirectives[name];
+        if (directive) {
+          app.directive(name, directive);
+        } else {
+          console.warn(`[Directix] Unknown directive: ${name}`);
+        }
+      });
+    }
+  };
+  const Directix = {
+    install
+  };
+  exports.Directix = Directix;
+  exports.addCleanupVue2 = addCleanup$1;
+  exports.addCleanupVue3 = addCleanup;
+  exports.clickOutside = vClickOutside;
+  exports.configurePermission = configurePermission;
+  exports.copy = vCopy;
+  exports.createVue2Directive = createVue2Directive;
+  exports.createVue3Directive = createVue3Directive;
+  exports.debounce = vDebounce;
+  exports.debounceFn = debounce;
+  exports.deepClone = deepClone;
+  exports.deepMerge = deepMerge;
+  exports.defineDirective = defineDirective;
+  exports.defineDirectiveGroup = defineDirectiveGroup;
+  exports.focus = vFocus;
+  exports.generateId = generateId;
+  exports.get = get;
+  exports.getPermissionConfig = getPermissionConfig;
+  exports.getVueVersion = getVueVersion;
+  exports.hover = vHover;
+  exports.infiniteScroll = vInfiniteScroll;
+  exports.intersect = vIntersect;
+  exports.isArray = isArray;
+  exports.isBoolean = isBoolean;
+  exports.isBrowser = isBrowser;
+  exports.isEmpty = isEmpty;
+  exports.isFunction = isFunction;
+  exports.isNumber = isNumber;
+  exports.isObject = isObject;
+  exports.isPromise = isPromise;
+  exports.isSSR = isSSR;
+  exports.isString = isString;
+  exports.isVue2 = isVue2;
+  exports.isVue27 = isVue27;
+  exports.isVue3 = isVue3;
+  exports.lazy = vLazy;
+  exports.loading = vLoading;
+  exports.longPress = vLongPress;
+  exports.mask = vMask;
+  exports.mutation = vMutation;
+  exports.parseTime = parseTime;
+  exports.permission = vPermission;
+  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.throttle = vThrottle;
+  exports.throttleFn = throttle;
+  exports.vClickOutside = vClickOutside;
+  exports.vCopy = vCopy;
+  exports.vDebounce = vDebounce;
+  exports.vFocus = vFocus;
+  exports.vHover = vHover;
+  exports.vInfiniteScroll = vInfiniteScroll;
+  exports.vIntersect = vIntersect;
+  exports.vLazy = vLazy;
+  exports.vLoading = vLoading;
+  exports.vLongPress = vLongPress;
+  exports.vMask = vMask;
+  exports.vMutation = vMutation;
+  exports.vPermission = vPermission;
+  exports.vResize = vResize;
+  exports.vRipple = vRipple;
+  exports.vSanitize = vSanitize;
+  exports.vScroll = vScroll;
+  exports.vSticky = vSticky;
+  exports.vThrottle = vThrottle;
+  exports.vVisible = vVisible;
+  exports.visible = vVisible;
+  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+})(this.Directix = this.Directix || {});
+//# sourceMappingURL=index.iife.js.map