@freshjuice/zest 0.1.0

package/dist/zest.de.js

@@ -0,0 +1,2621 @@
+var Zest = (function () {
+  'use strict';
+
+  /**
+   * Pattern Matcher - Categorizes cookies and storage keys by pattern
+   */
+
+  /**
+   * Default patterns for each category
+   */
+  const DEFAULT_PATTERNS = {
+    essential: [
+      /^zest_/,
+      /^csrf/i,
+      /^xsrf/i,
+      /^session/i,
+      /^__host-/i,
+      /^__secure-/i
+    ],
+    functional: [
+      /^lang/i,
+      /^locale/i,
+      /^theme/i,
+      /^preferences/i,
+      /^ui_/i
+    ],
+    analytics: [
+      /^_ga/,
+      /^_gid/,
+      /^_gat/,
+      /^_utm/,
+      /^__utm/,
+      /^plausible/i,
+      /^_pk_/,
+      /^matomo/i,
+      /^_hj/,
+      /^ajs_/
+    ],
+    marketing: [
+      /^_fbp/,
+      /^_fbc/,
+      /^_gcl/,
+      /^_ttp/,
+      /^ads/i,
+      /^doubleclick/i,
+      /^__gads/,
+      /^__gpi/,
+      /^_pin_/,
+      /^li_/
+    ]
+  };
+
+  let patterns = { ...DEFAULT_PATTERNS };
+
+  /**
+   * Set custom patterns
+   */
+  function setPatterns(customPatterns) {
+    patterns = { ...DEFAULT_PATTERNS };
+    for (const [category, regexList] of Object.entries(customPatterns)) {
+      if (Array.isArray(regexList)) {
+        patterns[category] = regexList.map(p =>
+          p instanceof RegExp ? p : new RegExp(p)
+        );
+      }
+    }
+  }
+
+  /**
+   * Determine category for a cookie/storage key name
+   * @param {string} name - Cookie or storage key name
+   * @returns {string} Category ID (defaults to 'marketing' for unknown)
+   */
+  function getCategoryForName(name) {
+    for (const [category, regexList] of Object.entries(patterns)) {
+      if (regexList.some(regex => regex.test(name))) {
+        return category;
+      }
+    }
+    // Unknown items default to marketing (strictest)
+    return 'marketing';
+  }
+
+  /**
+   * Parse cookie string to extract name
+   * @param {string} cookieString - Full cookie string (e.g., "name=value; path=/")
+   * @returns {string|null} Cookie name or null
+   */
+  function parseCookieName(cookieString) {
+    const match = cookieString.match(/^([^=]+)/);
+    return match ? match[1].trim() : null;
+  }
+
+  /**
+   * Cookie Interceptor - Intercepts document.cookie operations
+   */
+
+
+  // Store original descriptor
+  let originalCookieDescriptor = null;
+
+  // Queue for blocked cookies
+  const cookieQueue = [];
+
+  // Reference to consent checker function
+  let checkConsent$3 = () => false;
+
+  /**
+   * Set the consent checker function
+   */
+  function setConsentChecker$2(fn) {
+    checkConsent$3 = fn;
+  }
+
+  /**
+   * Get the original cookie descriptor
+   */
+  function getOriginalCookieDescriptor() {
+    return originalCookieDescriptor;
+  }
+
+  /**
+   * Replay queued cookies for allowed categories
+   */
+  function replayCookies(allowedCategories) {
+    const remaining = [];
+
+    for (const item of cookieQueue) {
+      if (allowedCategories.includes(item.category)) {
+        // Set the cookie using original setter
+        if (originalCookieDescriptor?.set) {
+          originalCookieDescriptor.set.call(document, item.value);
+        }
+      } else {
+        remaining.push(item);
+      }
+    }
+
+    cookieQueue.length = 0;
+    cookieQueue.push(...remaining);
+  }
+
+  /**
+   * Start intercepting cookies
+   */
+  function interceptCookies() {
+    // Store original
+    originalCookieDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
+
+    if (!originalCookieDescriptor) {
+      console.warn('[Zest] Could not get cookie descriptor');
+      return false;
+    }
+
+    Object.defineProperty(document, 'cookie', {
+      get() {
+        // Always allow reading
+        return originalCookieDescriptor.get.call(document);
+      },
+      set(value) {
+        const name = parseCookieName(value);
+        if (!name) {
+          return;
+        }
+
+        const category = getCategoryForName(name);
+
+        if (checkConsent$3(category)) {
+          // Consent given - set cookie
+          originalCookieDescriptor.set.call(document, value);
+        } else {
+          // No consent - queue for later
+          cookieQueue.push({
+            value,
+            name,
+            category,
+            timestamp: Date.now()
+          });
+        }
+      },
+      configurable: true
+    });
+
+    return true;
+  }
+
+  /**
+   * Storage Interceptor - Intercepts localStorage and sessionStorage operations
+   */
+
+
+  // Store originals
+  let originalLocalStorage = null;
+  let originalSessionStorage = null;
+
+  // Queues for blocked operations
+  const localStorageQueue = [];
+  const sessionStorageQueue = [];
+
+  // Reference to consent checker function
+  let checkConsent$2 = () => false;
+
+  /**
+   * Set the consent checker function
+   */
+  function setConsentChecker$1(fn) {
+    checkConsent$2 = fn;
+  }
+
+  /**
+   * Create a proxy for storage API
+   */
+  function createStorageProxy(storage, queue, storageName) {
+    return new Proxy(storage, {
+      get(target, prop) {
+        if (prop === 'setItem') {
+          return (key, value) => {
+            const category = getCategoryForName(key);
+
+            if (checkConsent$2(category)) {
+              target.setItem(key, value);
+            } else {
+              queue.push({
+                key,
+                value,
+                category,
+                timestamp: Date.now()
+              });
+            }
+          };
+        }
+
+        // Allow all other operations
+        const val = target[prop];
+        return typeof val === 'function' ? val.bind(target) : val;
+      }
+    });
+  }
+
+  /**
+   * Replay queued storage operations for allowed categories
+   */
+  function replayStorage(allowedCategories) {
+    // Replay localStorage
+    const remainingLocal = [];
+    for (const item of localStorageQueue) {
+      if (allowedCategories.includes(item.category)) {
+        originalLocalStorage?.setItem(item.key, item.value);
+      } else {
+        remainingLocal.push(item);
+      }
+    }
+    localStorageQueue.length = 0;
+    localStorageQueue.push(...remainingLocal);
+
+    // Replay sessionStorage
+    const remainingSession = [];
+    for (const item of sessionStorageQueue) {
+      if (allowedCategories.includes(item.category)) {
+        originalSessionStorage?.setItem(item.key, item.value);
+      } else {
+        remainingSession.push(item);
+      }
+    }
+    sessionStorageQueue.length = 0;
+    sessionStorageQueue.push(...remainingSession);
+  }
+
+  /**
+   * Start intercepting storage APIs
+   */
+  function interceptStorage() {
+    try {
+      originalLocalStorage = window.localStorage;
+      originalSessionStorage = window.sessionStorage;
+
+      Object.defineProperty(window, 'localStorage', {
+        value: createStorageProxy(originalLocalStorage, localStorageQueue, 'localStorage'),
+        configurable: true,
+        writable: false
+      });
+
+      Object.defineProperty(window, 'sessionStorage', {
+        value: createStorageProxy(originalSessionStorage, sessionStorageQueue, 'sessionStorage'),
+        configurable: true,
+        writable: false
+      });
+
+      return true;
+    } catch (e) {
+      console.warn('[Zest] Could not intercept storage APIs:', e);
+      return false;
+    }
+  }
+
+  /**
+   * Known Trackers - Lists of known tracking script domains by category
+   */
+
+  /**
+   * Safe mode - Major, well-known trackers only
+   */
+  const SAFE_TRACKERS = {
+    analytics: [
+      'google-analytics.com',
+      'www.google-analytics.com',
+      'analytics.google.com',
+      'googletagmanager.com',
+      'www.googletagmanager.com',
+      'plausible.io',
+      'cloudflareinsights.com',
+      'static.cloudflareinsights.com'
+    ],
+    marketing: [
+      'connect.facebook.net',
+      'www.facebook.com/tr',
+      'ads.google.com',
+      'www.googleadservices.com',
+      'googleads.g.doubleclick.net',
+      'pagead2.googlesyndication.com'
+    ]
+  };
+
+  /**
+   * Strict mode - Extended list including less common trackers
+   */
+  const STRICT_TRACKERS = {
+    analytics: [
+      ...SAFE_TRACKERS.analytics,
+      'analytics.tiktok.com',
+      'matomo.', // partial match
+      'hotjar.com',
+      'static.hotjar.com',
+      'script.hotjar.com',
+      'clarity.ms',
+      'www.clarity.ms',
+      'heapanalytics.com',
+      'cdn.heapanalytics.com',
+      'mixpanel.com',
+      'cdn.mxpnl.com',
+      'segment.com',
+      'cdn.segment.com',
+      'api.segment.io',
+      'fullstory.com',
+      'rs.fullstory.com',
+      'amplitude.com',
+      'cdn.amplitude.com',
+      'mouseflow.com',
+      'cdn.mouseflow.com',
+      'luckyorange.com',
+      'cdn.luckyorange.net',
+      'crazyegg.com',
+      'script.crazyegg.com'
+    ],
+    marketing: [
+      ...SAFE_TRACKERS.marketing,
+      'snap.licdn.com',
+      'px.ads.linkedin.com',
+      'ads.linkedin.com',
+      'analytics.twitter.com',
+      'static.ads-twitter.com',
+      't.co',
+      'analytics.tiktok.com',
+      'ads.tiktok.com',
+      'sc-static.net', // Snapchat
+      'tr.snapchat.com',
+      'ct.pinterest.com',
+      'pintrk.com',
+      's.pinimg.com',
+      'widgets.pinterest.com',
+      'bat.bing.com',
+      'ads.yahoo.com',
+      'sp.analytics.yahoo.com',
+      'amazon-adsystem.com',
+      'z-na.amazon-adsystem.com',
+      'criteo.com',
+      'static.criteo.net',
+      'dis.criteo.com',
+      'taboola.com',
+      'cdn.taboola.com',
+      'trc.taboola.com',
+      'outbrain.com',
+      'widgets.outbrain.com',
+      'adroll.com',
+      's.adroll.com'
+    ],
+    functional: [
+      'cdn.onesignal.com',
+      'onesignal.com',
+      'pusher.com',
+      'js.pusher.com',
+      'intercom.io',
+      'widget.intercom.io',
+      'js.intercomcdn.com',
+      'crisp.chat',
+      'client.crisp.chat',
+      'cdn.livechatinc.com',
+      'livechatinc.com',
+      'tawk.to',
+      'embed.tawk.to',
+      'zendesk.com',
+      'static.zdassets.com'
+    ]
+  };
+
+  /**
+   * Check if a URL matches any tracker in the list
+   */
+  function matchesTrackerList(url, trackerList) {
+    try {
+      const urlObj = new URL(url);
+      const hostname = urlObj.hostname.toLowerCase();
+      const fullUrl = url.toLowerCase();
+
+      for (const domain of trackerList) {
+        // Support partial matches (e.g., "matomo." matches "analytics.matomo.cloud")
+        if (domain.endsWith('.')) {
+          if (hostname.includes(domain.slice(0, -1))) {
+            return true;
+          }
+        } else if (hostname === domain || hostname.endsWith('.' + domain)) {
+          return true;
+        } else if (fullUrl.includes(domain)) {
+          return true;
+        }
+      }
+    } catch (e) {
+      // Invalid URL
+    }
+    return false;
+  }
+
+  /**
+   * Get category for a script URL based on tracker lists
+   */
+  function getCategoryForScript(url, mode = 'safe') {
+    const trackers = mode === 'strict' ? STRICT_TRACKERS : SAFE_TRACKERS;
+
+    for (const [category, domains] of Object.entries(trackers)) {
+      if (matchesTrackerList(url, domains)) {
+        return category;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if URL is third-party (different domain)
+   */
+  function isThirdParty(url) {
+    try {
+      const scriptHost = new URL(url).hostname;
+      const pageHost = window.location.hostname;
+
+      // Remove www. for comparison
+      const normalizeHost = (h) => h.replace(/^www\./, '');
+
+      return normalizeHost(scriptHost) !== normalizeHost(pageHost);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Script Blocker - Blocks and manages consent-gated scripts
+   *
+   * Modes:
+   * - manual: Only blocks scripts with data-consent-category attribute
+   * - safe: Manual + known major trackers (Google, Facebook, etc.)
+   * - strict: Safe + extended tracker list (Hotjar, Mixpanel, etc.)
+   * - doomsday: Block ALL third-party scripts
+   */
+
+
+  // Queue for blocked scripts
+  const scriptQueue = [];
+
+  // MutationObserver instance
+  let observer = null;
+
+  // Current blocking mode
+  let blockingMode = 'safe';
+
+  // Custom blocked domains (user-defined)
+  let customBlockedDomains = [];
+
+  // Reference to consent checker function
+  let checkConsent$1 = () => false;
+
+  /**
+   * Set the consent checker function
+   */
+  function setConsentChecker(fn) {
+    checkConsent$1 = fn;
+  }
+
+  /**
+   * Check if script URL matches custom blocked domains
+   */
+  function matchesCustomDomains(url) {
+    if (!url || customBlockedDomains.length === 0) return null;
+
+    try {
+      const hostname = new URL(url).hostname.toLowerCase();
+
+      for (const entry of customBlockedDomains) {
+        const domain = typeof entry === 'string' ? entry : entry.domain;
+        const category = typeof entry === 'string' ? 'marketing' : (entry.category || 'marketing');
+
+        if (hostname === domain || hostname.endsWith('.' + domain)) {
+          return category;
+        }
+      }
+    } catch (e) {
+      // Invalid URL
+    }
+
+    return null;
+  }
+
+  /**
+   * Determine if a script should be blocked and get its category
+   */
+  function getScriptBlockCategory(script) {
+    // 1. Check for explicit data-consent-category attribute (always respected)
+    const explicitCategory = script.getAttribute('data-consent-category');
+    if (explicitCategory) {
+      return explicitCategory;
+    }
+
+    // 2. Skip if script has data-zest-allow attribute
+    if (script.hasAttribute('data-zest-allow')) {
+      return null;
+    }
+
+    const src = script.src;
+
+    // No src = inline script, only block if explicitly tagged
+    if (!src) {
+      return null;
+    }
+
+    // 3. Check custom blocked domains
+    const customCategory = matchesCustomDomains(src);
+    if (customCategory) {
+      return customCategory;
+    }
+
+    // 4. Mode-based blocking
+    switch (blockingMode) {
+      case 'manual':
+        // Only explicit tags, already checked above
+        return null;
+
+      case 'safe':
+      case 'strict':
+        // Check against known tracker lists
+        return getCategoryForScript(src, blockingMode);
+
+      case 'doomsday':
+        // Block all third-party scripts
+        if (isThirdParty(src)) {
+          // Try to categorize, default to marketing
+          return getCategoryForScript(src, 'strict') || 'marketing';
+        }
+        return null;
+
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Block a script element
+   */
+  function blockScript(script) {
+    // Skip already processed scripts
+    if (script.hasAttribute('data-zest-processed')) {
+      return false;
+    }
+
+    const category = getScriptBlockCategory(script);
+
+    if (!category) {
+      script.setAttribute('data-zest-processed', 'allowed');
+      return false;
+    }
+
+    if (checkConsent$1(category)) {
+      // Consent already given - allow script
+      script.setAttribute('data-zest-processed', 'allowed');
+      return false;
+    }
+
+    // Store script info for later execution
+    const scriptInfo = {
+      category,
+      src: script.src,
+      inline: script.textContent,
+      type: script.type,
+      async: script.async,
+      defer: script.defer,
+      timestamp: Date.now()
+    };
+
+    // Mark as processed
+    script.setAttribute('data-zest-processed', 'blocked');
+    script.setAttribute('data-consent-category', category);
+
+    // Disable the script
+    script.type = 'text/plain';
+
+    // If it has a src, also remove it to prevent loading
+    if (script.src) {
+      script.setAttribute('data-blocked-src', script.src);
+      script.removeAttribute('src');
+    }
+
+    scriptQueue.push(scriptInfo);
+    return true;
+  }
+
+  /**
+   * Execute a queued script
+   */
+  function executeScript(scriptInfo) {
+    const script = document.createElement('script');
+
+    if (scriptInfo.src) {
+      script.src = scriptInfo.src;
+    } else if (scriptInfo.inline) {
+      script.textContent = scriptInfo.inline;
+    }
+
+    if (scriptInfo.async) script.async = true;
+    if (scriptInfo.defer) script.defer = true;
+
+    script.setAttribute('data-zest-processed', 'executed');
+    script.setAttribute('data-consent-executed', 'true');
+
+    document.head.appendChild(script);
+  }
+
+  /**
+   * Replay queued scripts for allowed categories
+   */
+  function replayScripts(allowedCategories) {
+    const remaining = [];
+
+    for (const scriptInfo of scriptQueue) {
+      if (allowedCategories.includes(scriptInfo.category)) {
+        executeScript(scriptInfo);
+      } else {
+        remaining.push(scriptInfo);
+      }
+    }
+
+    scriptQueue.length = 0;
+    scriptQueue.push(...remaining);
+
+    // Also re-enable any blocked scripts in the DOM
+    const blockedScripts = document.querySelectorAll('script[data-zest-processed="blocked"]');
+    blockedScripts.forEach(script => {
+      const category = script.getAttribute('data-consent-category');
+      if (allowedCategories.includes(category)) {
+        // Clone and replace to execute
+        const newScript = document.createElement('script');
+
+        const blockedSrc = script.getAttribute('data-blocked-src');
+        if (blockedSrc) {
+          newScript.src = blockedSrc;
+        } else {
+          newScript.textContent = script.textContent;
+        }
+
+        if (script.async) newScript.async = true;
+        if (script.defer) newScript.defer = true;
+
+        newScript.setAttribute('data-zest-processed', 'executed');
+        newScript.setAttribute('data-consent-executed', 'true');
+        script.parentNode?.replaceChild(newScript, script);
+      }
+    });
+  }
+
+  /**
+   * Process existing scripts in the DOM
+   */
+  function processExistingScripts() {
+    const scripts = document.querySelectorAll('script:not([data-zest-processed])');
+    scripts.forEach(blockScript);
+  }
+
+  /**
+   * Handle mutations (new scripts added to DOM)
+   */
+  function handleMutations(mutations) {
+    for (const mutation of mutations) {
+      for (const node of mutation.addedNodes) {
+        if (node.nodeName === 'SCRIPT' && !node.hasAttribute('data-zest-processed')) {
+          blockScript(node);
+        }
+
+        // Check child scripts
+        if (node.querySelectorAll) {
+          const scripts = node.querySelectorAll('script:not([data-zest-processed])');
+          scripts.forEach(blockScript);
+        }
+      }
+    }
+  }
+
+  /**
+   * Start observing for new scripts
+   */
+  function startScriptBlocking(mode = 'safe', customDomains = []) {
+    blockingMode = mode;
+    customBlockedDomains = customDomains;
+
+    // Process existing scripts
+    processExistingScripts();
+
+    // Watch for new scripts
+    observer = new MutationObserver(handleMutations);
+
+    observer.observe(document.documentElement, {
+      childList: true,
+      subtree: true
+    });
+
+    return true;
+  }
+
+  /**
+   * Default consent categories
+   */
+  const DEFAULT_CATEGORIES = {
+    essential: {
+      id: 'essential',
+      label: 'Essential',
+      description: 'Required for the website to function properly. Cannot be disabled.',
+      required: true,
+      default: true
+    },
+    functional: {
+      id: 'functional',
+      label: 'Functional',
+      description: 'Enable personalized features like language preferences and themes.',
+      required: false,
+      default: false
+    },
+    analytics: {
+      id: 'analytics',
+      label: 'Analytics',
+      description: 'Help us understand how visitors interact with our website.',
+      required: false,
+      default: false
+    },
+    marketing: {
+      id: 'marketing',
+      label: 'Marketing',
+      description: 'Used to deliver relevant advertisements and track campaign performance.',
+      required: false,
+      default: false
+    }
+  };
+
+  /**
+   * Default consent state
+   */
+  function getDefaultConsent() {
+    return {
+      essential: true,
+      functional: false,
+      analytics: false,
+      marketing: false
+    };
+  }
+
+  /**
+   * Get all category IDs
+   */
+  function getCategoryIds() {
+    return Object.keys(DEFAULT_CATEGORIES);
+  }
+
+  /**
+   * Do Not Track (DNT) Detection
+   *
+   * Detects browser DNT/GPC signals for privacy compliance
+   */
+
+  /**
+   * Check if Do Not Track is enabled
+   * Checks both DNT header and Global Privacy Control (GPC)
+   */
+  function isDoNotTrackEnabled() {
+    if (typeof navigator === 'undefined') {
+      return false;
+    }
+
+    // Check DNT (Do Not Track)
+    // Values: "1" = enabled, "0" = disabled, null/undefined = not set
+    const dnt = navigator.doNotTrack ||
+                window.doNotTrack ||
+                navigator.msDoNotTrack;
+
+    if (dnt === '1' || dnt === 'yes' || dnt === true) {
+      return true;
+    }
+
+    // Check GPC (Global Privacy Control) - newer standard
+    // https://globalprivacycontrol.org/
+    if (navigator.globalPrivacyControl === true) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get DNT signal details for logging/debugging
+   */
+  function getDNTDetails() {
+    if (typeof navigator === 'undefined') {
+      return { enabled: false, source: null };
+    }
+
+    const dnt = navigator.doNotTrack ||
+                window.doNotTrack ||
+                navigator.msDoNotTrack;
+
+    if (dnt === '1' || dnt === 'yes' || dnt === true) {
+      return { enabled: true, source: 'dnt' };
+    }
+
+    if (navigator.globalPrivacyControl === true) {
+      return { enabled: true, source: 'gpc' };
+    }
+
+    return { enabled: false, source: null };
+  }
+
+  /**
+   * DE only translation - auto-generated
+   * Do not edit manually, run: npm run build
+   */
+  const translations = {
+    de: {
+        "labels": {
+            "banner": {
+                "title": "Wir respektieren Ihre Privatsphäre",
+                "description": "Wir verwenden Cookies, um Ihr Surferlebnis zu verbessern, personalisierte Inhalte bereitzustellen und unseren Datenverkehr zu analysieren. Mit einem Klick auf „Alle akzeptieren\" stimmen Sie der Verwendung von Cookies zu.",
+                "acceptAll": "Alle akzeptieren",
+                "rejectAll": "Alle ablehnen",
+                "settings": "Einstellungen"
+            },
+            "modal": {
+                "title": "Datenschutzeinstellungen",
+                "description": "Verwalten Sie Ihre Cookie-Einstellungen. Sie können verschiedene Arten von Cookies unten aktivieren oder deaktivieren.",
+                "save": "Einstellungen speichern",
+                "acceptAll": "Alle akzeptieren",
+                "rejectAll": "Alle ablehnen"
+            },
+            "widget": {
+                "label": "Cookie-Einstellungen"
+            }
+        },
+        "categories": {
+            "essential": {
+                "label": "Notwendig",
+                "description": "Erforderlich für die ordnungsgemäße Funktion der Website. Können nicht deaktiviert werden."
+            },
+            "functional": {
+                "label": "Funktional",
+                "description": "Ermöglichen personalisierte Funktionen wie Spracheinstellungen und Designs."
+            },
+            "analytics": {
+                "label": "Analytisch",
+                "description": "Helfen uns zu verstehen, wie Besucher mit unserer Website interagieren."
+            },
+            "marketing": {
+                "label": "Marketing",
+                "description": "Werden verwendet, um relevante Werbung anzuzeigen und die Kampagnenleistung zu messen."
+            }
+        }
+    }
+  };
+
+  function detectLanguage() {
+    return 'de';
+  }
+
+  function getTranslation() {
+    return translations.de;
+  }
+
+  /**
+   * Default configuration values
+   */
+
+
+  const DEFAULTS = {
+    // Language: 'auto' | 'en' | 'de' | 'es' | 'fr' | 'it' | 'pt' | 'nl' | 'pl' | 'uk' | 'ru' | 'ja' | 'zh'
+    lang: 'auto',
+
+    // UI positioning
+    position: 'bottom', // 'bottom' | 'bottom-left' | 'bottom-right' | 'top'
+
+    // Theming
+    theme: 'auto', // 'light' | 'dark' | 'auto'
+    accentColor: '#0071e3',
+
+    // Categories
+    categories: DEFAULT_CATEGORIES,
+
+    // UI Labels
+    labels: {
+      banner: {
+        title: 'We value your privacy',
+        description: 'We use cookies to enhance your browsing experience, serve personalized content, and analyze our traffic. By clicking "Accept All", you consent to our use of cookies.',
+        acceptAll: 'Accept All',
+        rejectAll: 'Reject All',
+        settings: 'Settings'
+      },
+      modal: {
+        title: 'Privacy Settings',
+        description: 'Manage your cookie preferences. You can enable or disable different types of cookies below.',
+        save: 'Save Preferences',
+        acceptAll: 'Accept All',
+        rejectAll: 'Reject All'
+      },
+      widget: {
+        label: 'Cookie Settings'
+      }
+    },
+
+    // Behavior
+    autoInit: true,
+    showWidget: true,
+    expiration: 365,
+
+    // Do Not Track / Global Privacy Control
+    // respectDNT: true = respect DNT/GPC signals
+    // dntBehavior: 'reject' | 'preselect' | 'ignore'
+    //   - 'reject': auto-reject non-essential, don't show banner
+    //   - 'preselect': show banner with non-essential unchecked (same as normal)
+    //   - 'ignore': ignore DNT completely
+    respectDNT: true,
+    dntBehavior: 'reject',
+
+    // Custom styles to inject into Shadow DOM
+    customStyles: '',
+
+    // Blocking mode: 'manual' | 'safe' | 'strict' | 'doomsday'
+    mode: 'safe',
+
+    // Custom domains to block (in addition to mode-based blocking)
+    blockedDomains: [], // days
+
+    // Links
+    policyUrl: null,
+    imprintUrl: null,
+
+    // Callbacks
+    callbacks: {
+      onAccept: null,
+      onReject: null,
+      onChange: null,
+      onReady: null
+    }
+  };
+
+  /**
+   * Merge user config with defaults (deep merge)
+   */
+  function mergeConfig(userConfig) {
+    const config = { ...DEFAULTS };
+
+    if (!userConfig) {
+      userConfig = {};
+    }
+
+    // Simple properties
+    const simpleKeys = ['lang', 'position', 'theme', 'accentColor', 'autoInit', 'showWidget', 'expiration', 'policyUrl', 'imprintUrl', 'customStyles', 'mode', 'blockedDomains', 'respectDNT', 'dntBehavior'];
+    for (const key of simpleKeys) {
+      if (userConfig[key] !== undefined) {
+        config[key] = userConfig[key];
+      }
+    }
+
+    // Detect language and get translations
+    const detectedLang = detectLanguage(config.lang);
+    config.lang = detectedLang;
+    const translation = getTranslation();
+
+    // Deep merge labels (translation < user config)
+    const translationLabels = translation.labels || {};
+    const userLabels = userConfig.labels || {};
+    config.labels = {
+      banner: {
+        ...DEFAULTS.labels.banner,
+        ...translationLabels.banner,
+        ...userLabels.banner
+      },
+      modal: {
+        ...DEFAULTS.labels.modal,
+        ...translationLabels.modal,
+        ...userLabels.modal
+      },
+      widget: {
+        ...DEFAULTS.labels.widget,
+        ...translationLabels.widget,
+        ...userLabels.widget
+      }
+    };
+
+    // Deep merge categories (translation < user config)
+    const translationCategories = translation.categories || {};
+    const userCategories = userConfig.categories || {};
+    config.categories = { ...DEFAULTS.categories };
+    for (const key of Object.keys(DEFAULTS.categories)) {
+      config.categories[key] = {
+        ...DEFAULTS.categories[key],
+        ...translationCategories[key],
+        ...userCategories[key]
+      };
+    }
+
+    // Merge callbacks
+    if (userConfig.callbacks) {
+      config.callbacks = { ...DEFAULTS.callbacks, ...userConfig.callbacks };
+    }
+
+    // Patterns (for pattern matcher)
+    if (userConfig.patterns) {
+      config.patterns = userConfig.patterns;
+    }
+
+    return config;
+  }
+
+  /**
+   * Configuration Parser - Reads config from various sources
+   */
+
+
+  /**
+   * Parse data attributes from script tag
+   */
+  function parseDataAttributes() {
+    // Find the Zest script tag
+    const script = document.currentScript ||
+      document.querySelector('script[data-zest]') ||
+      document.querySelector('script[src*="zest"]');
+
+    if (!script) {
+      return {};
+    }
+
+    const config = {};
+
+    // Position
+    const position = script.getAttribute('data-position');
+    if (position) config.position = position;
+
+    // Theme
+    const theme = script.getAttribute('data-theme');
+    if (theme) config.theme = theme;
+
+    // Accent color
+    const accent = script.getAttribute('data-accent') || script.getAttribute('data-accent-color');
+    if (accent) config.accentColor = accent;
+
+    // Policy URL
+    const policyUrl = script.getAttribute('data-policy-url') || script.getAttribute('data-privacy-url');
+    if (policyUrl) config.policyUrl = policyUrl;
+
+    // Imprint URL
+    const imprintUrl = script.getAttribute('data-imprint-url');
+    if (imprintUrl) config.imprintUrl = imprintUrl;
+
+    // Show widget
+    const showWidget = script.getAttribute('data-show-widget');
+    if (showWidget !== null) config.showWidget = showWidget !== 'false';
+
+    // Auto init
+    const autoInit = script.getAttribute('data-auto-init');
+    if (autoInit !== null) config.autoInit = autoInit !== 'false';
+
+    // Expiration
+    const expiration = script.getAttribute('data-expiration');
+    if (expiration) config.expiration = parseInt(expiration, 10);
+
+    return config;
+  }
+
+  /**
+   * Parse window.ZestConfig object
+   */
+  function parseWindowConfig() {
+    if (typeof window !== 'undefined' && window.ZestConfig) {
+      return window.ZestConfig;
+    }
+    return {};
+  }
+
+  /**
+   * Get final merged configuration
+   * Priority: data attributes > window.ZestConfig > defaults
+   */
+  function getConfig() {
+    const windowConfig = parseWindowConfig();
+    const dataConfig = parseDataAttributes();
+
+    // Merge: defaults < windowConfig < dataConfig
+    return mergeConfig({
+      ...windowConfig,
+      ...dataConfig
+    });
+  }
+
+  /**
+   * Update configuration at runtime
+   */
+  let currentConfig = null;
+
+  function setConfig(config) {
+    currentConfig = mergeConfig(config);
+    return currentConfig;
+  }
+
+  function getCurrentConfig() {
+    if (!currentConfig) {
+      currentConfig = getConfig();
+    }
+    return currentConfig;
+  }
+
+  /**
+   * Consent Store - Manages consent state persistence
+   */
+
+
+  const COOKIE_NAME = 'zest_consent';
+  const CONSENT_VERSION = '1.0';
+
+  // Current consent state
+  let consent = null;
+
+  /**
+   * Get the original cookie setter (bypasses interception)
+   */
+  function setRawCookie(value) {
+    const descriptor = getOriginalCookieDescriptor();
+    if (descriptor?.set) {
+      descriptor.set.call(document, value);
+    } else {
+      // Fallback if interceptor not initialized yet
+      document.cookie = value;
+    }
+  }
+
+  /**
+   * Get the original cookie getter
+   */
+  function getRawCookie() {
+    const descriptor = getOriginalCookieDescriptor();
+    if (descriptor?.get) {
+      return descriptor.get.call(document);
+    }
+    return document.cookie;
+  }
+
+  /**
+   * Load consent from cookie
+   */
+  function loadConsent() {
+    try {
+      const cookies = getRawCookie();
+      const match = cookies.match(new RegExp(`${COOKIE_NAME}=([^;]+)`));
+
+      if (match) {
+        const data = JSON.parse(decodeURIComponent(match[1]));
+        consent = data.categories || getDefaultConsent();
+        return { ...consent };
+      }
+    } catch (e) {
+      // Invalid or missing cookie
+    }
+
+    consent = getDefaultConsent();
+    return { ...consent };
+  }
+
+  /**
+   * Save consent to cookie
+   */
+  function saveConsent(expirationDays = 365) {
+    if (!consent) {
+      consent = getDefaultConsent();
+    }
+
+    const data = {
+      version: CONSENT_VERSION,
+      timestamp: Date.now(),
+      categories: consent
+    };
+
+    const expires = new Date(Date.now() + expirationDays * 24 * 60 * 60 * 1000).toUTCString();
+    const cookieValue = `${COOKIE_NAME}=${encodeURIComponent(JSON.stringify(data))}; expires=${expires}; path=/; SameSite=Lax`;
+
+    setRawCookie(cookieValue);
+  }
+
+  /**
+   * Get current consent state
+   */
+  function getConsent() {
+    if (!consent) {
+      consent = loadConsent();
+    }
+    return { ...consent };
+  }
+
+  /**
+   * Update consent state
+   */
+  function updateConsent(newConsent, expirationDays = 365) {
+    const previous = consent ? { ...consent } : getDefaultConsent();
+
+    consent = {
+      essential: true, // Always true
+      functional: !!newConsent.functional,
+      analytics: !!newConsent.analytics,
+      marketing: !!newConsent.marketing
+    };
+
+    saveConsent(expirationDays);
+
+    return { current: { ...consent }, previous };
+  }
+
+  /**
+   * Check if specific category is allowed
+   */
+  function hasConsent(category) {
+    if (!consent) {
+      consent = loadConsent();
+    }
+    return consent[category] === true;
+  }
+
+  /**
+   * Accept all categories
+   */
+  function acceptAll(expirationDays = 365) {
+    return updateConsent({
+      functional: true,
+      analytics: true,
+      marketing: true
+    }, expirationDays);
+  }
+
+  /**
+   * Reject all (except essential)
+   */
+  function rejectAll(expirationDays = 365) {
+    return updateConsent({
+      functional: false,
+      analytics: false,
+      marketing: false
+    }, expirationDays);
+  }
+
+  /**
+   * Reset consent (clear cookie)
+   */
+  function resetConsent() {
+    setRawCookie(`${COOKIE_NAME}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`);
+    consent = null;
+  }
+
+  /**
+   * Check if consent has been given (any decision made)
+   */
+  function hasConsentDecision() {
+    try {
+      const cookies = getRawCookie();
+      return cookies.includes(COOKIE_NAME);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Get consent proof for compliance
+   */
+  function getConsentProof() {
+    try {
+      const cookies = getRawCookie();
+      const match = cookies.match(new RegExp(`${COOKIE_NAME}=([^;]+)`));
+
+      if (match) {
+        return JSON.parse(decodeURIComponent(match[1]));
+      }
+    } catch (e) {
+      // Invalid cookie
+    }
+
+    return null;
+  }
+
+  /**
+   * Events - Custom event dispatching for consent changes
+   */
+
+  // Event names
+  const EVENTS = {
+    READY: 'zest:ready',
+    CONSENT: 'zest:consent',
+    REJECT: 'zest:reject',
+    CHANGE: 'zest:change',
+    SHOW: 'zest:show',
+    HIDE: 'zest:hide'
+  };
+
+  /**
+   * Dispatch a custom event
+   */
+  function emit(eventName, detail = {}) {
+    const event = new CustomEvent(eventName, {
+      detail,
+      bubbles: true,
+      cancelable: true
+    });
+
+    document.dispatchEvent(event);
+    return event;
+  }
+
+  /**
+   * Emit ready event
+   */
+  function emitReady(consent) {
+    return emit(EVENTS.READY, { consent });
+  }
+
+  /**
+   * Emit consent event (user accepted)
+   */
+  function emitConsent(consent, previous) {
+    return emit(EVENTS.CONSENT, { consent, previous });
+  }
+
+  /**
+   * Emit reject event (user rejected all)
+   */
+  function emitReject(consent) {
+    return emit(EVENTS.REJECT, { consent });
+  }
+
+  /**
+   * Emit change event (any consent change)
+   */
+  function emitChange(consent, previous) {
+    return emit(EVENTS.CHANGE, { consent, previous });
+  }
+
+  /**
+   * Emit show event (banner/modal shown)
+   */
+  function emitShow(type = 'banner') {
+    return emit(EVENTS.SHOW, { type });
+  }
+
+  /**
+   * Emit hide event (banner/modal hidden)
+   */
+  function emitHide(type = 'banner') {
+    return emit(EVENTS.HIDE, { type });
+  }
+
+  /**
+   * Styles - Shadow DOM encapsulated CSS with theming
+   */
+
+  /**
+   * Generate CSS with custom properties
+   */
+  function generateStyles(config) {
+    const accentColor = config.accentColor || '#4F46E5';
+
+    return `
+:host {
+  --zest-accent: ${accentColor};
+  --zest-accent-hover: ${adjustColor(accentColor, -15)};
+  --zest-bg: #ffffff;
+  --zest-bg-secondary: #f3f4f6;
+  --zest-text: #1f2937;
+  --zest-text-secondary: #6b7280;
+  --zest-border: #e5e7eb;
+  --zest-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1);
+  --zest-radius: 12px;
+  --zest-radius-sm: 8px;
+  --zest-font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+
+  font-family: var(--zest-font);
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--zest-text);
+  box-sizing: border-box;
+}
+
+:host([data-theme="dark"]) {
+  --zest-bg: #1f2937;
+  --zest-bg-secondary: #374151;
+  --zest-text: #f9fafb;
+  --zest-text-secondary: #9ca3af;
+  --zest-border: #4b5563;
+  --zest-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.4), 0 8px 10px -6px rgba(0, 0, 0, 0.3);
+}
+
+@media (prefers-color-scheme: dark) {
+  :host([data-theme="auto"]) {
+    --zest-bg: #1f2937;
+    --zest-bg-secondary: #374151;
+    --zest-text: #f9fafb;
+    --zest-text-secondary: #9ca3af;
+    --zest-border: #4b5563;
+    --zest-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.4), 0 8px 10px -6px rgba(0, 0, 0, 0.3);
+  }
+}
+
+*, *::before, *::after {
+  box-sizing: border-box;
+}
+
+/* Banner */
+.zest-banner {
+  position: fixed;
+  z-index: 999999;
+  max-width: 480px;
+  padding: 20px;
+  background: var(--zest-bg);
+  border-radius: var(--zest-radius);
+  box-shadow: var(--zest-shadow);
+  animation: zest-slide-in 0.3s ease-out;
+}
+
+.zest-banner--bottom {
+  bottom: 20px;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+.zest-banner--bottom-left {
+  bottom: 20px;
+  left: 20px;
+}
+
+.zest-banner--bottom-right {
+  bottom: 20px;
+  right: 20px;
+}
+
+.zest-banner--top {
+  top: 20px;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+@keyframes zest-slide-in {
+  from {
+    opacity: 0;
+    transform: translateX(-50%) translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(-50%) translateY(0);
+  }
+}
+
+.zest-banner--bottom-left {
+  animation-name: zest-slide-in-left;
+}
+
+@keyframes zest-slide-in-left {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.zest-banner--bottom-right {
+  animation-name: zest-slide-in-right;
+}
+
+@keyframes zest-slide-in-right {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .zest-banner,
+  .zest-modal {
+    animation: none;
+  }
+}
+
+.zest-banner__title {
+  margin: 0 0 8px 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--zest-text);
+}
+
+.zest-banner__description {
+  margin: 0 0 16px 0;
+  font-size: 14px;
+  color: var(--zest-text-secondary);
+}
+
+.zest-banner__buttons {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+/* Buttons */
+.zest-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 10px 16px;
+  font-size: 14px;
+  font-weight: 500;
+  font-family: inherit;
+  border: none;
+  border-radius: var(--zest-radius-sm);
+  cursor: pointer;
+  transition: background-color 0.15s ease, transform 0.1s ease;
+}
+
+.zest-btn:hover {
+  transform: translateY(-1px);
+}
+
+.zest-btn:active {
+  transform: translateY(0);
+}
+
+.zest-btn:focus-visible {
+  outline: 2px solid var(--zest-accent);
+  outline-offset: 2px;
+}
+
+.zest-btn--primary {
+  background: var(--zest-accent);
+  color: #ffffff;
+}
+
+.zest-btn--primary:hover {
+  background: var(--zest-accent-hover);
+}
+
+.zest-btn--secondary {
+  background: var(--zest-bg-secondary);
+  color: var(--zest-text);
+}
+
+.zest-btn--secondary:hover {
+  background: var(--zest-border);
+}
+
+.zest-btn--ghost {
+  background: transparent;
+  color: var(--zest-text-secondary);
+}
+
+.zest-btn--ghost:hover {
+  background: var(--zest-bg-secondary);
+  color: var(--zest-text);
+}
+
+/* Modal */
+.zest-modal-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 999998;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 20px;
+  background: rgba(0, 0, 0, 0.5);
+  animation: zest-fade-in 0.2s ease-out;
+}
+
+@keyframes zest-fade-in {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+.zest-modal {
+  width: 100%;
+  max-width: 500px;
+  max-height: 90vh;
+  overflow-y: auto;
+  background: var(--zest-bg);
+  border-radius: var(--zest-radius);
+  box-shadow: var(--zest-shadow);
+  animation: zest-modal-in 0.3s ease-out;
+}
+
+@keyframes zest-modal-in {
+  from {
+    opacity: 0;
+    transform: scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+.zest-modal__header {
+  padding: 20px 20px 0;
+}
+
+.zest-modal__title {
+  margin: 0 0 8px 0;
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--zest-text);
+}
+
+.zest-modal__description {
+  margin: 0;
+  font-size: 14px;
+  color: var(--zest-text-secondary);
+}
+
+.zest-modal__body {
+  padding: 20px;
+}
+
+.zest-modal__footer {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 0 20px 20px;
+}
+
+/* Categories */
+.zest-category {
+  padding: 16px;
+  margin-bottom: 12px;
+  background: var(--zest-bg-secondary);
+  border-radius: var(--zest-radius-sm);
+}
+
+.zest-category:last-child {
+  margin-bottom: 0;
+}
+
+.zest-category__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.zest-category__info {
+  flex: 1;
+}
+
+.zest-category__label {
+  display: block;
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--zest-text);
+}
+
+.zest-category__description {
+  margin: 4px 0 0;
+  font-size: 13px;
+  color: var(--zest-text-secondary);
+}
+
+/* Toggle Switch */
+.zest-toggle {
+  position: relative;
+  width: 44px;
+  height: 24px;
+  flex-shrink: 0;
+}
+
+.zest-toggle__input {
+  position: absolute;
+  opacity: 0;
+  width: 100%;
+  height: 100%;
+  cursor: pointer;
+  margin: 0;
+}
+
+.zest-toggle__input:disabled {
+  cursor: not-allowed;
+}
+
+.zest-toggle__slider {
+  position: absolute;
+  inset: 0;
+  background: var(--zest-border);
+  border-radius: 12px;
+  transition: background-color 0.2s ease;
+  pointer-events: none;
+}
+
+.zest-toggle__slider::before {
+  content: '';
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 20px;
+  height: 20px;
+  background: #ffffff;
+  border-radius: 50%;
+  transition: transform 0.2s ease;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
+}
+
+.zest-toggle__input:checked + .zest-toggle__slider {
+  background: var(--zest-accent);
+}
+
+.zest-toggle__input:checked + .zest-toggle__slider::before {
+  transform: translateX(20px);
+}
+
+.zest-toggle__input:focus-visible + .zest-toggle__slider {
+  outline: 2px solid var(--zest-accent);
+  outline-offset: 2px;
+}
+
+.zest-toggle__input:disabled + .zest-toggle__slider {
+  opacity: 0.6;
+}
+
+/* Widget */
+.zest-widget {
+  position: fixed;
+  z-index: 999997;
+  bottom: 20px;
+  left: 20px;
+}
+
+.zest-widget__btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 48px;
+  height: 48px;
+  padding: 0;
+  background: var(--zest-bg);
+  border: 1px solid var(--zest-border);
+  border-radius: 50%;
+  box-shadow: var(--zest-shadow);
+  cursor: pointer;
+  transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+
+.zest-widget__btn:hover {
+  transform: scale(1.05);
+  box-shadow: 0 12px 28px -5px rgba(0, 0, 0, 0.15);
+}
+
+.zest-widget__btn:focus-visible {
+  outline: 2px solid var(--zest-accent);
+  outline-offset: 2px;
+}
+
+.zest-widget__icon {
+  width: 24px;
+  height: 24px;
+  fill: var(--zest-text);
+}
+
+/* Link */
+.zest-link {
+  color: var(--zest-accent);
+  text-decoration: none;
+}
+
+.zest-link:hover {
+  text-decoration: underline;
+}
+
+/* Mobile */
+@media (max-width: 480px) {
+  .zest-banner {
+    left: 10px;
+    right: 10px;
+    max-width: none;
+    transform: none;
+  }
+
+  .zest-banner--bottom,
+  .zest-banner--bottom-left,
+  .zest-banner--bottom-right {
+    bottom: 10px;
+  }
+
+  .zest-banner--top {
+    top: 10px;
+    transform: none;
+  }
+
+  @keyframes zest-slide-in {
+    from {
+      opacity: 0;
+      transform: translateY(20px);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0);
+    }
+  }
+
+  .zest-banner__buttons {
+    flex-direction: column;
+  }
+
+  .zest-btn {
+    width: 100%;
+  }
+
+  .zest-modal-overlay {
+    padding: 10px;
+  }
+
+  .zest-widget {
+    bottom: 10px;
+    left: 10px;
+  }
+}
+
+/* Hidden utility */
+.zest-hidden {
+  display: none !important;
+}
+${config.customStyles || ''}
+`;
+  }
+
+  /**
+   * Adjust color brightness
+   */
+  function adjustColor(hex, percent) {
+    const num = parseInt(hex.replace('#', ''), 16);
+    const amt = Math.round(2.55 * percent);
+    const R = Math.min(255, Math.max(0, (num >> 16) + amt));
+    const G = Math.min(255, Math.max(0, ((num >> 8) & 0x00ff) + amt));
+    const B = Math.min(255, Math.max(0, (num & 0x0000ff) + amt));
+    return '#' + (0x1000000 + R * 0x10000 + G * 0x100 + B).toString(16).slice(1);
+  }
+
+  /**
+   * Cookie icon SVG
+   */
+  const COOKIE_ICON = `<svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12 2C6.477 2 2 6.477 2 12s4.477 10 10 10 10-4.477 10-10c0-.728-.078-1.437-.225-2.12a1 1 0 0 0-1.482-.63 3 3 0 0 1-4.086-3.72 1 1 0 0 0-.793-1.263A10.05 10.05 0 0 0 12 2zm0 2c.178 0 .354.006.528.017a5 5 0 0 0 5.955 5.955c.011.174.017.35.017.528 0 4.418-3.582 8-8 8s-8-3.582-8-8 3.582-8 8-8zm-4 6a1.5 1.5 0 1 0 0 3 1.5 1.5 0 0 0 0-3zm5 0a1 1 0 1 0 0 2 1 1 0 0 0 0-2zm-2 4a1.5 1.5 0 1 0 0 3 1.5 1.5 0 0 0 0-3z"/></svg>`;
+
+  /**
+   * Banner - Main consent banner component
+   */
+
+
+  let bannerElement = null;
+  let shadowRoot$2 = null;
+
+  /**
+   * Create the banner HTML
+   */
+  function createBannerHTML(config) {
+    const labels = config.labels.banner;
+    const position = config.position || 'bottom';
+
+    return `
+    <div class="zest-banner zest-banner--${position}" role="dialog" aria-modal="false" aria-label="${labels.title}">
+      <h2 class="zest-banner__title">${labels.title}</h2>
+      <p class="zest-banner__description">${labels.description}</p>
+      <div class="zest-banner__buttons">
+        <button type="button" class="zest-btn zest-btn--primary" data-action="accept-all">
+          ${labels.acceptAll}
+        </button>
+        <button type="button" class="zest-btn zest-btn--secondary" data-action="reject-all">
+          ${labels.rejectAll}
+        </button>
+        <button type="button" class="zest-btn zest-btn--ghost" data-action="settings">
+          ${labels.settings}
+        </button>
+      </div>
+    </div>
+  `;
+  }
+
+  /**
+   * Create and mount the banner
+   */
+  function createBanner(callbacks = {}) {
+    if (bannerElement) {
+      return bannerElement;
+    }
+
+    const config = getCurrentConfig();
+
+    // Create host element
+    bannerElement = document.createElement('zest-banner');
+    bannerElement.setAttribute('data-theme', config.theme || 'light');
+
+    // Create shadow root
+    shadowRoot$2 = bannerElement.attachShadow({ mode: 'open' });
+
+    // Add styles
+    const styleEl = document.createElement('style');
+    styleEl.textContent = generateStyles(config);
+    shadowRoot$2.appendChild(styleEl);
+
+    // Add banner HTML
+    const container = document.createElement('div');
+    container.innerHTML = createBannerHTML(config);
+    shadowRoot$2.appendChild(container.firstElementChild);
+
+    // Add event listeners
+    const banner = shadowRoot$2.querySelector('.zest-banner');
+
+    banner.addEventListener('click', (e) => {
+      const action = e.target.dataset.action;
+      if (!action) return;
+
+      switch (action) {
+        case 'accept-all':
+          callbacks.onAcceptAll?.();
+          break;
+        case 'reject-all':
+          callbacks.onRejectAll?.();
+          break;
+        case 'settings':
+          callbacks.onSettings?.();
+          break;
+      }
+    });
+
+    // Keyboard handling
+    banner.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') {
+        callbacks.onSettings?.();
+      }
+    });
+
+    // Mount to document
+    document.body.appendChild(bannerElement);
+
+    // Focus first button for accessibility
+    requestAnimationFrame(() => {
+      const firstButton = shadowRoot$2.querySelector('button');
+      firstButton?.focus();
+    });
+
+    return bannerElement;
+  }
+
+  /**
+   * Show the banner
+   */
+  function showBanner(callbacks = {}) {
+    if (!bannerElement) {
+      createBanner(callbacks);
+    } else {
+      bannerElement.classList.remove('zest-hidden');
+    }
+  }
+
+  /**
+   * Hide the banner
+   */
+  function hideBanner() {
+    if (bannerElement) {
+      bannerElement.remove();
+      bannerElement = null;
+      shadowRoot$2 = null;
+    }
+  }
+
+  /**
+   * Modal - Settings modal component for category toggles
+   */
+
+
+  let modalElement = null;
+  let shadowRoot$1 = null;
+  let currentSelections = {};
+
+  /**
+   * Create category toggle HTML
+   */
+  function createCategoryHTML(category, isChecked, isRequired) {
+    const disabled = isRequired ? 'disabled' : '';
+    const checked = isChecked ? 'checked' : '';
+
+    return `
+    <div class="zest-category">
+      <div class="zest-category__header">
+        <div class="zest-category__info">
+          <span class="zest-category__label">${category.label}</span>
+          <p class="zest-category__description">${category.description}</p>
+        </div>
+        <label class="zest-toggle">
+          <input
+            type="checkbox"
+            class="zest-toggle__input"
+            data-category="${category.id}"
+            ${checked}
+            ${disabled}
+            aria-label="${category.label}"
+          >
+          <span class="zest-toggle__slider"></span>
+        </label>
+      </div>
+    </div>
+  `;
+  }
+
+  /**
+   * Create the modal HTML
+   */
+  function createModalHTML(config, consent) {
+    const labels = config.labels.modal;
+    const categories = config.categories || DEFAULT_CATEGORIES;
+
+    const categoriesHTML = Object.values(categories)
+      .map(cat => createCategoryHTML(
+        cat,
+        consent[cat.id] ?? cat.default,
+        cat.required
+      ))
+      .join('');
+
+    const policyLink = config.policyUrl
+      ? `<a href="${config.policyUrl}" class="zest-link" target="_blank" rel="noopener">Privacy Policy</a>`
+      : '';
+
+    return `
+    <div class="zest-modal-overlay" role="dialog" aria-modal="true" aria-label="${labels.title}">
+      <div class="zest-modal">
+        <div class="zest-modal__header">
+          <h2 class="zest-modal__title">${labels.title}</h2>
+          <p class="zest-modal__description">${labels.description} ${policyLink}</p>
+        </div>
+        <div class="zest-modal__body">
+          ${categoriesHTML}
+        </div>
+        <div class="zest-modal__footer">
+          <button type="button" class="zest-btn zest-btn--primary" data-action="save">
+            ${labels.save}
+          </button>
+          <button type="button" class="zest-btn zest-btn--secondary" data-action="accept-all">
+            ${labels.acceptAll}
+          </button>
+          <button type="button" class="zest-btn zest-btn--ghost" data-action="reject-all">
+            ${labels.rejectAll}
+          </button>
+        </div>
+      </div>
+    </div>
+  `;
+  }
+
+  /**
+   * Get current selections from toggles
+   */
+  function getSelections() {
+    if (!shadowRoot$1) return currentSelections;
+
+    const toggles = shadowRoot$1.querySelectorAll('.zest-toggle__input');
+    const selections = { essential: true };
+
+    toggles.forEach(toggle => {
+      const category = toggle.dataset.category;
+      if (category && category !== 'essential') {
+        selections[category] = toggle.checked;
+      }
+    });
+
+    return selections;
+  }
+
+  /**
+   * Create and show the modal
+   */
+  function showModal(consent = {}, callbacks = {}) {
+    if (modalElement) {
+      return modalElement;
+    }
+
+    const config = getCurrentConfig();
+    currentSelections = { ...consent };
+
+    // Create host element
+    modalElement = document.createElement('zest-modal');
+    modalElement.setAttribute('data-theme', config.theme || 'light');
+
+    // Create shadow root
+    shadowRoot$1 = modalElement.attachShadow({ mode: 'open' });
+
+    // Add styles
+    const styleEl = document.createElement('style');
+    styleEl.textContent = generateStyles(config);
+    shadowRoot$1.appendChild(styleEl);
+
+    // Add modal HTML
+    const container = document.createElement('div');
+    container.innerHTML = createModalHTML(config, consent);
+    shadowRoot$1.appendChild(container.firstElementChild);
+
+    // Add event listeners
+    const modal = shadowRoot$1.querySelector('.zest-modal-overlay');
+
+    // Button clicks
+    modal.addEventListener('click', (e) => {
+      const action = e.target.dataset.action;
+      if (!action) {
+        // Click on overlay background to close
+        if (e.target === modal) {
+          callbacks.onClose?.();
+        }
+        return;
+      }
+
+      switch (action) {
+        case 'save':
+          callbacks.onSave?.(getSelections());
+          break;
+        case 'accept-all':
+          callbacks.onAcceptAll?.();
+          break;
+        case 'reject-all':
+          callbacks.onRejectAll?.();
+          break;
+      }
+    });
+
+    // Keyboard handling
+    modal.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') {
+        callbacks.onClose?.();
+      }
+    });
+
+    // Track toggle changes
+    shadowRoot$1.querySelectorAll('.zest-toggle__input').forEach(toggle => {
+      toggle.addEventListener('change', () => {
+        currentSelections = getSelections();
+      });
+    });
+
+    // Mount to document
+    document.body.appendChild(modalElement);
+
+    // Trap focus
+    requestAnimationFrame(() => {
+      const firstButton = shadowRoot$1.querySelector('button');
+      firstButton?.focus();
+    });
+
+    return modalElement;
+  }
+
+  /**
+   * Hide the modal
+   */
+  function hideModal() {
+    if (modalElement) {
+      modalElement.remove();
+      modalElement = null;
+      shadowRoot$1 = null;
+    }
+  }
+
+  /**
+   * Widget - Minimal floating button to reopen settings
+   */
+
+
+  let widgetElement = null;
+  let shadowRoot = null;
+
+  /**
+   * Create the widget HTML
+   */
+  function createWidgetHTML(config) {
+    const labels = config.labels.widget;
+
+    return `
+    <div class="zest-widget">
+      <button type="button" class="zest-widget__btn" aria-label="${labels.label}" title="${labels.label}">
+        <span class="zest-widget__icon">${COOKIE_ICON}</span>
+      </button>
+    </div>
+  `;
+  }
+
+  /**
+   * Create and mount the widget
+   */
+  function createWidget(callbacks = {}) {
+    if (widgetElement) {
+      return widgetElement;
+    }
+
+    const config = getCurrentConfig();
+
+    // Create host element
+    widgetElement = document.createElement('zest-widget');
+    widgetElement.setAttribute('data-theme', config.theme || 'light');
+
+    // Create shadow root
+    shadowRoot = widgetElement.attachShadow({ mode: 'open' });
+
+    // Add styles
+    const styleEl = document.createElement('style');
+    styleEl.textContent = generateStyles(config);
+    shadowRoot.appendChild(styleEl);
+
+    // Add widget HTML
+    const container = document.createElement('div');
+    container.innerHTML = createWidgetHTML(config);
+    shadowRoot.appendChild(container.firstElementChild);
+
+    // Add event listener
+    const button = shadowRoot.querySelector('.zest-widget__btn');
+    button.addEventListener('click', () => {
+      callbacks.onClick?.();
+    });
+
+    // Mount to document
+    document.body.appendChild(widgetElement);
+
+    return widgetElement;
+  }
+
+  /**
+   * Show the widget
+   */
+  function showWidget(callbacks = {}) {
+    if (!widgetElement) {
+      createWidget(callbacks);
+    } else {
+      widgetElement.style.display = '';
+    }
+  }
+
+  /**
+   * Hide the widget
+   */
+  function hideWidget() {
+    if (widgetElement) {
+      widgetElement.style.display = 'none';
+    }
+  }
+
+  /**
+   * Remove the widget completely
+   */
+  function removeWidget() {
+    if (widgetElement) {
+      widgetElement.remove();
+      widgetElement = null;
+      shadowRoot = null;
+    }
+  }
+
+  /**
+   * Zest - Lightweight Cookie Consent Toolkit
+   * Main entry point
+   */
+
+
+  // State
+  let initialized = false;
+  let config = null;
+
+  /**
+   * Consent checker function shared across interceptors
+   */
+  function checkConsent(category) {
+    return hasConsent(category);
+  }
+
+  /**
+   * Replay all queued items for newly allowed categories
+   */
+  function replayAll(allowedCategories) {
+    replayCookies(allowedCategories);
+    replayStorage(allowedCategories);
+    replayScripts(allowedCategories);
+  }
+
+  /**
+   * Handle accept all
+   */
+  function handleAcceptAll() {
+    const result = acceptAll(config.expiration);
+    const categories = getCategoryIds();
+
+    hideBanner();
+    hideModal();
+
+    replayAll(categories);
+
+    if (config.showWidget) {
+      showWidget({ onClick: handleShowSettings });
+    }
+
+    emitConsent(result.current, result.previous);
+    emitChange(result.current, result.previous);
+    config.callbacks?.onAccept?.(result.current);
+    config.callbacks?.onChange?.(result.current);
+  }
+
+  /**
+   * Handle reject all
+   */
+  function handleRejectAll() {
+    const result = rejectAll(config.expiration);
+
+    hideBanner();
+    hideModal();
+
+    if (config.showWidget) {
+      showWidget({ onClick: handleShowSettings });
+    }
+
+    emitReject(result.current);
+    emitChange(result.current, result.previous);
+    config.callbacks?.onReject?.();
+    config.callbacks?.onChange?.(result.current);
+  }
+
+  /**
+   * Handle save preferences from modal
+   */
+  function handleSavePreferences(selections) {
+    const result = updateConsent(selections, config.expiration);
+
+    // Find newly allowed categories
+    const newlyAllowed = Object.keys(result.current).filter(
+      cat => result.current[cat] && !result.previous[cat]
+    );
+
+    if (newlyAllowed.length > 0) {
+      replayAll(newlyAllowed);
+    }
+
+    hideModal();
+
+    if (config.showWidget) {
+      showWidget({ onClick: handleShowSettings });
+    }
+
+    // Determine if this was acceptance or rejection based on selections
+    const hasNonEssential = Object.entries(selections)
+      .some(([cat, val]) => cat !== 'essential' && val);
+
+    if (hasNonEssential) {
+      emitConsent(result.current, result.previous);
+    } else {
+      emitReject(result.current);
+    }
+
+    emitChange(result.current, result.previous);
+    config.callbacks?.onChange?.(result.current);
+  }
+
+  /**
+   * Handle show settings
+   */
+  function handleShowSettings() {
+    hideBanner();
+    hideWidget();
+
+    showModal(getConsent(), {
+      onSave: handleSavePreferences,
+      onAcceptAll: handleAcceptAll,
+      onRejectAll: handleRejectAll,
+      onClose: handleCloseModal
+    });
+
+    emitShow('modal');
+  }
+
+  /**
+   * Handle close modal
+   */
+  function handleCloseModal() {
+    hideModal();
+    emitHide('modal');
+
+    // Show widget if consent was already given
+    if (hasConsentDecision() && config.showWidget) {
+      showWidget({ onClick: handleShowSettings });
+    } else {
+      // Show banner again if no decision made
+      showBanner({
+        onAcceptAll: handleAcceptAll,
+        onRejectAll: handleRejectAll,
+        onSettings: handleShowSettings
+      });
+    }
+  }
+
+  /**
+   * Initialize Zest
+   */
+  function init(userConfig = {}) {
+    if (initialized) {
+      console.warn('[Zest] Already initialized');
+      return Zest;
+    }
+
+    // Merge config
+    config = setConfig(userConfig);
+
+    // Set patterns if provided
+    if (config.patterns) {
+      setPatterns(config.patterns);
+    }
+
+    // Set up consent checkers
+    setConsentChecker$2(checkConsent);
+    setConsentChecker$1(checkConsent);
+    setConsentChecker(checkConsent);
+
+    // Start interception
+    interceptCookies();
+    interceptStorage();
+    startScriptBlocking(config.mode, config.blockedDomains);
+
+    // Load saved consent
+    const consent = loadConsent();
+
+    initialized = true;
+
+    // Check Do Not Track / Global Privacy Control
+    const dntEnabled = isDoNotTrackEnabled();
+    let dntApplied = false;
+
+    if (dntEnabled && config.respectDNT && config.dntBehavior !== 'ignore') {
+      if (config.dntBehavior === 'reject' && !hasConsentDecision()) {
+        // Auto-reject non-essential cookies silently
+        const result = rejectAll(config.expiration);
+        dntApplied = true;
+
+        // Emit events
+        emitReject(result.current);
+        emitChange(result.current, result.previous);
+        config.callbacks?.onReject?.();
+        config.callbacks?.onChange?.(result.current);
+      }
+      // 'preselect' behavior is handled by default (banner shows with defaults off)
+    }
+
+    // Emit ready event
+    emitReady(consent);
+    config.callbacks?.onReady?.(consent);
+
+    // Show UI based on consent state
+    if (!hasConsentDecision() && !dntApplied) {
+      // No consent decision yet - show banner
+      showBanner({
+        onAcceptAll: handleAcceptAll,
+        onRejectAll: handleRejectAll,
+        onSettings: handleShowSettings
+      });
+      emitShow('banner');
+    } else {
+      // Consent already given (or DNT auto-rejected) - show widget for reopening settings
+      if (config.showWidget) {
+        showWidget({ onClick: handleShowSettings });
+      }
+    }
+
+    return Zest;
+  }
+
+  /**
+   * Public API
+   */
+  const Zest = {
+    // Initialization
+    init,
+
+    // Banner control
+    show() {
+      if (!initialized) {
+        console.warn('[Zest] Not initialized. Call Zest.init() first.');
+        return;
+      }
+      hideModal();
+      hideWidget();
+      showBanner({
+        onAcceptAll: handleAcceptAll,
+        onRejectAll: handleRejectAll,
+        onSettings: handleShowSettings
+      });
+      emitShow('banner');
+    },
+
+    hide() {
+      hideBanner();
+      emitHide('banner');
+    },
+
+    // Settings modal
+    showSettings() {
+      if (!initialized) {
+        console.warn('[Zest] Not initialized. Call Zest.init() first.');
+        return;
+      }
+      handleShowSettings();
+    },
+
+    hideSettings() {
+      hideModal();
+      emitHide('modal');
+    },
+
+    // Consent management
+    getConsent,
+    hasConsent,
+    hasConsentDecision,
+    getConsentProof,
+
+    // DNT detection
+    isDoNotTrackEnabled,
+    getDNTDetails,
+
+    // Accept/Reject programmatically
+    acceptAll() {
+      if (!initialized) {
+        console.warn('[Zest] Not initialized. Call Zest.init() first.');
+        return;
+      }
+      handleAcceptAll();
+    },
+
+    rejectAll() {
+      if (!initialized) {
+        console.warn('[Zest] Not initialized. Call Zest.init() first.');
+        return;
+      }
+      handleRejectAll();
+    },
+
+    // Reset and show banner again
+    reset() {
+      resetConsent();
+      hideModal();
+      removeWidget();
+
+      if (initialized) {
+        showBanner({
+          onAcceptAll: handleAcceptAll,
+          onRejectAll: handleRejectAll,
+          onSettings: handleShowSettings
+        });
+        emitShow('banner');
+      }
+    },
+
+    // Config
+    getConfig: getCurrentConfig,
+
+    // Events
+    EVENTS
+  };
+
+  // Auto-init if config present
+  if (typeof window !== 'undefined') {
+    // Make Zest available globally
+    window.Zest = Zest;
+
+    const autoInit = () => {
+      const cfg = getConfig();
+      if (cfg.autoInit !== false) {
+        init(window.ZestConfig);
+      }
+    };
+
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', autoInit);
+    } else {
+      autoInit();
+    }
+  }
+
+  return Zest;
+
+})();
+//# sourceMappingURL=zest.de.js.map