c15t 1.6.0 → 1.7.0

package/dist/index.cjs

@@ -26,16 +26,23 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     CustomClient: ()=>CustomClient,
     consentTypes: ()=>gdpr_consentTypes,
-    C15tClient: ()=>C15tClient,
-    defaultTranslationConfig: ()=>defaultTranslationConfig,
-    deepMergeTranslations: ()=>translations_namespaceObject.deepMergeTranslations,
     mergeTranslationConfigs: ()=>translations_namespaceObject.mergeTranslationConfigs,
+    prepareTranslationConfig: ()=>translations_namespaceObject.prepareTranslationConfig,
+    deepMergeTranslations: ()=>translations_namespaceObject.deepMergeTranslations,
     createTrackingBlocker: ()=>createTrackingBlocker,
+    loadScripts: ()=>loadScripts,
+    getLoadedScriptIds: ()=>getLoadedScriptIds,
+    createConsentManagerStore: ()=>createConsentManagerStore,
+    unloadScripts: ()=>unloadScripts,
+    allConsentNames: ()=>allConsentNames,
+    C15tClient: ()=>C15tClient,
+    defaultTranslationConfig: ()=>defaultTranslationConfig,
     configureConsentManager: ()=>configureConsentManager,
+    createIframeBlocker: ()=>createIframeBlocker,
     detectBrowserLanguage: ()=>translations_namespaceObject.detectBrowserLanguage,
-    prepareTranslationConfig: ()=>translations_namespaceObject.prepareTranslationConfig,
+    isScriptLoaded: ()=>isScriptLoaded,
     OfflineClient: ()=>OfflineClient,
-    createConsentManagerStore: ()=>createConsentManagerStore,
+    updateScripts: ()=>core_updateScripts,
     API_ENDPOINTS: ()=>API_ENDPOINTS
 });
 const translations_namespaceObject = require("@c15t/translations");
@@ -643,6 +650,526 @@ function configureConsentManager(options) {
     clientRegistry.set(cacheKey, client);
     return client;
 }
+const gdpr_consentTypes = [
+    {
+        defaultValue: true,
+        description: 'These trackers are used for activities that are strictly necessary to operate or deliver the service you requested from us and, therefore, do not require you to consent.',
+        disabled: true,
+        display: true,
+        gdprType: 1,
+        name: 'necessary'
+    },
+    {
+        defaultValue: false,
+        description: 'These trackers enable basic interactions and functionalities that allow you to access selected features of our service and facilitate your communication with us.',
+        display: false,
+        gdprType: 2,
+        name: 'functionality'
+    },
+    {
+        defaultValue: false,
+        description: 'These trackers help us to measure traffic and analyze your behavior to improve our service.',
+        display: false,
+        gdprType: 4,
+        name: 'measurement'
+    },
+    {
+        defaultValue: false,
+        description: 'These trackers help us to improve the quality of your user experience and enable interactions with external content, networks, and platforms.',
+        display: false,
+        gdprType: 3,
+        name: 'experience'
+    },
+    {
+        defaultValue: false,
+        description: 'These trackers help us to deliver personalized ads or marketing content to you, and to measure their performance.',
+        display: false,
+        gdprType: 5,
+        name: 'marketing'
+    }
+];
+const allConsentNames = gdpr_consentTypes.map((consent)=>consent.name);
+function validateNonEmptyConditions(conditions, conditionType) {
+    if (0 === conditions.length) throw new TypeError(`${conditionType} condition cannot be empty`);
+}
+function evaluateCategoryCondition(category, consents) {
+    if (!(category in consents)) throw new Error(`Consent category "${category}" not found in consent state`);
+    return consents[category] || false;
+}
+function evaluateAndCondition(andCondition, consents) {
+    const andConditions = Array.isArray(andCondition) ? andCondition : [
+        andCondition
+    ];
+    validateNonEmptyConditions(andConditions, 'AND');
+    return andConditions.every((subCondition)=>evaluateConditionRecursive(subCondition, consents));
+}
+function evaluateOrCondition(orCondition, consents) {
+    const orConditions = Array.isArray(orCondition) ? orCondition : [
+        orCondition
+    ];
+    validateNonEmptyConditions(orConditions, 'OR');
+    return orConditions.some((subCondition)=>evaluateConditionRecursive(subCondition, consents));
+}
+function evaluateConditionRecursive(condition, consents) {
+    if ('string' == typeof condition) return evaluateCategoryCondition(condition, consents);
+    if ('object' == typeof condition && null !== condition) {
+        if ('and' in condition) return evaluateAndCondition(condition.and, consents);
+        if ('or' in condition) return evaluateOrCondition(condition.or, consents);
+        if ('not' in condition) return !evaluateConditionRecursive(condition.not, consents);
+    }
+    throw new TypeError(`Invalid condition structure: ${JSON.stringify(condition)}`);
+}
+function has_has(condition, consents) {
+    return evaluateConditionRecursive(condition, consents);
+}
+function extractConsentNamesFromCondition(condition) {
+    const categories = new Set();
+    function recurse(cond) {
+        if ('string' == typeof cond) return void categories.add(cond);
+        if ('object' == typeof cond && null !== cond) {
+            if ('and' in cond) {
+                const conditions = Array.isArray(cond.and) ? cond.and : [
+                    cond.and
+                ];
+                conditions.forEach(recurse);
+            } else if ('or' in cond) {
+                const conditions = Array.isArray(cond.or) ? cond.or : [
+                    cond.or
+                ];
+                conditions.forEach(recurse);
+            } else if ('not' in cond) recurse(cond.not);
+        }
+    }
+    recurse(condition);
+    return Array.from(categories);
+}
+function createDefaultConsentState() {
+    return {
+        experience: false,
+        functionality: false,
+        marketing: false,
+        measurement: false,
+        necessary: true
+    };
+}
+function determineRequiredConsent(iframe) {
+    const categoryAttr = iframe.getAttribute('data-category');
+    if (!categoryAttr) return;
+    if (!allConsentNames.includes(categoryAttr)) throw new Error(`Invalid category attribute "${categoryAttr}" on iframe. Must be one of: ${allConsentNames.join(', ')}`);
+    return categoryAttr;
+}
+function processIframeElement(iframe, consents) {
+    const dataSrc = iframe.getAttribute('data-src');
+    const requiredConsent = determineRequiredConsent(iframe);
+    if (!requiredConsent) return;
+    const hasConsent = has_has(requiredConsent, consents);
+    if (hasConsent) {
+        if (dataSrc && !iframe.src) {
+            iframe.src = dataSrc;
+            iframe.removeAttribute('data-src');
+        }
+    } else if (iframe.src) iframe.removeAttribute('src');
+}
+function createIframeBlocker(config = {}, initialConsents) {
+    const blockerConfig = {
+        disableAutomaticBlocking: false,
+        ...config
+    };
+    let consents = initialConsents || createDefaultConsentState();
+    function processIframes() {
+        const iframes = document.querySelectorAll('iframe');
+        iframes.forEach((iframe)=>{
+            processIframeElement(iframe, consents);
+        });
+    }
+    function setupMutationObserver() {
+        const observer = new MutationObserver((mutations)=>{
+            mutations.forEach((mutation)=>{
+                mutation.addedNodes.forEach((node)=>{
+                    if (node.nodeType === Node.ELEMENT_NODE) {
+                        const element = node;
+                        if (element.tagName && 'IFRAME' === element.tagName.toUpperCase()) processIframeElement(element, consents);
+                        const iframes = element.querySelectorAll?.('iframe');
+                        if (iframes) iframes.forEach((iframe)=>{
+                            processIframeElement(iframe, consents);
+                        });
+                    }
+                });
+            });
+        });
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        return observer;
+    }
+    let mutationObserver = null;
+    if (!blockerConfig.disableAutomaticBlocking) {
+        processIframes();
+        mutationObserver = setupMutationObserver();
+    }
+    return {
+        updateConsents: (newConsents)=>{
+            consents = {
+                ...consents,
+                ...newConsents
+            };
+            processIframes();
+        },
+        processIframes,
+        destroy: ()=>{
+            if (mutationObserver) {
+                mutationObserver.disconnect();
+                mutationObserver = null;
+            }
+        }
+    };
+}
+function getIframeConsentCategories() {
+    if ('undefined' == typeof document) return [];
+    const iframes = document.querySelectorAll('iframe[data-category]');
+    const categories = new Set();
+    iframes.forEach((iframe)=>{
+        const categoryAttr = iframe.getAttribute('data-category');
+        if (!categoryAttr) return;
+        const category = categoryAttr.trim();
+        if (allConsentNames.includes(category)) categories.add(category);
+    });
+    return Array.from(categories);
+}
+function processAllIframes(consents) {
+    if ('undefined' == typeof document) return;
+    const iframes = document.querySelectorAll('iframe');
+    iframes.forEach((iframe)=>{
+        processIframeElement(iframe, consents);
+    });
+}
+function setupIframeObserver(getConsents, onCategoriesDiscovered) {
+    const observer = new MutationObserver((mutations)=>{
+        const currentConsents = getConsents();
+        let hasNewCategories = false;
+        mutations.forEach((mutation)=>{
+            mutation.addedNodes.forEach((node)=>{
+                if (node.nodeType === Node.ELEMENT_NODE) {
+                    const element = node;
+                    if (element.tagName && 'IFRAME' === element.tagName.toUpperCase()) {
+                        processIframeElement(element, currentConsents);
+                        if (element.hasAttribute('data-category')) hasNewCategories = true;
+                    }
+                    const iframes = element.querySelectorAll?.('iframe');
+                    if (iframes && iframes.length > 0) iframes.forEach((iframe)=>{
+                        processIframeElement(iframe, currentConsents);
+                        if (iframe.hasAttribute('data-category')) hasNewCategories = true;
+                    });
+                }
+            });
+        });
+        if (hasNewCategories && onCategoriesDiscovered) {
+            const categories = getIframeConsentCategories();
+            if (categories.length > 0) onCategoriesDiscovered(categories);
+        }
+    });
+    observer.observe(document.body, {
+        childList: true,
+        subtree: true
+    });
+    return observer;
+}
+function generateRandomScriptId() {
+    if ('undefined' != typeof crypto && crypto.randomUUID) return crypto.randomUUID().replace(/-/g, '').substring(0, 8);
+    if ('undefined' != typeof crypto && crypto.getRandomValues) {
+        const array = new Uint8Array(4);
+        crypto.getRandomValues(array);
+        return Array.from(array, (byte)=>byte.toString(36)).join('').padEnd(8, '0').substring(0, 8);
+    }
+    const randomStr = Math.random().toString(36).substring(2);
+    return randomStr.padEnd(8, '0').substring(0, 8);
+}
+function getScriptElementId(scriptId, anonymizeId, scriptIdMap) {
+    if (anonymizeId) {
+        if (scriptIdMap[scriptId]) return scriptIdMap[scriptId];
+        scriptIdMap[scriptId] = generateRandomScriptId();
+        return scriptIdMap[scriptId];
+    }
+    return `c15t-script-${scriptId}`;
+}
+const loadedScripts = new Map();
+function hasLoadedScript(src) {
+    return loadedScripts.has(src);
+}
+function getLoadedScript(src) {
+    return loadedScripts.get(src);
+}
+function setLoadedScript(src, element) {
+    loadedScripts.set(src, element);
+}
+function deleteLoadedScript(src) {
+    loadedScripts.delete(src);
+}
+function utils_getLoadedScriptsSnapshot() {
+    return loadedScripts;
+}
+function loadScripts(scripts, consents, scriptIdMap = {}) {
+    const loadedScriptIds = [];
+    scripts.forEach((script)=>{
+        if (!script.alwaysLoad && !has_has(script.category, consents)) return;
+        if (hasLoadedScript(script.id)) return void script.onConsentChange?.({
+            id: script.id,
+            elementId: getScriptElementId(script.id, false !== script.anonymizeId, scriptIdMap),
+            hasConsent: has_has(script.category, consents),
+            consents
+        });
+        if (script.src && script.textContent) throw new Error(`Script '${script.id}' cannot have both 'src' and 'textContent'. Choose one.`);
+        if (!script.src && !script.textContent && !script.callbackOnly) throw new Error(`Script '${script.id}' must have either 'src', 'textContent', or 'callbackOnly' set to true.`);
+        if (true === script.callbackOnly) {
+            const shouldAnonymize = false !== script.anonymizeId;
+            const elementId = getScriptElementId(script.id, shouldAnonymize, scriptIdMap);
+            const callbackInfo = {
+                id: script.id,
+                elementId,
+                consents,
+                hasConsent: has_has(script.category, consents)
+            };
+            if (script.onBeforeLoad) script.onBeforeLoad(callbackInfo);
+            if (script.onLoad) script.onLoad(callbackInfo);
+            setLoadedScript(script.id, null);
+            loadedScriptIds.push(script.id);
+            return;
+        }
+        const shouldAnonymize = false !== script.anonymizeId;
+        const elementId = getScriptElementId(script.id, shouldAnonymize, scriptIdMap);
+        if (true === script.persistAfterConsentRevoked) {
+            const existingElement = document.getElementById(elementId);
+            if (existingElement) {
+                const callbackInfo = {
+                    id: script.id,
+                    hasConsent: has_has(script.category, consents),
+                    elementId,
+                    consents,
+                    element: existingElement
+                };
+                script.onConsentChange?.(callbackInfo);
+                script.onLoad?.(callbackInfo);
+                setLoadedScript(script.id, existingElement);
+                loadedScriptIds.push(script.id);
+                return;
+            }
+        }
+        const scriptElement = document.createElement("script");
+        scriptElement.id = elementId;
+        if (script.src) scriptElement.src = script.src;
+        else if (script.textContent) scriptElement.textContent = script.textContent;
+        if (script.fetchPriority) scriptElement.fetchPriority = script.fetchPriority;
+        if (script.async) scriptElement.async = true;
+        if (script.defer) scriptElement.defer = true;
+        if (script.nonce) scriptElement.nonce = script.nonce;
+        if (script.attributes) Object.entries(script.attributes).forEach(([key, value])=>{
+            scriptElement.setAttribute(key, value);
+        });
+        const callbackInfo = {
+            id: script.id,
+            hasConsent: has_has(script.category, consents),
+            elementId,
+            consents,
+            element: scriptElement
+        };
+        if (script.onLoad) if (script.textContent) setTimeout(()=>{
+            script.onLoad?.({
+                ...callbackInfo
+            });
+        }, 0);
+        else scriptElement.addEventListener('load', ()=>{
+            script.onLoad?.({
+                ...callbackInfo
+            });
+        });
+        if (script.onError) script.textContent || scriptElement.addEventListener('error', ()=>{
+            script.onError?.({
+                ...callbackInfo,
+                error: new Error(`Failed to load script: ${script.src}`)
+            });
+        });
+        if (script.onBeforeLoad) script.onBeforeLoad(callbackInfo);
+        document.head.appendChild(scriptElement);
+        setLoadedScript(script.id, scriptElement);
+        loadedScriptIds.push(script.id);
+    });
+    return loadedScriptIds;
+}
+function unloadScripts(scripts, consents, scriptIdMap = {}) {
+    const unloadedScriptIds = [];
+    scripts.forEach((script)=>{
+        if (!hasLoadedScript(script.id)) return;
+        if (script.alwaysLoad) return;
+        if (!has_has(script.category, consents)) {
+            const scriptElement = getLoadedScript(script.id);
+            const elementId = scriptIdMap[script.id] || `c15t-script-${script.id}`;
+            if (true === script.callbackOnly || null === scriptElement) {
+                const callbackInfo = {
+                    id: script.id,
+                    elementId,
+                    consents,
+                    hasConsent: has_has(script.category, consents)
+                };
+                if (script.onDelete) script.onDelete(callbackInfo);
+                deleteLoadedScript(script.id);
+                unloadedScriptIds.push(script.id);
+            } else if (scriptElement) {
+                const callbackInfo = {
+                    id: script.id,
+                    elementId,
+                    consents,
+                    hasConsent: has_has(script.category, consents),
+                    element: scriptElement
+                };
+                if (script.onDelete) script.onDelete(callbackInfo);
+                if (script.persistAfterConsentRevoked) {
+                    deleteLoadedScript(script.id);
+                    unloadedScriptIds.push(script.id);
+                } else {
+                    scriptElement.remove();
+                    deleteLoadedScript(script.id);
+                    unloadedScriptIds.push(script.id);
+                }
+            }
+        }
+    });
+    return unloadedScriptIds;
+}
+function core_updateScripts(scripts, consents, scriptIdMap = {}) {
+    const unloaded = unloadScripts(scripts, consents, scriptIdMap);
+    const loaded = loadScripts(scripts, consents, scriptIdMap);
+    return {
+        loaded,
+        unloaded
+    };
+}
+function isScriptLoaded(scriptId) {
+    return hasLoadedScript(scriptId);
+}
+function getLoadedScriptIds() {
+    return Array.from(utils_getLoadedScriptsSnapshot().keys());
+}
+function reloadScript(scriptId, scripts, consents, scriptIdMap = {}) {
+    const script = scripts.find((s)=>s.id === scriptId);
+    if (!script) return false;
+    if (hasLoadedScript(scriptId)) {
+        const scriptElement = getLoadedScript(scriptId);
+        const elementId = scriptIdMap[scriptId] || `c15t-script-${scriptId}`;
+        if (true === script.callbackOnly || null === scriptElement) {
+            const callbackInfo = {
+                id: scriptId,
+                elementId,
+                consents,
+                hasConsent: has_has(script.category, consents)
+            };
+            if (script.onDelete) script.onDelete(callbackInfo);
+            deleteLoadedScript(scriptId);
+        } else if (scriptElement) {
+            const callbackInfo = {
+                id: scriptId,
+                elementId,
+                consents,
+                hasConsent: has_has(script.category, consents),
+                element: scriptElement
+            };
+            if (script.onDelete) script.onDelete(callbackInfo);
+            if (!script.persistAfterConsentRevoked) scriptElement.remove();
+            deleteLoadedScript(scriptId);
+        }
+    }
+    if (!script.alwaysLoad && !has_has(script.category, consents)) return false;
+    loadScripts([
+        script
+    ], consents, scriptIdMap);
+    return true;
+}
+function createScriptManager(getState, setState, trackingBlocker) {
+    const updateScriptsFn = ()=>{
+        const { scripts, consents, scriptIdMap } = getState();
+        const result = core_updateScripts(scripts, consents, scriptIdMap);
+        const newLoadedScripts = {
+            ...getState().loadedScripts
+        };
+        result.loaded.forEach((id)=>{
+            newLoadedScripts[id] = true;
+        });
+        result.unloaded.forEach((id)=>{
+            newLoadedScripts[id] = false;
+        });
+        setState({
+            loadedScripts: newLoadedScripts
+        });
+        return result;
+    };
+    return {
+        updateScripts: ()=>updateScriptsFn(),
+        setScripts: (scripts)=>{
+            if (trackingBlocker) trackingBlocker.destroy();
+            const state = getState();
+            const newScriptIdMap = {
+                ...state.scriptIdMap
+            };
+            scripts.forEach((script)=>{
+                if (false !== script.anonymizeId) newScriptIdMap[script.id] = generateRandomScriptId();
+            });
+            const newCategories = scripts.flatMap((script)=>extractConsentNamesFromCondition(script.category));
+            const allCategories = [
+                ...new Set([
+                    ...state.gdprTypes,
+                    ...newCategories
+                ])
+            ];
+            setState({
+                scripts: [
+                    ...state.scripts,
+                    ...scripts
+                ],
+                scriptIdMap: newScriptIdMap,
+                gdprTypes: allCategories
+            });
+            updateScriptsFn();
+        },
+        removeScript: (scriptId)=>{
+            const state = getState();
+            const script = state.scripts.find((s)=>s.id === scriptId);
+            if (hasLoadedScript(scriptId)) {
+                const scriptElement = getLoadedScript(scriptId);
+                if (scriptElement) {
+                    const elementId = state.scriptIdMap[scriptId] || `c15t-script-${scriptId}`;
+                    const callbackInfo = {
+                        id: scriptId,
+                        elementId,
+                        consents: state.consents,
+                        element: scriptElement,
+                        hasConsent: has_has(script?.category ?? 'necessary', state.consents)
+                    };
+                    if (script?.onDelete) script.onDelete(callbackInfo);
+                    scriptElement.remove();
+                    deleteLoadedScript(scriptId);
+                }
+            }
+            const newScriptIdMap = {
+                ...state.scriptIdMap
+            };
+            delete newScriptIdMap[scriptId];
+            setState({
+                scripts: state.scripts.filter((script)=>script.id !== scriptId),
+                loadedScripts: {
+                    ...state.loadedScripts,
+                    [scriptId]: false
+                },
+                scriptIdMap: newScriptIdMap
+            });
+        },
+        reloadScript: (scriptId)=>{
+            const state = getState();
+            return reloadScript(scriptId, state.scripts, state.consents, state.scriptIdMap);
+        },
+        isScriptLoaded: (scriptId)=>isScriptLoaded(scriptId),
+        getLoadedScriptIds: ()=>getLoadedScriptIds()
+    };
+}
 const DEFAULT_DOMAIN_CONSENT_MAP = {
     'www.google-analytics.com': 'measurement',
     'analytics.google.com': 'measurement',
@@ -788,7 +1315,7 @@ const DEFAULT_DOMAIN_CONSENT_MAP = {
     'app.contentsquare.com': 'experience'
 };
 const tracking_domains = DEFAULT_DOMAIN_CONSENT_MAP;
-function createDefaultConsentState() {
+function tracking_blocker_createDefaultConsentState() {
     return {
         experience: false,
         functionality: false,
@@ -808,7 +1335,7 @@ function createTrackingBlocker(config = {}, initialConsents) {
             ...config.domainConsentMap
         }
     };
-    let consents = initialConsents || createDefaultConsentState();
+    let consents = initialConsents || tracking_blocker_createDefaultConsentState();
     const originalFetch = window.fetch;
     const originalXHR = window.XMLHttpRequest;
     function normalizeDomain(domain) {
@@ -889,7 +1416,7 @@ function hasConsentFor(consentType, consents, honorDoNotTrack) {
     const effectiveConsents = getEffectiveConsents(consents, honorDoNotTrack);
     return effectiveConsents[consentType] || false;
 }
-function consent_utils_hasConsented(consentInfo) {
+function hasConsented(consentInfo) {
     return null !== consentInfo;
 }
 function checkLocalStorageAccess(set) {
@@ -908,16 +1435,17 @@ function checkLocalStorageAccess(set) {
     }
     return false;
 }
-function updateStore(data, { set, get, initialTranslationConfig }, hasLocalStorageAccess) {
+function updateStore(data, { set, get, initialTranslationConfig, trackingBlocker }, hasLocalStorageAccess) {
     const { consentInfo, ignoreGeoLocation, callbacks, setDetectedCountry } = get();
     const { translations, location, showConsentBanner } = data;
+    const shouldAutoGrantConsents = data.jurisdiction?.code === 'NONE' && !data.showConsentBanner;
     const updatedStore = {
         isLoadingConsentInfo: false,
         branding: data.branding ?? 'c15t',
         ...null === consentInfo ? {
             showPopup: showConsentBanner && hasLocalStorageAccess || ignoreGeoLocation
         } : {},
-        ...data.jurisdiction?.code === 'NONE' && !data.showConsentBanner && {
+        ...shouldAutoGrantConsents && {
             consents: {
                 necessary: true,
                 functionality: true,
@@ -934,7 +1462,8 @@ function updateStore(data, { set, get, initialTranslationConfig }, hasLocalStora
         },
         jurisdictionInfo: data.jurisdiction
     };
-    if (translations?.language && translations?.translations) {
+    translations?.language && translations?.translations;
+    {
         const translationConfig = (0, translations_namespaceObject.prepareTranslationConfig)({
             translations: {
                 [translations.language]: translations.translations
@@ -948,6 +1477,15 @@ function updateStore(data, { set, get, initialTranslationConfig }, hasLocalStora
     updatedStore.hasFetchedBanner = true;
     updatedStore.lastBannerFetchData = data;
     set(updatedStore);
+    if (shouldAutoGrantConsents) callbacks?.onConsentSet?.({
+        preferences: {
+            necessary: true,
+            functionality: true,
+            experience: true,
+            marketing: true,
+            measurement: true
+        }
+    });
     callbacks?.onBannerFetched?.({
         showConsentBanner: data.showConsentBanner,
         jurisdiction: data.jurisdiction,
@@ -957,24 +1495,26 @@ function updateStore(data, { set, get, initialTranslationConfig }, hasLocalStora
             translations: translations.translations
         }
     });
+    trackingBlocker?.updateConsents(get().consents);
+    get().updateScripts();
 }
 async function fetchConsentBannerInfo(config) {
     const { get, set, manager, initialData } = config;
-    const { hasConsented, callbacks } = get();
-    if ('undefined' == typeof window || hasConsented()) return void set({
-        isLoadingConsentInfo: false
-    });
+    const { callbacks } = get();
+    if ('undefined' == typeof window) return;
     const hasLocalStorageAccess = checkLocalStorageAccess(set);
     if (!hasLocalStorageAccess) return;
     set({
         isLoadingConsentInfo: true
     });
-    if (initialData) {
+    if (initialData) try {
         const showConsentBanner = await initialData;
         if (showConsentBanner) {
             updateStore(showConsentBanner, config, true);
             return showConsentBanner;
         }
+    } catch (error) {
+        throw error;
     }
     try {
         const { data, error } = await manager.showConsentBanner({
@@ -1078,78 +1618,49 @@ function updateGTMConsent(consentState) {
     if (!window.gtag) return;
     window.gtag('consent', 'update', mapConsentStateToGTM(consentState));
 }
-function validateNonEmptyConditions(conditions, conditionType) {
-    if (0 === conditions.length) throw new TypeError(`${conditionType} condition cannot be empty`);
-}
-function evaluateCategoryCondition(category, consents) {
-    if (!(category in consents)) throw new Error(`Consent category "${category}" not found in consent state`);
-    return consents[category] || false;
-}
-function evaluateAndCondition(andCondition, consents) {
-    const andConditions = Array.isArray(andCondition) ? andCondition : [
-        andCondition
-    ];
-    validateNonEmptyConditions(andConditions, 'AND');
-    return andConditions.every((subCondition)=>evaluateConditionRecursive(subCondition, consents));
-}
-function evaluateOrCondition(orCondition, consents) {
-    const orConditions = Array.isArray(orCondition) ? orCondition : [
-        orCondition
-    ];
-    validateNonEmptyConditions(orConditions, 'OR');
-    return orConditions.some((subCondition)=>evaluateConditionRecursive(subCondition, consents));
-}
-function evaluateConditionRecursive(condition, consents) {
-    if ('string' == typeof condition) return evaluateCategoryCondition(condition, consents);
-    if ('object' == typeof condition && null !== condition) {
-        if ('and' in condition) return evaluateAndCondition(condition.and, consents);
-        if ('or' in condition) return evaluateOrCondition(condition.or, consents);
-        if ('not' in condition) return !evaluateConditionRecursive(condition.not, consents);
-    }
-    throw new TypeError(`Invalid condition structure: ${JSON.stringify(condition)}`);
-}
-function has(condition, consents) {
-    return evaluateConditionRecursive(condition, consents);
+function createIframeManager(get, _set) {
+    let observer = null;
+    let isInitialized = false;
+    return {
+        initializeIframeBlocker: ()=>{
+            if (isInitialized) return;
+            if ('undefined' == typeof document) return;
+            const state = get();
+            if (state.iframeBlockerConfig?.disableAutomaticBlocking) return;
+            const discoverAndRegisterCategories = ()=>{
+                const iframeCategories = getIframeConsentCategories();
+                if (iframeCategories.length > 0) get().updateConsentCategories(iframeCategories);
+            };
+            if ('loading' === document.readyState) document.addEventListener('DOMContentLoaded', discoverAndRegisterCategories);
+            else discoverAndRegisterCategories();
+            setTimeout(discoverAndRegisterCategories, 100);
+            processAllIframes(state.consents);
+            observer = setupIframeObserver(()=>get().consents, (categories)=>get().updateConsentCategories(categories));
+            isInitialized = true;
+        },
+        updateIframeConsents: ()=>{
+            if (!isInitialized) return;
+            if ('undefined' == typeof document) return;
+            const state = get();
+            const { consents, iframeBlockerConfig } = state;
+            if (iframeBlockerConfig?.disableAutomaticBlocking) return;
+            processAllIframes(consents);
+        },
+        destroyIframeBlocker: ()=>{
+            if (!isInitialized) return;
+            if ('undefined' == typeof document) return;
+            const state = get();
+            const { iframeBlockerConfig } = state;
+            if (iframeBlockerConfig?.disableAutomaticBlocking) return;
+            if (observer) {
+                observer.disconnect();
+                observer = null;
+            }
+            isInitialized = false;
+        }
+    };
 }
-const gdpr_consentTypes = [
-    {
-        defaultValue: true,
-        description: 'These trackers are used for activities that are strictly necessary to operate or deliver the service you requested from us and, therefore, do not require you to consent.',
-        disabled: true,
-        display: true,
-        gdprType: 1,
-        name: 'necessary'
-    },
-    {
-        defaultValue: false,
-        description: 'These trackers enable basic interactions and functionalities that allow you to access selected features of our service and facilitate your communication with us.',
-        display: false,
-        gdprType: 2,
-        name: 'functionality'
-    },
-    {
-        defaultValue: false,
-        description: 'These trackers help us to measure traffic and analyze your behavior to improve our service.',
-        display: false,
-        gdprType: 4,
-        name: 'measurement'
-    },
-    {
-        defaultValue: false,
-        description: 'These trackers help us to improve the quality of your user experience and enable interactions with external content, networks, and platforms.',
-        display: false,
-        gdprType: 3,
-        name: 'experience'
-    },
-    {
-        defaultValue: false,
-        description: 'These trackers help us to deliver personalized ads or marketing content to you, and to measure their performance.',
-        display: false,
-        gdprType: 5,
-        name: 'marketing'
-    }
-];
-const version = '1.6.0';
+const version = '1.7.0';
 const STORAGE_KEY = 'privacy-consent-storage';
 const initialState = {
     config: {
@@ -1206,6 +1717,9 @@ const initialState = {
     translationConfig: defaultTranslationConfig,
     includeNonDisplayedConsents: false,
     consentTypes: gdpr_consentTypes,
+    iframeBlockerConfig: {
+        disableAutomaticBlocking: false
+    },
     ignoreGeoLocation: false,
     privacySettings: {
         honorDoNotTrack: true
@@ -1223,13 +1737,17 @@ const initialState = {
     setLocationInfo: ()=>{},
     getDisplayedConsents: ()=>[],
     hasConsented: ()=>false,
-    setTranslationConfig: ()=>{}
+    setTranslationConfig: ()=>{},
+    scripts: [],
+    loadedScripts: {},
+    scriptIdMap: {}
 };
 async function saveConsents({ manager, type, get, set, trackingBlocker }) {
-    const { callbacks, selectedConsents, consents, consentTypes } = get();
+    const { callbacks, selectedConsents, consents, consentTypes, updateScripts, updateIframeConsents, gdprTypes } = get();
     const newConsents = selectedConsents ?? consents ?? {};
-    if ('all' === type) for (const consent of consentTypes)newConsents[consent.name] = true;
-    else if ('necessary' === type) for (const consent of consentTypes)newConsents[consent.name] = 'necessary' === consent.name;
+    if ('all' === type) {
+        for (const consent of consentTypes)if (gdprTypes.includes(consent.name)) newConsents[consent.name] = true;
+    } else if ('necessary' === type) for (const consent of consentTypes)newConsents[consent.name] = 'necessary' === consent.name;
     const consentInfo = {
         time: Date.now(),
         type: type
@@ -1242,7 +1760,9 @@ async function saveConsents({ manager, type, get, set, trackingBlocker }) {
     });
     await new Promise((resolve)=>setTimeout(resolve, 0));
     trackingBlocker?.updateConsents(newConsents);
+    updateIframeConsents();
     updateGTMConsent(newConsents);
+    updateScripts();
     try {
         localStorage.setItem(STORAGE_KEY, JSON.stringify({
             consents: newConsents,
@@ -1287,13 +1807,17 @@ const getStoredConsent = ()=>{
 const createConsentManagerStore = (manager, options = {})=>{
     const { namespace = 'c15tStore', trackingBlockerConfig, isConsentDomain = false, translationConfig } = options;
     const storedConsent = getStoredConsent();
-    const trackingBlocker = 'undefined' != typeof window ? createTrackingBlocker(trackingBlockerConfig || {}, storedConsent?.consents || initialState.consents) : null;
+    const shouldDisableTrackingBlocker = options.scripts && options.scripts.length > 0;
+    const trackingBlocker = 'undefined' == typeof window || shouldDisableTrackingBlocker ? null : createTrackingBlocker(trackingBlockerConfig || {}, storedConsent?.consents || initialState.consents);
     const store = (0, vanilla_namespaceObject.createStore)((set, get)=>({
             ...initialState,
+            gdprTypes: options.initialGdprTypes ?? initialState.gdprTypes,
             ignoreGeoLocation: options.ignoreGeoLocation ?? false,
             config: options.config ?? initialState.config,
+            iframeBlockerConfig: options.iframeBlockerConfig ?? initialState.iframeBlockerConfig,
             isConsentDomain,
             callbacks: options.callbacks ?? initialState.callbacks,
+            scripts: options.scripts ?? initialState.scripts,
             translationConfig: translationConfig || initialState.translationConfig,
             ...storedConsent ? {
                 consents: storedConsent.consents,
@@ -1392,6 +1916,9 @@ const createConsentManagerStore = (manager, options = {})=>{
                             [name]: callback
                         }
                     }));
+                if ('onConsentSet' === name && callback && 'function' == typeof callback) callback?.({
+                    preferences: currentState.consents
+                });
                 if ('onBannerFetched' === name && currentState.hasFetchedBanner && currentState.lastBannerFetchData && callback && 'function' == typeof callback) {
                     const { lastBannerFetchData } = currentState;
                     callback?.({
@@ -1416,7 +1943,8 @@ const createConsentManagerStore = (manager, options = {})=>{
                     initialData: options._initialData,
                     initialTranslationConfig: options.initialTranslationConfig,
                     get,
-                    set
+                    set,
+                    trackingBlocker
                 }),
             getDisplayedConsents: ()=>{
                 const { gdprTypes, consentTypes } = get();
@@ -1424,7 +1952,7 @@ const createConsentManagerStore = (manager, options = {})=>{
             },
             hasConsented: ()=>{
                 const { consentInfo } = get();
-                return consent_utils_hasConsented(consentInfo);
+                return hasConsented(consentInfo);
             },
             getEffectiveConsents: ()=>{
                 const { consents, privacySettings } = get();
@@ -1436,14 +1964,29 @@ const createConsentManagerStore = (manager, options = {})=>{
             },
             has: (condition)=>{
                 const { consents } = get();
-                return has(condition, consents);
+                return has_has(condition, consents);
             },
             setTranslationConfig: (config)=>{
                 set({
                     translationConfig: config
                 });
-            }
+            },
+            updateConsentCategories: (newCategories)=>{
+                const allCategories = [
+                    ...new Set([
+                        ...get().gdprTypes,
+                        ...newCategories
+                    ])
+                ];
+                set({
+                    gdprTypes: allCategories
+                });
+            },
+            ...createScriptManager(get, set, trackingBlocker),
+            ...createIframeManager(get, set)
         }));
+    store.getState().initializeIframeBlocker();
+    if (options.scripts && options.scripts.length > 0) store.getState().updateConsentCategories(options.scripts.flatMap((script)=>extractConsentNamesFromCondition(script.category)));
     if ('undefined' != typeof window) {
         window[namespace] = store;
         if (options.unstable_googleTagManager) try {
@@ -1454,7 +1997,10 @@ const createConsentManagerStore = (manager, options = {})=>{
         } catch (e) {
             console.error('Failed to setup Google Tag Manager:', e);
         }
-        if (!getStoredConsent()) store.getState().fetchConsentBannerInfo();
+        store.getState().callbacks.onConsentSet?.({
+            preferences: store.getState().consents
+        });
+        store.getState().fetchConsentBannerInfo();
     }
     return store;
 };
@@ -1462,29 +2008,43 @@ exports.API_ENDPOINTS = __webpack_exports__.API_ENDPOINTS;
 exports.C15tClient = __webpack_exports__.C15tClient;
 exports.CustomClient = __webpack_exports__.CustomClient;
 exports.OfflineClient = __webpack_exports__.OfflineClient;
+exports.allConsentNames = __webpack_exports__.allConsentNames;
 exports.configureConsentManager = __webpack_exports__.configureConsentManager;
 exports.consentTypes = __webpack_exports__.consentTypes;
 exports.createConsentManagerStore = __webpack_exports__.createConsentManagerStore;
+exports.createIframeBlocker = __webpack_exports__.createIframeBlocker;
 exports.createTrackingBlocker = __webpack_exports__.createTrackingBlocker;
 exports.deepMergeTranslations = __webpack_exports__.deepMergeTranslations;
 exports.defaultTranslationConfig = __webpack_exports__.defaultTranslationConfig;
 exports.detectBrowserLanguage = __webpack_exports__.detectBrowserLanguage;
+exports.getLoadedScriptIds = __webpack_exports__.getLoadedScriptIds;
+exports.isScriptLoaded = __webpack_exports__.isScriptLoaded;
+exports.loadScripts = __webpack_exports__.loadScripts;
 exports.mergeTranslationConfigs = __webpack_exports__.mergeTranslationConfigs;
 exports.prepareTranslationConfig = __webpack_exports__.prepareTranslationConfig;
+exports.unloadScripts = __webpack_exports__.unloadScripts;
+exports.updateScripts = __webpack_exports__.updateScripts;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "API_ENDPOINTS",
     "C15tClient",
     "CustomClient",
     "OfflineClient",
+    "allConsentNames",
     "configureConsentManager",
     "consentTypes",
     "createConsentManagerStore",
+    "createIframeBlocker",
     "createTrackingBlocker",
     "deepMergeTranslations",
     "defaultTranslationConfig",
     "detectBrowserLanguage",
+    "getLoadedScriptIds",
+    "isScriptLoaded",
+    "loadScripts",
     "mergeTranslationConfigs",
-    "prepareTranslationConfig"
+    "prepareTranslationConfig",
+    "unloadScripts",
+    "updateScripts"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true