directix 1.0.0-beta.2 → 1.0.0

package/dist/index.iife.js

@@ -0,0 +1,1224 @@
+/*!
+ * directix v1.0.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 _VueDemiGlobal = typeof globalThis !== 'undefined' 
+  ? globalThis
+  : typeof global !== 'undefined'
+    ? global
+    : typeof self !== 'undefined'
+      ? self
+      : this
+var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
+  if (VueDemi.install) {
+    return VueDemi
+  }
+  if (!Vue) {
+    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
+    return VueDemi
+  }
+
+  // Vue 2.7
+  if (Vue.version.slice(0, 4) === '2.7.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = true
+    VueDemi.isVue3 = false
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = Vue
+    VueDemi.version = Vue.version
+    VueDemi.warn = Vue.util.warn
+    VueDemi.hasInjectionContext = function() {
+      return !!VueDemi.getCurrentInstance()
+    }
+    function createApp(rootComponent, rootProps) {
+      var vm
+      var provide = {}
+      var app = {
+        config: Vue.config,
+        use: Vue.use.bind(Vue),
+        mixin: Vue.mixin.bind(Vue),
+        component: Vue.component.bind(Vue),
+        provide: function (key, value) {
+          provide[key] = value
+          return this
+        },
+        directive: function (name, dir) {
+          if (dir) {
+            Vue.directive(name, dir)
+            return app
+          } else {
+            return Vue.directive(name)
+          }
+        },
+        mount: function (el, hydrating) {
+          if (!vm) {
+            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+            vm.$mount(el, hydrating)
+            return vm
+          } else {
+            return vm
+          }
+        },
+        unmount: function () {
+          if (vm) {
+            vm.$destroy()
+            vm = undefined
+          }
+        },
+      }
+      return app
+    }
+    VueDemi.createApp = createApp
+  }
+  // Vue 2.6.x
+  else if (Vue.version.slice(0, 2) === '2.') {
+    if (VueCompositionAPI) {
+      for (var key in VueCompositionAPI) {
+        VueDemi[key] = VueCompositionAPI[key]
+      }
+      VueDemi.isVue2 = true
+      VueDemi.isVue3 = false
+      VueDemi.install = function () {}
+      VueDemi.Vue = Vue
+      VueDemi.Vue2 = Vue
+      VueDemi.version = Vue.version
+      VueDemi.hasInjectionContext = function() {
+        return !!VueDemi.getCurrentInstance()
+      }
+    } else {
+      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
+    }
+  }
+  // Vue 3
+  else if (Vue.version.slice(0, 2) === '3.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = false
+    VueDemi.isVue3 = true
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = undefined
+    VueDemi.version = Vue.version
+    VueDemi.set = function (target, key, val) {
+      if (Array.isArray(target)) {
+        target.length = Math.max(target.length, key)
+        target.splice(key, 1, val)
+        return val
+      }
+      target[key] = val
+      return val
+    }
+    VueDemi.del = function (target, key) {
+      if (Array.isArray(target)) {
+        target.splice(key, 1)
+        return
+      }
+      delete target[key]
+    }
+  } else {
+    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
+  }
+  return VueDemi
+})(
+  (_VueDemiGlobal.VueDemi = _VueDemiGlobal.VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
+  _VueDemiGlobal.Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
+  _VueDemiGlobal.VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
+);
+
+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 __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.0.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;
+  function getVueVersion() {
+    var _a, _b;
+    if (_vueVersion !== null) return _vueVersion;
+    try {
+      const vue = require("vue");
+      if ((_a = vue == null ? void 0 : vue.version) == null ? void 0 : _a.startsWith("2")) {
+        _vueVersion = 2;
+      } else if ((_b = vue == null ? void 0 : vue.version) == null ? void 0 : _b.startsWith("3")) {
+        _vueVersion = 3;
+      }
+    } catch (e) {
+    }
+    if (_vueVersion === null) {
+      if (typeof window !== "undefined") {
+        console.warn(
+          "[Directix] Unable to detect Vue version, defaulting to Vue 3. Please ensure Vue is installed correctly."
+        );
+      }
+      _vueVersion = 3;
+    }
+    return _vueVersion;
+  }
+  const isVue2 = () => getVueVersion() === 2;
+  const isVue3 = () => getVueVersion() === 3;
+  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) => {
+        const mergedBinding = applyDefaults(binding, defaults);
+        hooks.mounted(el, mergedBinding, vnode);
+      } : void 0,
+      updated: hooks.updated ? (el, binding, vnode, prevBinding, prevVnode) => {
+        const mergedBinding = applyDefaults(binding, defaults);
+        hooks.updated(el, mergedBinding, vnode, prevBinding, prevVnode);
+      } : void 0,
+      unmounted: hooks.unmounted
+    };
+    if (isVue2()) {
+      return createVue2Directive(wrappedHooks);
+    }
+    return createVue3Directive(wrappedHooks);
+  }
+  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 on(target, event, handler, options = false) {
+    if (!isBrowser()) return;
+    const opts = normalizeOptions$5(options);
+    target.addEventListener(event, handler, opts);
+  }
+  function off(target, event, handler, options = false) {
+    if (!isBrowser()) return;
+    const opts = normalizeOptions$5(options);
+    target.removeEventListener(event, handler, opts);
+  }
+  function normalizeOptions$5(options) {
+    if (typeof options === "boolean") {
+      return options;
+    }
+    const { capture = false, passive = false, once = false } = options;
+    if (supportsPassive()) {
+      return { capture, passive, once };
+    }
+    return capture;
+  }
+  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$4(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$4(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$4(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$3(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$3(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$3(binding) {
+    if (typeof binding === "string") {
+      return { value: binding };
+    }
+    return binding;
+  }
+  const vDebounce = defineDirective({
+    name: "debounce",
+    ssr: false,
+    defaults: {
+      wait: 300,
+      leading: false,
+      trailing: true
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$2(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$2(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$2(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: false,
+    defaults: {
+      wait: 300,
+      leading: true,
+      trailing: true
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions$1(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$1(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$1(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: false,
+    defaults: {
+      focus: true,
+      refocus: false
+    },
+    mounted(el, binding) {
+      const options = normalizeOptions(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(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(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;
+  }
+  const allDirectives = {
+    "click-outside": vClickOutside,
+    copy: vCopy,
+    debounce: vDebounce,
+    throttle: vThrottle,
+    focus: vFocus
+  };
+  const install = (app, options = {}) => {
+    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.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.getVueVersion = getVueVersion;
+  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.isVue3 = isVue3;
+  exports.parseTime = parseTime;
+  exports.set = set;
+  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.vThrottle = vThrottle;
+  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+})(this.Directix = this.Directix || {});
+//# sourceMappingURL=index.iife.js.map