@freshjuice/zest 0.1.0

package/dist/zest.js

@@ -0,0 +1,3109 @@
+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 };
+  }
+
+  /**
+   * Built-in translations for Zest
+   * Language is auto-detected from <html lang=""> or navigator.language
+   */
+
+  const translations = {
+    en: {
+      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'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Essential',
+          description: 'Required for the website to function properly. Cannot be disabled.'
+        },
+        functional: {
+          label: 'Functional',
+          description: 'Enable personalized features like language preferences and themes.'
+        },
+        analytics: {
+          label: 'Analytics',
+          description: 'Help us understand how visitors interact with our website.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Used to deliver relevant advertisements and track campaign performance.'
+        }
+      }
+    },
+
+    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.'
+        }
+      }
+    },
+
+    es: {
+      labels: {
+        banner: {
+          title: 'Valoramos tu privacidad',
+          description: 'Utilizamos cookies para mejorar tu experiencia de navegación, ofrecer contenido personalizado y analizar nuestro tráfico. Al hacer clic en "Aceptar todo", consientes el uso de cookies.',
+          acceptAll: 'Aceptar todo',
+          rejectAll: 'Rechazar todo',
+          settings: 'Configuración'
+        },
+        modal: {
+          title: 'Configuración de privacidad',
+          description: 'Gestiona tus preferencias de cookies. Puedes activar o desactivar diferentes tipos de cookies a continuación.',
+          save: 'Guardar preferencias',
+          acceptAll: 'Aceptar todo',
+          rejectAll: 'Rechazar todo'
+        },
+        widget: {
+          label: 'Configuración de cookies'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Esenciales',
+          description: 'Necesarias para el funcionamiento del sitio web. No se pueden desactivar.'
+        },
+        functional: {
+          label: 'Funcionales',
+          description: 'Permiten funciones personalizadas como preferencias de idioma y temas.'
+        },
+        analytics: {
+          label: 'Analíticas',
+          description: 'Nos ayudan a entender cómo los visitantes interactúan con nuestro sitio web.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Se utilizan para mostrar anuncios relevantes y medir el rendimiento de las campañas.'
+        }
+      }
+    },
+
+    fr: {
+      labels: {
+        banner: {
+          title: 'Nous respectons votre vie privée',
+          description: 'Nous utilisons des cookies pour améliorer votre expérience de navigation, proposer du contenu personnalisé et analyser notre trafic. En cliquant sur « Tout accepter », vous consentez à l\'utilisation de cookies.',
+          acceptAll: 'Tout accepter',
+          rejectAll: 'Tout refuser',
+          settings: 'Paramètres'
+        },
+        modal: {
+          title: 'Paramètres de confidentialité',
+          description: 'Gérez vos préférences en matière de cookies. Vous pouvez activer ou désactiver différents types de cookies ci-dessous.',
+          save: 'Enregistrer les préférences',
+          acceptAll: 'Tout accepter',
+          rejectAll: 'Tout refuser'
+        },
+        widget: {
+          label: 'Paramètres des cookies'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Essentiels',
+          description: 'Nécessaires au bon fonctionnement du site. Ne peuvent pas être désactivés.'
+        },
+        functional: {
+          label: 'Fonctionnels',
+          description: 'Permettent des fonctionnalités personnalisées comme les préférences de langue et de thème.'
+        },
+        analytics: {
+          label: 'Analytiques',
+          description: 'Nous aident à comprendre comment les visiteurs interagissent avec notre site.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Utilisés pour afficher des publicités pertinentes et mesurer les performances des campagnes.'
+        }
+      }
+    },
+
+    it: {
+      labels: {
+        banner: {
+          title: 'Rispettiamo la tua privacy',
+          description: 'Utilizziamo i cookie per migliorare la tua esperienza di navigazione, fornire contenuti personalizzati e analizzare il nostro traffico. Cliccando su "Accetta tutto", acconsenti all\'uso dei cookie.',
+          acceptAll: 'Accetta tutto',
+          rejectAll: 'Rifiuta tutto',
+          settings: 'Impostazioni'
+        },
+        modal: {
+          title: 'Impostazioni privacy',
+          description: 'Gestisci le tue preferenze sui cookie. Puoi attivare o disattivare diversi tipi di cookie qui sotto.',
+          save: 'Salva preferenze',
+          acceptAll: 'Accetta tutto',
+          rejectAll: 'Rifiuta tutto'
+        },
+        widget: {
+          label: 'Impostazioni cookie'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Essenziali',
+          description: 'Necessari per il corretto funzionamento del sito. Non possono essere disattivati.'
+        },
+        functional: {
+          label: 'Funzionali',
+          description: 'Abilitano funzionalità personalizzate come preferenze di lingua e tema.'
+        },
+        analytics: {
+          label: 'Analitici',
+          description: 'Ci aiutano a capire come i visitatori interagiscono con il nostro sito.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Utilizzati per mostrare annunci pertinenti e misurare le prestazioni delle campagne.'
+        }
+      }
+    },
+
+    pt: {
+      labels: {
+        banner: {
+          title: 'Valorizamos sua privacidade',
+          description: 'Usamos cookies para melhorar sua experiência de navegação, fornecer conteúdo personalizado e analisar nosso tráfego. Ao clicar em "Aceitar tudo", você consente com o uso de cookies.',
+          acceptAll: 'Aceitar tudo',
+          rejectAll: 'Rejeitar tudo',
+          settings: 'Configurações'
+        },
+        modal: {
+          title: 'Configurações de privacidade',
+          description: 'Gerencie suas preferências de cookies. Você pode ativar ou desativar diferentes tipos de cookies abaixo.',
+          save: 'Salvar preferências',
+          acceptAll: 'Aceitar tudo',
+          rejectAll: 'Rejeitar tudo'
+        },
+        widget: {
+          label: 'Configurações de cookies'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Essenciais',
+          description: 'Necessários para o funcionamento do site. Não podem ser desativados.'
+        },
+        functional: {
+          label: 'Funcionais',
+          description: 'Permitem recursos personalizados como preferências de idioma e tema.'
+        },
+        analytics: {
+          label: 'Analíticos',
+          description: 'Nos ajudam a entender como os visitantes interagem com nosso site.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Usados para exibir anúncios relevantes e medir o desempenho de campanhas.'
+        }
+      }
+    },
+
+    nl: {
+      labels: {
+        banner: {
+          title: 'Wij respecteren uw privacy',
+          description: 'Wij gebruiken cookies om uw browse-ervaring te verbeteren, gepersonaliseerde inhoud aan te bieden en ons verkeer te analyseren. Door op "Alles accepteren" te klikken, stemt u in met het gebruik van cookies.',
+          acceptAll: 'Alles accepteren',
+          rejectAll: 'Alles weigeren',
+          settings: 'Instellingen'
+        },
+        modal: {
+          title: 'Privacy-instellingen',
+          description: 'Beheer uw cookievoorkeuren. U kunt hieronder verschillende soorten cookies in- of uitschakelen.',
+          save: 'Voorkeuren opslaan',
+          acceptAll: 'Alles accepteren',
+          rejectAll: 'Alles weigeren'
+        },
+        widget: {
+          label: 'Cookie-instellingen'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Essentieel',
+          description: 'Noodzakelijk voor de goede werking van de website. Kunnen niet worden uitgeschakeld.'
+        },
+        functional: {
+          label: 'Functioneel',
+          description: 'Maken gepersonaliseerde functies mogelijk zoals taal- en themavoorkeuren.'
+        },
+        analytics: {
+          label: 'Analytisch',
+          description: 'Helpen ons te begrijpen hoe bezoekers onze website gebruiken.'
+        },
+        marketing: {
+          label: 'Marketing',
+          description: 'Worden gebruikt om relevante advertenties te tonen en campagneprestaties te meten.'
+        }
+      }
+    },
+
+    pl: {
+      labels: {
+        banner: {
+          title: 'Szanujemy Twoją prywatność',
+          description: 'Używamy plików cookie, aby poprawić Twoje wrażenia z przeglądania, dostarczać spersonalizowane treści i analizować nasz ruch. Klikając „Zaakceptuj wszystko", wyrażasz zgodę na używanie plików cookie.',
+          acceptAll: 'Zaakceptuj wszystko',
+          rejectAll: 'Odrzuć wszystko',
+          settings: 'Ustawienia'
+        },
+        modal: {
+          title: 'Ustawienia prywatności',
+          description: 'Zarządzaj swoimi preferencjami dotyczącymi plików cookie. Możesz włączyć lub wyłączyć różne typy plików cookie poniżej.',
+          save: 'Zapisz preferencje',
+          acceptAll: 'Zaakceptuj wszystko',
+          rejectAll: 'Odrzuć wszystko'
+        },
+        widget: {
+          label: 'Ustawienia plików cookie'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Niezbędne',
+          description: 'Wymagane do prawidłowego działania strony. Nie można ich wyłączyć.'
+        },
+        functional: {
+          label: 'Funkcjonalne',
+          description: 'Umożliwiają spersonalizowane funkcje, takie jak preferencje językowe i motywy.'
+        },
+        analytics: {
+          label: 'Analityczne',
+          description: 'Pomagają nam zrozumieć, jak odwiedzający korzystają z naszej strony.'
+        },
+        marketing: {
+          label: 'Marketingowe',
+          description: 'Służą do wyświetlania odpowiednich reklam i mierzenia skuteczności kampanii.'
+        }
+      }
+    },
+
+    uk: {
+      labels: {
+        banner: {
+          title: 'Ми цінуємо вашу конфіденційність',
+          description: 'Ми використовуємо файли cookie для покращення вашого досвіду перегляду, надання персоналізованого контенту та аналізу нашого трафіку. Натискаючи «Прийняти все», ви погоджуєтесь на використання файлів cookie.',
+          acceptAll: 'Прийняти все',
+          rejectAll: 'Відхилити все',
+          settings: 'Налаштування'
+        },
+        modal: {
+          title: 'Налаштування конфіденційності',
+          description: 'Керуйте своїми налаштуваннями файлів cookie. Ви можете ввімкнути або вимкнути різні типи файлів cookie нижче.',
+          save: 'Зберегти налаштування',
+          acceptAll: 'Прийняти все',
+          rejectAll: 'Відхилити все'
+        },
+        widget: {
+          label: 'Налаштування cookie'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Необхідні',
+          description: 'Потрібні для правильної роботи сайту. Не можуть бути вимкнені.'
+        },
+        functional: {
+          label: 'Функціональні',
+          description: 'Дозволяють персоналізовані функції, такі як мовні налаштування та теми.'
+        },
+        analytics: {
+          label: 'Аналітичні',
+          description: 'Допомагають нам зрозуміти, як відвідувачі взаємодіють з нашим сайтом.'
+        },
+        marketing: {
+          label: 'Маркетингові',
+          description: 'Використовуються для показу релевантної реклами та вимірювання ефективності кампаній.'
+        }
+      }
+    },
+
+    ru: {
+      labels: {
+        banner: {
+          title: 'Мы ценим вашу конфиденциальность',
+          description: 'Мы используем файлы cookie для улучшения вашего опыта просмотра, предоставления персонализированного контента и анализа нашего трафика. Нажимая «Принять все», вы соглашаетесь на использование файлов cookie.',
+          acceptAll: 'Принять все',
+          rejectAll: 'Отклонить все',
+          settings: 'Настройки'
+        },
+        modal: {
+          title: 'Настройки конфиденциальности',
+          description: 'Управляйте своими настройками файлов cookie. Вы можете включить или отключить различные типы файлов cookie ниже.',
+          save: 'Сохранить настройки',
+          acceptAll: 'Принять все',
+          rejectAll: 'Отклонить все'
+        },
+        widget: {
+          label: 'Настройки cookie'
+        }
+      },
+      categories: {
+        essential: {
+          label: 'Необходимые',
+          description: 'Требуются для правильной работы сайта. Не могут быть отключены.'
+        },
+        functional: {
+          label: 'Функциональные',
+          description: 'Позволяют использовать персонализированные функции, такие как языковые настройки и темы.'
+        },
+        analytics: {
+          label: 'Аналитические',
+          description: 'Помогают нам понять, как посетители взаимодействуют с нашим сайтом.'
+        },
+        marketing: {
+          label: 'Маркетинговые',
+          description: 'Используются для показа релевантной рекламы и измерения эффективности кампаний.'
+        }
+      }
+    },
+
+    ja: {
+      labels: {
+        banner: {
+          title: 'プライバシーを尊重します',
+          description: '当サイトでは、ブラウジング体験の向上、パーソナライズされたコンテンツの提供、トラフィックの分析のためにCookieを使用しています。「すべて同意」をクリックすると、Cookieの使用に同意したことになります。',
+          acceptAll: 'すべて同意',
+          rejectAll: 'すべて拒否',
+          settings: '設定'
+        },
+        modal: {
+          title: 'プライバシー設定',
+          description: 'Cookieの設定を管理できます。以下で各種Cookieを有効または無効にできます。',
+          save: '設定を保存',
+          acceptAll: 'すべて同意',
+          rejectAll: 'すべて拒否'
+        },
+        widget: {
+          label: 'Cookie設定'
+        }
+      },
+      categories: {
+        essential: {
+          label: '必須',
+          description: 'サイトの正常な動作に必要です。無効にすることはできません。'
+        },
+        functional: {
+          label: '機能性',
+          description: '言語設定やテーマなどのパーソナライズ機能を有効にします。'
+        },
+        analytics: {
+          label: '分析',
+          description: '訪問者がサイトをどのように利用しているかを理解するのに役立ちます。'
+        },
+        marketing: {
+          label: 'マーケティング',
+          description: '関連性の高い広告を表示し、キャンペーンの効果を測定するために使用されます。'
+        }
+      }
+    },
+
+    zh: {
+      labels: {
+        banner: {
+          title: '我们重视您的隐私',
+          description: '我们使用Cookie来改善您的浏览体验、提供个性化内容并分析我们的流量。点击"全部接受"即表示您同意我们使用Cookie。',
+          acceptAll: '全部接受',
+          rejectAll: '全部拒绝',
+          settings: '设置'
+        },
+        modal: {
+          title: '隐私设置',
+          description: '管理您的Cookie偏好设置。您可以在下方启用或禁用不同类型的Cookie。',
+          save: '保存设置',
+          acceptAll: '全部接受',
+          rejectAll: '全部拒绝'
+        },
+        widget: {
+          label: 'Cookie设置'
+        }
+      },
+      categories: {
+        essential: {
+          label: '必要',
+          description: '网站正常运行所必需的。无法禁用。'
+        },
+        functional: {
+          label: '功能性',
+          description: '启用个性化功能，如语言偏好和主题设置。'
+        },
+        analytics: {
+          label: '分析',
+          description: '帮助我们了解访问者如何与网站互动。'
+        },
+        marketing: {
+          label: '营销',
+          description: '用于展示相关广告并衡量营销活动效果。'
+        }
+      }
+    }
+  };
+
+  /**
+   * Detect language from various sources
+   * Priority: config.lang > <html lang=""> > navigator.language > 'en'
+   */
+  function detectLanguage(configLang) {
+    // 1. Explicit config
+    if (configLang && configLang !== 'auto') {
+      return normalizeLanguage(configLang);
+    }
+
+    // 2. HTML lang attribute
+    const htmlLang = document.documentElement.lang;
+    if (htmlLang) {
+      const normalized = normalizeLanguage(htmlLang);
+      if (translations[normalized]) {
+        return normalized;
+      }
+    }
+
+    // 3. Browser language
+    if (typeof navigator !== 'undefined' && navigator.language) {
+      const normalized = normalizeLanguage(navigator.language);
+      if (translations[normalized]) {
+        return normalized;
+      }
+    }
+
+    // 4. Default to English
+    return 'en';
+  }
+
+  /**
+   * Normalize language code (e.g., 'en-US' -> 'en', 'es_MX' -> 'es')
+   */
+  function normalizeLanguage(lang) {
+    if (!lang) return 'en';
+
+    // ISO 639-1 language codes are always 2 characters
+    const base = lang.slice(0, 2).toLowerCase();
+
+    // Check if we support it
+    if (translations[base]) {
+      return base;
+    }
+
+    return 'en';
+  }
+
+  /**
+   * Get translation for a language
+   */
+  function getTranslation(lang) {
+    return translations[lang] || translations.en;
+  }
+
+  /**
+   * 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(detectedLang);
+
+    // 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.js.map