@c15t/scripts 2.0.1 → 2.1.0

package/dist/vendors/analytics/plausible-analytics.js

@@ -0,0 +1,81 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+function buildPlausibleScriptUrl(options) {
+    if (options.scriptId) return `https://plausible.io/js/pa-${options.scriptId}.js`;
+    if (options.extension) {
+        let extensions;
+        extensions = Array.isArray(options.extension) ? options.extension.join('.') : options.extension;
+        return `https://plausible.io/js/script.${extensions}.js`;
+    }
+    return "https://plausible.io/js/script.js";
+}
+function buildPlausibleInitOptions(options) {
+    const initOptions = {};
+    if (options.customProperties) initOptions.customProperties = options.customProperties;
+    if (options.endpoint) initOptions.endpoint = options.endpoint;
+    if (options.fileDownloads) initOptions.fileDownloads = options.fileDownloads;
+    if (void 0 !== options.hashBasedRouting) initOptions.hashBasedRouting = options.hashBasedRouting;
+    if (void 0 !== options.autoCapturePageviews) initOptions.autoCapturePageviews = options.autoCapturePageviews;
+    if (void 0 !== options.captureOnLocalhost) initOptions.captureOnLocalhost = options.captureOnLocalhost;
+    return initOptions;
+}
+const plausibleAnalyticsManifest = {
+    ...vendorManifestContract,
+    vendor: 'plausible-analytics',
+    category: 'measurement',
+    bootstrap: [
+        {
+            type: 'defineStubFunction',
+            name: 'plausible',
+            queue: {
+                property: 'q'
+            },
+            queueFormat: 'array',
+            properties: {
+                o: '{{initOptions}}'
+            },
+            ifUndefined: true
+        }
+    ],
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            defer: true,
+            attributes: {
+                'data-domain': '{{domain}}',
+                'data-api': '{{apiAttribute}}'
+            }
+        }
+    ]
+};
+function plausibleAnalytics(options) {
+    let scriptId;
+    if (options.scriptId) scriptId = options.scriptId.trim();
+    let domain;
+    if (options.domain) domain = options.domain.trim();
+    if (!scriptId && !domain) throw new Error("plausibleAnalytics: missing scriptId or domain");
+    const normalizedOptions = {
+        ...options
+    };
+    if (scriptId) normalizedOptions.scriptId = scriptId;
+    else delete normalizedOptions.scriptId;
+    if (domain) normalizedOptions.domain = domain;
+    else delete normalizedOptions.domain;
+    const manifestOptions = {
+        scriptUrl: normalizedOptions.scriptUrl ?? buildPlausibleScriptUrl(normalizedOptions),
+        domain: void 0,
+        apiAttribute: void 0,
+        initOptions: buildPlausibleInitOptions(normalizedOptions)
+    };
+    if (scriptId) {
+        manifestOptions.domain = void 0;
+        manifestOptions.apiAttribute = void 0;
+    } else {
+        manifestOptions.domain = domain;
+        manifestOptions.apiAttribute = normalizedOptions.endpoint;
+    }
+    const resolved = resolveManifest(plausibleAnalyticsManifest, manifestOptions);
+    return resolved;
+}
+export { plausibleAnalytics, plausibleAnalyticsManifest };

package/dist/{posthog.cjs → vendors/analytics/posthog.cjs}

@@ -27,8 +27,53 @@ __webpack_require__.d(__webpack_exports__, {
     posthogManifest: ()=>posthogManifest,
     posthog: ()=>posthog
 });
-const external_resolve_cjs_namespaceObject = require("./resolve.cjs");
-const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const script_url_cjs_namespaceObject = require("../_shared/script-url.cjs");
+const DEFAULT_API_HOST = 'https://eu.i.posthog.com';
+const DEFAULT_SCRIPT_URL = 'https://eu-assets.i.posthog.com/static/array.js';
+const DEFAULT_UI_HOST = 'https://eu.posthog.com';
+const DEFAULTS_DATE = '2026-01-30';
+const REGION_HOSTS = {
+    eu: {
+        apiHost: DEFAULT_API_HOST,
+        uiHost: DEFAULT_UI_HOST,
+        scriptUrl: DEFAULT_SCRIPT_URL
+    },
+    us: {
+        apiHost: 'https://us.i.posthog.com',
+        uiHost: 'https://us.posthog.com',
+        scriptUrl: 'https://us-assets.i.posthog.com/static/array.js'
+    }
+};
+function normalizeHost(host) {
+    return (0, script_url_cjs_namespaceObject.stripTrailingSlashes)(host);
+}
+function regionFromHost(host) {
+    const normalized = normalizeHost(host);
+    if (/^https:\/\/(app|us|us-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'us';
+    if (/^https:\/\/(eu|eu-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'eu';
+}
+function deriveScriptUrlFromApiHost(apiHost) {
+    const normalized = normalizeHost(apiHost);
+    const region = regionFromHost(normalized);
+    if (region) return REGION_HOSTS[region].scriptUrl;
+    return `${normalized}/static/array.js`;
+}
+function resolvePosthogHosts(options) {
+    const regionDefaults = REGION_HOSTS[options.region ?? 'eu'];
+    const apiHost = normalizeHost(options.apiHost ?? regionDefaults.apiHost);
+    const inferredRegion = regionFromHost(apiHost);
+    let uiHost;
+    uiHost = void 0 !== options.uiHost ? options.uiHost : inferredRegion ? REGION_HOSTS[inferredRegion].uiHost : void 0 !== options.region ? REGION_HOSTS[options.region].uiHost : apiHost;
+    let scriptUrl;
+    scriptUrl = void 0 !== options.scriptUrl ? options.scriptUrl : void 0 !== options.apiHost ? deriveScriptUrlFromApiHost(apiHost) : regionDefaults.scriptUrl;
+    return {
+        apiHost,
+        uiHost: normalizeHost(uiHost),
+        scriptUrl
+    };
+}
 const posthogManifest = {
     ...external_types_cjs_namespaceObject.vendorManifestContract,
     vendor: 'posthog',
@@ -49,6 +94,10 @@ const posthogManifest = {
                     name: 'init',
                     behavior: 'noop'
                 },
+                {
+                    name: 'capture',
+                    behavior: 'noop'
+                },
                 {
                     name: 'opt_in_capturing',
                     behavior: 'noop'
@@ -73,7 +122,7 @@ const posthogManifest = {
             attributes: {
                 crossorigin: 'anonymous',
                 'data-api-host': '{{apiHost}}',
-                'data-ui-host': '{{apiHost}}'
+                'data-ui-host': '{{uiHost}}'
             }
         }
     ],
@@ -118,12 +167,26 @@ const posthogManifest = {
     ]
 };
 function posthog(options) {
+    if ('disabled' === options.loadMode) return {
+        id: 'posthog',
+        category: 'measurement',
+        callbackOnly: true
+    };
+    const { apiHost, uiHost, scriptUrl } = resolvePosthogHosts(options);
     const resolved = (0, external_resolve_cjs_namespaceObject.resolveManifest)(posthogManifest, {
         id: options.id,
-        apiHost: options.apiHost ?? 'https://eu.i.posthog.com',
-        scriptUrl: options.scriptUrl ?? 'https://eu-assets.i.posthog.com/static/array.js',
-        initOptions: options.initOptions ?? {}
+        apiHost,
+        uiHost,
+        scriptUrl,
+        initOptions: {
+            defaults: DEFAULTS_DATE,
+            cookieless_mode: 'on_reject',
+            ...options.initOptions,
+            api_host: apiHost,
+            ui_host: uiHost
+        }
     });
+    if ('after-consent' === options.loadMode) resolved.alwaysLoad = void 0;
     return resolved;
 }
 exports.posthog = __webpack_exports__.posthog;

package/dist/vendors/analytics/posthog.js

@@ -0,0 +1,163 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { stripTrailingSlashes } from "../_shared/script-url.js";
+const DEFAULT_API_HOST = 'https://eu.i.posthog.com';
+const DEFAULT_SCRIPT_URL = 'https://eu-assets.i.posthog.com/static/array.js';
+const DEFAULT_UI_HOST = 'https://eu.posthog.com';
+const DEFAULTS_DATE = '2026-01-30';
+const REGION_HOSTS = {
+    eu: {
+        apiHost: DEFAULT_API_HOST,
+        uiHost: DEFAULT_UI_HOST,
+        scriptUrl: DEFAULT_SCRIPT_URL
+    },
+    us: {
+        apiHost: 'https://us.i.posthog.com',
+        uiHost: 'https://us.posthog.com',
+        scriptUrl: 'https://us-assets.i.posthog.com/static/array.js'
+    }
+};
+function normalizeHost(host) {
+    return stripTrailingSlashes(host);
+}
+function regionFromHost(host) {
+    const normalized = normalizeHost(host);
+    if (/^https:\/\/(app|us|us-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'us';
+    if (/^https:\/\/(eu|eu-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'eu';
+}
+function deriveScriptUrlFromApiHost(apiHost) {
+    const normalized = normalizeHost(apiHost);
+    const region = regionFromHost(normalized);
+    if (region) return REGION_HOSTS[region].scriptUrl;
+    return `${normalized}/static/array.js`;
+}
+function resolvePosthogHosts(options) {
+    const regionDefaults = REGION_HOSTS[options.region ?? 'eu'];
+    const apiHost = normalizeHost(options.apiHost ?? regionDefaults.apiHost);
+    const inferredRegion = regionFromHost(apiHost);
+    let uiHost;
+    uiHost = void 0 !== options.uiHost ? options.uiHost : inferredRegion ? REGION_HOSTS[inferredRegion].uiHost : void 0 !== options.region ? REGION_HOSTS[options.region].uiHost : apiHost;
+    let scriptUrl;
+    scriptUrl = void 0 !== options.scriptUrl ? options.scriptUrl : void 0 !== options.apiHost ? deriveScriptUrlFromApiHost(apiHost) : regionDefaults.scriptUrl;
+    return {
+        apiHost,
+        uiHost: normalizeHost(uiHost),
+        scriptUrl
+    };
+}
+const posthogManifest = {
+    ...vendorManifestContract,
+    vendor: 'posthog',
+    category: 'measurement',
+    alwaysLoad: true,
+    bootstrap: [
+        {
+            type: 'setGlobal',
+            name: 'posthog',
+            value: {},
+            ifUndefined: true
+        },
+        {
+            type: 'defineGlobalMethods',
+            target: 'posthog',
+            methods: [
+                {
+                    name: 'init',
+                    behavior: 'noop'
+                },
+                {
+                    name: 'capture',
+                    behavior: 'noop'
+                },
+                {
+                    name: 'opt_in_capturing',
+                    behavior: 'noop'
+                },
+                {
+                    name: 'opt_out_capturing',
+                    behavior: 'noop'
+                },
+                {
+                    name: 'get_explicit_consent_status',
+                    behavior: 'return',
+                    value: 'pending'
+                }
+            ]
+        }
+    ],
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            async: true,
+            attributes: {
+                crossorigin: 'anonymous',
+                'data-api-host': '{{apiHost}}',
+                'data-ui-host': '{{uiHost}}'
+            }
+        }
+    ],
+    afterLoad: [
+        {
+            type: 'callGlobal',
+            global: 'posthog',
+            method: 'init',
+            args: [
+                '{{id}}',
+                '{{initOptions}}'
+            ]
+        }
+    ],
+    onLoadGranted: [
+        {
+            type: 'callGlobal',
+            global: 'posthog',
+            method: 'opt_in_capturing'
+        }
+    ],
+    onLoadDenied: [
+        {
+            type: 'callGlobal',
+            global: 'posthog',
+            method: 'opt_out_capturing'
+        }
+    ],
+    onConsentGranted: [
+        {
+            type: 'callGlobal',
+            global: 'posthog',
+            method: 'opt_in_capturing'
+        }
+    ],
+    onConsentDenied: [
+        {
+            type: 'callGlobal',
+            global: 'posthog',
+            method: 'opt_out_capturing'
+        }
+    ]
+};
+function posthog(options) {
+    if ('disabled' === options.loadMode) return {
+        id: 'posthog',
+        category: 'measurement',
+        callbackOnly: true
+    };
+    const { apiHost, uiHost, scriptUrl } = resolvePosthogHosts(options);
+    const resolved = resolveManifest(posthogManifest, {
+        id: options.id,
+        apiHost,
+        uiHost,
+        scriptUrl,
+        initOptions: {
+            defaults: DEFAULTS_DATE,
+            cookieless_mode: 'on_reject',
+            ...options.initOptions,
+            api_host: apiHost,
+            ui_host: uiHost
+        }
+    });
+    if ('after-consent' === options.loadMode) resolved.alwaysLoad = void 0;
+    return resolved;
+}
+export { posthog, posthogManifest };

package/dist/vendors/analytics/promptwatch.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (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 = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    promptwatchManifest: ()=>promptwatchManifest,
+    promptwatch: ()=>promptwatch
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const script_url_cjs_namespaceObject = require("../_shared/script-url.cjs");
+const promptwatchManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'promptwatch',
+    category: 'measurement',
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            async: true,
+            attributes: {
+                'data-project-id': '{{projectId}}'
+            }
+        }
+    ]
+};
+function promptwatch({ projectId, scriptUrl }) {
+    const normalizedProjectId = projectId.trim();
+    if (0 === normalizedProjectId.length) throw new Error('promptwatch: invalid projectId - must be a non-empty string');
+    const defaultScriptUrl = 'https://ingest.promptwatch.com/js/client.min.js';
+    const normalizedScriptUrl = (0, script_url_cjs_namespaceObject.resolveScriptUrl)((0, script_url_cjs_namespaceObject.trimToUndefined)(scriptUrl), defaultScriptUrl);
+    return (0, external_resolve_cjs_namespaceObject.resolveManifest)(promptwatchManifest, {
+        projectId: normalizedProjectId,
+        scriptUrl: normalizedScriptUrl
+    });
+}
+exports.promptwatch = __webpack_exports__.promptwatch;
+exports.promptwatchManifest = __webpack_exports__.promptwatchManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "promptwatch",
+    "promptwatchManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/vendors/analytics/promptwatch.js

@@ -0,0 +1,29 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
+const promptwatchManifest = {
+    ...vendorManifestContract,
+    vendor: 'promptwatch',
+    category: 'measurement',
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            async: true,
+            attributes: {
+                'data-project-id': '{{projectId}}'
+            }
+        }
+    ]
+};
+function promptwatch({ projectId, scriptUrl }) {
+    const normalizedProjectId = projectId.trim();
+    if (0 === normalizedProjectId.length) throw new Error('promptwatch: invalid projectId - must be a non-empty string');
+    const defaultScriptUrl = 'https://ingest.promptwatch.com/js/client.min.js';
+    const normalizedScriptUrl = resolveScriptUrl(trimToUndefined(scriptUrl), defaultScriptUrl);
+    return resolveManifest(promptwatchManifest, {
+        projectId: normalizedProjectId,
+        scriptUrl: normalizedScriptUrl
+    });
+}
+export { promptwatch, promptwatchManifest };

package/dist/vendors/analytics/rybbit-analytics.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (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 = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    rybbitAnalytics: ()=>rybbitAnalytics,
+    rybbitAnalyticsManifest: ()=>rybbitAnalyticsManifest
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const attributes_cjs_namespaceObject = require("../_shared/attributes.cjs");
+const script_url_cjs_namespaceObject = require("../_shared/script-url.cjs");
+const rybbitAnalyticsManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'rybbit-analytics',
+    category: 'measurement',
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            defer: true,
+            attributes: {
+                'data-site-id': '{{siteId}}',
+                'data-auto-track-pageview': '{{autoTrackPageview}}',
+                'data-track-spa': '{{trackSpa}}',
+                'data-track-query': '{{trackQuery}}',
+                'data-track-outbound': '{{trackOutbound}}',
+                'data-track-errors': '{{trackErrors}}',
+                'data-session-replay': '{{sessionReplay}}',
+                'data-web-vitals': '{{webVitals}}',
+                'data-skip-patterns': '{{skipPatterns}}',
+                'data-mask-patterns': '{{maskPatterns}}',
+                'data-debounce': '{{debounce}}',
+                'data-api-key': '{{apiKey}}'
+            }
+        }
+    ]
+};
+function getRybbitScriptUrl(options) {
+    const url = options.scriptUrl?.trim();
+    if (url && url.length > 0) return url;
+    if (options.analyticsHost) return (0, script_url_cjs_namespaceObject.joinUrlPath)(options.analyticsHost, "script.js");
+    return "https://app.rybbit.io/api/script.js";
+}
+function rybbitAnalytics(options) {
+    let siteId;
+    siteId = void 0 === options.siteId || null === options.siteId ? '' : String(options.siteId).trim();
+    if (0 === siteId.length) throw new Error('rybbitAnalytics: missing siteId');
+    let debounce;
+    if (void 0 !== options.debounce) debounce = String(options.debounce);
+    let skipPatterns;
+    if (options.skipPatterns) skipPatterns = JSON.stringify(options.skipPatterns);
+    let maskPatterns;
+    if (options.maskPatterns) maskPatterns = JSON.stringify(options.maskPatterns);
+    return (0, external_resolve_cjs_namespaceObject.resolveManifest)(rybbitAnalyticsManifest, {
+        scriptUrl: getRybbitScriptUrl(options),
+        siteId,
+        autoTrackPageview: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.autoTrackPageview),
+        trackSpa: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.trackSpa),
+        trackQuery: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.trackQuery),
+        trackOutbound: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.trackOutbound),
+        trackErrors: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.trackErrors),
+        sessionReplay: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.sessionReplay),
+        webVitals: (0, attributes_cjs_namespaceObject.booleanDataAttribute)(options.webVitals),
+        skipPatterns,
+        maskPatterns,
+        debounce,
+        apiKey: options.apiKey
+    });
+}
+exports.rybbitAnalytics = __webpack_exports__.rybbitAnalytics;
+exports.rybbitAnalyticsManifest = __webpack_exports__.rybbitAnalyticsManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rybbitAnalytics",
+    "rybbitAnalyticsManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/vendors/analytics/rybbit-analytics.js

@@ -0,0 +1,63 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { booleanDataAttribute } from "../_shared/attributes.js";
+import { joinUrlPath } from "../_shared/script-url.js";
+const rybbitAnalyticsManifest = {
+    ...vendorManifestContract,
+    vendor: 'rybbit-analytics',
+    category: 'measurement',
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            defer: true,
+            attributes: {
+                'data-site-id': '{{siteId}}',
+                'data-auto-track-pageview': '{{autoTrackPageview}}',
+                'data-track-spa': '{{trackSpa}}',
+                'data-track-query': '{{trackQuery}}',
+                'data-track-outbound': '{{trackOutbound}}',
+                'data-track-errors': '{{trackErrors}}',
+                'data-session-replay': '{{sessionReplay}}',
+                'data-web-vitals': '{{webVitals}}',
+                'data-skip-patterns': '{{skipPatterns}}',
+                'data-mask-patterns': '{{maskPatterns}}',
+                'data-debounce': '{{debounce}}',
+                'data-api-key': '{{apiKey}}'
+            }
+        }
+    ]
+};
+function getRybbitScriptUrl(options) {
+    const url = options.scriptUrl?.trim();
+    if (url && url.length > 0) return url;
+    if (options.analyticsHost) return joinUrlPath(options.analyticsHost, "script.js");
+    return "https://app.rybbit.io/api/script.js";
+}
+function rybbitAnalytics(options) {
+    let siteId;
+    siteId = void 0 === options.siteId || null === options.siteId ? '' : String(options.siteId).trim();
+    if (0 === siteId.length) throw new Error('rybbitAnalytics: missing siteId');
+    let debounce;
+    if (void 0 !== options.debounce) debounce = String(options.debounce);
+    let skipPatterns;
+    if (options.skipPatterns) skipPatterns = JSON.stringify(options.skipPatterns);
+    let maskPatterns;
+    if (options.maskPatterns) maskPatterns = JSON.stringify(options.maskPatterns);
+    return resolveManifest(rybbitAnalyticsManifest, {
+        scriptUrl: getRybbitScriptUrl(options),
+        siteId,
+        autoTrackPageview: booleanDataAttribute(options.autoTrackPageview),
+        trackSpa: booleanDataAttribute(options.trackSpa),
+        trackQuery: booleanDataAttribute(options.trackQuery),
+        trackOutbound: booleanDataAttribute(options.trackOutbound),
+        trackErrors: booleanDataAttribute(options.trackErrors),
+        sessionReplay: booleanDataAttribute(options.sessionReplay),
+        webVitals: booleanDataAttribute(options.webVitals),
+        skipPatterns,
+        maskPatterns,
+        debounce,
+        apiKey: options.apiKey
+    });
+}
+export { rybbitAnalytics, rybbitAnalyticsManifest };