@highfivve/ad-tag 5.5.4

package/lib/ads/modules/ad-reload/index.js

@@ -0,0 +1,163 @@
+import { AdVisibilityService } from './adVisibilityService';
+import { UserActivityService } from './userActivityService';
+import { mkConfigureStep } from '../../adPipeline';
+import { isNotNull } from 'ad-tag/util/arrayUtils';
+export class AdReload {
+    constructor() {
+        this.name = 'moli-ad-reload';
+        this.description = 'Moli implementation of an ad reload module.';
+        this.moduleType = 'ad-reload';
+        this.moduleConfig = null;
+        this.refreshIntervalMs = 20000;
+        this.reloadKeyValue = 'native-ad-reload';
+        this.initialized = false;
+        this.initialize = (context, config, slotsToMonitor, reloadAdSlotCallback) => {
+            if (context.env__ === 'test') {
+                context.logger__.info('AdReload', 'disabled in environment test');
+                return;
+            }
+            if (this.initialized) {
+                return;
+            }
+            context.logger__.debug('AdReload', 'initialize moli ad reload module');
+            this.setupAdVisibilityService(config, context.window__, context.logger__);
+            this.setupSlotRenderListener(config, slotsToMonitor, reloadAdSlotCallback, context.window__, context.logger__);
+            this.initialized = true;
+        };
+        this.setupAdVisibilityService = (config, window, logger) => {
+            this.adVisibilityService = new AdVisibilityService(new UserActivityService(window, config.userActivityLevelControl, logger), this.refreshIntervalMs, config.refreshIntervalMsOverrides ?? {}, false, !!config.disableAdVisibilityChecks, config.viewabilityOverrides ?? {}, window, logger);
+        };
+        this.setupSlotRenderListener = (config, slotsToMonitor, reloadAdSlotCallback, window, logger) => window.googletag.pubads().addEventListener('slotRenderEnded', renderEndedEvent => {
+            const { slot: googleTagSlot, campaignId, advertiserId, yieldGroupIds, isEmpty: slotIsEmpty } = renderEndedEvent;
+            const slotDomId = googleTagSlot.getSlotElementId();
+            const slotIsMonitored = slotsToMonitor.indexOf(slotDomId) > -1;
+            const orderIdNotExcluded = !campaignId || config.excludeOrderIds.indexOf(campaignId) === -1;
+            const orderIdIncluded = !!campaignId && config.includeOrderIds.indexOf(campaignId) > -1;
+            const advertiserIdIncluded = !!advertiserId && config.includeAdvertiserIds.indexOf(advertiserId) > -1;
+            const yieldGroupIdIncluded = !!yieldGroupIds && config.includeYieldGroupIds.some(id => yieldGroupIds.indexOf(id) > -1);
+            const trackingSlotAllowed = !slotIsEmpty &&
+                slotIsMonitored &&
+                orderIdNotExcluded &&
+                (orderIdIncluded || advertiserIdIncluded || yieldGroupIdIncluded);
+            if (!trackingSlotAllowed) {
+                this.logTrackingDisallowedReason(slotDomId, {
+                    slotIsEmpty,
+                    slotIsMonitored,
+                    orderIdNotExcluded,
+                    orderIdIncluded,
+                    advertiserIdIncluded,
+                    yieldGroupIdIncluded
+                }, logger, yieldGroupIds, campaignId, advertiserId);
+            }
+            const slotAlreadyTracked = !!this.adVisibilityService?.isSlotTracked(slotDomId);
+            if (trackingSlotAllowed) {
+                this.adVisibilityService.trackSlot(googleTagSlot, reloadAdSlotCallback, advertiserId);
+            }
+            else if (slotAlreadyTracked) {
+                this.adVisibilityService.removeSlotTracking(googleTagSlot);
+            }
+        });
+        this.reloadAdSlot = (config, ctx) => (googleTagSlot) => {
+            const slotId = googleTagSlot.getSlotElementId();
+            const moliSlot = ctx.config__.slots.find(moliSlot => moliSlot.domId === slotId);
+            if (moliSlot && moliSlot.behaviour.loaded !== 'infinite') {
+                ctx.logger__.debug('AdReload', 'fired slot reload', moliSlot.domId);
+                const sizesOverride = this.maybeOptimizeSlotForCls(config, moliSlot, googleTagSlot, ctx.logger__, ctx.window__);
+                googleTagSlot.setTargeting(this.reloadKeyValue, 'true');
+                const getBucketAndLoadingBehaviour = () => {
+                    const bucketOverride = config.viewabilityOverrides?.[slotId]?.refreshBucket;
+                    if (bucketOverride === true) {
+                        const loaded = moliSlot.behaviour.loaded;
+                        const bucket = moliSlot.behaviour.bucket;
+                        const bucketName = typeof bucket === 'string'
+                            ? bucket
+                            : bucket?.[ctx.labelConfigService__.getDeviceLabel()];
+                        return bucketName && loaded !== 'infinite' ? { name: bucketName, loaded } : undefined;
+                    }
+                };
+                const bucket = getBucketAndLoadingBehaviour();
+                if (bucket) {
+                    ctx.window__.moli
+                        .refreshBucket(bucket.name, { loaded: bucket.loaded })
+                        .then(result => ctx.logger__.debug('AdReload', `refreshBucket '${bucket.name}' result`, result))
+                        .catch(error => ctx.logger__.error('AdReload', `refreshBucket '${bucket.name}' failed`, error));
+                }
+                else {
+                    ctx.window__.moli
+                        .refreshAdSlot(slotId, {
+                        loaded: moliSlot.behaviour.loaded,
+                        ...(sizesOverride && { sizesOverride: sizesOverride })
+                    })
+                        .catch(error => ctx.logger__.error('AdReload', `refreshing ${slotId} failed`, error));
+                }
+            }
+        };
+        this.maybeOptimizeSlotForCls = (config, moliSlot, googleTagSlot, logger, _window) => {
+            const slotDomId = moliSlot.domId;
+            if (config.optimizeClsScoreDomIds.indexOf(slotDomId) > -1) {
+                const slotDomElement = _window.document.getElementById(slotDomId);
+                if (slotDomElement && !!slotDomElement.style) {
+                    const slotHeight = slotDomElement.scrollHeight;
+                    slotDomElement.style.setProperty('height', `${slotHeight}px`);
+                    const newSlotSizes = moliSlot.sizes.filter(size => size !== 'fluid' && size[1] <= slotHeight);
+                    logger.debug('AdReload', `CLS optimization: slot ${slotDomId} received fixed height ${slotHeight}px`, 'new sizes:', newSlotSizes);
+                    if (newSlotSizes.length < moliSlot.sizes.filter(size => size !== 'fluid').length) {
+                        _window.googletag.destroySlots([googleTagSlot]);
+                    }
+                    return newSlotSizes;
+                }
+                logger.warn('AdReload', `CLS optimization: slot ${slotDomId} to be optimized but not found in DOM.`);
+            }
+            return moliSlot.sizes;
+        };
+        this.logTrackingDisallowedReason = (slotDomId, reasons, logger, yieldGroupIds, campaignId, advertiserId) => {
+            const { slotIsEmpty, slotIsMonitored, orderIdNotExcluded, orderIdIncluded, advertiserIdIncluded, yieldGroupIdIncluded } = reasons;
+            if (slotIsEmpty) {
+                logger.debug('AdReload', slotDomId, 'slot not tracked: reported empty');
+            }
+            if (!slotIsMonitored) {
+                logger.debug('AdReload', slotDomId, 'slot not tracked: excluded by DOM id');
+            }
+            if (!orderIdNotExcluded) {
+                logger.debug('AdReload', slotDomId, 'slot not tracked: excluded by order id', campaignId);
+            }
+            if (!(orderIdIncluded || advertiserIdIncluded || yieldGroupIdIncluded)) {
+                logger.debug('AdReload', slotDomId, 'slot not tracked: neither order id', campaignId, 'nor advertiser id', advertiserId, 'nor yieldGroup id', yieldGroupIds, 'included');
+            }
+        };
+    }
+    config__() {
+        return this.moduleConfig;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.adReload?.enabled) {
+            this.moduleConfig = moduleConfig.adReload;
+        }
+    }
+    initSteps__() {
+        return [];
+    }
+    configureSteps__() {
+        const config = this.moduleConfig;
+        return config
+            ? [
+                mkConfigureStep(this.name, context => {
+                    const slotsToMonitor = context.config__.slots
+                        .filter(slot => config.excludeAdSlotDomIds.indexOf(slot.domId) === -1)
+                        .map(slot => slot.domId)
+                        .filter(isNotNull);
+                    const reloadAdSlotCallback = this.reloadAdSlot(config, context);
+                    context.logger__.debug('AdReload', 'monitoring slots', slotsToMonitor);
+                    this.initialize(context, config, slotsToMonitor, reloadAdSlotCallback);
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+}

package/lib/ads/modules/ad-reload/userActivityService.js

@@ -0,0 +1,70 @@
+export const userActivityParametersForLevel = new Map([
+    ['strict', { userActivityDuration: 10 * 1000, userBecomingInactiveDuration: 5 * 1000 }],
+    ['moderate', { userActivityDuration: 12 * 1000, userBecomingInactiveDuration: 8 * 1000 }],
+    ['lax', { userActivityDuration: 15 * 1000, userBecomingInactiveDuration: 12 * 1000 }]
+]);
+export class UserActivityService {
+    constructor(window, userActivityLevelControl = {
+        level: 'strict'
+    }, logger) {
+        this.window = window;
+        this.userActivityLevelControl = userActivityLevelControl;
+        this.logger = logger;
+        this.isActive = true;
+        this.handleUserInteraction = () => this.userActive();
+        this.handleUserIdle = () => this.userInactive();
+        this.handleUserBecomingIdle = () => this.userBecomingInactive();
+        this.handlePageVisibilityChanged = () => {
+            if (this.window.document.hidden) {
+                this.userInactive();
+            }
+            else {
+                this.userActive();
+            }
+        };
+        this.listener = [];
+        this.window.document.addEventListener('visibilitychange', this.handlePageVisibilityChanged);
+        this.logger?.debug('UserActivityService', 'initialized');
+        switch (userActivityLevelControl.level) {
+            case 'custom':
+                this.userActivityDuration = userActivityLevelControl.userActivityDuration;
+                this.userBecomingInactiveDuration = userActivityLevelControl.userBecomingInactiveDuration;
+                break;
+            default:
+                const { userActivityDuration, userBecomingInactiveDuration } = userActivityParametersForLevel.get(userActivityLevelControl.level);
+                this.userActivityDuration = userActivityDuration;
+                this.userBecomingInactiveDuration = userBecomingInactiveDuration;
+        }
+        this.userActive();
+    }
+    addUserActivityChangedListener(listener) {
+        this.listener.push(listener);
+    }
+    userActive() {
+        if (!this.isActive) {
+            this.isActive = true;
+            this.listener.forEach(listener => listener(this.isActive));
+            this.logger?.debug('UserActivityService', 'user has become active');
+        }
+        UserActivityService.observedEvents.forEach(event => this.window.removeEventListener(event, this.handleUserInteraction));
+        if (this.userInactiveTimer) {
+            this.window.clearTimeout(this.userInactiveTimer);
+        }
+        if (this.userBecomingIdleTimer) {
+            this.window.clearTimeout(this.userBecomingIdleTimer);
+        }
+        this.userInactiveTimer = this.window.setTimeout(this.handleUserIdle, this.userActivityDuration);
+        this.userBecomingIdleTimer = this.window.setTimeout(this.handleUserBecomingIdle, this.userBecomingInactiveDuration);
+    }
+    userInactive() {
+        this.isActive = false;
+        UserActivityService.observedEvents.forEach(event => this.window.addEventListener(event, this.handleUserInteraction));
+        this.listener.forEach(listener => listener(this.isActive));
+        this.logger?.debug('UserActivityService', 'user has become inactive');
+    }
+    userBecomingInactive() {
+        UserActivityService.observedEvents.forEach(event => this.window.addEventListener(event, this.handleUserInteraction));
+        this.logger?.debug('UserActivityService', 'user will shortly become inactive');
+    }
+}
+UserActivityService.observedEvents = ['mousemove', 'touchstart', 'scroll', 'keypress'];

package/lib/ads/modules/adex/adex-mapping.js

@@ -0,0 +1,77 @@
+export const toAdexMapType = (keyValueMap, mappingDefinition, logger) => {
+    const mapKey = keyValueMap[mappingDefinition.key];
+    const mapValue = extractStringOrNumber(keyValueMap, mappingDefinition.valueType, mappingDefinition.valueKey);
+    if (!mapKey ||
+        Array.isArray(mapKey) ||
+        (mapValue === undefined && mappingDefinition.defaultValue === undefined) ||
+        (mappingDefinition.valueType === 'number' &&
+            Number.isNaN(mapValue) &&
+            mappingDefinition.defaultValue === undefined)) {
+        logger.warn('Adex DMP', `values for key ${mappingDefinition.key}/valueKey ${mappingDefinition.valueKey} were empty or key was an array. Key/Value:`, mapKey, mapValue);
+        return undefined;
+    }
+    const adexTargetValue = convertToAdexTargetValue(mapValue, mappingDefinition, logger);
+    return {
+        [mappingDefinition.attribute]: {
+            [mapKey]: adexTargetValue
+        }
+    };
+};
+export const toAdexStringOrNumberType = (keyValueMap, mappingDefinition, logger) => {
+    const value = extractStringOrNumber(keyValueMap, mappingDefinition.adexValueType, mappingDefinition.key);
+    if ((value === undefined && mappingDefinition.defaultValue === undefined) ||
+        (mappingDefinition.adexValueType === 'number' &&
+            ((Number.isNaN(value) && mappingDefinition.defaultValue === undefined) ||
+                Array.isArray(value)))) {
+        logger.warn('Adex DMP', `value for key ${mappingDefinition.key} was empty or key was an array. Value:`, value);
+        return undefined;
+    }
+    const adexTargetValue = convertToAdexTargetValue(value, mappingDefinition, logger);
+    return {
+        [mappingDefinition.attribute]: adexTargetValue
+    };
+};
+export const toAdexListType = (keyValueMap, mappingDefinition, logger) => {
+    const value = extractStringOrNumber(keyValueMap, 'string', mappingDefinition.key);
+    if ((value === undefined &&
+        (mappingDefinition.defaultValue === undefined ||
+            mappingDefinition.defaultValue.length === 0)) ||
+        typeof value === 'number') {
+        logger.warn('Adex DMP', `value for key "${mappingDefinition.key}" was empty or number. Value:`, value);
+        return undefined;
+    }
+    const adexTargetValue = convertToAdexListValue(value, mappingDefinition, logger);
+    return {
+        [mappingDefinition.attribute]: adexTargetValue
+    };
+};
+const sortAndToListObject = (arr) => Object.fromEntries(arr.sort().map(listValue => [listValue, 1]));
+const sortAndJoin = (arr) => arr.sort().join(',');
+const extractStringOrNumber = (keyValueMap, valueType, keyToExtract) => (valueType === 'number' ? Number(keyValueMap[keyToExtract]) : keyValueMap[keyToExtract]);
+const convertToAdexTargetValue = (value, mappingDefinition, logger) => value !== undefined && !Number.isNaN(value)
+    ?
+        Array.isArray(value)
+            ?
+                sortAndJoin(value)
+            :
+                value
+    :
+        logAndUseDefaultValue(mappingDefinition, logger);
+const convertToAdexListValue = (value, mappingDefinition, logger) => {
+    if (value === undefined) {
+        return logAndUseDefaultValue(mappingDefinition, logger);
+    }
+    return Array.isArray(value)
+        ?
+            sortAndToListObject(value)
+        :
+            { [value]: 1 };
+};
+const logAndUseDefaultValue = (mappingDefinition, logger) => {
+    logger.warn('Adex DMP', 'using defaultValue', mappingDefinition.defaultValue, 'as fallback for key', mappingDefinition.key);
+    return mappingDefinition.adexValueType === 'list'
+        ? mappingDefinition.defaultValue
+            ? sortAndToListObject(mappingDefinition.defaultValue)
+            : undefined
+        : mappingDefinition.defaultValue;
+};

package/lib/ads/modules/adex/adexUtiq.js

@@ -0,0 +1,15 @@
+export const trackUtiqId = (config, window__) => {
+    var _a;
+    window__.Utiq || (window__.Utiq = { queue: [] });
+    (_a = window__.Utiq).queue || (_a.queue = []);
+    window__.Utiq.queue.push(() => {
+        window__.Utiq?.API?.addEventListener('onIdsAvailable', ({ mtid }) => {
+            window__._adexc.push([
+                `/${config.adexCustomerId}/${config.adexTagId}/`,
+                'cm',
+                '_cm',
+                [308, mtid]
+            ]);
+        });
+    });
+};

package/lib/ads/modules/adex/index.js

@@ -0,0 +1,142 @@
+import { mkConfigureStep, mkInitStep } from 'ad-tag/ads/adPipeline';
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+import { isNotNull } from 'ad-tag/util/arrayUtils';
+import { sendAdvertisingID } from 'ad-tag/ads/modules/adex/sendAdvertisingId';
+import { tcfapi } from 'ad-tag/types/tcfapi';
+var TCPurpose = tcfapi.responses.TCPurpose;
+import { toAdexListType, toAdexMapType, toAdexStringOrNumberType } from 'ad-tag/ads/modules/adex/adex-mapping';
+import { trackUtiqId } from 'ad-tag/ads/modules/adex/adexUtiq';
+export class AdexModule {
+    constructor() {
+        this.name = 'the-adex-dmp';
+        this.description = 'Moli DMP module for The Adex.';
+        this.moduleType = 'dmp';
+        this.adexConfig = null;
+        this.isLoaded = false;
+        this.hasRequiredConsent = (tcData) => !tcData.gdprApplies ||
+            (tcData.vendor.consents['44'] &&
+                [
+                    TCPurpose.STORE_INFORMATION_ON_DEVICE,
+                    TCPurpose.SELECT_BASIC_ADS,
+                    TCPurpose.CREATE_PERSONALISED_ADS_PROFILE,
+                    TCPurpose.SELECT_PERSONALISED_ADS,
+                    TCPurpose.CREATE_PERSONALISED_CONTENT_PROFILE,
+                    TCPurpose.SELECT_PERSONALISED_CONTENT,
+                    TCPurpose.MEASURE_AD_PERFORMANCE,
+                    TCPurpose.MEASURE_CONTENT_PERFORMANCE,
+                    TCPurpose.APPLY_MARKET_RESEARCH,
+                    TCPurpose.DEVELOP_IMPROVE_PRODUCTS
+                ].every(purpose => tcData.purpose.consents[purpose]));
+        this.getOrInitAdexQueue = (_window) => {
+            const adexWindow = _window;
+            adexWindow._adexc = adexWindow._adexc || [];
+            return adexWindow;
+        };
+        this.getAdexKeyValues = (context, config) => {
+            const gamKeyValues = {
+                ...context.config__.targeting?.keyValues,
+                ...context.runtimeConfig__.keyValues
+            };
+            if (Object.keys(gamKeyValues).length > 0) {
+                return config.mappingDefinitions
+                    .map(def => {
+                    switch (def.adexValueType) {
+                        case 'map':
+                            return toAdexMapType(gamKeyValues, def, context.logger__);
+                        case 'list':
+                            return toAdexListType(gamKeyValues, def, context.logger__);
+                        default:
+                            return toAdexStringOrNumberType(gamKeyValues, def, context.logger__);
+                    }
+                })
+                    .filter(isNotNull);
+            }
+        };
+        this.configureAdexC = (context, config) => {
+            const adexWindow = this.getOrInitAdexQueue(context.window__);
+            const adexKeyValues = this.getAdexKeyValues(context, config);
+            if (!adexKeyValues) {
+                context.logger__.warn('Adex DMP', 'targeting key/values are empty');
+            }
+            else {
+                adexWindow._adexc.push([
+                    `/${config.adexCustomerId}/${config.adexTagId}/`,
+                    'ut',
+                    '_kv',
+                    [
+                        adexKeyValues.reduce((aggregator, additionalKeyValue) => ({ ...aggregator, ...additionalKeyValue }), {}),
+                        config.spaMode ? 1 : 0
+                    ]
+                ]);
+            }
+            if (config.enabledPartners?.includes('utiq')) {
+                trackUtiqId(config, context.window__);
+            }
+        };
+    }
+    config__() {
+        return this.adexConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.adex && moduleConfig.adex.enabled) {
+            this.adexConfig = moduleConfig.adex;
+        }
+    }
+    initSteps__() {
+        const config = this.adexConfig;
+        if (config) {
+            return [mkInitStep('DMP module setup', context => this.track(context, config))];
+        }
+        return [];
+    }
+    configureSteps__() {
+        const config = this.adexConfig;
+        if (config?.spaMode) {
+            return [
+                mkConfigureStep('DMP module setup', context => {
+                    this.configureAdexC(context, config);
+                    return Promise.resolve();
+                })
+            ];
+        }
+        return [];
+    }
+    track(context, adexConfig) {
+        const { adexCustomerId, adexTagId, appConfig } = adexConfig;
+        this.configureAdexC(context, adexConfig);
+        const adexKeyValues = this.getAdexKeyValues(context, adexConfig);
+        const gamKeyValues = {
+            ...context.config__.targeting?.keyValues,
+            ...context.runtimeConfig__.keyValues
+        };
+        if (this.hasRequiredConsent(context.tcData__) &&
+            !this.isLoaded &&
+            Object.keys(gamKeyValues).length > 0) {
+            this.isLoaded = true;
+            const hasValidMobileKeyValues = isNotNull(appConfig) &&
+                isNotNull(gamKeyValues[appConfig.advertiserIdKey]) &&
+                (gamKeyValues[appConfig.clientTypeKey] === 'android' ||
+                    gamKeyValues[appConfig.clientTypeKey] === 'ios');
+            if (appConfig?.advertiserIdKey && hasValidMobileKeyValues) {
+                const consentString = context.tcData__.gdprApplies ? context.tcData__.tcString : undefined;
+                const advertisingIdValue = gamKeyValues[appConfig.advertiserIdKey];
+                typeof advertisingIdValue === 'string' &&
+                    adexKeyValues &&
+                    sendAdvertisingID(adexCustomerId, appConfig.adexMobileTagId ? appConfig.adexMobileTagId : adexTagId, advertisingIdValue, adexKeyValues, gamKeyValues[appConfig.clientTypeKey] ?? '', context.window__.fetch, context.logger__, consentString);
+            }
+            else {
+                context.assetLoaderService__
+                    .loadScript({
+                    name: this.name,
+                    assetUrl: `https://dmp.theadex.com/d/${adexCustomerId}/${adexTagId}/s/adex.js`,
+                    loadMethod: AssetLoadMethod.TAG
+                })
+                    .catch(error => context.logger__.error('failed to load adex', error));
+            }
+        }
+        return Promise.resolve();
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+}

package/lib/ads/modules/adex/sendAdvertisingId.js

@@ -0,0 +1,20 @@
+const getAdvertisingIdIFAType = (clientType) => {
+    if (clientType === 'android') {
+        return 'aaid';
+    }
+    else if (clientType === 'ios') {
+        return 'idfa';
+    }
+    else {
+        return;
+    }
+};
+export const sendAdvertisingID = (adexCustomerId, adexTagId, advertisingId, adexAttributes, clientType, fetch, logger, consentString) => {
+    const ifaType = getAdvertisingIdIFAType(typeof clientType === 'string' ? clientType : clientType[0]);
+    const keyValuesMap = adexAttributes.reduce((acc, currentValue) => {
+        return { ...acc, ...currentValue };
+    }, {});
+    const keyValuesParameter = !!adexAttributes.length ? `&kv=${JSON.stringify(keyValuesMap)}` : '';
+    const consentParameter = consentString ? `&gdpr_consent=${consentString}` : '';
+    fetch(`https://api.theadex.com/collector/v1/ifa/c/${adexCustomerId}/t/${adexTagId}/request?&ifa=${advertisingId}&ifa_type=${ifaType}${keyValuesParameter}${consentParameter}`).catch(error => logger.error(error));
+};

package/lib/ads/modules/blocklist-url/index.js

@@ -0,0 +1,118 @@
+import { mkConfigureStep, mkInitStep } from '../../adPipeline';
+const matches = (href, log) => (entry) => {
+    switch (entry.matchType) {
+        case 'exact':
+            return href === entry.pattern;
+        case 'contains':
+            return href.indexOf(entry.pattern) > -1;
+        case 'regex':
+            try {
+                return RegExp(entry.pattern).test(href);
+            }
+            catch (e) {
+                log.error(`Invalid regex pattern: ${entry.pattern}`, e);
+                return false;
+            }
+        default:
+            return false;
+    }
+};
+export const isBlocklisted = (blocklist, href, log) => blocklist.urls.some(matches(href, log));
+export const createBlocklistedUrls = () => {
+    let blocklistConfig = null;
+    let blocklistCache = null;
+    const config__ = () => blocklistConfig;
+    const configure__ = (moduleConfig) => {
+        if (moduleConfig?.blocklist && moduleConfig.blocklist.enabled) {
+            blocklistConfig = moduleConfig.blocklist;
+        }
+    };
+    const getBlocklist = (blocklist, assetLoaderService, log) => {
+        switch (blocklist.provider) {
+            case 'static':
+                return () => Promise.resolve(blocklist.blocklist);
+            case 'dynamic':
+                let cachedResult;
+                return () => {
+                    if (!cachedResult) {
+                        cachedResult = loadConfigWithRetry(assetLoaderService, blocklist.endpoint, 3).catch(e => {
+                            log.error('Blocklist URLs', 'Fetching blocklisted urls failed', e);
+                            return { urls: [] };
+                        });
+                    }
+                    return cachedResult;
+                };
+        }
+    };
+    const loadConfigWithRetry = (assetLoaderService, endpoint, retriesLeft, lastError = null) => {
+        if (retriesLeft <= 0) {
+            return Promise.reject(lastError);
+        }
+        if (!blocklistCache) {
+            blocklistCache = assetLoaderService
+                .loadJson('blocklist-urls.json', endpoint)
+                .catch(error => {
+                const exponentialBackoff = new Promise(resolve => setTimeout(resolve, 100 / retriesLeft));
+                return exponentialBackoff.then(() => loadConfigWithRetry(assetLoaderService, endpoint, retriesLeft - 1, error));
+            });
+        }
+        return blocklistCache;
+    };
+    const initSteps__ = () => {
+        return blocklistConfig
+            ? [
+                mkInitStep('blocklist-urls-init', ctx => {
+                    switch (blocklistConfig?.mode) {
+                        case 'key-value':
+                            const key = blocklistConfig.key;
+                            const value = blocklistConfig.isBlocklistedValue || 'true';
+                            return getBlocklist(blocklistConfig.blocklist, ctx.assetLoaderService__, ctx.logger__)().then(blocklist => {
+                                if (isBlocklisted(blocklist, ctx.window__.location.href, ctx.logger__)) {
+                                    ctx.window__.googletag
+                                        .pubads()
+                                        .setTargeting(key, value);
+                                }
+                            });
+                        case 'block':
+                            return getBlocklist(blocklistConfig.blocklist, ctx.assetLoaderService__, ctx.logger__)().then(blocklist => {
+                                ctx.logger__.debug('Blocklist URLs', 'using blocklist', blocklist);
+                                if (isBlocklisted(blocklist, ctx.window__.location.href, ctx.logger__)) {
+                                    return Promise.reject('blocklisted url found. Abort ad pipeline run');
+                                }
+                            });
+                        default:
+                            return Promise.resolve();
+                    }
+                })
+            ]
+            : [];
+    };
+    const configureSteps__ = () => {
+        const config = blocklistConfig;
+        return config
+            ? [
+                mkConfigureStep('blocklist-labels', async (ctx) => {
+                    const loadedBlocklist = await getBlocklist(config.blocklist, ctx.assetLoaderService__, ctx.logger__)();
+                    const matcher = matches(ctx.window__.location.href, ctx.logger__);
+                    loadedBlocklist.labels?.forEach(entry => {
+                        const result = entry.reverseMatch === true ? !matcher(entry) : matcher(entry);
+                        if (result) {
+                            ctx.labelConfigService__.addLabel(entry.label);
+                        }
+                    });
+                })
+            ]
+            : [];
+    };
+    const prepareRequestAdsSteps__ = () => [];
+    return {
+        name: 'Blocklist URLs',
+        description: '',
+        moduleType: 'policy',
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__
+    };
+};