accessify-widget 0.3.71 → 0.3.74

package/dist/alt-text-CoS2ISqs.js

@@ -0,0 +1,745 @@
+import { g as getCurrentWidgetLang } from "./index-DCvvWewP.js";
+const IDB_NAME = "accessify-alt-text-cache";
+const IDB_STORE = "alt-texts";
+const IDB_VERSION = 2;
+function hashSrc(src) {
+  let hash = 5381;
+  const n = src.toLowerCase().trim();
+  for (let i = 0; i < n.length; i++) {
+    hash = (hash << 5) + hash + n.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function normalizeImageUrl(url) {
+  try {
+    const u = new URL(url);
+    u.searchParams.delete("width");
+    u.searchParams.delete("height");
+    u.searchParams.delete("scale-down-to");
+    return u.href;
+  } catch {
+    return url;
+  }
+}
+function getImageSrc(img) {
+  return img.currentSrc || img.src;
+}
+function openCache() {
+  return new Promise((resolve) => {
+    try {
+      const req = indexedDB.open(IDB_NAME, IDB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(IDB_STORE)) db.createObjectStore(IDB_STORE, { keyPath: "key" });
+        if (!db.objectStoreNames.contains("alt-text-reports")) db.createObjectStore("alt-text-reports", { keyPath: "key" });
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+async function getAllCachedAltTexts() {
+  const db = await openCache();
+  const map = /* @__PURE__ */ new Map();
+  if (!db) return map;
+  return new Promise((resolve) => {
+    try {
+      const tx = db.transaction(IDB_STORE, "readonly");
+      const req = tx.objectStore(IDB_STORE).getAll();
+      req.onsuccess = () => {
+        for (const r of req.result) {
+          map.set(r.src, r.altText);
+        }
+        resolve(map);
+      };
+      req.onerror = () => resolve(map);
+    } catch {
+      resolve(map);
+    }
+  });
+}
+async function getCachedAltText(src) {
+  const db = await openCache();
+  if (!db) return null;
+  return new Promise((resolve) => {
+    try {
+      const tx = db.transaction(IDB_STORE, "readonly");
+      const store = tx.objectStore(IDB_STORE);
+      const req1 = store.get(hashSrc(src));
+      req1.onsuccess = () => {
+        if (req1.result?.altText) {
+          resolve(req1.result.altText);
+          return;
+        }
+        const norm = normalizeImageUrl(src);
+        if (norm !== src) {
+          const req2 = store.get(hashSrc(norm));
+          req2.onsuccess = () => resolve(req2.result?.altText || null);
+          req2.onerror = () => resolve(null);
+        } else {
+          resolve(null);
+        }
+      };
+      req1.onerror = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+async function setCachedAltText(src, altText, langCode) {
+  const db = await openCache();
+  if (!db) return;
+  return new Promise((resolve) => {
+    try {
+      const tx = db.transaction(IDB_STORE, "readwrite");
+      tx.objectStore(IDB_STORE).put({ key: hashSrc(src), src, altText, lang: langCode, createdAt: Date.now() });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+    } catch {
+      resolve();
+    }
+  });
+}
+const DEFAULT_API_BASE = "https://accessify-api.accessify.workers.dev";
+let currentAltSiteMode = "manual";
+async function fetchServerAltTexts(siteKey, proxyUrl, lang) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const base = proxyUrl || DEFAULT_API_BASE;
+    const pageUrl = window.location.origin + window.location.pathname;
+    const res = await fetch(`${base}/v1/manifest?siteKey=${encodeURIComponent(siteKey)}&url=${encodeURIComponent(pageUrl)}&feature=alt_text&variant=${encodeURIComponent(lang)}`, {
+      headers: { "Accept": "application/json" },
+      cache: "no-cache"
+    });
+    if (!res.ok) return map;
+    const data = await res.json();
+    currentAltSiteMode = data.siteMode === "auto" ? "auto" : "manual";
+    if (data.blocks) {
+      for (const block of data.blocks) {
+        if (block.selector && block.result) map.set(block.selector, block.result);
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function persistAltTextToServer(siteKey, proxyUrl, imageUrl, altText, lang) {
+  try {
+    const base = proxyUrl || DEFAULT_API_BASE;
+    const pageUrl = window.location.origin + window.location.pathname;
+    fetch(`${base}/v1/cache/persist-alt-text`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ siteKey, pageUrl, imageUrl, altText, lang })
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+let autoApplied = false;
+async function autoApplyCachedAltTexts(widgetConfig) {
+  if (autoApplied) return 0;
+  autoApplied = true;
+  const cache = /* @__PURE__ */ new Map();
+  const siteKey = widgetConfig?.siteKey;
+  const proxyUrl = widgetConfig?.proxyUrl || "";
+  const pageLang = widgetConfig?.lang?.split("-")[0] || document.documentElement.lang?.split("-")[0] || "en";
+  if (siteKey) {
+    const serverCache = await fetchServerAltTexts(siteKey, proxyUrl, pageLang);
+    for (const [url, alt] of serverCache) {
+      cache.set(url, alt);
+      const norm = normalizeImageUrl(url);
+      if (norm !== url) cache.set(norm, alt);
+      setCachedAltText(url, alt, pageLang).catch(() => {
+      });
+    }
+  }
+  const localCache = await getAllCachedAltTexts();
+  for (const [url, alt] of localCache) {
+    if (!cache.has(url)) cache.set(url, alt);
+  }
+  if (cache.size === 0) return 0;
+  function applyToImg(img) {
+    if (img.closest("#accessify-root") || img.closest("accessify-widget")) return false;
+    const src = getImageSrc(img);
+    const norm = normalizeImageUrl(src);
+    const imgSrcNorm = normalizeImageUrl(img.src);
+    const cached = cache.get(src) || cache.get(norm) || cache.get(img.src) || cache.get(imgSrcNorm);
+    if (!cached) return false;
+    const alt = img.getAttribute("alt");
+    if (alt === null || alt.trim() === "") {
+      img.setAttribute("alt", cached);
+      img.setAttribute("data-accessify-alt", "auto");
+    }
+    img.setAttribute("title", cached);
+    return true;
+  }
+  let applied = 0;
+  document.querySelectorAll("img").forEach((img) => {
+    if (applyToImg(img)) applied++;
+  });
+  const observer = new MutationObserver((mutations) => {
+    for (const m of mutations) {
+      for (const node of m.addedNodes) {
+        const imgs = node instanceof HTMLImageElement ? [node] : node instanceof HTMLElement ? Array.from(node.querySelectorAll("img")) : [];
+        for (const img of imgs) applyToImg(img);
+      }
+    }
+  });
+  observer.observe(document.body, { childList: true, subtree: true });
+  setTimeout(() => observer.disconnect(), 3e4);
+  return applied;
+}
+function createAltTextModule(aiService, initialLang = "de", serverConfig) {
+  const siteKey = serverConfig?.siteKey || "";
+  const proxyUrl = serverConfig?.proxyUrl || "";
+  let enabled = false;
+  let domObserver = null;
+  let autoGenerating = false;
+  let missingAltImages = [];
+  const processedImages = /* @__PURE__ */ new Map();
+  function lang() {
+    return getCurrentWidgetLang() || initialLang;
+  }
+  function isDE() {
+    return lang().startsWith("de");
+  }
+  function isGenericAlt(alt) {
+    if (!alt.trim()) return true;
+    if (/^(image|img|photo|bild|foto|untitled|placeholder)/i.test(alt)) return true;
+    if (/^IMG_\d+/i.test(alt)) return true;
+    if (/\.(jpg|jpeg|png|gif|webp|svg|avif)$/i.test(alt)) return true;
+    return false;
+  }
+  function isDecorativeImage(img) {
+    const role = img.getAttribute("role");
+    if (role === "presentation" || role === "none") return true;
+    if (img.complete && img.naturalWidth > 0 && (img.naturalWidth < 50 || img.naturalHeight < 50)) return true;
+    return false;
+  }
+  function isValidImage(img) {
+    if (img.closest("#accessify-root") || img.closest("accessify-widget")) return false;
+    if (img.complete && img.naturalWidth > 0 && (img.naturalWidth < 50 || img.naturalHeight < 50)) return false;
+    const rect = img.getBoundingClientRect();
+    if (rect.width < 40 || rect.height < 40) return false;
+    const style = getComputedStyle(img);
+    if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+    if (img.getAttribute("role") === "presentation" || img.getAttribute("aria-hidden") === "true") return false;
+    return true;
+  }
+  function needsAltText(img) {
+    if (!isValidImage(img)) return false;
+    const alt = img.getAttribute("alt");
+    if (alt === null) return true;
+    if (isGenericAlt(alt)) return true;
+    if (alt === "" && !isDecorativeImage(img)) return true;
+    return false;
+  }
+  function scanForMissingAlt() {
+    const missing = [];
+    document.querySelectorAll("img").forEach((img) => {
+      if (needsAltText(img)) missing.push(img);
+    });
+    document.querySelectorAll("picture").forEach((picture) => {
+      if (picture.closest("#accessify-root") || picture.closest("accessify-widget")) return;
+      const img = picture.querySelector("img");
+      if (img && !missing.includes(img) && needsAltText(img)) {
+        missing.push(img);
+      }
+    });
+    return missing;
+  }
+  function gatherImageContext(img) {
+    const parts = [];
+    try {
+      const url = new URL(getImageSrc(img), window.location.href);
+      const filename = url.pathname.split("/").pop();
+      if (filename) parts.push(`Filename: ${filename}`);
+    } catch {
+    }
+    const figure = img.closest("figure");
+    if (figure) {
+      const caption = figure.querySelector("figcaption");
+      if (caption?.textContent?.trim()) parts.push(`Caption: ${caption.textContent.trim()}`);
+    }
+    const container = img.parentElement?.parentElement || img.parentElement;
+    if (container) {
+      const heading = container.querySelector("h1, h2, h3, h4, h5, h6");
+      if (heading?.textContent?.trim()) parts.push(`Nearby heading: ${heading.textContent.trim()}`);
+    }
+    return parts.join(". ");
+  }
+  function applyAltText(img, altText) {
+    img.setAttribute("alt", altText);
+    img.setAttribute("title", altText);
+    processedImages.set(img, { generatedAlt: altText });
+    if (enabled) addInfoBadge(img, altText);
+  }
+  function applyTitlesToAllImages() {
+    document.querySelectorAll("img").forEach((img) => {
+      if (!isValidImage(img)) return;
+      if (img.getAttribute("title")) return;
+      const alt = img.getAttribute("alt");
+      if (alt && alt.trim()) {
+        img.setAttribute("title", alt);
+        img.setAttribute("data-accessify-title", "auto");
+      }
+    });
+  }
+  const BADGE_ATTR = "data-accessify-badge";
+  const WRAPPER_ATTR = "data-accessify-badge-wrap";
+  const OVERLAY_ID = "accessify-badge-overlay";
+  const BADGE_STYLE_ID = "accessify-badge-styles";
+  let badgePositionRAF = null;
+  let trackedBadges = [];
+  let outsideClickHandler = null;
+  function getOrCreateOverlay() {
+    let overlay = document.getElementById(OVERLAY_ID);
+    if (!overlay) {
+      overlay = document.createElement("div");
+      overlay.id = OVERLAY_ID;
+      Object.assign(overlay.style, {
+        position: "absolute",
+        top: "0",
+        left: "0",
+        width: "0",
+        height: "0",
+        overflow: "visible",
+        pointerEvents: "none",
+        zIndex: "10000"
+      });
+      document.body.appendChild(overlay);
+    }
+    if (!document.getElementById(BADGE_STYLE_ID)) {
+      const style = document.createElement("style");
+      style.id = BADGE_STYLE_ID;
+      style.textContent = `
+        [${BADGE_ATTR}="badge"]:hover + [${BADGE_ATTR}="tooltip"] { display: block !important; }
+        [${BADGE_ATTR}="badge"]:hover { background: rgba(0,0,0,0.85) !important; }
+        @media (pointer: coarse) {
+          [${BADGE_ATTR}="badge"] { width: 36px !important; height: 36px !important; line-height: 36px !important; font-size: 16px !important; }
+        }
+      `;
+      document.head.appendChild(style);
+    }
+    return overlay;
+  }
+  function positionBadge(target, badge, tooltip) {
+    const rect = target.getBoundingClientRect();
+    if (rect.width < 40 || rect.height < 40 || rect.bottom < 0 || rect.top > window.innerHeight + 200 || rect.right < 0 || rect.left > window.innerWidth + 200) {
+      badge.style.display = "none";
+      tooltip.style.display = "none";
+      return;
+    }
+    const scrollX = window.scrollX;
+    const scrollY = window.scrollY;
+    const top = rect.top + scrollY + 6;
+    const left = rect.left + scrollX + 6;
+    badge.style.display = "";
+    badge.style.top = `${top}px`;
+    badge.style.left = `${left}px`;
+    tooltip.style.top = `${top + 26}px`;
+    tooltip.style.left = `${left}px`;
+  }
+  function updateAllBadgePositions() {
+    for (const { target, badge, tooltip } of trackedBadges) {
+      if (!document.body.contains(target)) continue;
+      positionBadge(target, badge, tooltip);
+    }
+  }
+  function startBadgeTracking() {
+    if (badgePositionRAF !== null) return;
+    const tick = () => {
+      updateAllBadgePositions();
+      badgePositionRAF = requestAnimationFrame(tick);
+    };
+    badgePositionRAF = requestAnimationFrame(tick);
+    if (!outsideClickHandler) {
+      outsideClickHandler = (e) => {
+        const target = e.target;
+        if (target.getAttribute(BADGE_ATTR) === "badge") return;
+        for (const entry of trackedBadges) {
+          entry.tooltip.style.display = "none";
+          entry.badge.style.background = "rgba(0,0,0,0.6)";
+        }
+      };
+      document.addEventListener("click", outsideClickHandler, { passive: true });
+    }
+  }
+  function stopBadgeTracking() {
+    if (badgePositionRAF !== null) {
+      cancelAnimationFrame(badgePositionRAF);
+      badgePositionRAF = null;
+    }
+    if (outsideClickHandler) {
+      document.removeEventListener("click", outsideClickHandler);
+      outsideClickHandler = null;
+    }
+  }
+  function addInfoBadge(target, altText) {
+    if (target.getAttribute(BADGE_ATTR)) return;
+    target.setAttribute(BADGE_ATTR, "1");
+    const overlay = getOrCreateOverlay();
+    const badge = document.createElement("span");
+    Object.assign(badge.style, {
+      position: "absolute",
+      width: "22px",
+      height: "22px",
+      borderRadius: "50%",
+      background: "rgba(0,0,0,0.6)",
+      color: "#fff",
+      fontFamily: "sans-serif",
+      fontWeight: "bold",
+      fontSize: "13px",
+      lineHeight: "22px",
+      textAlign: "center",
+      cursor: "default",
+      pointerEvents: "auto",
+      boxShadow: "0 1px 4px rgba(0,0,0,0.4)",
+      transition: "background 0.15s"
+    });
+    badge.textContent = "i";
+    badge.setAttribute("aria-hidden", "true");
+    badge.setAttribute("translate", "no");
+    badge.classList.add("notranslate");
+    badge.setAttribute(BADGE_ATTR, "badge");
+    const tooltip = document.createElement("span");
+    Object.assign(tooltip.style, {
+      display: "none",
+      position: "absolute",
+      minWidth: "150px",
+      maxWidth: "280px",
+      padding: "6px 10px",
+      background: "rgba(0,0,0,0.88)",
+      color: "#fff",
+      fontFamily: "sans-serif",
+      fontSize: "12px",
+      lineHeight: "1.4",
+      borderRadius: "6px",
+      pointerEvents: "none",
+      wordWrap: "break-word",
+      boxShadow: "0 2px 8px rgba(0,0,0,0.3)",
+      zIndex: "1"
+    });
+    tooltip.textContent = altText;
+    tooltip.setAttribute("translate", "no");
+    tooltip.classList.add("notranslate");
+    tooltip.setAttribute(BADGE_ATTR, "tooltip");
+    badge.addEventListener("click", () => {
+      const isOpen = tooltip.style.display === "block";
+      for (const entry of trackedBadges) {
+        entry.tooltip.style.display = "none";
+        entry.badge.style.background = "rgba(0,0,0,0.6)";
+      }
+      if (!isOpen) {
+        badge.style.background = "rgba(0,0,0,0.85)";
+        tooltip.style.display = "block";
+      }
+    });
+    overlay.appendChild(badge);
+    overlay.appendChild(tooltip);
+    positionBadge(target, badge, tooltip);
+    trackedBadges.push({ target, badge, tooltip });
+  }
+  function removeAllBadges() {
+    stopBadgeTracking();
+    trackedBadges = [];
+    document.getElementById(OVERLAY_ID)?.remove();
+    document.getElementById(BADGE_STYLE_ID)?.remove();
+    document.querySelectorAll(`[${BADGE_ATTR}]`).forEach((el) => el.removeAttribute(BADGE_ATTR));
+    document.querySelectorAll(`[${WRAPPER_ATTR}]`).forEach((wrapper) => {
+      const img = wrapper.querySelector("img");
+      if (img && wrapper.parentElement) {
+        wrapper.parentElement.insertBefore(img, wrapper);
+        wrapper.remove();
+      }
+    });
+  }
+  function addBadgesToAllImages() {
+    document.querySelectorAll("img").forEach((img) => {
+      if (!isValidImage(img)) return;
+      const alt = img.getAttribute("alt") || img.getAttribute("title");
+      if (alt && alt.trim()) {
+        addInfoBadge(img, alt.trim());
+      }
+    });
+    document.querySelectorAll("[data-accessify-bg-alt]").forEach((el) => {
+      const alt = el.getAttribute("aria-label");
+      if (alt && alt.trim()) {
+        addInfoBadge(el, alt.trim());
+      }
+    });
+    if (trackedBadges.length > 0) startBadgeTracking();
+  }
+  function removeTitles() {
+    document.querySelectorAll('img[data-accessify-title="auto"]').forEach((img) => {
+      img.removeAttribute("title");
+      img.removeAttribute("data-accessify-title");
+    });
+    document.querySelectorAll("[data-accessify-bg-alt]").forEach((el) => {
+      el.removeAttribute("role");
+      el.removeAttribute("aria-label");
+      el.removeAttribute("title");
+      el.removeAttribute("data-accessify-bg-alt");
+    });
+    removeAllBadges();
+  }
+  function scanForBackgroundImages() {
+    const found = [];
+    const allElements = document.querySelectorAll("*");
+    for (const el of allElements) {
+      if (el.closest("#accessify-root") || el.closest("accessify-widget")) continue;
+      if (el.getAttribute("data-accessify-bg-alt")) continue;
+      if (el.offsetWidth < 200 || el.offsetHeight < 150) continue;
+      const style = getComputedStyle(el);
+      const bg = style.backgroundImage;
+      if (!bg || bg === "none") continue;
+      const urlMatch = bg.match(/url\(["']?([^"')]+)["']?\)/);
+      if (!urlMatch) continue;
+      if (urlMatch[1].startsWith("data:image/svg")) continue;
+      if (el.getAttribute("role") === "img" && el.getAttribute("aria-label")) continue;
+      found.push(el);
+    }
+    return found;
+  }
+  function getBackgroundImageUrl(el) {
+    const bg = getComputedStyle(el).backgroundImage;
+    const match = bg?.match(/url\(["']?([^"')]+)["']?\)/);
+    return match ? match[1] : null;
+  }
+  function applyBgAlt(el, altText) {
+    el.setAttribute("role", "img");
+    el.setAttribute("aria-label", altText);
+    el.setAttribute("title", altText);
+    el.setAttribute("data-accessify-bg-alt", "auto");
+    if (enabled) addInfoBadge(el, altText);
+  }
+  async function generateBgAlts() {
+    if (!aiService || !enabled) return;
+    if (currentAltSiteMode !== "auto") {
+      if (window.__ACCESSIFY_DEBUG) {
+        console.info("[Accessify] alt-text: siteMode=manual — skipping live generation for background images");
+      }
+      return;
+    }
+    const bgElements = scanForBackgroundImages();
+    for (const el of bgElements) {
+      if (!enabled) break;
+      const src = getBackgroundImageUrl(el);
+      if (!src) continue;
+      const cached = await getCachedAltText(src);
+      if (cached) {
+        applyBgAlt(el, cached);
+        continue;
+      }
+      try {
+        const ctx = gatherBgContext(el);
+        const alt = await aiService.generateAltText(src, ctx, lang());
+        if (alt && enabled) {
+          applyBgAlt(el, alt);
+          setCachedAltText(src, alt, lang()).catch(() => {
+          });
+          if (siteKey) persistAltTextToServer(siteKey, proxyUrl, src, alt, lang());
+        }
+      } catch (err) {
+        console.warn("[Accessify] Bg alt-text generation failed:", src, err);
+      }
+    }
+  }
+  function gatherBgContext(el) {
+    const parts = [];
+    parts.push(`Element: <${el.tagName.toLowerCase()}>`);
+    if (el.className) parts.push(`Class: ${el.className}`);
+    const text = el.textContent?.trim().slice(0, 100);
+    if (text) parts.push(`Overlay text: ${text}`);
+    const heading = el.querySelector("h1, h2, h3");
+    if (heading?.textContent?.trim()) parts.push(`Heading: ${heading.textContent.trim()}`);
+    return parts.join(". ");
+  }
+  async function generateAll() {
+    if (autoGenerating || !enabled || !aiService) return;
+    autoGenerating = true;
+    const CONCURRENCY = 3;
+    const uncached = [];
+    for (const img of missingAltImages) {
+      if (!enabled) {
+        autoGenerating = false;
+        return;
+      }
+      if (processedImages.has(img)) continue;
+      const src = getImageSrc(img);
+      const cached = await getCachedAltText(src);
+      if (cached) {
+        applyAltText(img, cached);
+      } else {
+        uncached.push(img);
+      }
+    }
+    if (!enabled) {
+      autoGenerating = false;
+      return;
+    }
+    if (!uncached.length) {
+      autoGenerating = false;
+      return;
+    }
+    if (currentAltSiteMode !== "auto") {
+      if (window.__ACCESSIFY_DEBUG) {
+        console.info(
+          `[Accessify] alt-text: siteMode=manual — ${uncached.length} image(s) left untouched. Trigger a crawl from the dashboard or enable auto mode.`
+        );
+      }
+      autoGenerating = false;
+      return;
+    }
+    for (let i = 0; i < uncached.length; i += CONCURRENCY) {
+      if (!enabled) {
+        autoGenerating = false;
+        return;
+      }
+      const batch = uncached.slice(i, i + CONCURRENCY);
+      await Promise.all(batch.map(async (img) => {
+        if (!enabled) return;
+        try {
+          const src = getImageSrc(img);
+          const ctx = gatherImageContext(img);
+          const alt = await aiService.generateAltText(src, ctx, lang());
+          if (alt && enabled) {
+            applyAltText(img, alt);
+            setCachedAltText(src, alt, lang()).catch(() => {
+            });
+            if (siteKey) persistAltTextToServer(siteKey, proxyUrl, src, alt, lang());
+          }
+        } catch (err) {
+          console.warn("[Accessify] Alt-text generation failed:", getImageSrc(img), err);
+        }
+      }));
+    }
+    autoGenerating = false;
+  }
+  async function generateSingle(img) {
+    if (!aiService || !enabled) return;
+    const src = getImageSrc(img);
+    const cached = await getCachedAltText(src);
+    if (cached) {
+      applyAltText(img, cached);
+      return;
+    }
+    if (currentAltSiteMode !== "auto") return;
+    try {
+      const ctx = gatherImageContext(img);
+      const alt = await aiService.generateAltText(src, ctx, lang());
+      if (alt && enabled) {
+        applyAltText(img, alt);
+        setCachedAltText(src, alt, lang()).catch(() => {
+        });
+        if (siteKey) persistAltTextToServer(siteKey, proxyUrl, src, alt, lang());
+      }
+    } catch (err) {
+      console.warn("[Accessify] Alt-text generation failed:", src, err);
+    }
+  }
+  function tryRegisterImage(img) {
+    if (!enabled) return;
+    if (!isValidImage(img)) return;
+    if (missingAltImages.includes(img)) return;
+    function addIfValid() {
+      if (!enabled || missingAltImages.includes(img)) return;
+      if (img.naturalWidth < 20 || img.naturalHeight < 20) return;
+      if (needsAltText(img)) {
+        missingAltImages.push(img);
+        generateSingle(img);
+      } else {
+        const alt = img.getAttribute("alt");
+        if (alt && alt.trim()) {
+          if (!img.getAttribute("title")) {
+            img.setAttribute("title", alt);
+            img.setAttribute("data-accessify-title", "auto");
+          }
+          addInfoBadge(img, alt.trim());
+        }
+      }
+    }
+    if (img.complete && img.naturalWidth > 0) addIfValid();
+    else img.addEventListener("load", addIfValid, { once: true });
+  }
+  function activate() {
+    if (enabled) return;
+    enabled = true;
+    document.querySelectorAll('img[data-accessify-alt="auto"]').forEach((img) => {
+      if (img.closest("#accessify-root")) return;
+      if (!processedImages.has(img)) {
+        processedImages.set(img, { generatedAlt: img.getAttribute("alt") || "" });
+        missingAltImages.push(img);
+      }
+    });
+    const missing = scanForMissingAlt();
+    for (const img of missing) {
+      if (!missingAltImages.includes(img)) {
+        missingAltImages.push(img);
+      }
+    }
+    generateAll();
+    generateBgAlts();
+    applyTitlesToAllImages();
+    addBadgesToAllImages();
+    document.querySelectorAll("img").forEach((img) => {
+      if (!img.complete) tryRegisterImage(img);
+    });
+    for (const delay of [2e3, 5e3, 1e4]) {
+      setTimeout(() => {
+        if (enabled) {
+          document.querySelectorAll("img").forEach(tryRegisterImage);
+          applyTitlesToAllImages();
+          addBadgesToAllImages();
+        }
+      }, delay);
+    }
+    domObserver = new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        for (const node of m.addedNodes) {
+          if (node instanceof HTMLImageElement) tryRegisterImage(node);
+          else if (node instanceof HTMLElement) {
+            node.querySelectorAll("img").forEach(tryRegisterImage);
+          }
+        }
+      }
+    });
+    domObserver.observe(document.body, { childList: true, subtree: true });
+  }
+  function deactivate() {
+    enabled = false;
+    autoGenerating = false;
+    domObserver?.disconnect();
+    domObserver = null;
+    removeTitles();
+    missingAltImages = [];
+  }
+  autoApplyCachedAltTexts({ siteKey, proxyUrl, lang: initialLang }).catch(() => {
+  });
+  return {
+    id: "alt-text",
+    name: () => isDE() ? "Bildbeschreibung" : "Image Description",
+    description: isDE() ? "Bildbeschreibungen per Hover anzeigen und fehlende automatisch erzeugen" : "Show image descriptions on hover and auto-generate missing ones",
+    icon: "alt-text",
+    category: "ai",
+    activate,
+    deactivate,
+    getState: () => ({
+      id: "alt-text",
+      enabled,
+      value: {
+        missingCount: missingAltImages.filter((img) => !processedImages.has(img)).length,
+        processedCount: processedImages.size
+      }
+    })
+  };
+}
+export {
+  autoApplyCachedAltTexts,
+  createAltTextModule as default
+};
+//# sourceMappingURL=alt-text-CoS2ISqs.js.map