directix 1.0.0-beta.1 → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1095 @@
+/*!
+ * 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.
+ */
+"use strict";
+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.
+ */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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;
+//# sourceMappingURL=index.cjs.map