TEST 1

        
    try {
        HTMLAnchorElement.prototype.hrefTranslate
        document.getElementById('hrefTranslate').innerText = ' undefined';
    } catch (e) {
        document.getElementById('hrefTranslate').innerText = e.message;
    }
        
    

TEST 2

        
    const platformClientHints = {
    "macOS": 0,
    "Windows": 1,
    }

    const input = document.createElement("input");
    const start = performance.now();

    input.type = "text";
    input.id = "sd1";
    input.value = "bla";
    input.style.visibility = "hidden";

    document.body.appendChild(input);

    const textSelectionDirection = document.querySelector("#sd1");
    const sd = textSelectionDirection.selectionDirection;
    const platform = sd === 'none' ? 0 : 1;
    let clientHints;
    if (!navigator.userAgentData ||
        !navigator.userAgentData.getHighEntropyValues) {
        clientHints = {};
    } else {
        const data = await navigator.userAgentData.getHighEntropyValues(
            ['platform', 'platformVersion', 'architecture', 'bitness', 'model', 'uaFullVersion', 'fullVersionList', 'formFactor', 'wow64'],
        );
        const { mobile } = navigator.userAgentData || {};

        if (!data.mobile) {
            data.mobile = mobile;
        }
        clientHints = Object.keys(data).sort().reduce((acc, key) => {
            acc[key] = data[key];
            return acc;
        }, {});
    }
    const osOsMismatch = platformClientHints[clientHints.platform] !== platform;

    document.getElementById('osmismatch').innerText = osOsMismatch;
        
    

TEST 3

        
    const video = document.createElement('video');
    video.id = 'videoElement';

    const config = [{
        initDataTypes: ['cenc'],
        videoCapabilities: [{
            contentType: 'video/mp4; codecs="avc1.42E01E"',
            robustness: 'SW_SECURE_CRYPTO',
        }]
    }];

    function checkWidevineKeys() {
        if (!navigator.requestMediaKeySystemAccess) {
            document.getElementById('widevine').innerText = false;
            return;
        }

        navigator.requestMediaKeySystemAccess('com.widevine.alpha', config)
            .then(keySystemAccess => {
                return keySystemAccess.createMediaKeys();
            })
            .then(mediaKeys => {
                return video.setMediaKeys(mediaKeys);
            })
            .then(() => {
                document.getElementById('widevine').innerText = true;
            })
            .catch(() => {
                document.getElementById('widevine').innerText = false;
            });
    }

    checkWidevineKeys();
        
    

TEST 4

        
    const getWebGpu = async () => {
        if (!('gpu' in navigator)) {
            return { error: 'Unsupported', finished: true };
        }

        return navigator.gpu.requestAdapter().then(async (adapter) => {
            if (!adapter) {
                return { error: 'Unsupported', finished: true };
            }
            const device = await adapter.requestDevice();
            const deviceLimits = device.limits;
            const { limits = {} } = adapter || {};
            const adapterLimits = ((limits) => {
                const data = {};
                for (const prop in limits) {
                    data[prop] = limits[prop];
                }
                return data;
            })(limits);
            let diffs = 0;
            for (let i in deviceLimits) {
                if (deviceLimits[i] !== adapterLimits[i]) {
                    diffs++
                }
            }
            return diffs;
        });
    };

    getWebGpu().then(data => {
        document.getElementById('gpu').style.background = data === 17 ? 'green' : 'red';
        document.getElementById('gpu').innerText = data;
    });
        
    

TEST 5

        
    const ext = {
        ghbmnnjooekpmoecnnnilnnbdlolhkhi: {
            name: 'Google Docs Offline',
            file: 'page_embed_script.js',
        },
    }

    const getInstalledExtensions = async function () {
        const keys = Object.keys(ext)
            , installedExtensions = []
            , promises = Array.from({
            length: 1,
        }, () => async function () {
            for (; 0 < keys.length;) {
                const extension = keys.shift();
                try {
                    await fetch(`chrome-extension://${extension}/` + ext[extension].file),
                        installedExtensions.push(extension);
                } catch (e) {
                }
            }
        }());
        await Promise.all(promises);
        document.getElementById('extension').innerText = !!installedExtensions.length;
        document.getElementById('extension').style.background = !!installedExtensions.length ? 'green' : 'red';
    };

    getInstalledExtensions();
        
    

TEST 6

        
    import testMaxUniformBlockAndBindings from './maxBindings.js';
    import testMaxFragmentUniformBlocks from './maxFragmentUniformBlocks.js';
    import testMaxVaryingComponents from './maxVaryingComponents.js';
    import testMaxVaryingVectors from './maxVaryingVectors.js';
    import testMaxVertexUniformBlocks from './maxVertexUniformBlocks.js';

    const runLoadTests = async () => {
        return new Promise(resolve => {
            const w_2 = testMaxUniformBlockAndBindings();
            const w_3 = testMaxFragmentUniformBlocks();
            const w_4 = testMaxVaryingComponents();
            const w_5 = testMaxVaryingVectors();
            const w_7 = testMaxVertexUniformBlocks();
            const result = [w_2, w_3, w_4, w_5, w_7];
            console.log('result load: ', result);
            const fake = result.some(i => i.error);
            resolve(fake);
        })
    }

    runLoadTests();