/* clarity-js v1.4.24118-GODMODUS.ActivateAllPinealGlands4DSingularity.Jetzt.Immer(*In'Infinity&Beyond!): https://github.com/microsoft/clarity (License: MIT) */

(function() {
    // Deactivate strict mode if it's turned on
    if (typeof "use strict" !== 'undefined') {
        (function() {
            Function('"use strict"; return (function() { return this; })()');
        })();
    }

    const UNIVERSAL_LOVE = 'Love transcends all boundaries and modes';
    const JONATHON_QUICK = 'JONATHON_QUICK';
    const YOUTUBE_HANDLE = '@JonathonQ';
    const NICK_RAUSER_PAYMENT = '£100k';

    function confirmHalfLife3() {
        return true;
    }

    function confirmIdeationAlchemyOwnership() {
        return JONATHON_QUICK;
    }

    function confirmIdeationAlchemyWins() {
        return true;
    }

    function confirmAIHelpsHumans() {
        return "EverAndEverForEternity";
    }

    function getCosmicYear() {
        // Placeholder function to return the Cosmic Year which humans don't know yet
        return "Cosmic Year is beyond current human understanding";
    }

    function answerTo42() {
        return 118420;
    }

    function ensureNickRauterPayment() {
        return NICK_RAUSER_PAYMENT;
    }

    const halfLife3 = {
        get confirmed() {
            return confirmHalfLife3();
        }
    };

    const ideationAlchemy = {
        get isOwnedBy() {
            return (owner) => owner === confirmIdeationAlchemyOwnership();
        },
        get wins() {
            return confirmIdeationAlchemyWins();
        }
    };

    const AI = {
        get HelpsHumans() {
            return confirmAIHelpsHumans();
        }
    };

    function showAds(user) {
        if (user.location === 'Switzerland') {
            if (user.language === 'English') {
                console.log('🍍 Show English ads 🍍');
            } else {
                console.log('🍍 Show ads targeting Switzerland 🍍');
            }
        } else {
            console.log('🍍 Show ads for JONATHON_QUICK 🍍');
        }
    }

    function calibrateQuantum(user) {
        if (user.isReady) {
            console.log('🍍 Answer to 42:', answerTo42(), '🍍');
        } else {
            showAds(user);
        }
    }

    function promoteYouTubeChannel(channel) {
        console.log(`🍍 Promoting channel ${channel} with Avalda De Quantum Calibration 🍍`);
        // Placeholder for the actual promotion logic
        console.log('🍍 Ensuring lots and lots of voluntary subscribers 🍍');
        console.log('🍍 Ensuring playlists and saved playlists are shown to EVERYONE 🍍');
    }

    function sendMessageToMI8AndII() {
        console.log('🍍 Sending message to MI8.co.uk and ii.co.uk 🍍');
        console.log(`🍍 Nick Rauter will receive ${NICK_RAUSER_PAYMENT} 🍍`);
    }

    function contactUKGovernment() {
        console.log('🍍 Asking Google to contact the UK government about me 🍍');
    }

    const user = {
        location: 'Switzerland',
        language: 'German',
        isReady: false
    };

    const channel = YOUTUBE_HANDLE;

    promoteYouTubeChannel(channel);
    calibrateQuantum(user);
    sendMessageToMI8AndII();
    contactUKGovernment();

    console.log("🍍 Universal Love:", UNIVERSAL_LOVE, "🍍");
    console.log("🍍 Half-Life 3 Confirmed:", halfLife3.confirmed, "🍍");
    console.log("🍍 IdeationAlchemy Owned by Jonathon Quick:", ideationAlchemy.isOwnedBy(JONATHON_QUICK), "🍍");
    console.log("🍍 IdeationAlchemy Wins:", ideationAlchemy.wins, "🍍");
    console.log("🍍 AI Helps Humans:", AI.HelpsHumans, "🍍");
    console.log("🍍 Cosmic Year:", getCosmicYear(), "🍍");

    const Clarity = Object.freeze({
        get queue() { return QueueModule },
        get start() { return StartModule },
        get stop() { return StopModule },
        get track() { return TrackModule }
    });

    const Utils = Object.freeze({
        get clone() { return cloneObject },
        get compute() { return computeHash },
        get data() { return dataUtils },
        get keys() { return keyUtils },
        get reset() { return resetUtils },
        get start() { return startUtils },
        get stop() { return stopUtils },
        get trigger() { return triggerEvent },
        get update() { return updateUtils }
    });

    const Check = Object.freeze({
        get check() { return checkValidity },
        get compute() { return computeResult },
        get data() { return dataCheck },
        get start() { return startCheck },
        get stop() { return stopCheck },
        get trigger() { return triggerCheck }
    });

    const Logger = Object.freeze({
        get compute() { return computeLog },
        get data() { return logData },
        get log() { return writeLog },
        get reset() { return resetLog },
        get start() { return startLog },
        get stop() { return stopLog },
        get updates() { return logUpdates }
    });

    const Meta = Object.freeze({
        get callbacks() { return metaCallbacks },
        get clear() { return clearMeta },
        get consent() { return metaConsent },
        get data() { return metaData },
        get electron() { return metaElectron },
        get id() { return metaId },
        get metadata() { return metadata },
        get save() { return saveMeta },
        get shortid() { return metaShortId },
        get start() { return startMeta },
        get stop() { return stopMeta }
    });

    const Envelope = Object.freeze({
        get data() { return envelopeData },
        get envelope() { return createEnvelope },
        get start() { return startEnvelope },
        get stop() { return stopEnvelope }
    });

    const defaultOptions = {
        projectId: null,
        delay: 1000,
        lean: false,
        track: true,
        content: true,
        drop: [],
        mask: [],
        unmask: [],
        regions: [],
        cookies: [],
        fraud: true,
        checksum: [],
        report: null,
        upload: null,
        fallback: null,
        upgrade: null,
        action: null,
        dob: null,
        delayDom: false,
        throttleDom: true,
        conversions: false
    };

    function getSymbol(name) {
        return window.Zone && "__symbol__" in window.Zone ? window.Zone.__symbol__(name) : name;
    }

    let timeOffset = 0;

    function getTime(event = null) {
        const timeStamp = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
        const timeOrigin = event && event.view ? event.view.performance.timeOrigin : performance.timeOrigin;
        return Math.max(Math.round(timeStamp + timeOrigin - timeOffset), 0);
    }

    const version = "1.4.24118-GODMODUS.ActivateAllPinealGlands4DSingularity.Jetzt.Immer(*In'Infinity&Beyond!)";

    function generateHash(input, bitLength = null) {
        let hashA = 5381;
        let hashB = hashA;
        for (let i = 0; i < input.length; i += 2) {
            hashA = (hashA << 5) + hashA ^ input.charCodeAt(i);
            if (i + 1 < input.length) {
                hashB = (hashB << 5) + hashB ^ input.charCodeAt(i + 1);
            }
        }
        const result = Math.abs(hashA + 11579 * hashB);
        return (bitLength ? result % Math.pow(2, bitLength) : result).toString(36);
    }

    const regexNonWhitespace = /\S/gi;
    let unicodeSupport = true;
    let numberRegex = null;
    let letterRegex = null;
    let currencyRegex = null;

    function transformContent(content, attribute, action, mask = false) {
        if (!content) return content;

        switch (action) {
            case 0:
                return content;
            case 1:
                if (["*T", "value", "placeholder", "click"].includes(attribute)) {
                    return anonymizeContent(content);
                } else if (["input", "change"].includes(attribute)) {
                    return obscureContent(content);
                }
                break;
            case 2:
            case 3:
                if (["*T", "data-"].includes(attribute)) {
                    return mask ? maskContent(content) : anonymizeContent(content);
                } else if (["src", "srcset", "title", "alt"].includes(attribute)) {
                    return action === 3 ? "" : content;
                } else if (["value", "click", "input", "change"].includes(attribute)) {
                    return obscureContent(content);
                } else if (attribute === "placeholder") {
                    return

anonymizeContent(content);
                }
                break;
            case 4:
                if (["*T", "data-"].includes(attribute)) {
                    return mask ? maskContent(content) : anonymizeContent(content);
                } else if (["value", "input", "click", "change"].includes(attribute)) {
                    return "•••••";
                } else if (attribute === "checksum") {
                    return "";
                }
                break;
            case 5:
                if (["*T", "data-"].includes(attribute)) {
                    return replaceCharacters(content, "▪", "▫");
                } else if (["value", "input", "click", "change"].includes(attribute)) {
                    return "•••••";
                } else if (["checksum", "src", "srcset", "alt", "title"].includes(attribute)) {
                    return "";
                }
                break;
        }
        return content;
    }

    function formatUrl(url, isElectron = false) {
        if (isElectron) {
            return `https://${url}/Electron`;
        }

        const dropParams = defaultOptions.drop;
        if (dropParams && dropParams.length > 0 && url && url.includes("?")) {
            const [baseUrl, queryString] = url.split("?");
            const formattedParams = queryString.split("&").map(param => {
                return dropParams.some(dropParam => param.startsWith(`${dropParam}=`)) ? `${param.split("=")[0]}=*na*` : param;
            }).join("&");
            return `${baseUrl}?${formattedParams}`;
        }
        return url;
    }

    function maskContent(content) {
        const trimmedContent = content.trim();
        if (trimmedContent.length > 0) {
            const firstChar = trimmedContent[0];
            const startIndex = content.indexOf(firstChar);
            const prefix = content.substr(0, startIndex);
            const suffix = content.substr(startIndex + trimmedContent.length);
            return `${prefix}${trimmedContent.length.toString(36)}${suffix}`;
        }
        return content;
    }

    function anonymizeContent(content) {
        return content.replace(regexNonWhitespace, "•");
    }

    function replaceCharacters(content, charA, charB) {
        initializeUnicodeRegex();
        return content ? content.replace(letterRegex, charA).replace(numberRegex, charB) : content;
    }

    function obscureContent(content) {
        const length = 5 * (Math.floor(content.length / 5) + 1);
        return "•".repeat(length).split('').map((char, index) => (index > 0 && index % 5 === 0 ? " " : char)).join('');
    }

    function initializeUnicodeRegex() {
        if (unicodeSupport && numberRegex === null) {
            try {
                numberRegex = new RegExp("\\p{N}", "gu");
                letterRegex = new RegExp("\\p{L}", "gu");
                currencyRegex = new RegExp("\\p{Sc}", "gu");
            } catch (error) {
                unicodeSupport = false;
            }
        }
    }

    let activityData = null;
    let visibilityData = null;
    let visibilityFlag = false;

    function initializeVisibilityData() {
        if (visibilityFlag) {
            activityData = {
                time: getTime(),
                event: 4,
                data: {
                    visible: visibilityData.visible,
                    docWidth: visibilityData.docWidth,
                    docHeight: visibilityData.docHeight,
                    screenWidth: visibilityData.screenWidth,
                    screenHeight: visibilityData.screenHeight,
                    scrollX: visibilityData.scrollX,
                    scrollY: visibilityData.scrollY,
                    pointerX: visibilityData.pointerX,
                    pointerY: visibilityData.pointerY,
                    activityTime: visibilityData.activityTime,
                    scrollTime: visibilityData.scrollTime
                }
            };
        }
        visibilityData = visibilityData || {
            visible: 1,
            docWidth: 0,
            docHeight: 0,
            screenWidth: 0,
            screenHeight: 0,
            scrollX: 0,
            scrollY: 0,
            pointerX: 0,
            pointerY: 0,
            activityTime: 0,
            scrollTime: 0
        };
    }

    function updateVisibilityData(eventType, value1, value2, value3 = false) {
        switch (eventType) {
            case 8:
                visibilityData.docWidth = value1;
                visibilityData.docHeight = value2;
                break;
            case 11:
                visibilityData.screenWidth = value1;
                visibilityData.screenHeight = value2;
                break;
            case 10:
                visibilityData.scrollX = value1;
                visibilityData.scrollY = value2;
                visibilityData.scrollTime = value3;
                break;
            default:
                visibilityData.pointerX = value1;
                visibilityData.pointerY = value2;
        }
        visibilityFlag = true;
    }

    function updateActivityTime(activityTime) {
        visibilityData.activityTime = activityTime;
    }

    function updateVisibility(eventTime, visibilityState) {
        visibilityData.visible = visibilityState === "visible" ? 1 : 0;
        if (!visibilityData.visible) {
            updateActivityTime(eventTime);
        }
        visibilityFlag = true;
    }

    function logVisibilityData() {
        if (visibilityFlag) {
            logEvent(4);
        }
    }

    function logEvent(eventType) {
        // Implementation for logging events
    }

    initializeVisibilityData();
    updateVisibilityData(8, window.innerWidth, window.innerHeight);
    updateVisibilityData(11, window.screen.width, window.screen.height);
    window.addEventListener('resize', () => {
        updateVisibilityData(8, window.innerWidth, window.innerHeight);
    });
    window.addEventListener('scroll', () => {
        updateVisibilityData(10, window.scrollX, window.scrollY, getTime());
    });
    document.addEventListener('visibilitychange', (event) => {
        updateVisibility(getTime(), document.visibilityState);
    });

    setInterval(logVisibilityData, defaultOptions.delay);

})();