@coframe/sdk 1.1.0

package/dist/pkg/cf.esm.mjs

@@ -0,0 +1,3344 @@
+if (!Array.prototype.find) {
+    Object.defineProperty(Array.prototype, 'find', {
+        value: function (predicate, thisArg) {
+            if (this == null) {
+                throw new TypeError('Array.prototype.find called on null or undefined');
+            }
+            if (typeof predicate !== 'function') {
+                throw new TypeError('predicate must be a function');
+            }
+            const list = Object(this);
+            const length = list.length >>> 0;
+            for (let i = 0; i < length; i++) {
+                const value = list[i];
+                if (predicate.call(thisArg, value, i, list)) {
+                    return value;
+                }
+            }
+            return undefined;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+if (!Array.prototype.flatMap) {
+    Object.defineProperty(Array.prototype, 'flatMap', {
+        value: function (callback, thisArg) {
+            if (this == null) {
+                throw new TypeError('Array.prototype.flatMap called on null or undefined');
+            }
+            if (typeof callback !== 'function') {
+                throw new TypeError('callback must be a function');
+            }
+            const result = [];
+            for (let i = 0; i < this.length; i++) {
+                if (i in this) {
+                    const mappedValue = callback.call(thisArg, this[i], i, this);
+                    if (Array.isArray(mappedValue)) {
+                        for (const item of mappedValue) {
+                            result.push(item);
+                        }
+                    }
+                    else {
+                        result.push(mappedValue);
+                    }
+                }
+            }
+            return result;
+        },
+        configurable: true,
+        writable: true,
+        enumerable: false,
+    });
+}
+if (typeof Promise !== 'undefined' && !Promise.prototype.finally) {
+    Object.defineProperty(Promise.prototype, 'finally', {
+        value: function (callback) {
+            if (typeof this !== 'object' || this === null) {
+                throw new TypeError('"this" is not a Promise');
+            }
+            if (typeof callback !== 'function') {
+                return this;
+            }
+            const PromiseCtor = this.constructor;
+            const onFinally = () => {
+                try {
+                    return callback();
+                }
+                catch (err) {
+                    return PromiseCtor.reject(err);
+                }
+            };
+            return this.then((value) => PromiseCtor.resolve(onFinally()).then(() => value), (reason) => PromiseCtor.resolve(onFinally()).then(() => {
+                throw reason;
+            }));
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+if (!Object.entries) {
+    Object.defineProperty(Object, 'entries', {
+        value: function (obj) {
+            if (obj === null || obj === undefined) {
+                throw new TypeError('Object.entries called on non-object');
+            }
+            const o = Object(obj);
+            return Object.keys(o).map((key) => [
+                key,
+                o[key],
+            ]);
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+if (typeof Event !== 'undefined' && !Event.prototype.composedPath) {
+    Object.defineProperty(Event.prototype, 'composedPath', {
+        value: function () {
+            if (!(this instanceof Event)) {
+                throw new TypeError('Illegal invocation');
+            }
+            const path = [];
+            let current = this.target;
+            while (current) {
+                path.push(current);
+                if (typeof ShadowRoot !== 'undefined' &&
+                    current instanceof ShadowRoot) {
+                    current = current.host;
+                }
+                else if (current instanceof Document) {
+                    current = current.defaultView;
+                }
+                else if (current instanceof Element) {
+                    current = current.parentNode;
+                }
+                else {
+                    current = null;
+                }
+            }
+            const win = window;
+            if (win && !path.includes(win)) {
+                path.push(win);
+            }
+            return path;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+if (!Array.from) {
+    Object.defineProperty(Array, 'from', {
+        value: function (arrayLike) {
+            if (arrayLike == null) {
+                throw new TypeError('Array.from requires an array-like or iterable object');
+            }
+            const items = Object(arrayLike);
+            const result = [];
+            let k = 0;
+            const isIterable = typeof items[Symbol.iterator] === 'function';
+            if (isIterable) {
+                const iterator = items[Symbol.iterator]();
+                let next = iterator.next();
+                while (!next.done) {
+                    result[k++] = next.value;
+                    next = iterator.next();
+                }
+            }
+            else {
+                const len = items.length >>> 0;
+                while (k < len) {
+                    result[k] = items[k];
+                    k++;
+                }
+            }
+            result.length = k;
+            return result;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+
+function getCurrentPageUrl() {
+    return window.location.href;
+}
+function getBrowserLanguages() {
+    var _a, _b;
+    return Array.from((_a = navigator === null || navigator === void 0 ? void 0 : navigator.languages) !== null && _a !== void 0 ? _a : [(_b = navigator === null || navigator === void 0 ? void 0 : navigator.language) !== null && _b !== void 0 ? _b : []]);
+}
+function getBrowserPlatform() {
+    var _a, _b, _c;
+    return ((_c = (_a = navigator === null || navigator === void 0 ? void 0 : navigator.platform) !== null && _a !== void 0 ? _a : (_b = navigator === null || navigator === void 0 ? void 0 : navigator.userAgentData) === null || _b === void 0 ? void 0 : _b.platform) !== null && _c !== void 0 ? _c : '');
+}
+function getBrowserReferrer() {
+    return document.referrer;
+}
+function getBrowserHostname() {
+    return window.location.hostname;
+}
+function getDocumentCookie() {
+    try {
+        return document.cookie;
+    }
+    catch (_error) {
+        return '';
+    }
+}
+function setDocumentCookie(cookie) {
+    document.cookie = cookie;
+}
+function getBrowserUserAgent() {
+    return (navigator && navigator.userAgent) || '';
+}
+function getBrowserFignerprintInfo() {
+    const cookieKeys = [];
+    const localStorageKeys = [];
+    const sessionStorageKeys = [];
+    try {
+        const cookieStr = getDocumentCookie();
+        if (cookieStr) {
+            const cookiePairs = cookieStr.split(';').map((c) => c.trim());
+            for (const cookie of cookiePairs) {
+                const [name] = cookie.split('=');
+                if (name) {
+                    if (name.startsWith('coframe.')) {
+                        continue;
+                    }
+                    cookieKeys.push(name);
+                }
+            }
+        }
+    }
+    catch (_error) {
+    }
+    try {
+        if (typeof window !== 'undefined' && window.localStorage) {
+            const keys = Object.keys(window.localStorage);
+            for (const key of keys) {
+                localStorageKeys.push(key);
+            }
+        }
+    }
+    catch (_error) {
+    }
+    try {
+        if (typeof window !== 'undefined' && window.sessionStorage) {
+            const keys = Object.keys(window.sessionStorage);
+            for (const key of keys) {
+                sessionStorageKeys.push(key);
+            }
+        }
+    }
+    catch (_error) {
+    }
+    return {
+        cookie_keys: cookieKeys,
+        local_storage_keys: localStorageKeys,
+        session_storage_keys: sessionStorageKeys,
+    };
+}
+
+const USER_TOKEN_COOKIE_KEY = 'coframe.user.token';
+const LAST_VISIT_TIME_KEY = 'coframe.lastVisitTime';
+const VISIT_COUNT_COOKIE_KEY = 'coframe.cvc';
+const LANE_COOKIE_KEY = 'coframe.lanes';
+const COOKIE_DAYS = 400;
+function getGlobalScope() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+}
+const generateUUID = () => {
+    var _a;
+    const cryptoObject = (_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.crypto;
+    if (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID)
+        return cryptoObject.randomUUID();
+    return `${1e7}${ -1e3}${ -4e3}${ -8e3}${ -1e11}`.replace(/[018]/g, (c) => {
+        var _a, _b;
+        const randomValue = (_b = (_a = cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues) === null || _a === void 0 ? void 0 : _a.call(cryptoObject, new Uint8Array(1))[0]) !== null && _b !== void 0 ? _b : 0;
+        return (c ^
+            (randomValue & (15 >> (c / 4)))).toString(16);
+    });
+};
+const getCookie = (name) => {
+    const cookieStr = getDocumentCookie();
+    const regex = new RegExp(`(?:^| )${name}=([^;]*)`, 'g');
+    let match = null;
+    let lastValue = '';
+    while (true) {
+        match = regex.exec(cookieStr);
+        if (match === null)
+            break;
+        lastValue = match[1];
+    }
+    return lastValue;
+};
+let isCookiesEnabled = false;
+const setCookiesEnabled = (allowed) => {
+    isCookiesEnabled = allowed;
+};
+const setCookie = (name, value, logger) => {
+    if (!isCookiesEnabled) {
+        logger.error('Cookies are not enabled', 'setting_cookie_when_disabled');
+        return;
+    }
+    const expirationDate = new Date();
+    expirationDate.setTime(expirationDate.getTime() + 24 * 60 * 60 * 1000 * COOKIE_DAYS);
+    const expires = expirationDate.toUTCString();
+    const setCookieForDomain = (domain) => {
+        const cookie = domain
+            ? `${name}=${value};path=/;domain=${domain};expires=${expires};secure`
+            : `${name}=${value};path=/;expires=${expires};secure`;
+        setDocumentCookie(cookie);
+    };
+    const hostname = getBrowserHostname();
+    if (hostname === 'localhost') {
+        setCookieForDomain();
+    }
+    else {
+        const domainParts = hostname.split('.');
+        for (let i = domainParts.length - 2; i >= 0; i--) {
+            let domain = `${domainParts.slice(i).join('.')}`;
+            if (i !== 0) {
+                domain = `.${domain}`;
+            }
+            setCookieForDomain(domain);
+        }
+    }
+    if (getCookie(name) !== value) {
+        logger.error(`Failed to set cookie ${name} for domain: ${hostname}`, 'failed_to_set_cookie', {
+            name,
+            hostname,
+        });
+    }
+};
+const getOrGenerateUserToken = () => {
+    let uuid = getCookie(USER_TOKEN_COOKIE_KEY);
+    if (!uuid) {
+        uuid = generateUUID();
+    }
+    return uuid;
+};
+const setUserTokenCookie = (uuid, logger) => {
+    setCookie(USER_TOKEN_COOKIE_KEY, uuid, logger);
+};
+const trackVisitCookie = (logger) => {
+    const visitCountString = getCookie(VISIT_COUNT_COOKIE_KEY);
+    const lastVisitTime = Number.parseInt(getCookie(LAST_VISIT_TIME_KEY), 10);
+    const currentTime = Date.now();
+    const twoHours = 2 * 60 * 60 * 1000;
+    if (!lastVisitTime || currentTime - lastVisitTime > twoHours) {
+        const visitCount = visitCountString
+            ? Number.parseInt(visitCountString, 10) + 1
+            : 1;
+        setCookie(VISIT_COUNT_COOKIE_KEY, visitCount.toString(), logger);
+        setCookie(LAST_VISIT_TIME_KEY, currentTime.toString(), logger);
+    }
+};
+
+const selectorCache = new WeakMap();
+const getSelector = (element, options) => {
+    const opts = {
+        withDescendants: true,
+        cache: true,
+        ...options,
+    };
+    if (opts.cache === false) {
+        return getSelectorWithoutCache(element, options);
+    }
+    const cacheKey = JSON.stringify(opts);
+    if (!selectorCache.has(element)) {
+        selectorCache.set(element, new Map());
+    }
+    const elementCache = selectorCache.get(element);
+    if (elementCache === null || elementCache === void 0 ? void 0 : elementCache.has(cacheKey)) {
+        const cachedSelector = elementCache.get(cacheKey);
+        if (cachedSelector) {
+            return cachedSelector;
+        }
+    }
+    const selector = getSelectorWithoutCache(element, options);
+    if (elementCache) {
+        elementCache.set(cacheKey, selector);
+    }
+    return selector;
+};
+const getSelectorWithoutCache = (element, options) => {
+    const opts = {
+        withDescendants: true,
+        ...options,
+    };
+    const generateHash = (data) => {
+        let hash = 0;
+        if (data.length === 0)
+            return hash.toString();
+        for (let i = 0; i < data.length; i++) {
+            const char = data.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16);
+    };
+    function getInnerText(element) {
+        const childNodes = element.childNodes;
+        for (let i = 0; i < childNodes.length; i++) {
+            const node = childNodes[i];
+            if (node.nodeType === Node.TEXT_NODE && node.nodeValue) {
+                return node.nodeValue.trim();
+            }
+        }
+        return null;
+    }
+    function getDescendants(element, max_depth) {
+        const descendants = [];
+        function collectDescendants(el, depth) {
+            if (depth > max_depth)
+                return;
+            for (let i = 0; i < el.childNodes.length; i++) {
+                const child = el.childNodes[i];
+                if (child.nodeType === Node.ELEMENT_NODE) {
+                    descendants.push({ element: child, depth: depth });
+                    collectDescendants(child, depth + 1);
+                }
+            }
+        }
+        collectDescendants(element, 1);
+        return descendants;
+    }
+    function getShadowHost(element) {
+        if (element === document.documentElement || element === document.body) {
+            return null;
+        }
+        const rootNode = element.getRootNode();
+        if (rootNode instanceof ShadowRoot) {
+            return rootNode.host;
+        }
+        return null;
+    }
+    const getParentNode = (element) => {
+        return element.parentElement || getShadowHost(element);
+    };
+    const buildSelector = (el, ascend) => {
+        var _a;
+        const selector = {
+            t: el.tagName.toLowerCase(),
+            id: el.getAttribute('id') || undefined,
+            text: getInnerText(el) || undefined,
+            href: el.getAttribute('href') || undefined,
+            dataTestId: el.getAttribute('data-test-id') || undefined,
+            ariaLabel: el.getAttribute('aria-label') || undefined,
+        };
+        for (const key of Object.keys(selector)) {
+            if (selector[key] === undefined) {
+                delete selector[key];
+            }
+        }
+        if (el.shadowRoot) {
+            selector.isShadowRoot = true;
+        }
+        let i = 0;
+        let totalSiblings = 0;
+        let sibling = (_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.firstElementChild;
+        while (sibling) {
+            if (sibling.tagName.toLowerCase() === selector.t) {
+                totalSiblings++;
+                if (sibling === el) {
+                    i = totalSiblings;
+                }
+            }
+            sibling = sibling.nextElementSibling;
+        }
+        if (i > 0 && totalSiblings > 0) {
+            selector.n = { i, t: totalSiblings };
+        }
+        const parent = getParentNode(el);
+        if (parent && ascend) {
+            const parentSelector = buildSelector(parent, ascend);
+            if (parentSelector) {
+                selector.p = parentSelector;
+            }
+        }
+        return selector;
+    };
+    const selector = buildSelector(element, true);
+    const descendants = opts.withDescendants ? getDescendants(element, 3) : [];
+    for (const descendant of descendants) {
+        const descSelector = buildSelector(descendant.element, false);
+        if (descSelector.id ||
+            descSelector.dataTestId ||
+            descSelector.ariaLabel ||
+            descSelector.href ||
+            descSelector.text) {
+            selector.descendants = selector.descendants || [];
+            selector.descendants.push({
+                depth: descendant.depth,
+                sel: descSelector,
+            });
+        }
+    }
+    selector.fingerprint = generateHash(JSON.stringify(selector));
+    return selector;
+};
+const getElementsByHrefPrefix = (currentUrl, hrefStartsWith) => {
+    const elements = [];
+    const elementsFullUrl = document.querySelectorAll(`a[href^="${hrefStartsWith}"]`);
+    elements.push(...Array.from(elementsFullUrl));
+    const currentUrlObj = new URL(currentUrl);
+    const hrefStartsWithObj = new URL(hrefStartsWith);
+    if (currentUrlObj.hostname === hrefStartsWithObj.hostname) {
+        let relativePrefix = hrefStartsWithObj.pathname.replace(currentUrlObj.pathname, '');
+        if (relativePrefix) {
+            if (!relativePrefix.startsWith('/')) {
+                relativePrefix = `/${relativePrefix}`;
+            }
+            const elementsRelativeUrl = document.querySelectorAll(`a[href^="${relativePrefix}"]`);
+            elements.push(...Array.from(elementsRelativeUrl));
+        }
+    }
+    return elements;
+};
+const getElement = (selector, options) => {
+    if (selector.universal) {
+        return getElementUniversal((options === null || options === void 0 ? void 0 : options.context) || document, selector.universal, (options === null || options === void 0 ? void 0 : options.debug) || false).element;
+    }
+    if (selector.css) {
+        return ((options === null || options === void 0 ? void 0 : options.context) || document).querySelector(selector.css);
+    }
+    return null;
+};
+const getElementUniversal = (document, selector, debug) => {
+    var _a, _b, _c;
+    const debugList = [];
+    const debugLog = (message, xpath, element) => {
+        if (!debug)
+            return;
+        debugList.push({ xpath, message, element });
+    };
+    const tryXpath = (xpath) => {
+        if (!xpath)
+            return null;
+        let elements;
+        try {
+            elements = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+        }
+        catch (e) {
+            console.error('[Coframe] Error evaluating xpath', xpath, e);
+            return null;
+        }
+        if (elements.snapshotLength === 1) {
+            const element = elements.snapshotItem(0);
+            if (xpath !== '/html') {
+                debugLog('Found unique', xpath, element);
+            }
+            return element;
+        }
+        if (elements.snapshotLength > 1) {
+            debugLog('Found more than one element for xpath:', xpath);
+            return null;
+        }
+        debugLog('No element found for xpath:', xpath);
+        return null;
+    };
+    const tryPath = (pathSegments) => {
+        const parentXpath = pathSegments[0].xpath;
+        let element = tryXpath(parentXpath);
+        if (!element) {
+            return null;
+        }
+        let currentShadowRoot = element.shadowRoot || element;
+        let accumulatedXpath = parentXpath;
+        for (let i = 1; i < pathSegments.length; i++) {
+            const segment = pathSegments[i];
+            if (segment.isInsideShadowRoot) {
+                const childElements = currentShadowRoot.querySelectorAll(segment.css);
+                if (childElements.length === 0) {
+                    return null;
+                }
+                if (childElements.length > 1) {
+                    debugLog(`Found more than one element for css: ${segment.css}`, accumulatedXpath);
+                    return null;
+                }
+                const childElement = childElements[0];
+                if (!childElement) {
+                    return null;
+                }
+                element = childElement;
+                currentShadowRoot = element.shadowRoot || element;
+                accumulatedXpath = `${accumulatedXpath}/${segment.xpath}`;
+                debugLog(`Found ${i} shadow element`, accumulatedXpath, element);
+            }
+            else {
+                let result;
+                try {
+                    result = document.evaluate(segment.xpath, element, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+                }
+                catch (e) {
+                    console.error('[Coframe] Error evaluating xpath', segment.xpath, e);
+                    return null;
+                }
+                const partElement = result.singleNodeValue;
+                if (!partElement) {
+                    return null;
+                }
+                accumulatedXpath = `${accumulatedXpath}/${segment.xpath}`;
+                debugLog(`Found ${i} element`, accumulatedXpath, partElement);
+                element = partElement;
+                currentShadowRoot = element.shadowRoot || element;
+            }
+        }
+        return element;
+    };
+    const naivePaths = generateNaivePaths(selector);
+    let element = tryPath(naivePaths[0]);
+    if (element && !debug)
+        return { element };
+    const [relativePaths, partialRelativePaths] = generateRelativePaths(selector, 10);
+    for (const relativePath of relativePaths) {
+        element = tryPath(relativePath);
+        if (element && !debug)
+            return { element };
+    }
+    if (selector.text) {
+        const textPaths = generatePathsByText(selector.text, selector.t);
+        for (const textPath of textPaths) {
+            element = tryPath(textPath);
+            if (element && !debug)
+                return { element };
+        }
+    }
+    if (selector.descendants) {
+        for (const descendant of selector.descendants) {
+            const ancestorSelectors = {
+                xpath: `/ancestor::*[${descendant.depth}][self::${selector.t}]`,
+                css: `:nth-ancestor(${descendant.depth}):is(${selector.t})`,
+            };
+            const descPath = (_a = generateRelativePaths(descendant.sel, 1)[0]) === null || _a === void 0 ? void 0 : _a[0];
+            if (descPath && descPath.length > 0) {
+                const modifiedPath = appendToLastPathSegment(descPath, ancestorSelectors);
+                element = tryPath(modifiedPath);
+                if (element && !debug)
+                    return { element };
+            }
+            if (descendant.sel.text) {
+                const textPaths = generatePathsByText(descendant.sel.text, descendant.sel.t);
+                for (const textPath of textPaths) {
+                    if (textPath && textPath.length > 0) {
+                        const textBasedPath = appendToLastPathSegment(textPath, ancestorSelectors);
+                        element = tryPath(textBasedPath);
+                        if (element && !debug)
+                            return { element };
+                    }
+                }
+            }
+        }
+    }
+    for (const partialPath of naivePaths.slice(1)) {
+        element = tryPath(partialPath);
+        if (element && !debug)
+            return { element };
+    }
+    for (const partialPath of partialRelativePaths) {
+        element = tryPath(partialPath);
+        if (element && !debug)
+            return { element };
+    }
+    if (debug) {
+        const lastNaivePath = naivePaths.length > 0 ? naivePaths[naivePaths.length - 1] : null;
+        const lastSegment = lastNaivePath && lastNaivePath.length > 0
+            ? lastNaivePath[lastNaivePath.length - 1]
+            : null;
+        const targetXpath = ((_b = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.xpath) === null || _b === void 0 ? void 0 : _b.replace(/^\//, '')) || '';
+        const sortedDebugElements = debugList
+            .filter((log) => log.element)
+            .filter((log) => log.xpath.endsWith(targetXpath))
+            .sort((a, b) => {
+            const lengthDiff = b.xpath.length - a.xpath.length;
+            return lengthDiff !== 0 ? lengthDiff : 0;
+        });
+        const element = ((_c = sortedDebugElements[0]) === null || _c === void 0 ? void 0 : _c.element) || null;
+        return {
+            element,
+            debugList,
+        };
+    }
+    return { element: null };
+};
+const generateNaivePaths = (sel) => {
+    var _a, _b;
+    const paths = [];
+    const emptySegment = {
+        xpath: '',
+        css: '',
+        isInsideShadowRoot: false,
+    };
+    let path = [emptySegment];
+    let currentSel = sel;
+    while (currentSel) {
+        const tagName = currentSel.t;
+        if (!tagName)
+            break;
+        let subpath = `/${tagName}`;
+        let cssSegment = tagName.toLowerCase();
+        if (((_a = currentSel.n) === null || _a === void 0 ? void 0 : _a.i) && ((_b = currentSel.n) === null || _b === void 0 ? void 0 : _b.t)) {
+            subpath += `[count(../${tagName})=${currentSel.n.t}][${currentSel.n.i}]`;
+            cssSegment = `${cssSegment}:nth-of-type(${currentSel.n.i})`;
+        }
+        const isShadowBoundary = currentSel.isShadowRoot === true;
+        if (isShadowBoundary) {
+            path.push({
+                xpath: '',
+                css: '',
+                isInsideShadowRoot: true,
+            });
+        }
+        const currSegment = path[path.length - 1];
+        const restSegments = path.slice(0, -1);
+        const updatedSegment = {
+            xpath: `${subpath}${currSegment.xpath}`,
+            css: `${cssSegment} ${currSegment.css}`.trim(),
+            isInsideShadowRoot: hasShadowRoot(currentSel),
+        };
+        path = [...restSegments, updatedSegment];
+        currentSel = currentSel.p;
+        const absoluteXpath = (currentSel ? '/' : '') + updatedSegment.xpath;
+        const finalSegment = {
+            ...updatedSegment,
+            xpath: absoluteXpath,
+        };
+        const filteredSegments = [finalSegment, ...restSegments.reverse()].filter((segment) => !isSegmentEmpty(segment));
+        paths.unshift(filteredSegments);
+    }
+    return paths;
+};
+const generatePathsByText = (text, tagName) => {
+    const paths = [];
+    for (const tagQuery of [tagName, '*']) {
+        const parts = text.split("'");
+        const containsQuery = parts.length === 1
+            ?
+                `'${text}'`
+            :
+                `concat(${parts.map((part) => `'${part}'`).join(`, "'", `)})`;
+        const xpath = `//${tagQuery}[not(self::script or self::style) and contains(text(), ${containsQuery})]`;
+        const regularSegment = {
+            isInsideShadowRoot: false,
+            xpath,
+            css: `*:contains("${text}")`,
+        };
+        paths.push([regularSegment]);
+    }
+    return paths;
+};
+const generateRelativePaths = (sel, max) => {
+    var _a, _b, _c;
+    const relativePaths = [];
+    const partialRelativePaths = [];
+    let wipPaths = [{ xpath: '', css: '' }];
+    let currentSel = sel;
+    while (currentSel) {
+        const tagName = currentSel.t;
+        const uniqueQueries = [];
+        const nonUniqQueries = [];
+        const newWipPaths = [];
+        if (currentSel.id) {
+            uniqueQueries.push({
+                xpath: `[@id="${currentSel.id}"]`,
+                css: `#${currentSel.id}`,
+            });
+        }
+        else if (currentSel.dataTestId) {
+            uniqueQueries.push({
+                xpath: `[@data-test-id="${currentSel.dataTestId}"]`,
+                css: `${tagName}[data-test-id="${currentSel.dataTestId}"]`,
+            });
+        }
+        if (currentSel.ariaLabel) {
+            nonUniqQueries.push({
+                xpath: `[@aria-label="${currentSel.ariaLabel}"]`,
+                css: `${tagName}[aria-label="${currentSel.ariaLabel}"]`,
+            });
+        }
+        if (currentSel.href) {
+            nonUniqQueries.push({
+                xpath: `[@href="${currentSel.href}"]`,
+                css: `${tagName}[href="${currentSel.href}"]`,
+            });
+        }
+        const positionalQuery = {
+            xpath: ((_a = currentSel.n) === null || _a === void 0 ? void 0 : _a.i) && ((_b = currentSel.n) === null || _b === void 0 ? void 0 : _b.t)
+                ? `[count(../${tagName})=${currentSel.n.t}][${currentSel.n.i}]`
+                : '',
+            css: ((_c = currentSel.n) === null || _c === void 0 ? void 0 : _c.i)
+                ? `${tagName}:nth-of-type(${currentSel.n.i})`
+                : tagName,
+        };
+        for (const query of uniqueQueries) {
+            for (const path of wipPaths) {
+                const xpath = `//${tagName}${query.xpath}${path.xpath}`;
+                const css = query.css + (path.css ? ` ${path.css}` : '');
+                const regularSegment = {
+                    xpath,
+                    css,
+                    isInsideShadowRoot: false,
+                };
+                relativePaths.push([regularSegment]);
+                if (relativePaths.length >= max)
+                    return [relativePaths, partialRelativePaths];
+            }
+        }
+        for (const query of nonUniqQueries) {
+            for (const path of wipPaths) {
+                const xpath = `/${tagName}${query.xpath}${path.xpath}`;
+                const css = query.css + (path.css ? ` > ${path.css}` : '');
+                newWipPaths.push({ xpath, css });
+                const regularSegment = {
+                    xpath: `/${xpath}`,
+                    css,
+                    isInsideShadowRoot: false,
+                };
+                partialRelativePaths.unshift([regularSegment]);
+            }
+        }
+        for (const path of wipPaths) {
+            const xpath = `/${tagName}${positionalQuery.xpath}${path.xpath}`;
+            const css = positionalQuery.css + (path.css ? ` > ${path.css}` : '');
+            newWipPaths.push({ xpath, css });
+        }
+        wipPaths = newWipPaths;
+        currentSel = currentSel.p;
+    }
+    return [relativePaths, partialRelativePaths];
+};
+const hasShadowRoot = (sel) => {
+    if (!sel)
+        return false;
+    if (sel.isShadowRoot === true) {
+        return true;
+    }
+    if (sel.p && hasShadowRoot(sel.p)) {
+        return true;
+    }
+    return false;
+};
+const appendToLastPathSegment = (path, selectors) => {
+    if (path.length === 0)
+        return path;
+    const allSegments = [...path];
+    const last = allSegments.pop();
+    const leading = allSegments;
+    return [
+        ...leading,
+        {
+            ...last,
+            xpath: `${last.xpath}${selectors.xpath}`,
+            css: `${last.css} ${selectors.css}`,
+        },
+    ];
+};
+const isSegmentEmpty = (segment) => {
+    return segment.xpath === '';
+};
+
+const USER_CONTEXT_KEY_PREFIX = 'x-ctx-';
+const MAX_USER_CONTEXT_JSON_BYTES = 4096;
+function userContextJsonByteLength(userContext) {
+    try {
+        return new TextEncoder().encode(JSON.stringify(userContext !== null && userContext !== void 0 ? userContext : null)).length;
+    }
+    catch (_a) {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+function sanitizeUserContext(userContext) {
+    if (userContext === undefined ||
+        userContext === null ||
+        typeof userContext !== 'object' ||
+        Array.isArray(userContext)) {
+        return undefined;
+    }
+    if (userContextJsonByteLength(userContext) > MAX_USER_CONTEXT_JSON_BYTES) {
+        return undefined;
+    }
+    return userContext;
+}
+
+function canSendWithConsent() {
+    if (!waitingForCookies) {
+        return true;
+    }
+    return isCookiesEnabled;
+}
+function shouldSendEvents(options = {}) {
+    if (forceSendEvents) {
+        return true;
+    }
+    if (isPreviewVariant) {
+        warnEventsNotSent();
+        return false;
+    }
+    if (!options.ignoreConsent && !canSendWithConsent()) {
+        return false;
+    }
+    if (trackOnlyActivatedFrames && !frameActivated) {
+        return false;
+    }
+    return true;
+}
+let isPreviewVariant = false;
+const setIsPreviewVariant = (value) => {
+    isPreviewVariant = value;
+};
+let waitingForCookies = false;
+const setWaitingForCookies = (value) => {
+    waitingForCookies = value;
+};
+let frameActivated = false;
+const setFrameActivated = (value) => {
+    frameActivated = value;
+};
+let trackOnlyActivatedFrames = false;
+const setTrackOnlyActivatedFrames = (value) => {
+    trackOnlyActivatedFrames = value;
+};
+let forceSendEvents = false;
+const setForceSendEvents = (value) => {
+    forceSendEvents = value;
+};
+let eventsNotSentWarned = false;
+function warnEventsNotSent() {
+    if (!eventsNotSentWarned) {
+        eventsNotSentWarned = true;
+        console.warn('[Coframe] Events not sent. Use ?coframe_should_send_events=true to force sending events for testing');
+    }
+}
+
+const SDK_VERSION = '2.4.0';
+const queuedEvents = [];
+const queuedMonitoringEvents = [];
+const queuedSessions = [];
+function queueMonitoringEvent(coframe, data) {
+    queuedMonitoringEvents.push(data);
+    if (queuedMonitoringEvents.length >= coframe.batchSize) {
+        flushQueuedEvents(coframe.projectId);
+    }
+}
+function queueEventForBatchedSending(coframe, data, flushImmediately = false) {
+    queuedEvents.push(data);
+    if (flushImmediately || queuedEvents.length >= coframe.batchSize) {
+        flushQueuedEvents(coframe.projectId);
+    }
+}
+function queueCreateSession(coframe, orgId, projectId, sessionId, userToken, experimentsInfo, startTime, referrer, platform, languages, userAgent, url, storageInfo, gaSessionInfo, cfId, personalizationHeaders) {
+    queuedSessions.push({
+        org_id: orgId,
+        project_id: projectId,
+        session_id: sessionId,
+        experiments: experimentsInfo,
+        method: 'script',
+        sdk_version: SDK_VERSION,
+        metadata: {
+            local_time: startTime,
+            languages,
+            platform,
+            referrer: referrer,
+            user_token: userToken,
+            user_agent: userAgent,
+            session_metadata: JSON.stringify({
+                url,
+                storage_info: storageInfo,
+            }),
+            ga_session_id: gaSessionInfo === null || gaSessionInfo === void 0 ? void 0 : gaSessionInfo.ga_session_id,
+            ga_session_number: gaSessionInfo === null || gaSessionInfo === void 0 ? void 0 : gaSessionInfo.ga_session_number,
+            coframe_user_id: cfId,
+            url: url,
+            ...(personalizationHeaders
+                ? {
+                    personalization_headers: { ...personalizationHeaders },
+                }
+                : {}),
+        },
+    });
+    if (queuedSessions.length >= coframe.batchSize) {
+        flushQueuedEvents(coframe.projectId);
+    }
+}
+function flushQueuedEvents(projectId) {
+    if (!shouldSendEvents()) {
+        return;
+    }
+    if (queuedEvents.length > 0) {
+        sendEventToBackend(projectId, queuedEvents, 'batched_events');
+        queuedEvents.length = 0;
+    }
+    if (queuedMonitoringEvents.length > 0) {
+        sendEventToBackend(projectId, queuedMonitoringEvents, 'batched_monitoring');
+        queuedMonitoringEvents.length = 0;
+    }
+    if (queuedSessions.length > 0) {
+        for (const session of queuedSessions) {
+            createSession(session);
+        }
+        queuedSessions.length = 0;
+    }
+}
+function queueEvent(coframe, sessionInfo) {
+    const { projectId, sessionId, eventType, orgId, userToken } = sessionInfo;
+    const data = {
+        type: eventType,
+        project_id: projectId,
+        session_id: sessionId,
+        time: new Date(),
+        url: getCurrentPageUrl(),
+        org_id: orgId,
+        user_token: userToken,
+    };
+    const seg = sessionInfo.personalizationHeaders;
+    const metadata = seg ? { personalization_headers: { ...seg } } : {};
+    if (eventType === 'page_view') {
+        data.content = { universal_selector: {}, metadata };
+    }
+    else {
+        data.content = { metadata };
+    }
+    queueEventForBatchedSending(coframe, data);
+}
+function sendPageEngagementEvent(coframe, eventType, event, { isEngaged, projectId, sessionId, orgId, duration = 0, userToken, personalizationHeaders, }) {
+    var _a;
+    const startTime = performance.now();
+    if (!isEngaged && eventType === 'click') {
+        isEngaged = true;
+        queueEvent(coframe, {
+            projectId,
+            sessionId,
+            eventType: 'session_start',
+            orgId,
+            userToken: userToken || '',
+            personalizationHeaders,
+        });
+    }
+    const x = event.clientX + window.scrollX;
+    const y = event.clientY + window.scrollY;
+    const screenWidth = window.innerWidth;
+    const screenHeight = window.innerHeight;
+    const realEventTarget = event.composedPath()[0];
+    const conversionElement = realEventTarget === null || realEventTarget === void 0 ? void 0 : realEventTarget.closest('[coframe-metric-ids], a, button, input, [onclick], [href]');
+    const targetElement = conversionElement || realEventTarget;
+    const metricIds = (_a = targetElement.getAttribute('coframe-metric-ids')) === null || _a === void 0 ? void 0 : _a.split(',');
+    const data = {
+        type: eventType,
+        project_id: projectId,
+        session_id: sessionId,
+        time: new Date(),
+        url: getCurrentPageUrl(),
+        user_token: userToken,
+        content: {
+            universal_selector: getSelector(targetElement, {
+                withDescendants: false,
+            }),
+            metric_ids: metricIds,
+            position: {
+                x: Math.round(x),
+                y: Math.round(y),
+            },
+            screen_size: {
+                width: screenWidth,
+                height: screenHeight,
+            },
+            'duration-ms': Math.round(duration),
+            ...(personalizationHeaders && {
+                metadata: {
+                    personalization_headers: { ...personalizationHeaders },
+                },
+            }),
+        },
+    };
+    queueEventForBatchedSending(coframe, data, Boolean(metricIds === null || metricIds === void 0 ? void 0 : metricIds.length));
+    const processingDuration = performance.now() - startTime;
+    if (coframe.status) {
+        if (!coframe.status.events) {
+            coframe.status.events = [];
+        }
+        coframe.status.events.push({
+            ...data,
+            processing_duration_ms: Math.round(processingDuration),
+            timestamp: Date.now(),
+        });
+    }
+}
+function sendEventToBackend(projectId, data, eventCategory = 'events') {
+    const eventsEndpoint = `${"https://ingest.app.coframe.com/ingest/v2"}/${eventCategory}/${projectId}/`;
+    if (navigator.sendBeacon) {
+        const textData = JSON.stringify(data);
+        const blob = new Blob([textData], { type: 'text/plain' });
+        if (!navigator.sendBeacon(eventsEndpoint, blob)) {
+            console.warn('[Coframe] failed to send event beacon');
+        }
+    }
+    else {
+        console.warn('[Coframe] cannot send event beacon, feature unavailable');
+    }
+}
+function createSession(data) {
+    const sessionApiUrl = `${"https://ingest.app.coframe.com/ingest/v2"}/session_result/`;
+    if (navigator.sendBeacon) {
+        const textData = JSON.stringify(data);
+        const blob = new Blob([textData], { type: 'text/plain' });
+        if (!navigator.sendBeacon(sessionApiUrl, blob)) {
+            console.warn('[Coframe] failed to send event beacon');
+        }
+    }
+    else {
+        console.warn('[Coframe] cannot send event beacon, feature unavailable');
+    }
+}
+async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext, headers) {
+    const payload = { projectId, currentUrl };
+    const safe = sanitizeUserContext(userContext);
+    if (safe) {
+        payload.userContext = safe;
+    }
+    const config = encodeURIComponent(JSON.stringify(payload));
+    const edgeUrl = new URL(`${"https://edge.cofra.me"}/api/v1/frames`);
+    edgeUrl.searchParams.set('config', config);
+    try {
+        const response = await fetch(edgeUrl, { headers, signal });
+        if (!response.ok)
+            return null;
+        return await response.json();
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            return null;
+        }
+        return null;
+    }
+}
+
+const isPageElement = (element) => {
+    return (element === document.body ||
+        element === document ||
+        element === document.documentElement);
+};
+const inputButtonTypes = ['submit', 'button', 'reset'];
+function isInputButton(el) {
+    if (el.tagName.toLowerCase() !== 'input') {
+        return false;
+    }
+    const type = el.type;
+    if (!type) {
+        return false;
+    }
+    return inputButtonTypes.includes(type.toLowerCase());
+}
+const convertToFrontendStyle = (style) => {
+    const result = {};
+    if (style) {
+        for (const key in style) {
+            const styleKey = key.replace(/_/g, '-');
+            result[styleKey] = style[key];
+        }
+    }
+    return result;
+};
+const applyUpdateModification = (element, args, logger, logMetadata = {}) => {
+    const { innerHTML, textContent, src, styles, onClick, ...otherAttributes } = args.attributes;
+    if (innerHTML) {
+        element.innerHTML = innerHTML;
+    }
+    else if (textContent && typeof textContent === 'string') {
+        if (isInputButton(element)) {
+            element.value = textContent;
+        }
+        else {
+            element.textContent = textContent;
+        }
+    }
+    if (src) {
+        element.setAttribute('src', src);
+    }
+    if (styles) {
+        const convertedStyle = convertToFrontendStyle(styles);
+        for (const [styleName, styleValue] of Object.entries(convertedStyle)) {
+            if (!styleValue)
+                continue;
+            const currentStyleValue = element.style.getPropertyValue(styleName);
+            if (currentStyleValue !== styleValue) {
+                element.style.setProperty(styleName, styleValue, 'important');
+            }
+        }
+    }
+    if (otherAttributes && Object.keys(otherAttributes).length > 0) {
+        if (logger === null || logger === void 0 ? void 0 : logger.warn) {
+            logger.warn('Unknown attributes', 'unknown_attributes', {
+                ...logMetadata,
+                otherAttributes,
+            });
+        }
+        else {
+            console.warn('[Coframe] Unknown attributes', otherAttributes);
+        }
+    }
+    return true;
+};
+const executeJs = (jsCode, args = {}, opts = {}) => {
+    const key = `__cf_${Math.random().toString(36).slice(2, 12)}`;
+    const w = window;
+    w.Coframe = w.Coframe || {};
+    w.Coframe.vars = w.Coframe.vars || {};
+    const elKey = `${key}_el`;
+    if (opts.elementRef) {
+        w.Coframe.vars[elKey] = opts.elementRef;
+    }
+    const invocation = opts.isExpression
+        ? `(${jsCode})(__args)`
+        : opts.elementRef
+            ? `(function(el){ ${jsCode} })(__args.el)`
+            : `(function(){ ${jsCode} })()`;
+    const ranKey = `${key}_ran`;
+    const script = document.createElement('script');
+    script.id = `coframe-script-${key}`;
+    if (opts.nonce)
+        script.nonce = opts.nonce;
+    script.textContent = `
+    (function() {
+      try {
+        var __args = ${JSON.stringify(args)};
+        ${opts.elementRef ? `__args.el = window.Coframe.vars[${JSON.stringify(elKey)}];` : ''}
+        window.Coframe.vars[${JSON.stringify(key)}] = ${invocation};
+      } catch (e) {
+        window.Coframe.vars[${JSON.stringify(`${key}_err`)}] = (e && (e.stack || e.message)) ? String(e.stack || e.message) : (String(e) || 'Unknown error');
+      }
+      window.Coframe.vars[${JSON.stringify(ranKey)}] = true;
+    })();
+  `;
+    document.head.appendChild(script);
+    document.head.removeChild(script);
+    const value = w.Coframe.vars[key];
+    const err = w.Coframe.vars[`${key}_err`];
+    const ran = w.Coframe.vars[ranKey];
+    delete w.Coframe.vars[key];
+    delete w.Coframe.vars[`${key}_err`];
+    delete w.Coframe.vars[ranKey];
+    if (opts.elementRef)
+        delete w.Coframe.vars[elKey];
+    if (err !== undefined)
+        throw new Error(err);
+    if (!ran) {
+        throw new SyntaxError('Failed to parse JavaScript (likely a syntax error in variant code)');
+    }
+    return value;
+};
+const applyJavascriptModification = (element, args, logger, nonce, logMetadata = {}) => {
+    const javascript = args.js;
+    try {
+        if (!javascript) {
+            if (logger === null || logger === void 0 ? void 0 : logger.warn) {
+                logger.warn('No JavaScript to execute', 'no_javascript_to_execute', logMetadata);
+            }
+            else {
+                console.warn('[Coframe] No JavaScript to execute');
+            }
+            return false;
+        }
+        executeJs(javascript, {}, {
+            nonce,
+            elementRef: isPageElement(element) ? undefined : element,
+        });
+        return true;
+    }
+    catch (error) {
+        if (logger === null || logger === void 0 ? void 0 : logger.error) {
+            logger.error('Error executing JavaScript:', 'error_execute_js', {
+                ...logMetadata,
+                error,
+                javascript,
+                element,
+            });
+        }
+        else {
+            console.error('[Coframe] Error executing JavaScript:', error, javascript, element);
+        }
+        return false;
+    }
+};
+const executeTags = (tags, logger, nonce) => {
+    for (const tag of tags) {
+        if (tag.js) {
+            applyJavascriptModification(document.body, { js: tag.js }, logger, nonce);
+        }
+    }
+};
+
+function getLogCallback() {
+    const queue = window.CFQ;
+    if (!queue) {
+        return;
+    }
+    for (let i = queue.length - 1; i >= 0; i--) {
+        const cmd = queue[i];
+        if (!cmd || typeof cmd !== 'object') {
+            continue;
+        }
+        if (cmd.subscribe === 'log' && cmd.logCallback) {
+            return cmd.logCallback;
+        }
+    }
+}
+function emitLogCallback(callback, payload) {
+    if (!callback) {
+        return;
+    }
+    try {
+        callback(payload);
+    }
+    catch (e) {
+        console.warn('[Coframe] Error in log callback:', e);
+    }
+}
+function reportException({ err, orgId, projectId, sessionId, }) {
+    let errorMessage = 'Unknown error';
+    let stack = '';
+    if (typeof err === 'string') {
+        errorMessage = err;
+    }
+    else if (err && typeof err === 'object') {
+        if ('message' in err && typeof err.message === 'string') {
+            errorMessage = err.message;
+        }
+        if ('stack' in err && typeof err.stack === 'string') {
+            stack = err.stack;
+        }
+    }
+    if (!stack) {
+        stack = new Error().stack || '';
+    }
+    try {
+        const payload = {
+            kind: 'exception',
+            org_id: orgId,
+            project_id: projectId,
+            event_id: generateUUID(),
+            variant_id: '',
+            experiment_id: '',
+            session_id: sessionId,
+            url: window.location.href,
+            monitoring_type: 'sdk_error',
+            local_time: new Date().toISOString(),
+            metadata: {
+                error_message: errorMessage,
+                stack,
+                user_agent: navigator.userAgent,
+            },
+        };
+        emitLogCallback(getLogCallback(), payload);
+        if (canSendWithConsent()) {
+            sendEventToBackend(projectId, payload, 'monitoring');
+        }
+    }
+    catch (e) {
+        console.warn('[Coframe] Error in reportException:', e);
+    }
+}
+const LCP_ENTRY_TYPE = 'largest-contentful-paint';
+function reportLCP({ coframe, projectId, orgId, sessionId, }) {
+    var _a;
+    if (typeof PerformanceObserver === 'undefined' ||
+        !((_a = PerformanceObserver.supportedEntryTypes) === null || _a === void 0 ? void 0 : _a.includes(LCP_ENTRY_TYPE))) {
+        return;
+    }
+    let latestEntry;
+    let hasReported = false;
+    const observer = new PerformanceObserver((list) => {
+        const entries = list.getEntries();
+        if (entries.length > 0) {
+            latestEntry = entries[entries.length - 1];
+        }
+    });
+    try {
+        observer.observe({ type: LCP_ENTRY_TYPE, buffered: true });
+    }
+    catch (err) {
+        console.warn('[Coframe] Failed to observe LCP:', err);
+        return;
+    }
+    document.addEventListener('visibilitychange', () => {
+        var _a, _b, _c, _d;
+        if (document.visibilityState === 'hidden' && !hasReported) {
+            const pending = observer.takeRecords();
+            if (pending.length > 0) {
+                latestEntry = pending[pending.length - 1];
+            }
+            if (latestEntry) {
+                try {
+                    const lcp = latestEntry;
+                    queueMonitoringEvent(coframe, {
+                        event_id: generateUUID(),
+                        monitoring_type: 'web_performance_lcp',
+                        local_time: new Date().toISOString(),
+                        project_id: projectId,
+                        session_id: sessionId,
+                        url: getCurrentPageUrl(),
+                        org_id: orgId,
+                        metadata: {
+                            lcp: lcp.startTime,
+                            size: (_a = lcp.size) !== null && _a !== void 0 ? _a : 0,
+                            element: (_c = (_b = lcp.element) === null || _b === void 0 ? void 0 : _b.tagName) !== null && _c !== void 0 ? _c : '',
+                            url: (_d = lcp.url) !== null && _d !== void 0 ? _d : '',
+                        },
+                    });
+                    hasReported = true;
+                }
+                catch (e) {
+                    console.warn('[Coframe] Error reporting LCP:', e);
+                }
+            }
+            observer.disconnect();
+        }
+    });
+}
+function createLogger(getContext) {
+    let totalLogCount = 0;
+    const MAX_LOG_COUNT = 15;
+    function logEvent(kind, getContext, message, type, metadata) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (totalLogCount >= MAX_LOG_COUNT) {
+            console.warn('[Coframe] Max log count reached, auto-mute');
+            return;
+        }
+        totalLogCount++;
+        const tag = '[Coframe]';
+        const context = getContext();
+        const trimMessage = (message !== null && message !== void 0 ? message : '').trim();
+        const { org_id: _orgId, variant_id = '', experiment_id = '', ...restMetadata } = metadata;
+        const now = Date.now();
+        const localTime = new Date(now).toISOString();
+        const variantIds = ((_a = context.variantsAndElements) !== null && _a !== void 0 ? _a : [])
+            .map((v) => v.variant.id)
+            .filter(Boolean);
+        const singleVariant = ((_c = (_b = context.variantsAndElements) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) === 1
+            ? (_e = (_d = context.variantsAndElements) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.variant
+            : undefined;
+        const data = {
+            kind,
+            org_id: context.orgId || '',
+            variant_id: variant_id || (singleVariant === null || singleVariant === void 0 ? void 0 : singleVariant.id) || '',
+            experiment_id: experiment_id || (singleVariant === null || singleVariant === void 0 ? void 0 : singleVariant.experiment_id) || '',
+            variant_ids: variantIds,
+            project_id: (_f = context.projectId) !== null && _f !== void 0 ? _f : '',
+            event_id: generateUUID(),
+            session_id: (_g = context.sessionId) !== null && _g !== void 0 ? _g : '',
+            url: getCurrentPageUrl(),
+            monitoring_type: `log_${type}`,
+            local_time: localTime,
+            metadata: {
+                ...restMetadata,
+                message: trimMessage,
+            },
+        };
+        if (kind === 'warn') {
+            console.warn(`${tag} ${trimMessage}`, { ...restMetadata });
+        }
+        else {
+            console.error(`${tag} ${trimMessage}`, { ...restMetadata });
+        }
+        emitLogCallback(getLogCallback(), data);
+        (_j = (_h = context.debug) === null || _h === void 0 ? void 0 : _h.logs) === null || _j === void 0 ? void 0 : _j.push({
+            logger: kind,
+            timestamp: now,
+            message: trimMessage,
+            type,
+            metadata: { ...restMetadata },
+        });
+        queueMonitoringEvent(context, data);
+        if (context.status) {
+            if (!context.status.events) {
+                context.status.events = [];
+            }
+            context.status.events.push({
+                ...data,
+                timestamp: now,
+            });
+        }
+    }
+    return {
+        warn: (message, type = 'coframe_warn', metadata = {}) => logEvent('warn', getContext, message, type, metadata),
+        error: (message, type = 'coframe_error', metadata = {}) => logEvent('error', getContext, message, type, metadata),
+    };
+}
+
+const GLOBAL_HOLDOUT = 'global_holdout';
+const EXPERIMENT_HOLDOUT = 'experiment_holdout';
+const EXPERIMENT = 'experiment';
+const QueueName = {
+    CFQ: 'CFQ'};
+
+function ensureQueueExists(queueName = QueueName.CFQ) {
+    var _a;
+    const descriptor = Object.getOwnPropertyDescriptor(window, queueName);
+    if (descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) {
+        return window[queueName];
+    }
+    const queue = (_a = window[queueName]) !== null && _a !== void 0 ? _a : [];
+    Object.defineProperty(window, queueName, {
+        get() {
+            return queue;
+        },
+        set(val) {
+            if (val !== queue) {
+                console.warn(`[Coframe] Attempt to reassign ${queueName} queue — assignment ignored. Use .push() instead.`);
+            }
+        },
+        configurable: false,
+    });
+    return queue;
+}
+function __ensureQueuePushListenerHooked(queueName = QueueName.CFQ) {
+    const queue = ensureQueueExists(queueName);
+    if (queue.__cfqHooked) {
+        return queue;
+    }
+    queue.__cfqHooked = true;
+    queue.__cfqListeners = [];
+    const originalPush = queue.push.bind(queue);
+    queue.push = (...items) => {
+        const len = originalPush(...items);
+        const listeners = queue.__cfqListeners;
+        for (let i = 0; i < items.length; i++) {
+            const cmd = items[i];
+            const snapshot = listeners.slice();
+            for (let j = 0; j < snapshot.length; j++) {
+                const l = snapshot[j];
+                if (l.predicate(cmd))
+                    l.callback(cmd);
+            }
+        }
+        return len;
+    };
+    return queue;
+}
+function __addListener(predicate, callback, queueName = QueueName.CFQ) {
+    const queue = __ensureQueuePushListenerHooked(queueName);
+    const entry = { predicate, callback };
+    queue.__cfqListeners.push(entry);
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        const arr = queue.__cfqListeners;
+        const idx = arr.indexOf(entry);
+        if (idx !== -1)
+            arr.splice(idx, 1);
+    };
+}
+function findLastCmd(predicate, queueName = QueueName.CFQ) {
+    const queue = ensureQueueExists(queueName);
+    for (let i = queue.length - 1; i >= 0; i--) {
+        if (predicate(queue[i])) {
+            return queue[i];
+        }
+    }
+    return undefined;
+}
+function waitForCmd(predicate, coframe, timeoutMs = 3600000, queueName = QueueName.CFQ) {
+    return new Promise((resolve) => {
+        const existing = findLastCmd(predicate, queueName);
+        if (existing) {
+            resolve(existing);
+            return;
+        }
+        const stop = __addListener(predicate, (cmd) => {
+            stop();
+            clearTimeout(timer);
+            resolve(cmd);
+        }, queueName);
+        const timer = setTimeout(() => {
+            stop();
+            const error = new Error(`Timeout waiting for command after ${timeoutMs}ms for:\n${predicate.toString()}`);
+            if ((coframe === null || coframe === void 0 ? void 0 : coframe.projectId) && (coframe === null || coframe === void 0 ? void 0 : coframe.sessionId)) {
+                reportException({
+                    err: error,
+                    orgId: coframe.orgId || '',
+                    projectId: coframe.projectId,
+                    sessionId: coframe.sessionId,
+                });
+            }
+            resolve(undefined);
+        }, timeoutMs);
+    });
+}
+function listenForCmd(predicate, callback, queueName = QueueName.CFQ) {
+    const queue = ensureQueueExists(queueName);
+    for (let i = 0; i < queue.length; i++) {
+        const cmd = queue[i];
+        if (predicate(cmd))
+            callback(cmd);
+    }
+    return __addListener(predicate, callback, queueName);
+}
+function subscribeToCmd(predicate, callback, queueName = QueueName.CFQ) {
+    return __addListener(predicate, callback, queueName);
+}
+
+function querySelector(config) {
+    const result = findElementsRecursive(config);
+    if (result !== null && result.length === 0) {
+        return null;
+    }
+    return result;
+}
+function handleAndCondition(children, currentUrl, isQueryingAll) {
+    if (children.length === 0)
+        return null;
+    const childResultsForAnd = [];
+    for (const condition of children) {
+        const currentChildResult = findElementsRecursive({
+            selector: condition,
+            currentUrl: currentUrl,
+            isQueryingAll,
+        });
+        if (currentChildResult === null) {
+            return null;
+        }
+        childResultsForAnd.push(currentChildResult);
+    }
+    for (let i = childResultsForAnd.length - 1; i >= 0; i--) {
+        const res = childResultsForAnd[i];
+        if (res && res.length > 0) {
+            return res;
+        }
+    }
+    return [];
+}
+function handleOrCondition(children, currentUrl, isQueryingAll) {
+    let accumulatedElementsForOrAll = null;
+    let orConditionMet = false;
+    for (const condition of children) {
+        const currentChildResult = findElementsRecursive({
+            selector: condition,
+            currentUrl: currentUrl,
+            isQueryingAll,
+        });
+        if (currentChildResult !== null) {
+            orConditionMet = true;
+            if (!isQueryingAll) {
+                if (currentChildResult.length > 0) {
+                    return currentChildResult;
+                }
+            }
+            else {
+                if (currentChildResult.length > 0) {
+                    if (accumulatedElementsForOrAll === null) {
+                        accumulatedElementsForOrAll = [];
+                    }
+                    accumulatedElementsForOrAll.push(...currentChildResult);
+                }
+            }
+        }
+    }
+    if (!isQueryingAll) {
+        return null;
+    }
+    if (orConditionMet) {
+        return accumulatedElementsForOrAll !== null
+            ? accumulatedElementsForOrAll
+            : [];
+    }
+    return null;
+}
+function findElementsRecursive({ selector, currentUrl, isQueryingAll = false, }) {
+    if (selector.url_starts_with) {
+        return currentUrl.startsWith(selector.url_starts_with) ? [] : null;
+    }
+    if (selector.url) {
+        const url = new URL(currentUrl);
+        const targetUrl = new URL(selector.url);
+        return url.hostname === targetUrl.hostname &&
+            url.pathname === targetUrl.pathname
+            ? []
+            : null;
+    }
+    if (selector.universal || selector.css) {
+        const element = getElement(selector);
+        return element ? [element] : null;
+    }
+    if (selector.navigate_to_url_starts_with) {
+        const elements = getElementsByHrefPrefix(currentUrl, selector.navigate_to_url_starts_with);
+        return elements.length > 0 ? elements : null;
+    }
+    if (selector.and) {
+        return handleAndCondition(selector.and, currentUrl, isQueryingAll);
+    }
+    if (selector.or) {
+        return handleOrCondition(selector.or, currentUrl, isQueryingAll);
+    }
+    return null;
+}
+let applyVariantChangesStarted = false;
+function setApplyVariantChangesStarted(value) {
+    applyVariantChangesStarted = value;
+}
+function variantRendered() {
+    const queue = ensureQueueExists();
+    queue.push({
+        emit: 'variantRendered',
+    });
+}
+const applyVariantChanges = (variantElements, currentUrl, logger, nonce) => {
+    var _a;
+    const { variant, elements } = variantElements;
+    const variantMetadata = {
+        variant_id: variant.id,
+        experiment_id: variant.experiment_id,
+    };
+    setApplyVariantChangesStarted(true);
+    if (!variant.modifications ||
+        Object.keys(variant.modifications).length === 0) {
+        variantRendered();
+        return true;
+    }
+    for (const [elementId, _] of Object.entries(variant.modifications)) {
+        const elementSelectors = elements[elementId];
+        let selectedElement = null;
+        for (const selector of elementSelectors || []) {
+            selectedElement = (_a = querySelector({ selector, currentUrl })) === null || _a === void 0 ? void 0 : _a[0];
+            if (selectedElement)
+                break;
+        }
+        if (!selectedElement) {
+            logger.error(`element not found: elementId ${elementId}`, 'element_not_found', {
+                element_id: elementId,
+                selectors: elementSelectors,
+                variant_id: variant.id,
+                experiment_id: variant.experiment_id,
+            });
+            continue;
+        }
+        const edited = editElement(selectedElement, variant.modifications, elementId, logger, nonce, variantMetadata);
+        if (edited && selectedElement instanceof HTMLElement) {
+            selectedElement.setAttribute('coframe-exp-id', variant.id);
+        }
+        else {
+            logger.error('element not edited', 'element_not_edited', {
+                ...variantMetadata,
+                selectedElement,
+                elementSelectors,
+            });
+        }
+    }
+    return true;
+};
+const editElement = (element, modifications, elementId, logger, nonce, logMetadata = {}) => {
+    if (!modifications[elementId]) {
+        logger.warn('no modifications for element', 'no_modifications_for_element', {
+            ...logMetadata,
+            elementId,
+            modifications,
+        });
+        return false;
+    }
+    for (const content of modifications[elementId]) {
+        switch (content.type) {
+            case 'execute_js':
+                applyJavascriptModification(element, content, logger, nonce, logMetadata);
+                break;
+            case 'update':
+                applyUpdateModification(element, content, logger, logMetadata);
+                variantRendered();
+                break;
+            case 'delete':
+                deleteElement(element);
+                variantRendered();
+                break;
+            default:
+                logger.warn('unknown modification type', 'unknown_modification_type', {
+                    ...logMetadata,
+                    modificationType: content.type,
+                    elementId,
+                });
+                variantRendered();
+                return false;
+        }
+    }
+    return true;
+};
+const deleteElement = (element) => {
+    var _a;
+    (_a = element.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(element);
+    return true;
+};
+const waitForBody = (timeout = 10000) => {
+    return new Promise((resolve, reject) => {
+        if (document.body) {
+            resolve(document.body);
+            return;
+        }
+        let timeoutId;
+        const observer = new MutationObserver(() => {
+            if (document.body) {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                observer.disconnect();
+                resolve(document.body);
+            }
+        });
+        timeoutId = setTimeout(() => {
+            observer.disconnect();
+            reject(new Error('Timeout waiting for document.body'));
+        }, timeout);
+        observer.observe(document.documentElement || document, {
+            childList: true,
+            subtree: true,
+        });
+    });
+};
+function revealPage() {
+    document.dispatchEvent(new CustomEvent('coframe:show', {}));
+    document.documentElement.style.setProperty('--cf-show', '1');
+}
+async function replaceVariants(variants, orgId, logger, nonce) {
+    const failedReplacements = [];
+    let currentVariant;
+    try {
+        for (const v of variants) {
+            currentVariant = v.variant;
+            if (!applyVariantChanges(v, getCurrentPageUrl(), logger, nonce)) {
+                failedReplacements.push({
+                    message: 'Original element not found',
+                    metadata: {
+                        description: 'Original element not found',
+                        experiment_id: v.variant.experiment_id,
+                        variant_id: v.variant.id,
+                        org_id: orgId,
+                    },
+                });
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.stack || error.message : String(error);
+        failedReplacements.push({
+            metadata: {
+                description: error instanceof Error ? error.toString() : String(error),
+                org_id: orgId,
+                variant_id: currentVariant === null || currentVariant === void 0 ? void 0 : currentVariant.id,
+                experiment_id: currentVariant === null || currentVariant === void 0 ? void 0 : currentVariant.experiment_id,
+            },
+            message: errorMessage,
+        });
+    }
+    for (const event of failedReplacements) {
+        logger.error(event.message, 'failed_replacement', event.metadata);
+    }
+}
+
+function _x86Multiply(m, n) {
+    return (m & 0xffff) * n + ((((m >>> 16) * n) & 0xffff) << 16);
+}
+function _x86Rotl(m, n) {
+    return (m << n) | (m >>> (32 - n));
+}
+function _x86Fmix(h) {
+    h ^= h >>> 16;
+    h = _x86Multiply(h, 0x85ebca6b);
+    h ^= h >>> 13;
+    h = _x86Multiply(h, 0xc2b2ae35);
+    h ^= h >>> 16;
+    return h;
+}
+function murmurHash3_x86_32(key, seed) {
+    key = key || '';
+    seed = seed || 0;
+    const remainder = key.length % 4;
+    const bytes = key.length - remainder;
+    let h1 = seed;
+    let k1 = 0;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    let i = 0;
+    for (i = 0; i < bytes; i = i + 4) {
+        k1 =
+            (key.charCodeAt(i) & 0xff) |
+                ((key.charCodeAt(i + 1) & 0xff) << 8) |
+                ((key.charCodeAt(i + 2) & 0xff) << 16) |
+                ((key.charCodeAt(i + 3) & 0xff) << 24);
+        k1 = _x86Multiply(k1, c1);
+        k1 = _x86Rotl(k1, 15);
+        k1 = _x86Multiply(k1, c2);
+        h1 ^= k1;
+        h1 = _x86Rotl(h1, 13);
+        h1 = _x86Multiply(h1, 5) + 0xe6546b64;
+    }
+    k1 = 0;
+    switch (remainder) {
+        case 3:
+            k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+        case 2:
+            k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+        case 1:
+            k1 ^= key.charCodeAt(i) & 0xff;
+            k1 = _x86Multiply(k1, c1);
+            k1 = _x86Rotl(k1, 15);
+            k1 = _x86Multiply(k1, c2);
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 = _x86Fmix(h1);
+    return h1 >>> 0;
+}
+
+function parseClaims(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        const out = {};
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            for (const laneId of Object.keys(parsed)) {
+                const c = parsed[laneId];
+                if (c && typeof c.e === 'string' && typeof c.i === 'string') {
+                    out[laneId] = { e: c.e, i: c.i };
+                }
+            }
+        }
+        return out;
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function serializeClaims(claims) {
+    return JSON.stringify(claims);
+}
+function validateClaims(claims, lanes) {
+    const valid = {};
+    if (!lanes)
+        return valid;
+    for (const laneId of Object.keys(claims)) {
+        const claim = claims[laneId];
+        const lane = lanes[laneId];
+        if (!lane)
+            continue;
+        const member = lane.members.find((m) => m.experiment_id === claim.e);
+        if (!member)
+            continue;
+        if (member.iteration_id !== claim.i)
+            continue;
+        valid[laneId] = claim;
+    }
+    return valid;
+}
+function experimentLaneIds(metadata) {
+    var _a;
+    return (_a = metadata.lane_ids) !== null && _a !== void 0 ? _a : [];
+}
+function makeClaim(metadata) {
+    return { e: metadata.experiment_id, i: metadata.iteration_id };
+}
+function pickWinner(reachableMemberIds, seed, userToken) {
+    const sorted = [...reachableMemberIds].sort();
+    if (sorted.length <= 1)
+        return sorted[0];
+    const hash = murmurHash3_x86_32(userToken, seed);
+    return sorted[hash % sorted.length];
+}
+function resolveLaneWinners(claims, reachableByLane, lanes, userToken) {
+    var _a, _b;
+    const excluded = new Set();
+    for (const laneId of Object.keys(reachableByLane)) {
+        const reachable = reachableByLane[laneId];
+        if (reachable.length === 0)
+            continue;
+        const claim = claims[laneId];
+        const seed = (_b = (_a = lanes === null || lanes === void 0 ? void 0 : lanes[laneId]) === null || _a === void 0 ? void 0 : _a.seed) !== null && _b !== void 0 ? _b : 0;
+        const winner = claim ? claim.e : pickWinner(reachable, seed, userToken);
+        for (const experimentId of reachable) {
+            if (experimentId !== winner)
+                excluded.add(experimentId);
+        }
+    }
+    return excluded;
+}
+
+function isElementVisible(el) {
+    const rect = el.getBoundingClientRect();
+    return rect.top >= 0 && rect.bottom <= window.innerHeight;
+}
+const VALUE_UNKNOWN_YET = 'n/a';
+function checkActivationCondition(condition, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger) {
+    if (condition.and) {
+        const results = condition.and.map((c) => checkActivationCondition(c, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger));
+        const hasUnknown = results.some((r) => r === VALUE_UNKNOWN_YET);
+        if (hasUnknown) {
+            const hasFalse = results.some((r) => r === false);
+            if (hasUnknown && hasFalse) {
+                return false;
+            }
+            if (hasUnknown && !hasFalse) {
+                return VALUE_UNKNOWN_YET;
+            }
+        }
+        return results.every((r) => r === true);
+    }
+    if (condition.or) {
+        const results = condition.or.map((c) => checkActivationCondition(c, personalizationHeaders, currentUrl, languages, browserPlatform, userToken, userVisitCount, runJsFunction, logger));
+        const hasAtLeastOneTrue = results.some((r) => r === true);
+        if (hasAtLeastOneTrue) {
+            return true;
+        }
+        const hasUnknown = results.some((r) => r === VALUE_UNKNOWN_YET);
+        return hasUnknown ? VALUE_UNKNOWN_YET : false;
+    }
+    if (condition.url ||
+        condition.base_url_matches ||
+        condition.url_regex ||
+        condition.search) {
+        if (currentUrl === VALUE_UNKNOWN_YET) {
+            return VALUE_UNKNOWN_YET;
+        }
+    }
+    if (condition.url &&
+        condition.url !== '*' &&
+        !urlsMatch(condition.url, currentUrl)) {
+        return false;
+    }
+    if (condition.base_url_matches &&
+        !urlsMatch(condition.base_url_matches, currentUrl, true)) {
+        return false;
+    }
+    if (condition.url_regex) {
+        try {
+            const regex = new RegExp(condition.url_regex);
+            return regex.test(currentUrl);
+        }
+        catch (error) {
+            logger.error('Error parsing URL regex', 'url_regex_error', {
+                error: error instanceof Error ? error.message : String(error),
+                url_regex: condition.url_regex,
+                currentUrl,
+            });
+            return false;
+        }
+    }
+    if (condition.search && !queryParamsMatch(condition.search, currentUrl)) {
+        return false;
+    }
+    if (condition.user_context &&
+        !userContextConditionsMatch(condition.user_context, personalizationHeaders)) {
+        return false;
+    }
+    if (condition.language) {
+        if (languages === VALUE_UNKNOWN_YET) {
+            return VALUE_UNKNOWN_YET;
+        }
+        for (const language of condition.language) {
+            if (languages.some((l) => l.includes(language))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (condition.time) {
+        const currentTime = new Date();
+        if (condition.time.before && currentTime >= condition.time.before) {
+            return false;
+        }
+        if (condition.time.after && currentTime <= condition.time.after) {
+            return false;
+        }
+    }
+    if (condition.platform) {
+        if (browserPlatform === VALUE_UNKNOWN_YET) {
+            return VALUE_UNKNOWN_YET;
+        }
+        return isPlatformSupported(condition, browserPlatform);
+    }
+    if (condition.country &&
+        !isCountrySupported(condition.country, personalizationHeaders)) {
+        return false;
+    }
+    if (condition.first_time_vs_returning) {
+        if (userVisitCount === VALUE_UNKNOWN_YET) {
+            return true;
+        }
+        if (condition.first_time_vs_returning.length !== 2) {
+            if (condition.first_time_vs_returning.includes('first_time') &&
+                userVisitCount > 1) {
+                return false;
+            }
+            if (condition.first_time_vs_returning.includes('returning') &&
+                userVisitCount <= 1) {
+                return false;
+            }
+        }
+    }
+    if (condition.device) {
+        const isMobileDevice = personalizationHeaders['x-is-mobile-viewer'] === 'true';
+        if (condition.device.includes('mobile') && !isMobileDevice) {
+            return false;
+        }
+        if (condition.device.includes('desktop') && isMobileDevice) {
+            return false;
+        }
+    }
+    if (condition.allocation) {
+        if (userToken === VALUE_UNKNOWN_YET) {
+            return VALUE_UNKNOWN_YET;
+        }
+        const inAllocation = inRange(condition.allocation.allocation_bins, condition.allocation.allocation_scale, condition.allocation.seed, userToken);
+        return inAllocation;
+    }
+    if (condition.js_function) {
+        if (runJsFunction === undefined) {
+            return VALUE_UNKNOWN_YET;
+        }
+        try {
+            const result = runJsFunction(`(${condition.js_function})`, {});
+            return Boolean(result);
+        }
+        catch (error) {
+            logger.error('Error evaluating JS function', 'js_eval_error', {
+                error: error instanceof Error ? error.message : String(error),
+                js_function: condition.js_function,
+            });
+            return false;
+        }
+    }
+    return true;
+}
+const normalizeUrl = (url, baseUrlMatch) => {
+    const parsedUrl = new URL(url);
+    const hostname = parsedUrl.hostname.replace(/^www\./, '');
+    const pathname = parsedUrl.pathname.endsWith('/')
+        ? parsedUrl.pathname.slice(0, -1)
+        : parsedUrl.pathname;
+    if (baseUrlMatch) {
+        return `${hostname}${pathname}`;
+    }
+    return `${hostname}${pathname}${parsedUrl.search}${parsedUrl.hash}`;
+};
+function urlsMatch(conditionUrl, currentUrl, baseUrlMatch) {
+    if (currentUrl.includes('localhost') || currentUrl.includes('0.0.0.0')) {
+        const conditionUrlObj = new URL(conditionUrl);
+        const currentUrlObj = new URL(currentUrl);
+        const normalizePath = (path) => path.endsWith('/') ? path.slice(0, -1) : path;
+        if (baseUrlMatch) {
+            return (normalizePath(currentUrlObj.pathname) ===
+                normalizePath(conditionUrlObj.pathname));
+        }
+        return (normalizePath(currentUrlObj.pathname) ===
+            normalizePath(conditionUrlObj.pathname) &&
+            currentUrlObj.search === conditionUrlObj.search);
+    }
+    return (normalizeUrl(conditionUrl, baseUrlMatch) ===
+        normalizeUrl(currentUrl, baseUrlMatch));
+}
+function isPlatformSupported(condition, browserPlatform) {
+    const conditionPlatforms = Array.isArray(condition.platform)
+        ? condition.platform
+        : [condition.platform];
+    return conditionPlatforms.some((condPlatform) => condPlatform &&
+        browserPlatform.toLowerCase().includes(condPlatform.toLowerCase()));
+}
+function isCountrySupported(countries, personalizationHeaders) {
+    return personalizationHeaders
+        ? countries.includes(personalizationHeaders['x-viewer-country'])
+        : false;
+}
+function queryParamsMatch(conditions, currentUrl) {
+    const search = new URL(currentUrl).search;
+    return conditions.some((c) => {
+        const q = decodeURIComponent(search).toLowerCase();
+        const operand = c.operand.toLowerCase();
+        if (c.operator === 'equals')
+            return q === operand;
+        if (c.operator === 'contains')
+            return q.includes(operand);
+        if (c.operator === 'not_contains')
+            return !q.includes(operand);
+        return false;
+    });
+}
+function userContextConditionsMatch(conditions, personalizationHeaders) {
+    const headers = personalizationHeaders;
+    return conditions.some((c) => {
+        var _a;
+        if (!c.key)
+            return false;
+        const value = ((_a = headers[`${USER_CONTEXT_KEY_PREFIX}${c.key}`]) !== null && _a !== void 0 ? _a : '').toLowerCase();
+        const operand = c.operand.toLowerCase();
+        if (c.operator === 'equals')
+            return value === operand;
+        if (c.operator === 'contains')
+            return value.includes(operand);
+        if (c.operator === 'not_contains')
+            return !value.includes(operand);
+        return false;
+    });
+}
+function debounce(func, wait) {
+    let timeoutId = null;
+    return function (...args) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            func.apply(this, args);
+        }, wait);
+    };
+}
+function parseQueryString(query) {
+    const params = {};
+    const cleanQuery = query.startsWith('?') ? query.slice(1) : query;
+    if (!cleanQuery)
+        return params;
+    for (const pair of cleanQuery.split('&')) {
+        if (!pair)
+            continue;
+        const [key, value = ''] = pair.split('=').map(decodeURIComponent);
+        if (!(key in params)) {
+            params[key] = value;
+        }
+    }
+    return params;
+}
+function createURLSearchParams(query) {
+    if (typeof URLSearchParams !== 'undefined') {
+        const nativeParams = new URLSearchParams(query);
+        return {
+            get: (key) => nativeParams.get(key),
+        };
+    }
+    const simpleParams = parseQueryString(query);
+    return {
+        get: (key) => { var _a; return (_a = simpleParams[key]) !== null && _a !== void 0 ? _a : null; },
+    };
+}
+function getCurrentUrlSearchParams() {
+    const url = getCurrentPageUrl();
+    const searchIndex = url.indexOf('?');
+    if (searchIndex === -1) {
+        return createURLSearchParams('');
+    }
+    const hashIndex = url.indexOf('#', searchIndex);
+    const search = hashIndex !== -1
+        ? url.substring(searchIndex, hashIndex)
+        : url.substring(searchIndex);
+    return createURLSearchParams(search);
+}
+
+const defaultScale = 100000;
+const variantPartition = (seed, uid, scale) => {
+    const hash = murmurHash3_x86_32(uid, seed);
+    const maxUnsigned32BitInt = 0xffffffff;
+    const scaledValue = hash / maxUnsigned32BitInt;
+    const normalized = Math.floor(scaledValue * (scale - 1));
+    return normalized;
+};
+const chooseVariant = (uid, allocation, seed, defaultId) => {
+    const defaultVariant = defaultId;
+    const assignment = variantPartition(seed, uid, defaultScale);
+    let variantId = '';
+    outerloop: for (const variant in allocation) {
+        for (let j = 0; j < allocation[variant].length; j++) {
+            const [start, end] = allocation[variant][j];
+            if (assignment >= start && assignment <= end) {
+                variantId = variant;
+                break outerloop;
+            }
+        }
+    }
+    if (variantId === '') {
+        variantId = defaultVariant;
+    }
+    return variantId;
+};
+const inRange = (bins, scale, seed, uid) => {
+    const assignment = variantPartition(seed, uid, scale);
+    for (let j = 0; j < bins.length; j++) {
+        const [start, end] = bins[j];
+        if (assignment >= start && assignment <= end) {
+            return true;
+        }
+    }
+    return false;
+};
+function checkAllAudiences(metadata, project, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, nonce, logger) {
+    var _a;
+    const audienceIds = (_a = metadata.activation_condition.audience_ids) !== null && _a !== void 0 ? _a : [];
+    let result = true;
+    for (const audienceId of audienceIds) {
+        const audience = project.audiences[audienceId];
+        if (!audience)
+            continue;
+        const activated = checkActivationCondition(audience.selector, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce }), logger);
+        if (activated === false)
+            return false;
+        if (activated !== true)
+            result = activated;
+    }
+    return result;
+}
+async function getVariantsAndElements(personalizationHeaders, project, previewVariantId, userToken, currentPageUrl, languages, browserPlatform, logger, nonce, laneClaims = {}) {
+    var _a, _b;
+    const experimentsInfo = [];
+    const variantsAndElements = [];
+    const cloakBot = !!((_a = project.settings) === null || _a === void 0 ? void 0 : _a.bot_cloaking_enabled) &&
+        personalizationHeaders['x-is-bot'] === 'true';
+    const buildResponse = ({ variantsAndElements, experimentsInfo, hasActivatedFrames: frameActivated = false, laneClaims: meClaims = laneClaims, }) => {
+        return {
+            variantsAndElements: variantsAndElements || [],
+            experimentsInfo: experimentsInfo || [],
+            hasActivatedFrames: frameActivated,
+            laneClaims: meClaims,
+        };
+    };
+    const previewVariantIds = (_b = previewVariantId === null || previewVariantId === void 0 ? void 0 : previewVariantId.split(',').map((id) => id.trim()).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+    if (previewVariantIds.length > 0) {
+        const filteredVariantsAndElements = project.frames
+            .flatMap((frame) => frame.experiments.flatMap((experiment) => experiment.variants.map((variant) => ({
+            variant,
+            elements: frame.elements,
+        }))))
+            .filter((item) => previewVariantIds.includes(item.variant.id));
+        const skipAlert = previewVariantIds.some((id) => id === project.holdout_info.holdout_variant_id || id === GLOBAL_HOLDOUT);
+        if (filteredVariantsAndElements.length > 0) {
+            return buildResponse({
+                variantsAndElements: filteredVariantsAndElements,
+                hasActivatedFrames: true,
+            });
+        }
+        if (!skipAlert) {
+            window.alert(`[Coframe] Variant preview unavailable: ${previewVariantId}.`);
+        }
+        return buildResponse({});
+    }
+    const userVisitCount = Number.parseInt(getCookie(VISIT_COUNT_COOKIE_KEY) || '0', 10);
+    const validatedClaims = validateClaims(laneClaims, project.lanes);
+    const activeFrames = project.frames.filter((frame) => {
+        if (!frame.experiments)
+            return false;
+        const frameActivated = checkActivationCondition(frame.activation_condition, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, (js, args) => executeJs(js, args, { isExpression: true, nonce }), logger);
+        if (!frameActivated)
+            return false;
+        return true;
+    });
+    if (activeFrames.length === 0) {
+        return buildResponse({ laneClaims: validatedClaims });
+    }
+    const globalVariantId = cloakBot
+        ? project.holdout_info.holdout_variant_id
+        : chooseVariant(userToken, project.holdout_info.variant_bins, project.holdout_info.seed, project.holdout_info.holdout_variant_id);
+    if (globalVariantId === project.holdout_info.holdout_variant_id) {
+        experimentsInfo.push({
+            variant_id: project.holdout_info.holdout_variant_id,
+            variant_slug: project.holdout_info.holdout_variant_slug,
+            experiment_id: project.holdout_info.holdout_experiment_id,
+            experiment_slug: project.holdout_info.holdout_experiment_slug,
+            iteration_id: '',
+            final_state: true,
+            level: GLOBAL_HOLDOUT,
+        });
+        return buildResponse({
+            variantsAndElements,
+            experimentsInfo,
+            hasActivatedFrames: true,
+            laneClaims: validatedClaims,
+        });
+    }
+    experimentsInfo.push({
+        variant_id: globalVariantId,
+        variant_slug: project.holdout_info.treatment_variant_slug,
+        experiment_id: project.holdout_info.holdout_experiment_id,
+        experiment_slug: project.holdout_info.holdout_experiment_slug,
+        iteration_id: '',
+        final_state: false,
+        level: GLOBAL_HOLDOUT,
+    });
+    const evalAudiences = (metadata) => checkAllAudiences(metadata, project, personalizationHeaders, currentPageUrl, languages, browserPlatform, userToken, userVisitCount, nonce, logger) !== false;
+    const audiencePass = new Map();
+    const reachableByLane = {};
+    for (const frame of activeFrames) {
+        for (const experiment of frame.experiments) {
+            const metadata = experiment.metadata;
+            const laneIds = experimentLaneIds(metadata);
+            if (laneIds.length === 0)
+                continue;
+            const passes = evalAudiences(metadata);
+            audiencePass.set(metadata.experiment_id, passes);
+            if (passes) {
+                for (const laneId of laneIds) {
+                    if (!reachableByLane[laneId])
+                        reachableByLane[laneId] = [];
+                    reachableByLane[laneId].push(metadata.experiment_id);
+                }
+            }
+        }
+    }
+    const excludedExperimentIds = resolveLaneWinners(validatedClaims, reachableByLane, project.lanes, userToken);
+    const updatedClaims = { ...validatedClaims };
+    let hasActivatedFrames = false;
+    for (const frame of activeFrames) {
+        let atLeastOneExperimentWasActivated = false;
+        for (const experiment of frame.experiments) {
+            if (atLeastOneExperimentWasActivated)
+                break;
+            const metadata = experiment.metadata;
+            const variants = experiment.variants;
+            const elements = frame.elements;
+            if (excludedExperimentIds.has(metadata.experiment_id))
+                continue;
+            let activated = audiencePass.get(metadata.experiment_id);
+            if (activated === undefined) {
+                activated = evalAudiences(metadata);
+            }
+            if (!activated)
+                continue;
+            atLeastOneExperimentWasActivated = true;
+            hasActivatedFrames = true;
+            for (const laneId of experimentLaneIds(metadata)) {
+                updatedClaims[laneId] = makeClaim(metadata);
+            }
+            const experimentHoldoutInfo = metadata.holdout_info;
+            const experimentUniverseVid = chooseVariant(userToken, experimentHoldoutInfo.variant_bins, experimentHoldoutInfo.seed, experimentHoldoutInfo.holdout_variant_id);
+            if (experimentUniverseVid === experimentHoldoutInfo.holdout_variant_id) {
+                experimentsInfo.push({
+                    variant_id: experimentHoldoutInfo.holdout_variant_id,
+                    variant_slug: experimentHoldoutInfo.holdout_variant_slug,
+                    experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                    experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                    iteration_id: '',
+                    level: EXPERIMENT_HOLDOUT,
+                    final_state: true,
+                    holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                    holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                });
+                continue;
+            }
+            experimentsInfo.push({
+                variant_id: experimentHoldoutInfo.treatment_variant_id,
+                variant_slug: experimentHoldoutInfo.treatment_variant_slug,
+                experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+                iteration_id: '',
+                level: EXPERIMENT_HOLDOUT,
+                final_state: false,
+                holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+            });
+            const variantId = chooseVariant(userToken, metadata.allocation, metadata.seed, '');
+            const variant = variants.find((v) => v.id === variantId);
+            if (!variant) {
+                logger.error(`Variant not found for experiment ${metadata.experiment_id}`, 'variant_not_found', {
+                    experiment_id: metadata.experiment_id,
+                });
+                break;
+            }
+            experimentsInfo.push({
+                variant_id: variant.id,
+                variant_slug: variant.slug,
+                experiment_id: metadata.experiment_id,
+                experiment_slug: metadata.slug,
+                iteration_id: metadata.iteration_id,
+                level: EXPERIMENT,
+                final_state: true,
+                holdout_experiment_id: experimentHoldoutInfo.holdout_experiment_id,
+                holdout_experiment_slug: experimentHoldoutInfo.holdout_experiment_slug,
+            });
+            variantsAndElements.push({ variant, elements });
+        }
+    }
+    return buildResponse({
+        variantsAndElements,
+        experimentsInfo,
+        hasActivatedFrames,
+        laneClaims: updatedClaims,
+    });
+}
+
+const CACHE_TTL_MS = 60 * 1000;
+const cache = new Map();
+function getCachedFrames(url) {
+    const key = normalizeUrl(url);
+    const entry = cache.get(key);
+    if (!entry)
+        return null;
+    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+        cache.delete(key);
+        return null;
+    }
+    return entry.data;
+}
+function cacheFrames(url, data) {
+    const key = normalizeUrl(url);
+    cache.set(key, { data, timestamp: Date.now() });
+}
+
+let conversionListenerStop = null;
+const activeJSBinders = new Set();
+function rebindMetrics(coframe, logger, metrics, nonce) {
+    var _a, _b;
+    if (!metrics || metrics.length === 0) {
+        logger.warn('No metrics defined in the project config');
+        return;
+    }
+    if (!conversionListenerStop) {
+        conversionListenerStop = listenForCmd((cmd) => cmd.conversion !== undefined ||
+            (cmd.emit === 'conversion' && cmd.payload !== undefined), (cmd) => {
+            const payload = cmd.conversion ||
+                (cmd.emit === 'conversion'
+                    ? cmd.payload
+                    : undefined);
+            if (!payload || (!payload.metricId && !payload.metricName)) {
+                logger.error('Conversion event payload must have metricId or metricName', 'conversion_event_payload_error', { payload });
+                return;
+            }
+            const content = { metadata: payload.metadata };
+            if (payload.metricId) {
+                content.metric_ids = [payload.metricId];
+            }
+            if (payload.metricName) {
+                content.metric_names = [payload.metricName];
+            }
+            if (payload.value) {
+                content.value = payload.value;
+            }
+            const eventData = {
+                type: 'conversion',
+                project_id: coframe.projectId,
+                session_id: coframe.sessionId,
+                time: new Date(),
+                url: getCurrentPageUrl(),
+                user_token: coframe.userToken,
+                content,
+            };
+            queueEventForBatchedSending(coframe, eventData, true);
+        });
+    }
+    const elementsToClean = document.querySelectorAll('[coframe-metric-ids]');
+    for (let i = 0; i < elementsToClean.length; i++) {
+        elementsToClean[i].removeAttribute('coframe-metric-ids');
+    }
+    for (let i = 0; i < metrics.length; i++) {
+        const metric = metrics[i];
+        if (metric.js_binder) {
+            if (activeJSBinders.has(metric.js_binder)) {
+                continue;
+            }
+            activeJSBinders.add(metric.js_binder);
+            try {
+                executeJs(metric.js_binder, { metricId: metric.id, metricName: (_a = metric.selector) === null || _a === void 0 ? void 0 : _a.name }, { nonce, isExpression: true });
+            }
+            catch (error) {
+                logger.error(`Failed to execute js_binder for metric ${metric.id}`, 'js_binder_execution_error', { error, metricId: metric.id });
+            }
+            continue;
+        }
+        if (metric.selector) {
+            const elements = (_b = querySelector({
+                selector: metric.selector,
+                currentUrl: getCurrentPageUrl(),
+                isQueryingAll: true,
+            })) !== null && _b !== void 0 ? _b : [];
+            for (let j = 0; j < elements.length; j++) {
+                const e = elements[j];
+                const metricIdsStr = e.getAttribute('coframe-metric-ids');
+                if (metricIdsStr) {
+                    const metricIds = metricIdsStr.split(',');
+                    metricIds.push(metric.id);
+                    e.setAttribute('coframe-metric-ids', Array.from(new Set(metricIds)).join(','));
+                }
+                else {
+                    e.setAttribute('coframe-metric-ids', metric.id);
+                }
+            }
+        }
+    }
+}
+
+let lastUrl = null;
+function observeUrlChanges(baseUrlMatch, onUrlChange) {
+    const tryTrack = () => {
+        const currentUrl = getCurrentPageUrl();
+        const previousUrl = lastUrl;
+        if (previousUrl && !urlsMatch(currentUrl, previousUrl, baseUrlMatch)) {
+            lastUrl = currentUrl;
+            onUrlChange(currentUrl, previousUrl);
+        }
+    };
+    lastUrl = getCurrentPageUrl();
+    tryTrack();
+    window.addEventListener('popstate', tryTrack);
+    window.addEventListener('hashchange', tryTrack);
+    const patchHistoryMethod = (method) => {
+        const original = history[method];
+        history[method] = function (...args) {
+            const result = original.apply(this, args);
+            setTimeout(tryTrack, 0);
+            return result;
+        };
+    };
+    patchHistoryMethod('pushState');
+    patchHistoryMethod('replaceState');
+}
+
+function startSession(Coframe, cookiesEnabled, executionStartTime, personalizationHeaders) {
+    const sessionPayload = [
+        Coframe,
+        Coframe.orgId,
+        Coframe.projectId,
+        Coframe.sessionId,
+        Coframe.userToken,
+        Coframe.experimentInfo,
+        executionStartTime,
+        getBrowserReferrer(),
+        getBrowserPlatform(),
+        getBrowserLanguages(),
+        getBrowserUserAgent(),
+        getCurrentPageUrl(),
+        getBrowserFignerprintInfo(),
+    ];
+    {
+        queueCreateSession(...sessionPayload, undefined, undefined, personalizationHeaders);
+    }
+    queueEvent(Coframe, {
+        projectId: Coframe.projectId,
+        sessionId: Coframe.sessionId,
+        eventType: 'page_view',
+        orgId: Coframe.orgId,
+        userToken: Coframe.userToken,
+        personalizationHeaders,
+    });
+}
+function reportInitTiming(Coframe, project, integrationStartTime, executionStartTime) {
+    var _a;
+    reportLCP({
+        coframe: Coframe,
+        projectId: Coframe.projectId,
+        orgId: Coframe.orgId,
+        sessionId: Coframe.sessionId,
+    });
+    const now = new Date();
+    const elapsedFromInstallation = integrationStartTime
+        ? now.getTime() - integrationStartTime.getTime()
+        : 0;
+    const elapsedFromExecution = now.getTime() - executionStartTime.getTime();
+    Coframe.status = {
+        initialized: true,
+        elapsedFromInstallation,
+        elapsedFromExecution,
+        trackOnlyActivatedFrames: !!((_a = project === null || project === void 0 ? void 0 : project.settings) === null || _a === void 0 ? void 0 : _a.track_only_activated_frames),
+    };
+    queueMonitoringEvent(Coframe, {
+        event_id: generateUUID(),
+        monitoring_type: 'init',
+        local_time: new Date().toISOString(),
+        project_id: Coframe.projectId,
+        session_id: Coframe.sessionId,
+        url: getCurrentPageUrl(),
+        org_id: Coframe.orgId,
+        metadata: {
+            elapsedFromInstallation,
+            elapsedFromExecution,
+        },
+    });
+}
+function createTreatmentAnalytics(Coframe, previewVariantId) {
+    Coframe.treatmentsData = null;
+    Coframe.treatmentsDataV2 = null;
+    let treatmentDataCallback;
+    let treatmentDataAllCallback;
+    let treatmentDataAllCallbackV2;
+    let treatmentDataAllCallbackV2WithoutConsent;
+    let withConsentBroadcasted = false;
+    let withoutConsentBroadcasted = false;
+    const buildTreatmentData = () => {
+        const activeExperiments = Coframe.experimentInfo;
+        const sessionId = Coframe.sessionId;
+        const userToken = Coframe.userToken;
+        const treatmentsData = [];
+        const treatmentsDataV2 = [];
+        for (const experimentInfo of activeExperiments) {
+            if (experimentInfo.final_state) {
+                const data = {
+                    impressionId: sessionId,
+                    userToken,
+                    experimentId: experimentInfo.experiment_id,
+                    variantId: experimentInfo.variant_id,
+                    inGlobalHoldout: experimentInfo.level === GLOBAL_HOLDOUT,
+                    isBaseline: experimentInfo.level === EXPERIMENT_HOLDOUT,
+                    ...(experimentInfo.holdout_experiment_id
+                        ? { holdoutExperimentId: experimentInfo.holdout_experiment_id }
+                        : {}),
+                };
+                treatmentsData.push(data);
+                treatmentsDataV2.push({
+                    coframe_experiment_id: experimentInfo.holdout_experiment_id ||
+                        experimentInfo.experiment_id,
+                    coframe_experiment_slug: experimentInfo.holdout_experiment_slug ||
+                        experimentInfo.experiment_slug,
+                    coframe_variant_id: experimentInfo.variant_id,
+                    coframe_variant_slug: experimentInfo.variant_slug,
+                    coframe_user_token: userToken,
+                    coframe_impression_id: sessionId,
+                    coframe_in_global_holdout: experimentInfo.level === GLOBAL_HOLDOUT,
+                    coframe_in_exp_baseline: experimentInfo.level === EXPERIMENT_HOLDOUT,
+                });
+            }
+        }
+        if (previewVariantId) {
+            const previewIds = previewVariantId.split(',');
+            for (const id of previewIds) {
+                treatmentsData.push({
+                    impressionId: sessionId,
+                    userToken,
+                    experimentId: `preview_id_${id}`,
+                    holdoutExperimentId: `preview_holdout_id_${id}`,
+                    variantId: id,
+                    inGlobalHoldout: false,
+                    isBaseline: false,
+                });
+                treatmentsDataV2.push({
+                    coframe_experiment_id: `preview_id_${id}`,
+                    coframe_experiment_slug: `preview_id_${id}`,
+                    coframe_variant_id: id,
+                    coframe_variant_slug: id,
+                    coframe_user_token: userToken,
+                    coframe_impression_id: sessionId,
+                    coframe_in_global_holdout: false,
+                    coframe_in_exp_baseline: false,
+                });
+            }
+        }
+        Coframe.treatmentsData = treatmentsData;
+        Coframe.treatmentsDataV2 = treatmentsDataV2;
+        Coframe.experimentInfo = activeExperiments;
+    };
+    const broadcastWithConsentCallbacksOnce = () => {
+        var _a, _b, _c, _d;
+        const hasData = ((_b = (_a = Coframe.treatmentsData) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 ||
+            ((_d = (_c = Coframe.treatmentsDataV2) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+        if ((treatmentDataCallback ||
+            treatmentDataAllCallback ||
+            treatmentDataAllCallbackV2) &&
+            hasData &&
+            !withConsentBroadcasted &&
+            canSendWithConsent()) {
+            if (Coframe.treatmentsData && treatmentDataCallback) {
+                for (const treatmentData of Coframe.treatmentsData) {
+                    treatmentDataCallback(treatmentData);
+                }
+                withConsentBroadcasted = true;
+            }
+            if (Coframe.treatmentsData && treatmentDataAllCallback) {
+                treatmentDataAllCallback(Coframe.treatmentsData);
+                withConsentBroadcasted = true;
+            }
+            if (Coframe.treatmentsDataV2 && treatmentDataAllCallbackV2) {
+                treatmentDataAllCallbackV2(Coframe.treatmentsDataV2, Coframe.experimentInfo);
+                withConsentBroadcasted = true;
+            }
+        }
+    };
+    const broadcastWithoutConsentCallbacksOnce = () => {
+        var _a, _b;
+        const hasData = ((_b = (_a = Coframe.treatmentsDataV2) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+        if (treatmentDataAllCallbackV2WithoutConsent &&
+            hasData &&
+            !withoutConsentBroadcasted &&
+            shouldSendEvents({ ignoreConsent: true })) {
+            treatmentDataAllCallbackV2WithoutConsent(Coframe.treatmentsDataV2, Coframe.experimentInfo);
+            withoutConsentBroadcasted = true;
+        }
+    };
+    const sendAnalytics = () => {
+        if (!shouldSendEvents({ ignoreConsent: true })) {
+            return;
+        }
+        buildTreatmentData();
+        broadcastWithoutConsentCallbacksOnce();
+        broadcastWithConsentCallbacksOnce();
+    };
+    const registerCallbacks = (cmd) => {
+        treatmentDataCallback = cmd.callback;
+        treatmentDataAllCallback = cmd.bulkCallback;
+        treatmentDataAllCallbackV2 = cmd.bulkCallbackV2;
+        treatmentDataAllCallbackV2WithoutConsent = cmd.bulkCallbackV2WithoutConsent;
+        broadcastWithoutConsentCallbacksOnce();
+        broadcastWithConsentCallbacksOnce();
+    };
+    const resetBroadcasted = () => {
+        withConsentBroadcasted = false;
+        withoutConsentBroadcasted = false;
+    };
+    return { sendAnalytics, registerCallbacks, resetBroadcasted };
+}
+const ENGAGED_SESSION_THRESHOLD = 10000;
+function setupListeners(Coframe, executionStartTime) {
+    const experiencedCoframeIds = new Set();
+    let isEngaged = false;
+    function measureEngagement() {
+        const timeSpent = Date.now() - (executionStartTime ? executionStartTime.getTime() : 0);
+        if (!isEngaged && timeSpent >= ENGAGED_SESSION_THRESHOLD) {
+            isEngaged = true;
+            queueEvent(Coframe, {
+                projectId: Coframe.projectId,
+                sessionId: Coframe.sessionId,
+                eventType: 'session_start',
+                orgId: Coframe.orgId,
+                userToken: Coframe.userToken,
+                personalizationHeaders: Coframe.personalizationHeaders,
+            });
+        }
+        else {
+            setTimeout(measureEngagement, ENGAGED_SESSION_THRESHOLD - timeSpent);
+        }
+    }
+    function updateViewedVariants() {
+        for (const variantElement of Coframe.variantsAndElements || []) {
+            const variant = variantElement.variant;
+            if (!experiencedCoframeIds.has(variant.id)) {
+                const elements = document.querySelectorAll(`[coframe-exp-id="${variant.id}"]`);
+                for (const el of Array.from(elements)) {
+                    if (isElementVisible(el)) {
+                        el.setAttribute('coframe-experienced', 'true');
+                        experiencedCoframeIds.add(variant.id);
+                        queueEventForBatchedSending(Coframe, {
+                            type: 'view',
+                            project_id: Coframe.projectId,
+                            session_id: Coframe.sessionId,
+                            experiment_id: variant.experiment_id,
+                            variant_id: variant.id,
+                            time: new Date(),
+                            orgId: Coframe.orgId,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    document.addEventListener('visibilitychange', measureEngagement);
+    setTimeout(measureEngagement, ENGAGED_SESSION_THRESHOLD);
+    document.addEventListener('coframe:dom-renderer:complete', updateViewedVariants);
+    document.addEventListener('scroll', updateViewedVariants);
+    document.dispatchEvent(new CustomEvent('coframe:dom-renderer:complete', {}));
+    document.addEventListener('click', (event) => {
+        sendPageEngagementEvent(Coframe, 'click', event, {
+            projectId: Coframe.projectId,
+            isEngaged,
+            sessionId: Coframe.sessionId,
+            orgId: Coframe.orgId,
+            userToken: Coframe.userToken,
+            personalizationHeaders: Coframe.personalizationHeaders,
+        });
+    }, true);
+    const handleEventFlush = debounce((eventType) => {
+        queueEvent(Coframe, {
+            projectId: Coframe.projectId,
+            sessionId: Coframe.sessionId,
+            eventType: eventType,
+            orgId: Coframe.orgId,
+            userToken: Coframe.userToken,
+            personalizationHeaders: Coframe.personalizationHeaders,
+        });
+        flushQueuedEvents(Coframe.projectId);
+    }, 1);
+    window.addEventListener('beforeunload', () => handleEventFlush('before_unload'));
+    window.addEventListener('pagehide', () => handleEventFlush('page_hide'));
+    window.addEventListener('visibilitychange', () => {
+        const isPageHidden = document.hidden;
+        const eventType = isPageHidden ? 'tab_hide' : 'tab_show';
+        handleEventFlush(eventType);
+    });
+}
+function setupTracking(Coframe, projectResult, previewVariantId, executionStartTime, nonce, waitForCookiesEnabled, onConsentChange) {
+    var _a, _b;
+    const logger = Coframe.logger;
+    const { project } = projectResult;
+    setTrackOnlyActivatedFrames(!!((_a = project === null || project === void 0 ? void 0 : project.settings) === null || _a === void 0 ? void 0 : _a.track_only_activated_frames));
+    const analytics = createTreatmentAnalytics(Coframe, previewVariantId);
+    setupListeners(Coframe, executionStartTime);
+    const managedAnalyticsCallback = (_b = project === null || project === void 0 ? void 0 : project.settings) === null || _b === void 0 ? void 0 : _b.analytics_callback;
+    if (managedAnalyticsCallback === null || managedAnalyticsCallback === void 0 ? void 0 : managedAnalyticsCallback.callback) {
+        try {
+            const cfg = executeJs(`function() { return (${managedAnalyticsCallback.callback.trim()}); }`, {}, { isExpression: true, nonce });
+            analytics.registerCallbacks(cfg);
+        }
+        catch (_e) {
+            logger.error('Failed to evaluate managed analytics callback', 'managed_callback_eval_error');
+        }
+    }
+    else {
+        waitForCmd((cmd) => !!(cmd.subscribe === 'treatmentApplied'), Coframe).then((cmd) => {
+            if (cmd) {
+                if (!cmd.callback &&
+                    !cmd.bulkCallback &&
+                    !cmd.bulkCallbackV2 &&
+                    !cmd.bulkCallbackV2WithoutConsent) {
+                    logger.warn('treatmentApplied callback is not set, skipping', 'treatment_applied_callback_not_set');
+                    return;
+                }
+                analytics.registerCallbacks(cmd);
+            }
+        });
+    }
+    if (waitForCookiesEnabled) {
+        onConsentChange === null || onConsentChange === void 0 ? void 0 : onConsentChange((enabled) => {
+            if (enabled) {
+                flushQueuedEvents(Coframe.projectId);
+                analytics.sendAnalytics();
+            }
+        });
+    }
+    return analytics;
+}
+
+async function awaitHydration(config, Coframe) {
+    if (!config.waitForHydration)
+        return true;
+    const cmd = await waitForCmd((cmd) => cmd.pageHydrated === true || cmd.emit === 'pageHydrated', Coframe);
+    if (!cmd) {
+        Coframe.logger.warn('Failed to wait for page hydrated command', 'wait_for_cmd_timeout');
+        return false;
+    }
+    return true;
+}
+async function ensureBody(Coframe, cdnProject, timeoutMs, nonce) {
+    const bodyPresent = await waitForBody(timeoutMs).catch(() => false);
+    if (!bodyPresent) {
+        Coframe.logger.error('Timeout waiting for document.body, exiting gracefully', 'body_timeout');
+        variantRendered();
+        return false;
+    }
+    rebindMetrics(Coframe, Coframe.logger, cdnProject === null || cdnProject === void 0 ? void 0 : cdnProject.metrics, nonce);
+    return true;
+}
+const FLUSH_EVENTS_TIME = 1000 * 3;
+let flushInterval = null;
+function setupFlushInterval(projectId) {
+    flushQueuedEvents(projectId);
+    if (flushInterval !== null) {
+        clearInterval(flushInterval);
+    }
+    flushInterval = setInterval(() => flushQueuedEvents(projectId), FLUSH_EVENTS_TIME);
+}
+function setupSPANavigation(Coframe, project, config, applyVariants) {
+    var _a;
+    if (!((_a = project === null || project === void 0 ? void 0 : project.settings) === null || _a === void 0 ? void 0 : _a.mutation_observer_active))
+        return;
+    const infiniteLoopProtectionMax = 5000;
+    let infiniteLoopProtection = 0;
+    const rebindMetricsOnChildListChange = debounce(() => {
+        rebindMetrics(Coframe, Coframe.logger, project === null || project === void 0 ? void 0 : project.metrics, config.nonce);
+    }, 100);
+    const mutationCallback = (mutations) => {
+        infiniteLoopProtection++;
+        if (infiniteLoopProtection >= infiniteLoopProtectionMax) {
+            Coframe.logger.error('Mutation callback infinite loop protection triggered, disconnecting mutation observer', 'mutation_observer_loop_protection', mutations);
+            observer.disconnect();
+            return;
+        }
+        for (const mutation of mutations) {
+            if (mutation.type === 'childList') {
+                rebindMetricsOnChildListChange();
+            }
+        }
+    };
+    const observer = new MutationObserver(mutationCallback);
+    observer.observe(document.body, { childList: true, subtree: true });
+    let navigationAbortController = null;
+    observeUrlChanges(false, async (newPageUrl, _oldPageUrl) => {
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        infiniteLoopProtection = 0;
+        if (navigationAbortController)
+            navigationAbortController.abort();
+        navigationAbortController = new AbortController();
+        const { signal } = navigationAbortController;
+        let pageProject = project;
+        const cached = getCachedFrames(newPageUrl);
+        if (cached) {
+            pageProject = cached.project;
+        }
+        else {
+            try {
+                const result = await fetchProjectFromEdge(Coframe.projectId, newPageUrl, signal, config.userContext);
+                if (signal.aborted)
+                    return;
+                if (result) {
+                    pageProject = result.project;
+                    cacheFrames(newPageUrl, result);
+                }
+            }
+            catch (_a) {
+            }
+        }
+        if (signal.aborted)
+            return;
+        await applyVariants(newPageUrl, pageProject);
+    });
+}
+function readLaneClaims() {
+    const cookie = getCookie(LANE_COOKIE_KEY);
+    if (cookie) {
+        try {
+            return parseClaims(decodeURIComponent(cookie));
+        }
+        catch (_a) {
+            return parseClaims(cookie);
+        }
+    }
+    try {
+        return parseClaims(localStorage.getItem(LANE_COOKIE_KEY));
+    }
+    catch (_b) {
+        return {};
+    }
+}
+function persistLaneClaims(claims, logger) {
+    const serialized = serializeClaims(claims);
+    try {
+        localStorage.setItem(LANE_COOKIE_KEY, serialized);
+    }
+    catch (_a) {
+    }
+    if (isCookiesEnabled) {
+        setCookie(LANE_COOKIE_KEY, encodeURIComponent(serialized), logger);
+    }
+}
+function createApplyVariants(Coframe, config, previewVariantId, executionStartTime, analytics, personalizationHeaders, laneStore) {
+    return async (pageUrl, pageProject) => {
+        const sessionId = generateUUID();
+        Coframe.sessionId = sessionId;
+        const urlPreviewVariantId = getCurrentUrlSearchParams().get('coframe_variant_id') || null;
+        const updatedPreviewVariantId = urlPreviewVariantId !== previewVariantId
+            ? urlPreviewVariantId
+            : previewVariantId;
+        const { variantsAndElements, experimentsInfo, hasActivatedFrames, laneClaims, } = await getVariantsAndElements(personalizationHeaders, pageProject, updatedPreviewVariantId, Coframe.userToken, pageUrl, getBrowserLanguages(), getBrowserPlatform(), Coframe.logger, config.nonce, laneStore.claims);
+        laneStore.claims = laneClaims;
+        persistLaneClaims(laneClaims, Coframe.logger);
+        Coframe.experimentInfo = experimentsInfo;
+        Coframe.variantsAndElements = variantsAndElements;
+        setFrameActivated(hasActivatedFrames);
+        if (Coframe.debug) {
+            Coframe.debug.project = pageProject;
+            Coframe.debug.frames = pageProject.frames;
+            Coframe.debug.laneClaims = laneClaims;
+        }
+        if (config.trackingOnly) {
+            variantRendered();
+        }
+        else {
+            replaceVariants(variantsAndElements, Coframe.orgId, Coframe.logger, config.nonce);
+        }
+        startSession(Coframe, isCookiesEnabled, executionStartTime, personalizationHeaders);
+        analytics.resetBroadcasted();
+        analytics.sendAnalytics();
+    };
+}
+async function modifyPage(Coframe, configResult, projectResult, analytics) {
+    const { config, timeoutMs, previewVariantId, integrationStartTime, executionStartTime, } = configResult;
+    const { project: cdnProject, personalizationHeaders } = projectResult;
+    if (!(await awaitHydration(config, Coframe)))
+        return;
+    if (cdnProject.tags) {
+        executeTags(cdnProject.tags, Coframe.logger, config.nonce);
+        Coframe.status.tags = cdnProject.tags;
+    }
+    if (!(await ensureBody(Coframe, cdnProject, timeoutMs, config.nonce)))
+        return;
+    const laneStore = { claims: readLaneClaims() };
+    const applyVariants = createApplyVariants(Coframe, config, previewVariantId, executionStartTime, analytics, personalizationHeaders, laneStore);
+    await applyVariants(getCurrentPageUrl(), cdnProject);
+    if (!Coframe.variantsAndElements ||
+        Coframe.variantsAndElements.length === 0) {
+        revealPage();
+        variantRendered();
+    }
+    reportInitTiming(Coframe, cdnProject, integrationStartTime, executionStartTime);
+    setupSPANavigation(Coframe, cdnProject, config, applyVariants);
+    setupFlushInterval(Coframe.projectId);
+}
+
+const TIMEOUT_MAX_MS = 5000;
+function getFeatureFlagValue(cmd) {
+    if (cmd.featureFlagSet !== undefined)
+        return cmd.featureFlagSet;
+    if (typeof cmd.emit === 'object' &&
+        cmd.emit !== null &&
+        'featureFlagSet' in cmd.emit) {
+        return cmd.emit.featureFlagSet;
+    }
+    return undefined;
+}
+async function resolveFeatureFlag(Coframe, timeoutMs) {
+    const cmd = await waitForCmd((cmd) => typeof getFeatureFlagValue(cmd) === 'boolean', Coframe, timeoutMs);
+    if (!cmd)
+        return undefined;
+    return getFeatureFlagValue(cmd);
+}
+async function resolveConfig(Coframe, revealPage) {
+    const logger = Coframe.logger;
+    const configCmd = await waitForCmd((cmd) => !!cmd.config, Coframe);
+    if (!configCmd) {
+        logger.error('Failed to wait for config cmd', 'wait_for_cmd_timeout');
+        return null;
+    }
+    const config = configCmd.config;
+    const timeoutMs = (config === null || config === void 0 ? void 0 : config.timeoutMs)
+        ? Math.min(config.timeoutMs, TIMEOUT_MAX_MS)
+        : TIMEOUT_MAX_MS;
+    const integrationStartTime = (config === null || config === void 0 ? void 0 : config.startTime)
+        ? new Date(config.startTime)
+        : null;
+    const executionStartTime = new Date();
+    Coframe.batchSize = config.batchSize || 32;
+    const gracefulExit = (msg) => {
+        console.warn(`[Coframe] ${msg}`);
+        revealPage();
+        return null;
+    };
+    if (config.waitForFeatureFlag) {
+        const flag = await resolveFeatureFlag(Coframe, timeoutMs);
+        if (flag === undefined) {
+            return gracefulExit('Feature flag was not set after timeout, graceful exit');
+        }
+        if (flag === false) {
+            return gracefulExit('Feature flag is set to false, graceful exit');
+        }
+    }
+    const projectId = config === null || config === void 0 ? void 0 : config.projectId;
+    const warnMissingVariant = () => {
+        if (applyVariantChangesStarted) {
+            logger.warn('Failed to wait for variant rendered command', 'missing_variant_rendered');
+        }
+    };
+    waitForCmd((cmd) => cmd.variantRendered === true || cmd.emit === 'variantRendered', Coframe, timeoutMs)
+        .then((cmd) => {
+        if (!cmd) {
+            warnMissingVariant();
+        }
+    })
+        .finally(() => {
+        revealPage();
+    });
+    if (!projectId) {
+        logger.error('No project ID', 'no_project_id', {
+            description: 'No Coframe Page ID',
+        });
+        variantRendered();
+        return null;
+    }
+    Coframe.projectId = projectId;
+    const urlParams = getCurrentUrlSearchParams();
+    const previewVariantId = urlParams.get('coframe_variant_id');
+    const shouldSendEventsParam = urlParams.get('coframe_should_send_events');
+    setForceSendEvents(shouldSendEventsParam === 'true');
+    setIsPreviewVariant(!!previewVariantId);
+    setWaitingForCookies(!!config.waitForCookiesEnabled);
+    return {
+        config,
+        timeoutMs,
+        projectId,
+        previewVariantId,
+        integrationStartTime,
+        executionStartTime,
+    };
+}
+
+async function resolveIdentity(config, Coframe, timeoutMs, gracefulExit) {
+    const logger = Coframe.logger;
+    let userToken;
+    if (config.waitForUserToken) {
+        const tokenCmd = await waitForCmd((cmd) => !!cmd.setUserToken && typeof cmd.setUserToken === 'string', Coframe, timeoutMs);
+        if (!tokenCmd || !tokenCmd.setUserToken) {
+            gracefulExit('User token was not provided after timeout, graceful exit');
+            return null;
+        }
+        userToken = tokenCmd.setUserToken;
+    }
+    else {
+        userToken = getOrGenerateUserToken();
+    }
+    Coframe.userToken = userToken;
+    const persistCookies = () => {
+        if (config.waitForUserToken)
+            return;
+        setUserTokenCookie(userToken, logger);
+        trackVisitCookie(logger);
+    };
+    const consentListeners = [];
+    const onConsentChange = (cb) => {
+        consentListeners.push(cb);
+        return () => {
+            const idx = consentListeners.indexOf(cb);
+            if (idx !== -1)
+                consentListeners.splice(idx, 1);
+        };
+    };
+    const applyCookieConsent = (enabled) => {
+        if (isCookiesEnabled === enabled) {
+            return;
+        }
+        setCookiesEnabled(enabled);
+        if (enabled) {
+            persistCookies();
+        }
+        for (const cb of consentListeners.slice()) {
+            cb(enabled);
+        }
+    };
+    if (!(config === null || config === void 0 ? void 0 : config.waitForCookiesEnabled)) {
+        applyCookieConsent(true);
+        return { userToken, applyCookieConsent, onConsentChange };
+    }
+    setCookiesEnabled(false);
+    variantRendered();
+    const initial = findLastCmd((cmd) => typeof cmd.cookiesEnabled === 'boolean');
+    if (initial) {
+        applyCookieConsent(!!initial.cookiesEnabled);
+    }
+    subscribeToCmd((cmd) => typeof cmd.cookiesEnabled === 'boolean', (cmd) => applyCookieConsent(!!cmd.cookiesEnabled));
+    return { userToken, applyCookieConsent, onConsentChange };
+}
+
+async function resolveProject(Coframe, previewVariantId, config) {
+    var _a;
+    const logger = Coframe.logger;
+    const projectData = (_a = findLastCmd((c) => !!c.projectData)) === null || _a === void 0 ? void 0 : _a.projectData;
+    let personalizationHeaders = (projectData === null || projectData === void 0 ? void 0 : projectData.personalizationHeaders) || null;
+    let project = projectData === null || projectData === void 0 ? void 0 : projectData.project;
+    if (!project) {
+        const edgeResult = await fetchProjectFromEdge(Coframe.projectId, config.currentUrl || getCurrentPageUrl(), undefined, config.userContext);
+        personalizationHeaders = (edgeResult === null || edgeResult === void 0 ? void 0 : edgeResult.personalizationHeaders) || null;
+        project = (edgeResult === null || edgeResult === void 0 ? void 0 : edgeResult.project) || undefined;
+    }
+    if (!project) {
+        logger.error('No Coframe Project Config', 'no_project_config', {
+            previewVariantId,
+        });
+        variantRendered();
+        return null;
+    }
+    return {
+        project,
+        personalizationHeaders: personalizationHeaders,
+    };
+}
+
+function injectOptions(options) {
+    var _a;
+    if (options.config) {
+        window.CFQ = window.CFQ || [];
+        window.CFQ.push({ config: options.config });
+    }
+    if (options.projectData) {
+        window.CFQ = window.CFQ || [];
+        window.CFQ.push({
+            projectData: {
+                project: options.projectData.project,
+                personalizationHeaders: (_a = options.projectData.personalizationHeaders) !== null && _a !== void 0 ? _a : {},
+            },
+        });
+    }
+}
+
+function push(cmd) {
+    if (typeof window === 'undefined')
+        return;
+    window.CFQ = window.CFQ || [];
+    window.CFQ.push(cmd);
+}
+function setConsent(enabled) {
+    push({ cookiesEnabled: enabled });
+}
+function setUserToken(token) {
+    push({ setUserToken: token });
+}
+function setFeatureFlag(enabled) {
+    push({ featureFlagSet: enabled });
+}
+function setPageHydrated() {
+    push({ pageHydrated: true });
+}
+function trackConversion(payload) {
+    push({ conversion: payload });
+}
+function onTreatmentApplied(handlers) {
+    push({ subscribe: 'treatmentApplied', ...handlers });
+}
+function onLog(cb) {
+    push({ subscribe: 'log', logCallback: cb });
+}
+
+const Coframe = {
+    status: {
+        initialized: false,
+    },
+    projectId: '',
+    orgId: '',
+    variantsAndElements: [],
+    userToken: '',
+    sessionId: generateUUID(),
+    batchSize: 32,
+    treatmentsData: null,
+    treatmentsDataV2: null,
+    experimentInfo: [],
+    logger: {
+        warn: () => { },
+        error: () => { },
+    },
+};
+Coframe.logger = createLogger(() => Coframe);
+async function init(options) {
+    if (options)
+        injectOptions(options);
+    const gracefulExit = (msg) => {
+        console.warn(`[Coframe] ${msg}`);
+        revealPage();
+        return;
+    };
+    const configResult = await resolveConfig(Coframe, revealPage);
+    if (!configResult)
+        return;
+    const projectResult = await resolveProject(Coframe, configResult.previewVariantId, configResult.config);
+    if (!projectResult)
+        return;
+    Coframe.orgId = projectResult.project.org_id || '';
+    Coframe.personalizationHeaders = projectResult.personalizationHeaders;
+    const identity = await resolveIdentity(configResult.config, Coframe, configResult.timeoutMs, gracefulExit);
+    if (!identity)
+        return;
+    const analytics = setupTracking(Coframe, projectResult, configResult.previewVariantId, configResult.executionStartTime, configResult.config.nonce, configResult.config.waitForCookiesEnabled, identity.onConsentChange);
+    await modifyPage(Coframe, configResult, projectResult, analytics);
+}
+Coframe.debug = {
+    getSelector,
+    getElement,
+    getElementUniversal,
+    waitForCmd,
+    flushQueuedEvents: () => {
+        flushQueuedEvents(Coframe.projectId);
+    },
+    queuedEvents,
+    shouldSendEvents,
+    querySelector,
+    logs: [],
+};
+Coframe.init = init;
+if (typeof window !== 'undefined') {
+    window.Coframe = Coframe;
+}
+
+export { init, onLog, onTreatmentApplied, setConsent, setFeatureFlag, setPageHydrated, setUserToken, trackConversion };