directix 1.9.0 → 1.10.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * directix v1.9.0
+ * directix v1.10.0
  * A comprehensive, easy-to-use, and high-performance Vue custom directives library supporting both Vue 2 and Vue 3
  * (c) 2021-present saqqdy <https://github.com/saqqdy>
  * Released under the MIT License.
@@ -58,13 +58,13 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 /*!
- * directix v1.9.0
+ * directix v1.10.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 _a;
-import { ref, unref, onUnmounted, watch, readonly, shallowRef, computed, onMounted } from "vue";
+import { ref, unref, onUnmounted, watch, readonly, shallowRef, computed, onMounted, reactive, watchEffect, isRef, toRaw, markRaw } from "vue";
 function createVue2Directive(hooks) {
   const directive = {
     bind(el, binding, vnode) {
@@ -7171,23 +7171,23 @@ function handleEnd(e, state2, el) {
   state2.initialAngle = 0;
   state2.currentAngle = 0;
 }
-const DEFAULT_ALLOWED_TAGS$1 = ["b", "i", "u", "strong", "em", "br", "p", "span", "div"];
-const DEFAULT_ALLOWED_ATTRIBUTES$1 = ["title", "alt", "href", "src"];
-const DANGEROUS_TAGS$1 = ["script", "iframe", "object", "embed", "form", "input", "style", "link", "meta", "base"];
-const DANGEROUS_ATTRIBUTES$1 = ["onclick", "onerror", "onload", "onmouseover", "onfocus", "onblur", "onchange", "onsubmit"];
+const DEFAULT_ALLOWED_TAGS$2 = ["b", "i", "u", "strong", "em", "br", "p", "span", "div"];
+const DEFAULT_ALLOWED_ATTRIBUTES$2 = ["title", "alt", "href", "src"];
+const DANGEROUS_TAGS$2 = ["script", "iframe", "object", "embed", "form", "input", "style", "link", "meta", "base"];
+const DANGEROUS_ATTRIBUTES$2 = ["onclick", "onerror", "onload", "onmouseover", "onfocus", "onblur", "onchange", "onsubmit"];
 function normalizeOptions$e(binding) {
   if (binding === false) {
     return { disabled: true };
   }
   if (binding === true) {
     return {
-      allowedTags: DEFAULT_ALLOWED_TAGS$1,
-      allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$1
+      allowedTags: DEFAULT_ALLOWED_TAGS$2,
+      allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$2
     };
   }
   return __spreadValues({
-    allowedTags: DEFAULT_ALLOWED_TAGS$1,
-    allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$1,
+    allowedTags: DEFAULT_ALLOWED_TAGS$2,
+    allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$2,
     allowDataUrls: false,
     allowStyles: false,
     allowClass: false,
@@ -7196,14 +7196,14 @@ function normalizeOptions$e(binding) {
     sanitizeOnUpdate: true
   }, binding);
 }
-function sanitizeHtml(html, options) {
+function sanitizeHtml$1(html, options) {
   var _a2;
   if (options.handler) {
     return options.handler(html);
   }
   const temp = document.createElement("div");
   temp.innerHTML = html;
-  for (const tag of DANGEROUS_TAGS$1) {
+  for (const tag of DANGEROUS_TAGS$2) {
     const elements = temp.getElementsByTagName(tag);
     while (elements.length > 0) {
       (_a2 = elements[0].parentNode) == null ? void 0 : _a2.removeChild(elements[0]);
@@ -7217,7 +7217,7 @@ function sanitizeHtml(html, options) {
       (_a3 = el.parentNode) == null ? void 0 : _a3.replaceChild(text, el);
       return;
     }
-    for (const attr of DANGEROUS_ATTRIBUTES$1) {
+    for (const attr of DANGEROUS_ATTRIBUTES$2) {
       el.removeAttribute(attr);
     }
     const href = el.getAttribute("href");
@@ -7255,8 +7255,8 @@ const vSanitize = defineDirective({
   name: "sanitize",
   ssr: true,
   defaults: {
-    allowedTags: DEFAULT_ALLOWED_TAGS$1,
-    allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$1,
+    allowedTags: DEFAULT_ALLOWED_TAGS$2,
+    allowedAttributes: DEFAULT_ALLOWED_ATTRIBUTES$2,
     allowDataUrls: false,
     allowStyles: false,
     allowClass: false,
@@ -7271,7 +7271,7 @@ const vSanitize = defineDirective({
     if (options.disabled) return;
     const content = el.innerHTML;
     if (content) {
-      el.innerHTML = sanitizeHtml(content, options);
+      el.innerHTML = sanitizeHtml$1(content, options);
     }
   },
   updated(el, binding) {
@@ -7283,14 +7283,14 @@ const vSanitize = defineDirective({
       if (prevDisabled && !state2.options.disabled) {
         const content2 = el.innerHTML;
         if (content2) {
-          el.innerHTML = sanitizeHtml(content2, state2.options);
+          el.innerHTML = sanitizeHtml$1(content2, state2.options);
         }
       }
       return;
     }
     const content = el.innerHTML;
     if (content) {
-      el.innerHTML = sanitizeHtml(content, state2.options);
+      el.innerHTML = sanitizeHtml$1(content, state2.options);
     }
   },
   unmounted(el) {
@@ -13698,14 +13698,14 @@ function useRotateGesture(options = {}) {
     bind
   };
 }
-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"];
+const DEFAULT_ALLOWED_TAGS$1 = ["b", "i", "u", "strong", "em", "br", "p", "span", "div"];
+const DEFAULT_ALLOWED_ATTRIBUTES$1 = ["title", "alt", "href", "src"];
+const DANGEROUS_TAGS$1 = ["script", "iframe", "object", "embed", "form", "input", "style", "link", "meta", "base"];
+const DANGEROUS_ATTRIBUTES$1 = ["onclick", "onerror", "onload", "onmouseover", "onfocus", "onblur", "onchange", "onsubmit"];
 function useSanitize(options = {}) {
   const {
-    allowedTags = DEFAULT_ALLOWED_TAGS,
-    allowedAttributes = DEFAULT_ALLOWED_ATTRIBUTES,
+    allowedTags = DEFAULT_ALLOWED_TAGS$1,
+    allowedAttributes = DEFAULT_ALLOWED_ATTRIBUTES$1,
     allowDataUrls = false,
     allowStyles = false,
     allowClass = false,
@@ -13720,7 +13720,7 @@ function useSanitize(options = {}) {
     if (!isBrowser()) return html;
     const temp = document.createElement("div");
     temp.innerHTML = html;
-    for (const tag of DANGEROUS_TAGS) {
+    for (const tag of DANGEROUS_TAGS$1) {
       const elements = temp.getElementsByTagName(tag);
       while (elements.length > 0) {
         (_a2 = elements[0].parentNode) == null ? void 0 : _a2.removeChild(elements[0]);
@@ -13734,7 +13734,7 @@ function useSanitize(options = {}) {
         (_a3 = el.parentNode) == null ? void 0 : _a3.replaceChild(text, el);
         return;
       }
-      for (const attr of DANGEROUS_ATTRIBUTES) {
+      for (const attr of DANGEROUS_ATTRIBUTES$1) {
         el.removeAttribute(attr);
       }
       const href = el.getAttribute("href");
@@ -15770,6 +15770,1734 @@ function createStyleDirective(options) {
     }
   });
 }
+function applyAriaAttributes(el, config) {
+  clearAriaAttributes(el);
+  if (config.role) {
+    el.setAttribute("role", config.role);
+  }
+  if (config.ariaExpanded !== void 0) {
+    el.setAttribute("aria-expanded", String(config.ariaExpanded));
+  }
+  if (config.ariaSelected !== void 0) {
+    el.setAttribute("aria-selected", String(config.ariaSelected));
+  }
+  if (config.ariaChecked !== void 0) {
+    el.setAttribute("aria-checked", String(config.ariaChecked));
+  }
+  if (config.ariaDisabled !== void 0) {
+    el.setAttribute("aria-disabled", String(config.ariaDisabled));
+    if (config.ariaDisabled) {
+      el.setAttribute("tabindex", "-1");
+    }
+  }
+  if (config.ariaHidden !== void 0) {
+    el.setAttribute("aria-hidden", String(config.ariaHidden));
+  }
+  if (config.ariaBusy !== void 0) {
+    el.setAttribute("aria-busy", String(config.ariaBusy));
+  }
+  if (config.ariaPressed !== void 0) {
+    el.setAttribute("aria-pressed", String(config.ariaPressed));
+  }
+  if (config.ariaCurrent !== void 0) {
+    el.setAttribute("aria-current", typeof config.ariaCurrent === "boolean" ? String(config.ariaCurrent) : config.ariaCurrent);
+  }
+  if (config.ariaLabel) {
+    el.setAttribute("aria-label", config.ariaLabel);
+  }
+  if (config.ariaLabelledBy) {
+    el.setAttribute("aria-labelledby", config.ariaLabelledBy);
+  }
+  if (config.ariaDescribedBy) {
+    el.setAttribute("aria-describedby", config.ariaDescribedBy);
+  }
+  if (config.ariaControls) {
+    el.setAttribute("aria-controls", config.ariaControls);
+  }
+  if (config.ariaOwns) {
+    el.setAttribute("aria-owns", config.ariaOwns);
+  }
+  if (config.ariaHasPopup !== void 0) {
+    const value = typeof config.ariaHasPopup === "boolean" ? "true" : config.ariaHasPopup;
+    el.setAttribute("aria-haspopup", value);
+  }
+  if (config.ariaAutoComplete) {
+    el.setAttribute("aria-autocomplete", config.ariaAutoComplete);
+  }
+  if (config.ariaLive) {
+    el.setAttribute("aria-live", config.ariaLive);
+  }
+  if (config.ariaAtomic !== void 0) {
+    el.setAttribute("aria-atomic", String(config.ariaAtomic));
+  }
+  if (config.ariaRelevant) {
+    el.setAttribute("aria-relevant", config.ariaRelevant);
+  }
+  if (config.ariaValueNow !== void 0) {
+    el.setAttribute("aria-valuenow", String(config.ariaValueNow));
+  }
+  if (config.ariaValueMin !== void 0) {
+    el.setAttribute("aria-valuemin", String(config.ariaValueMin));
+  }
+  if (config.ariaValueMax !== void 0) {
+    el.setAttribute("aria-valuemax", String(config.ariaValueMax));
+  }
+  if (config.ariaValueText) {
+    el.setAttribute("aria-valuetext", config.ariaValueText);
+  }
+  if (config.ariaPlaceholder) {
+    el.setAttribute("aria-placeholder", config.ariaPlaceholder);
+  }
+  if (config.ariaRequired !== void 0) {
+    el.setAttribute("aria-required", String(config.ariaRequired));
+  }
+  if (config.ariaReadonly !== void 0) {
+    el.setAttribute("aria-readonly", String(config.ariaReadonly));
+  }
+  if (config.ariaModal !== void 0) {
+    el.setAttribute("aria-modal", String(config.ariaModal));
+  }
+  if (config.tabIndex !== void 0) {
+    el.setAttribute("tabindex", String(config.tabIndex));
+  }
+}
+function clearAriaAttributes(el) {
+  const ariaAttrs = Array.from(el.attributes).filter((attr) => attr.name.startsWith("aria-") || attr.name === "role");
+  ariaAttrs.forEach((attr) => el.removeAttribute(attr.name));
+}
+function generateAriaId(prefix = "directix-aria") {
+  return `${prefix}-${Math.random().toString(36).substring(2, 10)}`;
+}
+let announcerElement = null, announcerId = null;
+function ensureAnnouncer() {
+  if (announcerElement && document.getElementById(announcerId || "")) {
+    return announcerElement;
+  }
+  announcerId = "directix-sr-announcer";
+  announcerElement = document.createElement("div");
+  announcerElement.id = announcerId;
+  announcerElement.setAttribute("aria-live", "polite");
+  announcerElement.setAttribute("aria-atomic", "true");
+  announcerElement.setAttribute(
+    "style",
+    "position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0;"
+  );
+  document.body.appendChild(announcerElement);
+  return announcerElement;
+}
+function announce(message, options = {}) {
+  if (!isBrowser()) return;
+  const { priority = "polite", timeout = 1e3, clear = true } = options;
+  const announcer = ensureAnnouncer();
+  announcer.setAttribute("aria-live", priority);
+  announcer.textContent = "";
+  requestAnimationFrame(() => {
+    announcer.textContent = message;
+    if (clear) {
+      setTimeout(() => {
+        if (announcer.textContent === message) {
+          announcer.textContent = "";
+        }
+      }, timeout);
+    }
+  });
+}
+function clearAnnouncer() {
+  if (announcerElement) {
+    announcerElement.textContent = "";
+  }
+}
+const DEFAULT_NEXT_KEYS = ["ArrowDown", "ArrowRight"];
+const DEFAULT_PREV_KEYS = ["ArrowUp", "ArrowLeft"];
+const DEFAULT_SELECT_KEYS = ["Enter", " "];
+const DEFAULT_CLOSE_KEYS = ["Escape"];
+const DEFAULT_HOME_KEYS = ["Home"];
+const DEFAULT_END_KEYS = ["End"];
+function useKeyboardNavigation(options = {}) {
+  const {
+    nextKeys = DEFAULT_NEXT_KEYS,
+    prevKeys = DEFAULT_PREV_KEYS,
+    selectKeys = DEFAULT_SELECT_KEYS,
+    closeKeys = DEFAULT_CLOSE_KEYS,
+    homeKeys = DEFAULT_HOME_KEYS,
+    endKeys = DEFAULT_END_KEYS,
+    focusTrap = false,
+    returnFocus = true,
+    mode: _mode = "linear",
+    loop = true,
+    rovingTabindex = false
+  } = options;
+  const focusedIndex = ref(0);
+  let items = [], triggerElement = null, cleanup2 = null;
+  function getFocusables() {
+    return items.filter((item) => !item.hasAttribute("disabled") && item.getAttribute("aria-disabled") !== "true");
+  }
+  function focusIndex(index) {
+    const focusables = getFocusables();
+    if (focusables.length === 0) return;
+    let newIndex = index;
+    if (newIndex < 0) {
+      newIndex = loop ? focusables.length - 1 : 0;
+    } else if (newIndex >= focusables.length) {
+      newIndex = loop ? 0 : focusables.length - 1;
+    }
+    const target = focusables[newIndex];
+    if (target) {
+      target.focus();
+      if (rovingTabindex) {
+        focusables.forEach((item, i) => {
+          item.setAttribute("tabindex", i === newIndex ? "0" : "-1");
+        });
+      }
+      focusedIndex.value = newIndex;
+    }
+  }
+  function focusNext() {
+    focusIndex(focusedIndex.value + 1);
+  }
+  function focusPrev() {
+    focusIndex(focusedIndex.value - 1);
+  }
+  function focusFirst() {
+    focusIndex(0);
+  }
+  function focusLast() {
+    focusIndex(getFocusables().length - 1);
+  }
+  function handleKeyDown(e) {
+    var _a2;
+    const isModified = e.altKey || e.ctrlKey || e.metaKey;
+    if (isModified) return;
+    if (focusTrap && e.key === "Tab") {
+      const focusables = getFocusables();
+      if (focusables.length === 0) return;
+      e.preventDefault();
+      if (e.shiftKey) {
+        focusPrev();
+      } else {
+        focusNext();
+      }
+      return;
+    }
+    if (nextKeys.includes(e.key)) {
+      e.preventDefault();
+      focusNext();
+    } else if (prevKeys.includes(e.key)) {
+      e.preventDefault();
+      focusPrev();
+    } else if (homeKeys.includes(e.key)) {
+      e.preventDefault();
+      focusFirst();
+    } else if (endKeys.includes(e.key)) {
+      e.preventDefault();
+      focusLast();
+    } else if (selectKeys.includes(e.key)) {
+      e.preventDefault();
+      (_a2 = items[focusedIndex.value]) == null ? void 0 : _a2.click();
+    } else if (closeKeys.includes(e.key)) {
+      e.preventDefault();
+      if (returnFocus && triggerElement) {
+        triggerElement.focus();
+      }
+    }
+  }
+  function bind(el, itemElements) {
+    cleanup2 == null ? void 0 : cleanup2();
+    items = itemElements;
+    triggerElement = document.activeElement;
+    el.addEventListener("keydown", handleKeyDown);
+    if (rovingTabindex && items.length > 0) {
+      items.forEach((item, i) => {
+        item.setAttribute("tabindex", i === 0 ? "0" : "-1");
+      });
+    }
+    if (items.length > 0) {
+      focusIndex(0);
+    }
+    cleanup2 = () => {
+      el.removeEventListener("keydown", handleKeyDown);
+      items = [];
+    };
+    return cleanup2;
+  }
+  onUnmounted(() => {
+    cleanup2 == null ? void 0 : cleanup2();
+  });
+  return {
+    focusedIndex: readonly(focusedIndex),
+    bind,
+    focusIndex,
+    focusNext,
+    focusPrev,
+    focusFirst,
+    focusLast
+  };
+}
+function useFocusTrap(container, options = {}) {
+  const {
+    initialFocus,
+    allowOutsideClick = false,
+    escapeDeactivates = true,
+    onActivate,
+    onDeactivate
+  } = options;
+  const isActive = ref(false);
+  let lastFocusedElement = null;
+  function getFocusableElements() {
+    const el = container.value;
+    if (!el) return [];
+    const selector = [
+      "a[href]",
+      "button:not([disabled])",
+      "textarea:not([disabled])",
+      "input:not([disabled])",
+      "select:not([disabled])",
+      '[tabindex]:not([tabindex="-1"])'
+    ].join(", ");
+    return Array.from(el.querySelectorAll(selector)).filter((item) => !item.hasAttribute("aria-hidden"));
+  }
+  function handleKeyDown(e) {
+    if (!isActive.value) return;
+    if (escapeDeactivates && e.key === "Escape") {
+      e.preventDefault();
+      deactivate();
+      return;
+    }
+    if (e.key !== "Tab") return;
+    const el = container.value;
+    if (!el) return;
+    const focusables = getFocusableElements();
+    if (focusables.length === 0) return;
+    const firstFocusable = focusables[0];
+    const lastFocusable = focusables[focusables.length - 1];
+    const currentElement = document.activeElement;
+    if (e.shiftKey) {
+      if (currentElement === firstFocusable || !el.contains(currentElement)) {
+        e.preventDefault();
+        lastFocusable.focus();
+      }
+    } else {
+      if (currentElement === lastFocusable || !el.contains(currentElement)) {
+        e.preventDefault();
+        firstFocusable.focus();
+      }
+    }
+  }
+  function handleOutsideClick(event) {
+    if (!isActive.value) return;
+    if (!container.value) return;
+    if (typeof allowOutsideClick === "boolean" && !allowOutsideClick) {
+      event.preventDefault();
+      return;
+    }
+    if (typeof allowOutsideClick === "function" && !allowOutsideClick(event)) {
+      event.preventDefault();
+    }
+  }
+  function activate() {
+    var _a2;
+    if (isActive.value) return;
+    lastFocusedElement = document.activeElement;
+    if (initialFocus) {
+      let initialEl = null;
+      if (typeof initialFocus === "function") {
+        initialEl = initialFocus();
+      } else if (typeof initialFocus === "string") {
+        initialEl = ((_a2 = container.value) == null ? void 0 : _a2.querySelector(initialFocus)) || null;
+      } else {
+        initialEl = initialFocus;
+      }
+      initialEl == null ? void 0 : initialEl.focus();
+    } else {
+      const focusables = getFocusableElements();
+      if (focusables.length > 0) {
+        focusables[0].focus();
+      }
+    }
+    document.addEventListener("keydown", handleKeyDown);
+    document.addEventListener("mousedown", handleOutsideClick);
+    document.addEventListener("touchstart", handleOutsideClick);
+    isActive.value = true;
+    onActivate == null ? void 0 : onActivate();
+  }
+  function deactivate() {
+    if (!isActive.value) return;
+    document.removeEventListener("keydown", handleKeyDown);
+    document.removeEventListener("mousedown", handleOutsideClick);
+    document.removeEventListener("touchstart", handleOutsideClick);
+    if (lastFocusedElement && lastFocusedElement.focus) {
+      lastFocusedElement.focus();
+    }
+    isActive.value = false;
+    onDeactivate == null ? void 0 : onDeactivate();
+  }
+  onUnmounted(() => {
+    deactivate();
+  });
+  return {
+    activate,
+    deactivate,
+    isActive: readonly(isActive)
+  };
+}
+function getAutoAriaConfig(options) {
+  const { type, label, expanded, disabled, relatedId } = options;
+  const configs = {
+    tooltip: {
+      role: "tooltip",
+      ariaHidden: expanded === void 0 ? true : !expanded
+    },
+    menu: {
+      role: "menu",
+      ariaLabel: label,
+      ariaExpanded: expanded,
+      ariaDisabled: disabled
+    },
+    dialog: {
+      role: "dialog",
+      ariaLabel: label,
+      ariaModal: true
+    },
+    popover: {
+      role: "region",
+      ariaLabel: label,
+      ariaExpanded: expanded
+    },
+    dropdown: {
+      role: "listbox",
+      ariaLabel: label,
+      ariaExpanded: expanded
+    },
+    modal: {
+      role: "dialog",
+      ariaModal: true,
+      ariaLabel: label
+    },
+    alert: {
+      role: "alert",
+      ariaLive: "assertive",
+      ariaAtomic: true
+    },
+    region: {
+      role: "region",
+      ariaLabel: label
+    }
+  };
+  const config = __spreadValues({}, configs[type] || {});
+  if (relatedId) {
+    if (type === "tooltip") {
+      config.ariaDescribedBy = relatedId;
+    } else {
+      config.ariaControls = relatedId;
+    }
+  }
+  return config;
+}
+const DEFAULT_THRESHOLDS = {
+  tap: 10,
+  longPress: 500,
+  swipe: 30,
+  pinch: 0.1,
+  rotate: 5,
+  doubleTap: 300,
+  swipeVelocity: 0.3
+};
+function triggerHaptic(type = "light") {
+  if (!isBrowser()) return;
+  const nav = navigator;
+  if (nav.vibrate) {
+    const patterns = {
+      light: 10,
+      medium: 20,
+      heavy: 30,
+      selection: [10, 50, 10]
+    };
+    nav.vibrate(patterns[type]);
+  }
+}
+function applyVisualFeedback(element, options = {}) {
+  const {
+    visualClass = "directix-touch-active",
+    visualDuration = 150
+  } = options;
+  element.classList.add(visualClass);
+  const timer = setTimeout(() => {
+    element.classList.remove(visualClass);
+  }, visualDuration);
+  return () => {
+    clearTimeout(timer);
+    element.classList.remove(visualClass);
+  };
+}
+function calculateVelocity(startX, startY, endX, endY, duration) {
+  if (duration === 0) return 0;
+  const distance = Math.sqrt(__pow(endX - startX, 2) + __pow(endY - startY, 2));
+  return distance / duration;
+}
+function isEdgePoint(x, y, edgeSize = 20) {
+  if (!isBrowser()) return { isEdge: false };
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  if (x <= edgeSize) return { isEdge: true, edge: "left" };
+  if (x >= width - edgeSize) return { isEdge: true, edge: "right" };
+  if (y <= edgeSize) return { isEdge: true, edge: "top" };
+  if (y >= height - edgeSize) return { isEdge: true, edge: "bottom" };
+  return { isEdge: false };
+}
+function useEnhancedTouch(options = {}) {
+  const {
+    thresholds: userThresholds = {},
+    feedback = {},
+    debounce: debounce2 = 0,
+    throttle: throttle2 = 16,
+    passive = true,
+    disabled = false,
+    onTap,
+    onDoubleTap,
+    onLongPress,
+    onSwipe,
+    onSwipeLeft,
+    onSwipeRight,
+    onSwipeUp,
+    onSwipeDown,
+    onPan,
+    onPinch,
+    onPinchIn,
+    onPinchOut,
+    onRotate,
+    onTwoFingerTap,
+    onEdgeSwipe
+  } = options;
+  const thresholds = __spreadValues(__spreadValues({}, DEFAULT_THRESHOLDS), userThresholds);
+  const activeGesture = ref(null);
+  const isTouching = ref(false);
+  let currentElement = null, startX = 0, startY = 0, startTime = 0, lastTapTime = 0, lastPanTime = 0, longPressTimer = null, initialPinchDistance = 0, initialAngle = 0, removeVisualFeedback = null, lastGestureTime = 0;
+  function getTouchCenter(touches) {
+    let x = 0, y = 0;
+    for (let i = 0; i < touches.length; i++) {
+      x += touches[i].clientX;
+      y += touches[i].clientY;
+    }
+    return { x: x / touches.length, y: y / touches.length };
+  }
+  function getDistance2(t1, t2) {
+    return Math.sqrt(__pow(t1.clientX - t2.clientX, 2) + __pow(t1.clientY - t2.clientY, 2));
+  }
+  function getAngle2(t1, t2) {
+    return Math.atan2(t2.clientY - t1.clientY, t2.clientX - t1.clientX) * (180 / Math.PI);
+  }
+  function shouldProcessGesture() {
+    if (typeof disabled === "boolean" ? disabled : disabled.value) return false;
+    if (debounce2 > 0 && Date.now() - lastGestureTime < debounce2) return false;
+    return true;
+  }
+  function handleTouchStart(e) {
+    if (!shouldProcessGesture()) return;
+    isTouching.value = true;
+    startTime = Date.now();
+    activeGesture.value = null;
+    if (feedback.haptic) {
+      triggerHaptic("light");
+    }
+    if (e.touches.length === 1) {
+      startX = e.touches[0].clientX;
+      startY = e.touches[0].clientY;
+      if (onLongPress) {
+        longPressTimer = setTimeout(() => {
+          if (!activeGesture.value) {
+            activeGesture.value = "longPress";
+            lastGestureTime = Date.now();
+            onLongPress({
+              type: "longPress",
+              center: { x: startX, y: startY },
+              event: e,
+              duration: Date.now() - startTime
+            });
+            if (feedback.haptic) triggerHaptic("medium");
+          }
+        }, thresholds.longPress);
+      }
+    } else if (e.touches.length === 2) {
+      if (longPressTimer) {
+        clearTimeout(longPressTimer);
+        longPressTimer = null;
+      }
+      initialPinchDistance = getDistance2(e.touches[0], e.touches[1]);
+      initialAngle = getAngle2(e.touches[0], e.touches[1]);
+    }
+  }
+  function handleTouchMove(e) {
+    if (!shouldProcessGesture()) return;
+    if (longPressTimer) {
+      clearTimeout(longPressTimer);
+      longPressTimer = null;
+    }
+    if (e.touches.length === 1) {
+      const currentX = e.touches[0].clientX;
+      const currentY = e.touches[0].clientY;
+      if (onPan) {
+        const now = Date.now();
+        if (now - lastPanTime >= throttle2) {
+          lastPanTime = now;
+          const deltaX = currentX - startX;
+          const deltaY = currentY - startY;
+          const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+          if (distance > thresholds.tap) {
+            activeGesture.value = "pan";
+            onPan({
+              type: "pan",
+              distance,
+              angle: Math.atan2(deltaY, deltaX) * (180 / Math.PI),
+              center: { x: currentX, y: currentY },
+              event: e
+            });
+          }
+        }
+      }
+    } else if (e.touches.length === 2) {
+      const currentDistance = getDistance2(e.touches[0], e.touches[1]);
+      const currentAngle = getAngle2(e.touches[0], e.touches[1]);
+      if (onPinch && initialPinchDistance > 0) {
+        const scale = currentDistance / initialPinchDistance;
+        const deltaScale = Math.abs(scale - 1);
+        if (deltaScale > thresholds.pinch) {
+          activeGesture.value = "pinch";
+          onPinch({
+            type: "pinch",
+            scale,
+            center: getTouchCenter(e.touches),
+            event: e
+          });
+          if (scale < 1 && onPinchIn) {
+            onPinchIn({
+              type: "pinchIn",
+              scale,
+              center: getTouchCenter(e.touches),
+              event: e
+            });
+          } else if (scale > 1 && onPinchOut) {
+            onPinchOut({
+              type: "pinchOut",
+              scale,
+              center: getTouchCenter(e.touches),
+              event: e
+            });
+          }
+        }
+      }
+      if (onRotate) {
+        const rotation = currentAngle - initialAngle;
+        if (Math.abs(rotation) > thresholds.rotate) {
+          activeGesture.value = "rotate";
+          onRotate({
+            type: "rotate",
+            rotation,
+            center: getTouchCenter(e.touches),
+            event: e
+          });
+        }
+      }
+    }
+  }
+  function handleTouchEnd(e) {
+    var _a2, _b, _c, _d;
+    if (!shouldProcessGesture()) return;
+    isTouching.value = false;
+    if (longPressTimer) {
+      clearTimeout(longPressTimer);
+      longPressTimer = null;
+    }
+    const duration = Date.now() - startTime;
+    const endX = (_b = (_a2 = e.changedTouches[0]) == null ? void 0 : _a2.clientX) != null ? _b : startX;
+    const endY = (_d = (_c = e.changedTouches[0]) == null ? void 0 : _c.clientY) != null ? _d : startY;
+    const deltaX = endX - startX;
+    const deltaY = endY - startY;
+    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    const velocity = calculateVelocity(startX, startY, endX, endY, duration);
+    if (e.touches.length === 0 && e.changedTouches.length === 2 && onTwoFingerTap) {
+      const twoFingerDistance = getDistance2(e.changedTouches[0], e.changedTouches[1]);
+      if (twoFingerDistance < 50) {
+        activeGesture.value = "twoFingerTap";
+        onTwoFingerTap({
+          type: "twoFingerTap",
+          center: getTouchCenter(e.changedTouches),
+          event: e
+        });
+      }
+    }
+    if (e.changedTouches.length === 1) {
+      if (distance >= thresholds.swipe) {
+        let direction;
+        if (Math.abs(deltaX) > Math.abs(deltaY)) {
+          direction = deltaX > 0 ? "right" : "left";
+        } else {
+          direction = deltaY > 0 ? "down" : "up";
+        }
+        const edge = isEdgePoint(startX, startY);
+        if (edge.isEdge && onEdgeSwipe) {
+          activeGesture.value = "edgeSwipe";
+          onEdgeSwipe({
+            type: "edgeSwipe",
+            direction,
+            distance,
+            velocity,
+            center: { x: endX, y: endY },
+            event: e
+          });
+        }
+        if (!activeGesture.value) {
+          activeGesture.value = "swipe";
+          const swipeEvent = {
+            type: "swipe",
+            direction,
+            distance,
+            velocity,
+            angle: Math.atan2(deltaY, deltaX) * (180 / Math.PI),
+            center: { x: endX, y: endY },
+            event: e,
+            duration
+          };
+          onSwipe == null ? void 0 : onSwipe(swipeEvent);
+          if (direction === "left") onSwipeLeft == null ? void 0 : onSwipeLeft(swipeEvent);
+          if (direction === "right") onSwipeRight == null ? void 0 : onSwipeRight(swipeEvent);
+          if (direction === "up") onSwipeUp == null ? void 0 : onSwipeUp(swipeEvent);
+          if (direction === "down") onSwipeDown == null ? void 0 : onSwipeDown(swipeEvent);
+          if (feedback.haptic) triggerHaptic("light");
+        }
+      } else if (distance < thresholds.tap && duration < 300) {
+        const now = Date.now();
+        const timeSinceLastTap = now - lastTapTime;
+        if (timeSinceLastTap < thresholds.doubleTap && onDoubleTap) {
+          activeGesture.value = "doubleTap";
+          onDoubleTap({
+            type: "doubleTap",
+            center: { x: endX, y: endY },
+            event: e,
+            duration
+          });
+          if (feedback.haptic) triggerHaptic("medium");
+          lastTapTime = 0;
+        } else if (onTap) {
+          if (onDoubleTap) {
+            setTimeout(() => {
+              if (activeGesture.value !== "doubleTap") {
+                activeGesture.value = "tap";
+                onTap({
+                  type: "tap",
+                  center: { x: endX, y: endY },
+                  event: e,
+                  duration
+                });
+                if (feedback.haptic) triggerHaptic("light");
+              }
+            }, thresholds.doubleTap);
+          } else {
+            activeGesture.value = "tap";
+            onTap({
+              type: "tap",
+              center: { x: endX, y: endY },
+              event: e,
+              duration
+            });
+            if (feedback.haptic) triggerHaptic("light");
+          }
+          lastTapTime = now;
+        }
+      }
+    }
+    if (removeVisualFeedback) {
+      removeVisualFeedback();
+      removeVisualFeedback = null;
+    }
+    lastGestureTime = Date.now();
+    setTimeout(() => {
+      activeGesture.value = null;
+    }, 100);
+  }
+  function bind(element) {
+    if (!isBrowser()) return () => {
+    };
+    unbind();
+    currentElement = element;
+    const touchOptions = passive ? { passive: true } : void 0;
+    element.addEventListener("touchstart", handleTouchStart, touchOptions);
+    element.addEventListener("touchmove", handleTouchMove, { passive: false });
+    element.addEventListener("touchend", handleTouchEnd);
+    element.addEventListener("touchcancel", handleTouchEnd);
+    if (feedback.visual) {
+      element.addEventListener("touchstart", () => {
+        removeVisualFeedback = applyVisualFeedback(element, feedback);
+      });
+    }
+    return unbind;
+  }
+  function unbind() {
+    if (currentElement) {
+      currentElement.removeEventListener("touchstart", handleTouchStart);
+      currentElement.removeEventListener("touchmove", handleTouchMove);
+      currentElement.removeEventListener("touchend", handleTouchEnd);
+      currentElement.removeEventListener("touchcancel", handleTouchEnd);
+    }
+    if (longPressTimer) {
+      clearTimeout(longPressTimer);
+      longPressTimer = null;
+    }
+    if (removeVisualFeedback) {
+      removeVisualFeedback();
+      removeVisualFeedback = null;
+    }
+    currentElement = null;
+    activeGesture.value = null;
+    isTouching.value = false;
+  }
+  onUnmounted(unbind);
+  return {
+    activeGesture: readonly(activeGesture),
+    bind,
+    isTouching: readonly(isTouching)
+  };
+}
+function addPassiveListener(element, event, handler, options) {
+  element.addEventListener(event, handler, __spreadValues({ passive: true }, options));
+  return () => element.removeEventListener(event, handler);
+}
+function addNonPassiveListener(element, event, handler, options) {
+  element.addEventListener(event, handler, __spreadValues({ passive: false }, options));
+  return () => element.removeEventListener(event, handler);
+}
+function isTouchDevice() {
+  if (!isBrowser()) return false;
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function isMobileDevice() {
+  if (!isBrowser()) return false;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+function getDevicePixelRatio() {
+  if (!isBrowser()) return 1;
+  return window.devicePixelRatio || 1;
+}
+function usePWA(config = {}) {
+  const {
+    serviceWorker: swConfig = {}
+  } = config;
+  const isOnline = ref(isBrowser() ? navigator.onLine : true);
+  const isRegistered = ref(false);
+  const needsUpdate = ref(false);
+  let registration = null;
+  function handleOnline() {
+    isOnline.value = true;
+  }
+  function handleOffline() {
+    isOnline.value = false;
+  }
+  function register() {
+    return __async(this, null, function* () {
+      if (!isBrowser() || !("serviceWorker" in navigator)) return;
+      if (!swConfig.enabled) return;
+      try {
+        registration = yield navigator.serviceWorker.register(
+          swConfig.path || "/sw.js",
+          { scope: swConfig.scope || "/" }
+        );
+        isRegistered.value = true;
+        registration.addEventListener("updatefound", () => {
+          const newWorker = registration == null ? void 0 : registration.installing;
+          if (newWorker) {
+            newWorker.addEventListener("statechange", () => {
+              if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
+                needsUpdate.value = true;
+              }
+            });
+          }
+        });
+      } catch (error2) {
+        console.warn("[Directix] Service Worker registration failed:", error2);
+      }
+    });
+  }
+  function update() {
+    return __async(this, null, function* () {
+      if (!registration) return;
+      try {
+        yield registration.update();
+        if (registration.waiting) {
+          registration.waiting.postMessage({ type: "SKIP_WAITING" });
+        }
+      } catch (error2) {
+        console.warn("[Directix] Service Worker update failed:", error2);
+      }
+    });
+  }
+  function unregister() {
+    return __async(this, null, function* () {
+      if (!registration) return;
+      try {
+        yield registration.unregister();
+        isRegistered.value = false;
+        registration = null;
+      } catch (error2) {
+        console.warn("[Directix] Service Worker unregistration failed:", error2);
+      }
+    });
+  }
+  function init() {
+    if (!isBrowser()) return () => {
+    };
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    register();
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+    };
+  }
+  onUnmounted(() => {
+    unregister();
+  });
+  return {
+    isOnline: readonly(isOnline),
+    isRegistered: readonly(isRegistered),
+    needsUpdate: readonly(needsUpdate),
+    register,
+    update,
+    unregister,
+    init
+  };
+}
+class ObjectPool {
+  constructor(factory, reset, maxSize = 100) {
+    __publicField(this, "pool", []);
+    __publicField(this, "factory");
+    __publicField(this, "reset");
+    __publicField(this, "maxSize");
+    this.factory = factory;
+    this.reset = reset;
+    this.maxSize = maxSize;
+  }
+  acquire() {
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return this.factory();
+  }
+  release(item) {
+    if (this.pool.length < this.maxSize) {
+      this.reset(item);
+      this.pool.push(item);
+    }
+  }
+  get size() {
+    return this.pool.length;
+  }
+  clear() {
+    this.pool.length = 0;
+  }
+}
+const DEFAULT_ALLOWED_TAGS = [
+  "b",
+  "i",
+  "u",
+  "strong",
+  "em",
+  "br",
+  "p",
+  "span",
+  "div",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "pre",
+  "code",
+  "a",
+  "img",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "td",
+  "th"
+];
+const DEFAULT_ALLOWED_ATTRIBUTES = {
+  "*": ["title", "alt", "class", "id"],
+  a: ["href", "target", "rel", "title"],
+  img: ["src", "alt", "title", "width", "height"]
+};
+const DEFAULT_ALLOWED_PROTOCOLS = ["http", "https", "mailto", "tel"];
+const DANGEROUS_TAGS = [
+  "script",
+  "iframe",
+  "object",
+  "embed",
+  "applet",
+  "form",
+  "input",
+  "button",
+  "select",
+  "textarea",
+  "style",
+  "link",
+  "meta",
+  "base",
+  "frame",
+  "frameset",
+  "svg",
+  "math",
+  "template"
+];
+const DANGEROUS_ATTRIBUTES = [
+  "onclick",
+  "onerror",
+  "onload",
+  "onmouseover",
+  "onmouseout",
+  "onmousedown",
+  "onmouseup",
+  "onmousemove",
+  "onfocus",
+  "onblur",
+  "onchange",
+  "onsubmit",
+  "onreset",
+  "onkeydown",
+  "onkeyup",
+  "onkeypress",
+  "oninput",
+  "onscroll",
+  "onresize",
+  "onunload",
+  "onbeforeunload",
+  "onabort",
+  "oncanplay",
+  "oncanplaythrough",
+  "ondurationchange",
+  "onemptied",
+  "onended",
+  "onloadeddata",
+  "onloadedmetadata",
+  "onloadstart",
+  "onpause",
+  "onplay",
+  "onplaying",
+  "onprogress",
+  "onratechange",
+  "onseeked",
+  "onseeking",
+  "onstalled",
+  "onsuspend",
+  "ontimeupdate",
+  "onvolumechange",
+  "onwaiting",
+  "onafterprint",
+  "onbeforeprint",
+  "oncontextmenu",
+  "oncopy",
+  "oncut",
+  "onpaste",
+  "ondblclick",
+  "ondrag",
+  "ondragend",
+  "ondragenter",
+  "ondragleave",
+  "ondragover",
+  "ondragstart",
+  "ondrop",
+  // Form-related
+  "formaction",
+  "action",
+  "method",
+  "enctype"
+];
+const DANGEROUS_URL_PATTERNS = [
+  /^javascript:/i,
+  /^data:/i,
+  /^vbscript:/i,
+  /^file:/i
+];
+function isUrlSafe(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
+  if (!url) return true;
+  const trimmed = url.trim();
+  for (const pattern of DANGEROUS_URL_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return false;
+    }
+  }
+  const protocolMatch = trimmed.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
+  if (protocolMatch) {
+    return allowedProtocols.includes(protocolMatch[1].toLowerCase());
+  }
+  return true;
+}
+function sanitizeUrl(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
+  if (!url) return "";
+  const trimmed = url.trim();
+  if (!isUrlSafe(trimmed, allowedProtocols)) {
+    return "";
+  }
+  return trimmed;
+}
+function escapeHtml(str) {
+  const escapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "/": "&#x2F;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+  };
+  return str.replace(/[&<>"'`=/]/g, (char) => escapeMap[char] || char);
+}
+function unescapeHtml(str) {
+  const unescapeMap = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#x27;": "'",
+    "&#x2F;": "/",
+    "&#x60;": "`",
+    "&#x3D;": "=",
+    "&#39;": "'"
+  };
+  return str.replace(/&[^;]+;/g, (entity) => unescapeMap[entity] || entity).replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10)));
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+function sanitizeHtml(html, config = {}) {
+  var _a2;
+  if (!html) return "";
+  if (!isBrowser()) return html;
+  const {
+    allowedTags = DEFAULT_ALLOWED_TAGS,
+    allowedAttributes = DEFAULT_ALLOWED_ATTRIBUTES,
+    allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS,
+    allowDataUrls = false,
+    allowInlineStyles = false,
+    allowClass = true,
+    allowId = false,
+    detectDangerousPatterns = true,
+    customFilters = []
+  } = config;
+  let result = html;
+  for (const filter of customFilters) {
+    result = filter(result);
+  }
+  if (detectDangerousPatterns) {
+    const dangerousPatterns = [
+      /<script[\s\S]*?>[\s\S]*?<\/script>/gi,
+      /javascript:/gi,
+      /on\w+\s*=/gi,
+      /data:\s*text\/html/gi,
+      /vbscript:/gi,
+      /expression\s*\(/gi,
+      /url\s*\(\s*["']?javascript:/gi
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(result)) {
+        result = result.replace(pattern, "");
+      }
+    }
+  }
+  const temp = document.createElement("div");
+  temp.innerHTML = result;
+  for (const tag of DANGEROUS_TAGS) {
+    const elements = temp.getElementsByTagName(tag);
+    while (elements.length > 0) {
+      (_a2 = elements[0].parentNode) == null ? void 0 : _a2.removeChild(elements[0]);
+    }
+  }
+  function processElement(el) {
+    var _a3;
+    const tagName = el.tagName.toLowerCase();
+    if (!allowedTags.includes(tagName)) {
+      const text = document.createTextNode(el.textContent || "");
+      (_a3 = el.parentNode) == null ? void 0 : _a3.replaceChild(text, el);
+      return;
+    }
+    for (const attr of DANGEROUS_ATTRIBUTES) {
+      el.removeAttribute(attr);
+    }
+    const attrs = Array.from(el.attributes);
+    for (const attr of attrs) {
+      const attrName = attr.name.toLowerCase();
+      if (attrName.startsWith("on")) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      let isAllowed2 = false;
+      if (Array.isArray(allowedAttributes)) {
+        isAllowed2 = allowedAttributes.includes(attrName);
+      } else {
+        const globalAttrs = allowedAttributes["*"] || [];
+        const tagAttrs = allowedAttributes[tagName] || [];
+        isAllowed2 = globalAttrs.includes(attrName) || tagAttrs.includes(attrName);
+      }
+      if (attrName === "class" && !allowClass) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (attrName === "id" && !allowId) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (attrName === "style" && !allowInlineStyles) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (attrName === "href" || attrName === "src") {
+        const url = attr.value;
+        if (!isUrlSafe(url, allowDataUrls ? [...allowedProtocols, "data"] : allowedProtocols)) {
+          el.removeAttribute(attr.name);
+          continue;
+        }
+      }
+      if (!isAllowed2 && attrName !== "class" && attrName !== "id" && attrName !== "style") {
+        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;
+}
+function getCSPNonce() {
+  if (!isBrowser()) return null;
+  const meta = document.querySelector('meta[http-equiv="Content-Security-Policy"]');
+  if (meta) {
+    const content = meta.content;
+    const match = content.match(/nonce-([a-zA-Z0-9+/=]+)/);
+    if (match) {
+      return match[1];
+    }
+  }
+  const scripts = document.querySelectorAll("script[nonce]");
+  if (scripts.length > 0) {
+    return scripts[0].nonce || null;
+  }
+  return null;
+}
+function injectStylesCSP(css, options = {}) {
+  if (!isBrowser()) return null;
+  const { nonce } = options;
+  if (nonce || getCSPNonce()) {
+    const style2 = document.createElement("style");
+    style2.setAttribute("nonce", nonce || getCSPNonce() || "");
+    style2.textContent = css;
+    document.head.appendChild(style2);
+    return style2;
+  }
+  const style = document.createElement("style");
+  style.textContent = css;
+  document.head.appendChild(style);
+  return style;
+}
+function injectScriptCSP(src, options = {}) {
+  if (!isBrowser()) return null;
+  const { nonce } = options;
+  const script = document.createElement("script");
+  script.src = src;
+  if (nonce || getCSPNonce()) {
+    script.setAttribute("nonce", nonce || getCSPNonce() || "");
+  }
+  document.head.appendChild(script);
+  return script;
+}
+const SecurityAudit = {
+  /**
+   * Scan for potential security issues in HTML
+   */
+  scanHtml(html) {
+    const issues = [];
+    if (/<script[\s\S]*?>[\s\S]*?<\/script>/gi.test(html)) {
+      issues.push({
+        type: "script-injection",
+        severity: "critical",
+        description: "HTML contains script tags which could lead to XSS attacks",
+        remediation: "Remove script tags or use a sanitization library"
+      });
+    }
+    const eventHandlerMatch = html.match(/on\w+\s*=/gi);
+    if (eventHandlerMatch) {
+      issues.push({
+        type: "event-handler",
+        severity: "high",
+        description: `Found ${eventHandlerMatch.length} event handler(s) which could be exploited`,
+        remediation: "Remove inline event handlers and use addEventListener instead"
+      });
+    }
+    if (/javascript:/gi.test(html)) {
+      issues.push({
+        type: "javascript-url",
+        severity: "high",
+        description: "HTML contains javascript: URLs which could lead to XSS attacks",
+        remediation: "Remove javascript: URLs or validate/sanitize them"
+      });
+    }
+    if (/data:\s*text\/html/gi.test(html)) {
+      issues.push({
+        type: "data-url",
+        severity: "high",
+        description: "HTML contains data:text/html URLs which could execute scripts",
+        remediation: "Remove or sanitize data: URLs"
+      });
+    }
+    if (/<iframe[\s\S]*?srcdoc=/gi.test(html)) {
+      issues.push({
+        type: "iframe-srcdoc",
+        severity: "high",
+        description: "HTML contains iframe with srcdoc attribute",
+        remediation: "Avoid using srcdoc or sanitize its content"
+      });
+    }
+    if (/<form[\s\S]*?action\s*=/gi.test(html)) {
+      issues.push({
+        type: "form-action",
+        severity: "medium",
+        description: "HTML contains form with action attribute",
+        remediation: "Validate form actions or use CSRF protection"
+      });
+    }
+    return issues;
+  },
+  /**
+   * Check CSP configuration
+   */
+  checkCSP() {
+    var _a2, _b;
+    const result = {
+      policies: {},
+      warnings: [],
+      recommendations: []
+    };
+    if (!isBrowser()) {
+      result.warnings.push("CSP check requires browser environment");
+      return result;
+    }
+    const meta = document.querySelector('meta[http-equiv="Content-Security-Policy"]');
+    if (meta) {
+      const content = meta.content;
+      const directives = content.split(";").map((d) => d.trim());
+      for (const directive of directives) {
+        const [name, ...values] = directive.split(/\s+/);
+        if (name) {
+          result.policies[name.toLowerCase()] = values;
+        }
+      }
+      if ((_a2 = result.policies["script-src"]) == null ? void 0 : _a2.includes("'unsafe-inline'")) {
+        result.warnings.push("CSP allows unsafe-inline scripts - this reduces XSS protection");
+      }
+      if ((_b = result.policies["script-src"]) == null ? void 0 : _b.includes("'unsafe-eval'")) {
+        result.warnings.push("CSP allows unsafe-eval - this reduces XSS protection");
+      }
+      const recommendedDirectives = ["default-src", "script-src", "style-src", "img-src", "connect-src"];
+      for (const directive of recommendedDirectives) {
+        if (!result.policies[directive]) {
+          result.recommendations.push(`Consider adding ${directive} directive to CSP`);
+        }
+      }
+    } else {
+      result.warnings.push("No CSP meta tag found - consider adding Content Security Policy");
+      result.recommendations.push("Add a Content-Security-Policy meta tag or header");
+    }
+    return result;
+  },
+  /**
+   * Check for known dependency vulnerabilities (Node.js environment only)
+   * Note: This is a client-side check that uses npm audit API when available.
+   * For production use, run `npm audit` or `pnpm audit` in CI/CD.
+   */
+  checkDependencies() {
+    return __async(this, null, function* () {
+      var _a2, _b, _c, _d, _e;
+      const vulnerabilities = [];
+      if (typeof process === "undefined" || !((_a2 = process.versions) == null ? void 0 : _a2.node)) {
+        console.warn("[Directix] checkDependencies() is only available in Node.js environment");
+        return vulnerabilities;
+      }
+      try {
+        const { execSync } = yield import("node:child_process");
+        try {
+          const result = execSync("npm audit --json", {
+            encoding: "utf-8",
+            timeout: 3e4
+          });
+          const audit = JSON.parse(result);
+          if (audit.vulnerabilities) {
+            for (const [name, info2] of Object.entries(audit.vulnerabilities)) {
+              if (info2.via && Array.isArray(info2.via)) {
+                for (const via of info2.via) {
+                  if (typeof via === "object" && via.title) {
+                    vulnerabilities.push({
+                      name,
+                      id: (_c = (_b = via.url) == null ? void 0 : _b.match(/(CVE-\d+-\d+|GHSA-[a-zA-Z0-9-]+)/)) == null ? void 0 : _c[0],
+                      version: info2.version || "unknown",
+                      severity: via.severity || info2.severity || "medium",
+                      title: via.title,
+                      url: via.url,
+                      patchedVersions: info2.fixAvailable ? "Available" : void 0
+                    });
+                  }
+                }
+              }
+            }
+          }
+        } catch (execError) {
+          if (execError.stdout) {
+            try {
+              const audit = JSON.parse(execError.stdout);
+              if (audit.vulnerabilities) {
+                for (const [name, info2] of Object.entries(audit.vulnerabilities)) {
+                  if (info2.via && Array.isArray(info2.via)) {
+                    for (const via of info2.via) {
+                      if (typeof via === "object" && via.title) {
+                        vulnerabilities.push({
+                          name,
+                          id: (_e = (_d = via.url) == null ? void 0 : _d.match(/(CVE-\d+-\d+|GHSA-[a-zA-Z0-9-]+)/)) == null ? void 0 : _e[0],
+                          version: info2.version || "unknown",
+                          severity: via.severity || info2.severity || "medium",
+                          title: via.title,
+                          url: via.url,
+                          patchedVersions: info2.fixAvailable ? "Available" : void 0
+                        });
+                      }
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+            }
+          }
+        }
+      } catch (error2) {
+        console.warn("[Directix] Failed to check dependencies:", error2);
+      }
+      return vulnerabilities;
+    });
+  },
+  /**
+   * Generate security report
+   */
+  generateReport(html) {
+    const report = {
+      vulnerabilities: [],
+      warnings: [],
+      recommendations: [],
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    if (html) {
+      report.vulnerabilities = this.scanHtml(html);
+    }
+    const cspResult = this.checkCSP();
+    for (const warning of cspResult.warnings) {
+      report.warnings.push({
+        type: "csp-warning",
+        severity: "medium",
+        description: warning
+      });
+    }
+    report.recommendations.push(...cspResult.recommendations);
+    return report;
+  },
+  /**
+   * Format security report
+   */
+  formatReport(report, format = "text") {
+    if (format === "json") {
+      return JSON.stringify(report, null, 2);
+    }
+    if (format === "html") {
+      let html = '<div class="security-report">';
+      html += `<h2>Security Report</h2>`;
+      html += `<p>Generated: ${report.timestamp.toISOString()}</p>`;
+      if (report.vulnerabilities.length > 0) {
+        html += "<h3>Vulnerabilities</h3><ul>";
+        for (const vuln of report.vulnerabilities) {
+          html += `<li class="severity-${vuln.severity}"><strong>${vuln.type}</strong>: ${vuln.description}</li>`;
+        }
+        html += "</ul>";
+      }
+      if (report.warnings.length > 0) {
+        html += "<h3>Warnings</h3><ul>";
+        for (const warning of report.warnings) {
+          html += `<li class="severity-${warning.severity}"><strong>${warning.type}</strong>: ${warning.description}</li>`;
+        }
+        html += "</ul>";
+      }
+      if (report.recommendations.length > 0) {
+        html += "<h3>Recommendations</h3><ul>";
+        for (const rec of report.recommendations) {
+          html += `<li>${rec}</li>`;
+        }
+        html += "</ul>";
+      }
+      html += "</div>";
+      return html;
+    }
+    let text = "Security Report\n";
+    text += `Generated: ${report.timestamp.toISOString()}
+
+`;
+    if (report.vulnerabilities.length > 0) {
+      text += "Vulnerabilities:\n";
+      for (const vuln of report.vulnerabilities) {
+        text += `  [${vuln.severity.toUpperCase()}] ${vuln.type}: ${vuln.description}
+`;
+      }
+      text += "\n";
+    }
+    if (report.warnings.length > 0) {
+      text += "Warnings:\n";
+      for (const warning of report.warnings) {
+        text += `  [${warning.severity.toUpperCase()}] ${warning.type}: ${warning.description}
+`;
+      }
+      text += "\n";
+    }
+    if (report.recommendations.length > 0) {
+      text += "Recommendations:\n";
+      for (const rec of report.recommendations) {
+        text += `  - ${rec}
+`;
+      }
+    }
+    return text;
+  }
+};
+class SafeContentHandler {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Sanitize and set HTML content
+   */
+  setHtml(element, content) {
+    element.innerHTML = sanitizeHtml(content, this.config);
+  }
+  /**
+   * Sanitize and set text content
+   */
+  setText(element, content) {
+    element.textContent = content;
+  }
+  /**
+   * Set attribute with URL validation
+   */
+  setAttribute(element, name, value) {
+    if (name.toLowerCase().startsWith("on")) {
+      return;
+    }
+    if (name.toLowerCase() === "href" || name.toLowerCase() === "src") {
+      value = sanitizeUrl(value, this.config.allowedProtocols);
+    }
+    element.setAttribute(name, value);
+  }
+  /**
+   * Get sanitized HTML
+   */
+  getSanitizedHtml(content) {
+    return sanitizeHtml(content, this.config);
+  }
+}
+function createSafeContentHandler(config) {
+  return new SafeContentHandler(config);
+}
+function useLazyOptimized(options = {}) {
+  const {
+    threshold = 0,
+    rootMargin = "0px",
+    once = true,
+    onLoad
+  } = options;
+  const state2 = shallowRef({
+    loading: false,
+    loaded: false,
+    error: null,
+    isVisible: false
+  });
+  let observer = null;
+  function disconnect() {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  }
+  function observe2(el) {
+    disconnect();
+    observer = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (entry == null ? void 0 : entry.isIntersecting) {
+          state2.value = __spreadProps(__spreadValues({}, state2.value), { isVisible: true });
+          load2();
+          if (once) {
+            disconnect();
+          }
+        }
+      },
+      { threshold, rootMargin }
+    );
+    observer.observe(el);
+  }
+  function load2() {
+    if (state2.value.loading || state2.value.loaded) return;
+    state2.value = __spreadProps(__spreadValues({}, state2.value), { loading: true, error: null });
+    try {
+      onLoad == null ? void 0 : onLoad({});
+      state2.value = __spreadProps(__spreadValues({}, state2.value), { loading: false, loaded: true });
+    } catch (e) {
+      state2.value = __spreadProps(__spreadValues({}, state2.value), { loading: false, error: e });
+    }
+  }
+  return {
+    state: readonly(state2),
+    observe: observe2,
+    disconnect,
+    load: load2
+  };
+}
+function useDirectiveInstance(options = {}) {
+  const { initialState = {}, shallow = false } = options;
+  let element = null;
+  const state2 = shallow ? reactive(initialState) : reactive(initialState);
+  function setElement(el) {
+    element = markRaw(el);
+  }
+  function setState2(updater) {
+    const newState = updater(toRaw(state2));
+    Object.assign(state2, newState);
+  }
+  function reset() {
+    Object.assign(state2, initialState);
+  }
+  return {
+    get element() {
+      return element;
+    },
+    set element(el) {
+      if (el) setElement(el);
+    },
+    state: readonly(state2),
+    setElement,
+    setState: setState2,
+    reset
+  };
+}
+function computedWithCleanup(options) {
+  const { get: get2, cleanup: cleanup2 } = options;
+  let oldValue;
+  return computed({
+    get() {
+      const newValue = get2();
+      if (oldValue !== void 0 && oldValue !== newValue) {
+        cleanup2 == null ? void 0 : cleanup2(oldValue);
+      }
+      oldValue = newValue;
+      return newValue;
+    },
+    set() {
+    }
+  });
+}
+function watchEffectBinding(options) {
+  const { binding, effect } = options;
+  let cleanupFn = null, cleanup2 = (fn) => {
+    cleanupFn = fn;
+  };
+  const stop = watchEffect((onCleanup) => {
+    cleanup2 = onCleanup;
+    if (cleanupFn) {
+      cleanupFn();
+      cleanupFn = null;
+    }
+    if (isRef(binding)) {
+      effect(binding.value, void 0, cleanup2);
+    } else {
+      effect(binding, void 0, cleanup2);
+    }
+  });
+  return () => {
+    if (cleanupFn) {
+      cleanupFn();
+    }
+    stop();
+  };
+}
+function useSuspenseDirective(options) {
+  const { loader, onSuccess, onError } = options;
+  const state2 = shallowRef({
+    loading: false,
+    error: null,
+    data: null
+  });
+  function load2() {
+    return __async(this, null, function* () {
+      if (state2.value.loading) return;
+      state2.value = __spreadProps(__spreadValues({}, state2.value), { loading: true, error: null });
+      try {
+        const data = yield loader();
+        state2.value = { loading: false, error: null, data };
+        onSuccess == null ? void 0 : onSuccess(data);
+      } catch (error2) {
+        state2.value = __spreadProps(__spreadValues({}, state2.value), { loading: false, error: error2 });
+        onError == null ? void 0 : onError(error2);
+      }
+    });
+  }
+  function retry() {
+    return __async(this, null, function* () {
+      state2.value = __spreadProps(__spreadValues({}, state2.value), { error: null });
+      yield load2();
+    });
+  }
+  return {
+    state: readonly(state2),
+    load: load2,
+    retry
+  };
+}
+function ensureTeleportTarget(target) {
+  if (typeof document === "undefined") return null;
+  let el = document.querySelector(target);
+  if (!el) {
+    el = document.createElement("div");
+    el.id = target.replace("#", "");
+    document.body.appendChild(el);
+  }
+  return el;
+}
+function teleportContent(content, options) {
+  const { to, disabled = false } = options;
+  if (disabled || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const targetEl = typeof to === "string" ? ensureTeleportTarget(to) : to;
+  if (!targetEl) return () => {
+  };
+  const parent = content.parentNode;
+  const nextSibling = content.nextSibling;
+  targetEl.appendChild(content);
+  return () => {
+    if (parent && content.parentNode === targetEl) {
+      parent.insertBefore(content, nextSibling);
+    }
+  };
+}
 const zhCN = {
   directives: {
     debounce: {
@@ -17852,10 +19580,17 @@ const Directix = {
 };
 export {
   Directix,
+  ObjectPool,
   PluginManager,
   PluginRegistry,
+  SafeContentHandler,
+  SecurityAudit,
   addCleanup$1 as addCleanupVue2,
   addCleanup as addCleanupVue3,
+  addNonPassiveListener,
+  addPassiveListener,
+  announce,
+  applyAriaAttributes,
   assert,
   assertPositive,
   assertRange,
@@ -17864,8 +19599,11 @@ export {
   calculateTime,
   capitalizeText,
   capitalizeWord,
+  clearAnnouncer,
+  clearAriaAttributes,
   clearDevtoolsState,
   clearPerformanceMetrics,
+  computedWithCleanup,
   configurePerformance,
   configurePermission,
   createCapitalizer,
@@ -17877,6 +19615,7 @@ export {
   createMoneyFormatter,
   createNumberFormatter,
   createPermissionChecker,
+  createSafeContentHandler,
   createStyleDirective,
   createTrimmer,
   createUppercaser,
@@ -17899,7 +19638,9 @@ export {
   enableDevtools,
   enablePerformance,
   endMeasure,
+  ensureTeleportTarget,
   error,
+  escapeHtml,
   exportPerformanceData,
   formatCurrencyLocale,
   formatDateLocale,
@@ -17907,9 +19648,13 @@ export {
   formatNumber,
   formatNumberLocale,
   formatTime,
+  generateAriaId,
   generateId,
   get,
+  getAutoAriaConfig,
+  getCSPNonce,
   getDateFormat,
+  getDevicePixelRatio,
   getDevtoolsState,
   getDirectiveMetrics,
   getLocale,
@@ -17926,18 +19671,23 @@ export {
   getTimezoneInfo,
   getVueVersion,
   info,
+  injectScriptCSP,
+  injectStylesCSP,
   isArray,
   isBoolean,
   isBrowser,
   isDevtoolsAvailable,
   isEmpty,
   isFunction,
+  isMobileDevice,
   isNumber,
   isObject,
   isPerformanceEnabled,
   isPromise,
   isSSR,
   isString,
+  isTouchDevice,
+  isUrlSafe,
   isVue2,
   isVue27,
   isVue3,
@@ -17954,6 +19704,8 @@ export {
   resetPluginManager,
   resetPluginRegistry,
   resetVueVersion,
+  sanitizeHtml,
+  sanitizeUrl,
   set,
   setLocale,
   setVueVersion,
@@ -17961,17 +19713,21 @@ export {
   setWarningI18n,
   setWarningLevel,
   startMeasure,
+  stripHtml,
   supportsClipboard,
   supportsIntersectionObserver,
   supportsMutationObserver,
   supportsPassive,
   supportsResizeObserver,
   t,
+  teleportContent,
   throttleFn,
   trackDirective,
   trackPlugin,
+  triggerHaptic,
   trimText,
   truncateText,
+  unescapeHtml,
   untrackDirective,
   untrackPlugin,
   uppercaseText,
@@ -17985,12 +19741,15 @@ export {
   useCountdown,
   useCounter,
   useDebounce,
+  useDirectiveInstance,
   useDraggable,
   useEllipsis,
   useEmoji,
+  useEnhancedTouch,
   useExport,
   useFade,
   useFocus,
+  useFocusTrap,
   useFullscreen,
   useHighlight,
   useHotkey,
@@ -17998,7 +19757,9 @@ export {
   useImagePreview,
   useInfiniteScroll,
   useIntersect,
+  useKeyboardNavigation,
   useLazy,
+  useLazyOptimized,
   useLoading,
   useLongPress,
   useLottie,
@@ -18007,6 +19768,7 @@ export {
   useMoney,
   useMutation,
   useNumber,
+  usePWA,
   usePan,
   useParallax,
   usePermission,
@@ -18021,6 +19783,7 @@ export {
   useScroll,
   useSkeleton,
   useSticky,
+  useSuspenseDirective,
   useSwipe,
   useThrottle,
   useTooltip,
@@ -18095,6 +19858,7 @@ export {
   warnMissingParam,
   warnNotSupported,
   warnSSRNotSupported,
+  watchEffectBinding,
   withPerformanceMonitoring,
   wouldTextTruncate,
   zhCN