c15t 0.0.1-rc.3

package/dist/libs/__tests__/tracking-blocker.test.js

@@ -0,0 +1,267 @@
+import * as __WEBPACK_EXTERNAL_MODULE_vitest__ from 'vitest';
+import * as __WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__ from '../tracking-blocker.js';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.g = (function () {
+		if ('object' == typeof globalThis) return globalThis;
+		try {
+			return this || new Function('return this')();
+		} catch (e) {
+			if ('object' == typeof window) return window;
+		}
+	})();
+})();
+const BLOCKED_CONSENT = {
+	experience: false,
+	functionality: false,
+	marketing: false,
+	measurement: false,
+	necessary: true,
+};
+const ALLOWED_CONSENT = {
+	...BLOCKED_CONSENT,
+	measurement: true,
+};
+(0, __WEBPACK_EXTERNAL_MODULE_vitest__.describe)('TrackingBlocker', () => {
+	const originalFetch = __webpack_require__.g.fetch;
+	const originalXHR = __webpack_require__.g.XMLHttpRequest;
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.beforeAll)(() => {
+		__webpack_require__.g.fetch = __WEBPACK_EXTERNAL_MODULE_vitest__.vi
+			.fn()
+			.mockImplementation(() => Promise.resolve(new Response()));
+		if (!__webpack_require__.g.XMLHttpRequest)
+			__webpack_require__.g.XMLHttpRequest = originalXHR;
+	});
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.afterAll)(() => {
+		__webpack_require__.g.fetch = originalFetch;
+		__webpack_require__.g.XMLHttpRequest = originalXHR;
+	});
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.beforeEach)(() => {
+		__WEBPACK_EXTERNAL_MODULE_vitest__.vi.clearAllMocks();
+		__WEBPACK_EXTERNAL_MODULE_vitest__.vi.restoreAllMocks();
+		__webpack_require__.g.fetch = __WEBPACK_EXTERNAL_MODULE_vitest__.vi
+			.fn()
+			.mockImplementation(() => Promise.resolve(new Response()));
+		window.fetch = __webpack_require__.g.fetch;
+		window.XMLHttpRequest = originalXHR;
+		__WEBPACK_EXTERNAL_MODULE_vitest__.vi.spyOn(document, 'dispatchEvent');
+	});
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'blocks fetch requests to tracking domains when consent not granted',
+		async () => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			await (0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch('https://www.google-analytics.com/analytics.js')
+			).rejects.toThrow(
+				'Request to https://www.google-analytics.com/analytics.js blocked due to missing consent'
+			);
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				document.dispatchEvent
+			).toHaveBeenCalledWith(
+				__WEBPACK_EXTERNAL_MODULE_vitest__.expect.objectContaining({
+					type: 'ConsentBlockedRequest',
+					detail: {
+						url: 'https://www.google-analytics.com/analytics.js',
+					},
+				})
+			);
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'blocks XMLHttpRequest to tracking domains when consent not granted',
+		() => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			const xhr = new XMLHttpRequest();
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(() => {
+				xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+			}).toThrow(
+				'Request to https://www.google-analytics.com/analytics.js blocked due to missing consent'
+			);
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				document.dispatchEvent
+			).toHaveBeenCalledWith(
+				__WEBPACK_EXTERNAL_MODULE_vitest__.expect.objectContaining({
+					type: 'ConsentBlockedRequest',
+					detail: {
+						url: 'https://www.google-analytics.com/analytics.js',
+					},
+				})
+			);
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'allows fetch requests to tracking domains after consent granted',
+		async () => {
+			window.fetch = __webpack_require__.g.fetch;
+			const trackingBlocker = (0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				ALLOWED_CONSENT
+			);
+			const fetchSpy = __WEBPACK_EXTERNAL_MODULE_vitest__.vi.spyOn(
+				window,
+				'fetch'
+			);
+			await fetch('https://www.google-analytics.com/analytics.js');
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetchSpy
+			).toHaveBeenCalledWith('https://www.google-analytics.com/analytics.js');
+			trackingBlocker.destroy();
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'allows XMLHttpRequest to tracking domains after consent granted',
+		() => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				ALLOWED_CONSENT
+			);
+			const xhr = new XMLHttpRequest();
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(() => {
+				xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+			}).not.toThrow();
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'allows requests to non-tracking domains regardless of consent',
+		async () => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			const fetchSpy = __WEBPACK_EXTERNAL_MODULE_vitest__.vi.spyOn(
+				window,
+				'fetch'
+			);
+			await fetch('https://api.example.com/data');
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetchSpy
+			).toHaveBeenCalledWith('https://api.example.com/data');
+			const xhr = new XMLHttpRequest();
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(() => {
+				xhr.open('GET', 'https://api.example.com/data');
+			}).not.toThrow();
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'handles custom domain consent map',
+		async () => {
+			const trackingBlocker = (0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{
+					overrideDomainConsentMap: true,
+					domainConsentMap: {
+						'custom-analytics.example.com': 'measurement',
+					},
+				},
+				BLOCKED_CONSENT
+			);
+			await (0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch('https://custom-analytics.example.com/track')
+			).rejects.toThrow(
+				'Request to https://custom-analytics.example.com/track blocked due to missing consent'
+			);
+			trackingBlocker.updateConsents({
+				experience: false,
+				functionality: false,
+				marketing: false,
+				measurement: true,
+				necessary: true,
+			});
+			const fetchSpy = __WEBPACK_EXTERNAL_MODULE_vitest__.vi.spyOn(
+				window,
+				'fetch'
+			);
+			await fetch('https://custom-analytics.example.com/track');
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetchSpy
+			).toHaveBeenCalledWith('https://custom-analytics.example.com/track');
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'handles subdomains correctly',
+		async () => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			await (0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch('https://subdomain.google-analytics.com/track')
+			).rejects.toThrow(
+				'Request to https://subdomain.google-analytics.com/track blocked due to missing consent'
+			);
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'can be disabled via config',
+		async () => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{
+					disableAutomaticBlocking: true,
+				},
+				BLOCKED_CONSENT
+			);
+			await fetch('https://www.google-analytics.com/analytics.js');
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch
+			).toHaveBeenCalledWith('https://www.google-analytics.com/analytics.js');
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'cleanup restores original fetch and XMLHttpRequest functionality',
+		async () => {
+			const trackingBlocker = (0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			await (0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch('https://www.google-analytics.com/analytics.js')
+			).rejects.toThrow();
+			trackingBlocker.destroy();
+			await fetch('https://www.google-analytics.com/analytics.js');
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				fetch
+			).toHaveBeenCalledWith('https://www.google-analytics.com/analytics.js');
+			const xhr = new XMLHttpRequest();
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(() => {
+				xhr.open('GET', 'https://www.google-analytics.com/analytics.js');
+			}).not.toThrow();
+		}
+	);
+	(0, __WEBPACK_EXTERNAL_MODULE_vitest__.test)(
+		'handles multiple concurrent requests correctly',
+		async () => {
+			(0,
+			__WEBPACK_EXTERNAL_MODULE__tracking_blocker_js_d038b07a__.createTrackingBlocker)(
+				{},
+				BLOCKED_CONSENT
+			);
+			const requests = Promise.all([
+				(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+					fetch('https://www.google-analytics.com/analytics.js')
+				).rejects.toThrow(),
+				(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+					fetch('https://www.google-analytics.com/collect')
+				).rejects.toThrow(),
+				fetch('https://api.example.com/data'),
+			]);
+			await requests;
+			(0, __WEBPACK_EXTERNAL_MODULE_vitest__.expect)(
+				document.dispatchEvent
+			).toHaveBeenCalledTimes(6);
+		}
+	);
+});

package/dist/libs/consent-utils.cjs

@@ -0,0 +1,68 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.d = function (exports1, definition) {
+		for (var key in definition)
+			if (
+				__webpack_require__.o(definition, key) &&
+				!__webpack_require__.o(exports1, key)
+			)
+				Object.defineProperty(exports1, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+	};
+})();
+(() => {
+	__webpack_require__.o = function (obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	};
+})();
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+	getEffectiveConsents: () => getEffectiveConsents,
+	hasConsentFor: () => hasConsentFor,
+	hasConsented: () => hasConsented,
+	isConsentEnabled: () => isConsentEnabled,
+});
+function getEffectiveConsents(consents, honorDoNotTrack) {
+	if (
+		honorDoNotTrack &&
+		'undefined' != typeof window &&
+		'1' === window.navigator.doNotTrack
+	)
+		return Object.keys(consents).reduce((acc, key) => {
+			if (key in consents) acc[key] = 'necessary' === key;
+			return acc;
+		}, {});
+	return consents;
+}
+function hasConsentFor(consentType, consents, honorDoNotTrack) {
+	const effectiveConsents = getEffectiveConsents(consents, honorDoNotTrack);
+	return effectiveConsents[consentType] || false;
+}
+function hasConsented(consentInfo) {
+	return null !== consentInfo;
+}
+function isConsentEnabled(consentType, consents) {
+	return consents[consentType] || false;
+}
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/libs/consent-utils.d.ts

@@ -0,0 +1,49 @@
+import type { AllConsentNames, ConsentState } from '../types';
+/**
+ * Determines the effective consents based on the user's Do Not Track setting.
+ *
+ * @param consents - The current state of user consents.
+ * @param honorDoNotTrack - Whether to respect the user's Do Not Track setting.
+ * @returns The effective consents after considering Do Not Track.
+ */
+export declare function getEffectiveConsents(
+	consents: ConsentState,
+	honorDoNotTrack: boolean
+): ConsentState;
+/**
+ * Checks if the user has given consent for a specific type.
+ *
+ * @param consentType - The type of consent to check.
+ * @param consents - The current state of user consents.
+ * @param honorDoNotTrack - Whether to respect the user's Do Not Track setting.
+ * @returns True if consent is given, false otherwise.
+ */
+export declare function hasConsentFor(
+	consentType: AllConsentNames,
+	consents: ConsentState,
+	honorDoNotTrack: boolean
+): boolean;
+/**
+ * Determines if the user has consented based on consent information.
+ *
+ * @param consentInfo - The consent information.
+ * @returns True if the user has consented, false otherwise.
+ */
+export declare function hasConsented(
+	consentInfo: {
+		time: number;
+		type: 'all' | 'custom' | 'necessary';
+	} | null
+): boolean;
+/**
+ * Checks if a specific consent type is enabled.
+ *
+ * @param consentType - The type of consent to check.
+ * @param consents - The current state of user consents.
+ * @returns True if the consent type is enabled, false otherwise.
+ */
+export declare function isConsentEnabled(
+	consentType: AllConsentNames,
+	consents: ConsentState
+): boolean;
+//# sourceMappingURL=consent-utils.d.ts.map

package/dist/libs/consent-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-utils.d.ts","sourceRoot":"","sources":["../../src/libs/consent-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,YAAY,EACtB,eAAe,EAAE,OAAO,GACtB,YAAY,CAcd;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,WAAW,EAAE,eAAe,EAC5B,QAAQ,EAAE,YAAY,EACtB,eAAe,EAAE,OAAO,GACtB,OAAO,CAGT;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC3B,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,WAAW,CAAA;CAAE,GAAG,IAAI,GACxE,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,eAAe,EAC5B,QAAQ,EAAE,YAAY,GACpB,OAAO,CAET"}

package/dist/libs/consent-utils.js

@@ -0,0 +1,23 @@
+function getEffectiveConsents(consents, honorDoNotTrack) {
+	if (
+		honorDoNotTrack &&
+		'undefined' != typeof window &&
+		'1' === window.navigator.doNotTrack
+	)
+		return Object.keys(consents).reduce((acc, key) => {
+			if (key in consents) acc[key] = 'necessary' === key;
+			return acc;
+		}, {});
+	return consents;
+}
+function hasConsentFor(consentType, consents, honorDoNotTrack) {
+	const effectiveConsents = getEffectiveConsents(consents, honorDoNotTrack);
+	return effectiveConsents[consentType] || false;
+}
+function hasConsented(consentInfo) {
+	return null !== consentInfo;
+}
+function isConsentEnabled(consentType, consents) {
+	return consents[consentType] || false;
+}
+export { getEffectiveConsents, hasConsentFor, hasConsented, isConsentEnabled };

package/dist/libs/tracking-blocker.cjs

@@ -0,0 +1,167 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.n = function (module) {
+		var getter =
+			module && module.__esModule
+				? function () {
+						return module['default'];
+					}
+				: function () {
+						return module;
+					};
+		__webpack_require__.d(getter, {
+			a: getter,
+		});
+		return getter;
+	};
+})();
+(() => {
+	__webpack_require__.d = function (exports1, definition) {
+		for (var key in definition)
+			if (
+				__webpack_require__.o(definition, key) &&
+				!__webpack_require__.o(exports1, key)
+			)
+				Object.defineProperty(exports1, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+	};
+})();
+(() => {
+	__webpack_require__.o = function (obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	};
+})();
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+	createTrackingBlocker: () => createTrackingBlocker,
+});
+const external_tracking_domains_cjs_namespaceObject = require('./tracking-domains.cjs');
+var external_tracking_domains_cjs_default = /*#__PURE__*/ __webpack_require__.n(
+	external_tracking_domains_cjs_namespaceObject
+);
+function createDefaultConsentState() {
+	return {
+		experience: false,
+		functionality: false,
+		marketing: false,
+		measurement: false,
+		necessary: true,
+	};
+}
+function createTrackingBlocker(config = {}, initialConsents) {
+	const blockerConfig = {
+		disableAutomaticBlocking: false,
+		...config,
+		domainConsentMap: config.overrideDomainConsentMap
+			? config.domainConsentMap
+			: {
+					...external_tracking_domains_cjs_default(),
+					...config.domainConsentMap,
+				},
+	};
+	let consents = initialConsents || createDefaultConsentState();
+	const originalFetch = window.fetch;
+	const originalXHR = window.XMLHttpRequest;
+	function normalizeDomain(domain) {
+		return domain
+			.toLowerCase()
+			.replace(/^www\./, '')
+			.replace(/:\d+$/, '')
+			.trim();
+	}
+	function findMatchingDomain(domain, domainMap) {
+		const normalizedDomain = normalizeDomain(domain);
+		const directMatch = domainMap[normalizedDomain];
+		if (directMatch) return directMatch;
+		for (const [mapDomain, consent] of Object.entries(domainMap)) {
+			const normalizedMapDomain = normalizeDomain(mapDomain);
+			if (
+				normalizedDomain.endsWith(`.${normalizedMapDomain}`) ||
+				normalizedDomain === normalizedMapDomain
+			)
+				return consent;
+		}
+	}
+	function isRequestAllowed(url) {
+		try {
+			const domain = new URL(url).hostname;
+			const requiredConsent = findMatchingDomain(
+				domain,
+				blockerConfig.domainConsentMap || {}
+			);
+			if (!requiredConsent) return true;
+			const isAllowed = true === consents[requiredConsent];
+			return isAllowed;
+		} catch (error) {
+			return true;
+		}
+	}
+	function dispatchConsentBlockedEvent(url) {
+		document.dispatchEvent(
+			new CustomEvent('ConsentBlockedRequest', {
+				detail: {
+					url,
+				},
+			})
+		);
+	}
+	function interceptNetworkRequests() {
+		if (window.fetch === originalFetch)
+			window.fetch = async (input, init) => {
+				const url = input instanceof Request ? input.url : input.toString();
+				if (!isRequestAllowed(url)) {
+					dispatchConsentBlockedEvent(url);
+					return Promise.reject(
+						new Error(`Request to ${url} blocked due to missing consent`)
+					);
+				}
+				return await originalFetch.call(window, input, init);
+			};
+		if (window.XMLHttpRequest === originalXHR)
+			window.XMLHttpRequest = class extends originalXHR {
+				open(method, url, async = true, username, password) {
+					if (!isRequestAllowed(url.toString())) {
+						dispatchConsentBlockedEvent(url.toString());
+						throw new Error(`Request to ${url} blocked due to missing consent`);
+					}
+					super.open(method, url, async, username, password);
+				}
+			};
+	}
+	function restoreOriginalRequests() {
+		if (window.fetch !== originalFetch) window.fetch = originalFetch;
+		if (window.XMLHttpRequest !== originalXHR)
+			window.XMLHttpRequest = originalXHR;
+	}
+	if (!blockerConfig.disableAutomaticBlocking) interceptNetworkRequests();
+	return {
+		updateConsents: (newConsents) => {
+			consents = newConsents;
+		},
+		destroy: () => {
+			restoreOriginalRequests();
+		},
+	};
+}
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/libs/tracking-blocker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @packageDocumentation
+ * Implements automatic blocking of tracking scripts and network requests until user consent is granted.
+ *
+ * IMPORTANT: This module overrides global `fetch` and `XMLHttpRequest` APIs to enforce consent requirements.
+ * While this approach is necessary for proper consent management, it may conflict with other libraries that
+ * also modify these APIs. This implementation takes precedence to ensure compliance.
+ */
+import type { AllConsentNames, ConsentState } from '../types';
+/**
+ * Configuration options for the tracking blocker
+ */
+export interface TrackingBlockerConfig {
+	/** Whether to disable automatic blocking (defaults to false) */
+	disableAutomaticBlocking?: boolean;
+	/** Override the default domain consent map */
+	overrideDomainConsentMap?: boolean;
+	/** Map of domains to their required consent types */
+	domainConsentMap?: Record<string, AllConsentNames>;
+}
+interface TrackingBlocker {
+	updateConsents: (newConsents: ConsentState) => void;
+	destroy: () => void;
+}
+/**
+ * Creates a tracking blocker instance that handles blocking of tracking scripts and network requests
+ */
+export declare function createTrackingBlocker(
+	config?: TrackingBlockerConfig,
+	initialConsents?: ConsentState
+): TrackingBlocker;
+export {};
+//# sourceMappingURL=tracking-blocker.d.ts.map

package/dist/libs/tracking-blocker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking-blocker.d.ts","sourceRoot":"","sources":["../../src/libs/tracking-blocker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG9D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,gEAAgE;IAChE,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAEnC,8CAA8C;IAC9C,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAEnC,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACnD;AAeD,UAAU,eAAe;IACxB,cAAc,EAAE,CAAC,WAAW,EAAE,YAAY,KAAK,IAAI,CAAC;IACpD,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,GAAE,qBAA0B,EAClC,eAAe,CAAC,EAAE,YAAY,GAC5B,eAAe,CAuJjB"}