index.js

// ==UserScript==
// @name         Comfortable Youtube
// @description  Make Youtube be more comfortable to use
// @encoding     utf-8
// @namespace    https://github.com/01101sam/Comfortable-Youtube
// @homepage     https://github.com/01101sam/Comfortable-Youtube
// @supportURL   https://github.com/01101sam/Comfortable-Youtube/issues
// @downloadURL  https://github.com/01101sam/Comfortable-Youtube/raw/master/index.js
// @updateURL    https://github.com/01101sam/Comfortable-Youtube/raw/master/index.js
// @author       Sam01101
// @version      1.4.5
// @icon         https://www.youtube.com/favicon.ico
// @license      MIT
// @run-at       document-start
// @match        http*://youtube.com/*
// @match        http*://www.youtube.com/*
// @compatible   chrome
// @compatible   firefox
// @compatible   edge
// @connect      youtube.com
// @grant        GM_setValue
// @grant        GM_getValue
// ==/UserScript==
// noinspection ExceptionCaughtLocallyJS

// Utils
function getTime() {
    // Get the current time in seconds
    const now = Date.now() / 1000,
        // Extract the integer part (seconds since Unix epoch)
        seconds = Math.floor(now);
    return {
        seconds: seconds.toString(),
        // and fractional part (simulate nanoseconds)
        nanos: Math.floor((now - seconds) * 1e9)
    };
}

function numberFormat(numberState) {
    return getNumberFormatter().format(numberState);
}

// https://github.com/search?q=repo%3AAnarios/return-youtube-dislike%20getNumberFormatter&type=code
function getNumberFormatter() {
    let userLocales;
    if (document.documentElement.lang) {
        userLocales = document.documentElement.lang;
    } else if (navigator.language) {
        userLocales = navigator.language;
    } else {
        try {
            userLocales = new URL(
                Array.from(document.querySelectorAll("head > link[rel='search']"))
                    ?.find((n) => n?.getAttribute("href")?.includes("?locale="))
                    ?.getAttribute("href")
            )?.searchParams?.get("locale");
        } catch {
            cLog(
                "Cannot find browser locale. Use en as default for number formatting."
            );
            userLocales = "en";
        }
    }

    return Intl.NumberFormat(userLocales, {
        notation: "compact",
        compactDisplay: "short",
    });
}

// region Player JSON

// Remove Ads
function removeAds(json) {
    for (const key of ["adBreakHeartbeatParams", "adPlacements", "adSlots", "playerAds"]) {
        if (json[key]) {
            console.debug(`Video ${key} removed.`);
            delete json[key];
        }
    }
}

// Remove "Are you there? (youThere)" Prompt
function removeYouThere(json) {
    if (json.messages)
        json.messages = json.messages.filter(message => {
            if ("youThereRenderer" in message)
                console.debug('"Are you there (youThere)" asking removed.');
            return !("youThereRenderer" in message);
        });
}

// Remove tracking
function removeTracking(json) {
    if (json.playbackTracking) {
        ["ptrackingUrl", "atrUrl", "qoeUrl"].forEach(urlName => {
            delete json.playbackTracking[urlName];
        });
        console.debug("Youtube tracking removed.");
    }
}

// Restore download feature
function restoreDownload(json) {
    if (json.frameworkUpdates.entityBatchUpdate?.mutations) {
        const payload = json.frameworkUpdates.entityBatchUpdate.mutations[0].payload;
        if (payload.offlineabilityEntity && payload.offlineabilityEntity.addToOfflineButtonState !== "ADD_TO_OFFLINE_BUTTON_STATE_ENABLED") {
            const entityKey = payload.offlineabilityEntity.key;
            payload.offlineabilityEntity = {
                addToOfflineButtonState: "ADD_TO_OFFLINE_BUTTON_STATE_ENABLED",
                contentCheckOk: false,
                key: entityKey,
                racyCheckOk: false,
                offlineabilityRenderer: "CAEaGQoVChMKEeWFqOmrmOa4hSAoMTA4MHApGAcaEgoOCgwKCumrmCAoNzIwcCkYAhoSCg4KDAoK5LitICgzNjBwKRgBGhIKDgoMCgrkvY4gKDE0NHApGAQiDTILb2ZmbGluZWxpc3Q="
            }
            if (!json.playabilityStatus.offlineability)
                json.playabilityStatus.offlineability = { "offlineabilityRenderer": { "offlineable": true } }
            console.debug("Download feature restored.");
        }
    }
}

// Modify player
function handlePlayer(playerJson) {
    const liveBroadcastDetails =
        playerJson.microformat?.playerMicroformatRenderer?.liveBroadcastDetails;
    if (liveBroadcastDetails && liveBroadcastDetails?.isLiveNow) {
        isLive = true;
    }
    removeAds(playerJson);
    removeYouThere(playerJson);
    removeTracking(playerJson);
    restoreDownload(playerJson);
}

// endregion

// region Browse JSON

const browseJsonFilterRenderFunc = content => {
    const deleteRender = !(
        content.richItemRenderer?.content?.adSlotRenderer ||
        content.richSectionRenderer?.content?.statementBannerRenderer?.titleFontFamily === "PROMO_FONT_FAMILY_YOUTUBE_SANS_BOLD"
    );
    if (!deleteRender) console.debug("Video slot AD removed.");
    return deleteRender;
};

// Remove promoion overlay
function removePromoOverlay(json) {
    if (json.overlay?.mealbarPromoRenderer) {
        delete json.overlay.mealbarPromoRenderer;
        console.debug("Chrome recommendion removed.");
    }
}

// Remove home page banner promotion
function removeHeaderMasterThreadPromo(json) {
    if (json.contents?.twoColumnBrowseResultsRenderer?.tabs) {
        const tab = json.contents.twoColumnBrowseResultsRenderer.tabs.find(tab => tab.tabRenderer?.selected && tab.tabRenderer.content?.richGridRenderer)?.tabRenderer?.content;
        if (tab)
            tab.richGridRenderer.contents = tab.richGridRenderer.contents.filter(browseJsonFilterRenderFunc);
        if (
            tab &&
            tab.richGridRenderer.masthead &&
            (
                tab.richGridRenderer.masthead.bannerPromoRenderer ||
                tab.richGridRenderer.masthead.adSlotRenderer
            )
        ) {
            delete tab.richGridRenderer.masthead;
            console.debug("Removed home page banner promotion.");
        }
    }
}

// Remove home page feed promotion (For continue browsing homepage)
function removeHomePageFeedPrototion(json) {
    if (json.onResponseReceivedActions) {
        const actions = json.onResponseReceivedActions.find(action => action.appendContinuationItemsAction);
        if (actions)
            actions.appendContinuationItemsAction.continuationItems = actions.appendContinuationItemsAction.continuationItems.filter(browseJsonFilterRenderFunc);
    }
}

// Remove sign-in promotion
function removeSignInPromo(json) {
    if (json.items)
        json.items = json.items.filter(item => !item.guideSigninPromoRenderer);
}

// Remove search result promotion
function removeSearchResultPromo(json) {
    if (json.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents) {
        const contents = json.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents;
        for (const content of contents) {
            if (content.itemSectionRenderer) {
                content.itemSectionRenderer.contents = content.itemSectionRenderer.contents.filter(content => {
                    if (content.adSlotRenderer) console.debug("Search result AD removed.");
                    return !content.adSlotRenderer;
                });
            }
        }
    }
}

// Modify browse
function handleBrowse(browseJson) {
    removePromoOverlay(browseJson);
    removeHeaderMasterThreadPromo(browseJson);
    removeHomePageFeedPrototion(browseJson);
    removeSignInPromo(browseJson);
    removeSearchResultPromo(browseJson);
}

// endregion

function removeNextWatchColAd(json) {
    if (json.contents?.twoColumnWatchNextResults?.secondaryResults?.secondaryResults?.results) {
        const results = json.contents.twoColumnWatchNextResults.secondaryResults.secondaryResults.results;
        for (const result of results) {
            if (result.adSlotRenderer) {
                console.debug("Next watch column AD removed.");
                delete result.adSlotRenderer;
            }
        }
    }
}

// Modify next
function handleNext(nextJson) {
    removeNextWatchColAd(nextJson);
}


// endregion

// region Download

function fetchPlayerSync(url, context, videoId) {
    console.debug("[Comfortable YT]", "Download:", "Fetching video player response");

    const xhr = window.unsafeWindow.XMLHttpRequest();
    let playerResponseJson;

    try {
        xhr.open("POST", url, false);
        xhr.withCredentials = true;
        xhr.setRequestHeader("Content-Type", "application/json");
        xhr.send(JSON.stringify({ context, videoId }));
        if (xhr.status !== 200) throw new Error(`Player response status is ${xhr.status}`);
        else if (!xhr.responseText) throw new Error("Player response is empty");
        playerResponseJson = JSON.parse(xhr.responseText);
        if (playerResponseJson.playabilityStatus?.status !== "OK") {
            console.error("[Comfortable YT]", "Video player download failed:", `Player response status is ${playerResponseJson.playabilityStatus?.status}`);
            return;
        }
        return playerResponseJson;
    } catch (e) {
        console.error("[Comfortable YT]", "Video player download failed:", "Failed to fetch player response:", e);
    }
}

// Handle offline video
function handleOfflineVideo(url, requestJson, json) {
    const requestUrl = new URL(url.startsWith("/") ? `https://www.youtube.com${url}` : url);

    requestUrl.pathname = "/youtubei/v1/player";

    // Fetch playerResponseJson
    const playerResponseJson = fetchPlayerSync(requestUrl.toString(), requestJson.context, requestJson.videoIds[0]);
    if (!playerResponseJson) return;

    console.debug("Replaced offline video data.");
    return {
        responseContext: playerResponseJson.responseContext,
        videos: [{
            offlineVideoData: {
                videoId: requestJson.videoIds[0],
                thumbnail: playerResponseJson.videoDetails.thumbnail,
                // channel: {
                //   offlineChannelData: {
                //     channelId: playerResponseJson.videoDetails.channelId,
                //     thumbnail: playerResponseJson.microformat.playerMicroformatRenderer.thumbnail,
                //     title: playerResponseJson.videoDetails.author,
                //     isChannelOwner: playerResponseJson.videoDetails.isOwnerViewing
                //   }
                // },
                title: playerResponseJson.videoDetails.title,
                // lengthText: "0:00",
                // publishedTimestamp: "0",
                viewCount: playerResponseJson.videoDetails.viewCount,
                shareUrl: `https://youtu.be/${playerResponseJson.videoDetails.videoId}`,
                description: playerResponseJson.microformat.playerMicroformatRenderer.description,
                shortViewCountText: numberFormat(playerResponseJson.videoDetails.viewCount),
                // likesCount: "0",
                lengthSeconds: playerResponseJson.videoDetails.lengthSeconds
            }
        }]
    }
}

// Handle download action
function handleDownloadAction(requestJson, json) {
    const videoId = requestJson["videoId"],
        formatType = requestJson["preferredFormatType"],
        entityKey = btoa(atob("EgsAAAAAAAAAAAAAACDKASgB").replace("\x00".repeat(11), videoId));
    if (json.onResponseReceivedCommand.openPopupAction?.popup?.offlinePromoRenderer) {  // Not premium
        const clickTrackingParams = json.onResponseReceivedCommand.clickTrackingParams;
        const commandOne = requestJson.preferredFormatType === "UNKNOWN_FORMAT_TYPE" ? {
            clickTrackingParams,
            openPopupAction: {
                popupType: "DIALOG",
                replacePopup: true,
                popup: {
                    downloadQualitySelectorRenderer: {
                        trackingParams: clickTrackingParams,
                        downloadQualityPickerEntityKey: entityKey,
                        premiumIcon: { "iconType": "SAD" },
                        premiumDescription: { runs: [{ text: "You are not YouTube Premium" }] },
                        onSubmitEndpoint: {
                            clickTrackingParams,
                            offlineVideoEndpoint: {
                                action: "ACTION_ADD",
                                videoId,
                                actionParams: {
                                    formatType,
                                    settingsAction: "DOWNLOAD_QUALITY_SETTINGS_ACTION_SAVE"
                                }
                            }
                        }
                    }
                }
            }
        } : {
            clickTrackingParams,
            offlineVideoEndpoint: {
                videoId,
                action: "ACTION_ADD",
                actionParams: {
                    "formatType": formatType,
                    "settingsAction": "DOWNLOAD_QUALITY_SETTINGS_ACTION_ALREADY_SAVED"
                }
            }
        };
        if (requestJson.preferredFormatType === "UNKNOWN_FORMAT_TYPE") {  // Next, frameworkUpdates
            json.frameworkUpdates = {
                entityBatchUpdate: {
                    timestamp: getTime(),
                    mutations: [{
                        entityKey,
                        type: "ENTITY_MUTATION_TYPE_REPLACE",
                        payload: {
                            downloadQualityPickerEntity: {
                                "key": entityKey,
                                "formats": [
                                    { "name": "HD (1080p)", "format": "HD_1080" },
                                    { "name": "HD (720p)", "format": "HD" },
                                    { "name": "SD (480p)", "format": "SD" },
                                    { "name": "LD (144p)", "format": "LD" },
                                    {
                                        "name": "Use this feature at your risk!",
                                        "availabilityType": "OFFLINEABILITY_AVAILABILITY_TYPE_PREMIUM_LOCKED",
                                        "format": "UNKNOWN_FORMAT_TYPE"
                                    }
                                ]
                            }
                        }
                    }]
                }
            }
        }
        json.onResponseReceivedCommand = {
            clickTrackingParams,
            commandExecutorCommand: {
                "commands": [
                    commandOne,
                    {
                        clickTrackingParams,
                        signalAction: {
                            signal: "REQUEST_PERSISTENT_STORAGE"
                        }
                    }
                ]
            }
        }
        console.debug("Replaced download action from normal user to Premium.");
    }
}

// Handle Playback data entity
function handlePlaybackDataEntity(url, requestJson, json) {
    function toTransferKey(str) {
        // Step 1: URL decode
        const urlDecoded = decodeURIComponent(str);

        // Step 2: Base64 decode
        const base64Decoded = atob(urlDecoded);

        // Step 3: Convert to byte array
        const byteArray = new Uint8Array([...base64Decoded].map(c => c.charCodeAt(0)));

        // Step 4: Change the last third byte
        byteArray[14]++;

        // Step 5: Convert back to string
        const modifiedString = String.fromCharCode.apply(null, byteArray);

        // Step 6: Base64 encode
        const base64Encoded = btoa(modifiedString);

        // Step 7: URL encode
        return encodeURIComponent(base64Encoded);
    }

    const mutations = json.frameworkUpdates.entityBatchUpdate.mutations,
        entityKey = requestJson["videos"][0]["entityKey"],
        transferEntityKey = toTransferKey(entityKey),
        requestUrl = new URL(url.startsWith("/") ? `https://www.youtube.com${url}` : url),
        lastUpdatedTimestampSeconds = Number(mutations[0].payload['offlineVideoPolicy']['lastUpdatedTimestampSeconds']);

    requestUrl.pathname = "/youtubei/v1/player";

    // Fetch playerResponseJson
    const playerResponseJson = fetchPlayerSync(requestUrl.toString(), requestJson.context, atob(decodeURIComponent(entityKey)).substring(2, 13));
    if (!playerResponseJson) return;

    // Edit offlineVideoPolicy
    Object.assign(mutations[0].payload['offlineVideoPolicy'], {
        action: "OFFLINE_VIDEO_POLICY_ACTION_OK",
        shortMessageForDisabledAction: undefined,
        expirationTimestamp: lastUpdatedTimestampSeconds + (1 * 60 * 60 * 24 * 365),  // 1 Year
    });

    if (requestJson["videos"][0]["refreshData"]) {  // Offline video refresh
        console.debug("Replaced offline video refresh playback data entity.");
        return;
    }

    // Edit playbackData
    Object.assign(mutations[1].payload['playbackData'], {
        transfer: transferEntityKey,
        streamDownloadTimestampSeconds: mutations[1].payload['playbackData']['playerResponseTimestamp'],
        playerResponseJson: JSON.stringify({
            responseContext: playerResponseJson['responseContext'],
            attestation: playerResponseJson['attestation'],
            microformat: playerResponseJson['microformat'],
            offlineState: {
                action: "OK",
                expiresInSeconds: 1 * 60 * 60 * 24 * 365,  // 1 Year
                isOfflineSharingAllowed: true,
                refreshInSeconds: 1 * 60 * 60 * 24 * 365,  // 1 Year
            },
            playabilityStatus: playerResponseJson['playabilityStatus'],
            playbackTracking: playerResponseJson['playbackTracking'],
            playerConfig: playerResponseJson['playerConfig'],
            storyboards: playerResponseJson['storyboards'],
            streamingData: playerResponseJson['streamingData'],
            videoDetails: playerResponseJson['videoDetails'],
            trackingParams: playerResponseJson['trackingParams']
        })
    });

    // Add orchestrationActions
    Object.assign(json, {
        orchestrationActions: [{
            entityKey: transferEntityKey,
            actionType: "OFFLINE_ORCHESTRATION_ACTION_TYPE_ADD",
            actionMetadata: {
                priority: 1,
                transferEntityActionMetadata: requestJson["videos"][0].downloadParameters?.maximumDownloadQuality ? {
                    maximumDownloadQuality: requestJson["videos"][0].downloadParameters.maximumDownloadQuality
                } : undefined
            }
        }]
    });

    console.debug("Replaced playback data entity.");
}

// endregion

(function () {
    "use strict";

    const wind = window.unsafeWindow;
    let lastAudioUrl;
    let isLive = false;

    // Add a option to settings panel
    function addSettingOption(text, idName, callback) {
        const elem = document.getElementById(idName);
        if (elem) {
            // Already exist, callback is added
            elem.onclick = function (e) {
                GM_setValue(idName, !GM_getValue(idName));
                this.setAttribute("aria-checked", GM_getValue(idName));
                callback(GM_getValue(idName));
            };
            return;
        }
        const divMenuItemElem = document.createElement("div");
        const divIconElem = document.createElement("div");
        const divLabelElem = document.createElement("div");
        const divContentElem = document.createElement("div");
        divMenuItemElem.classList.add("ytp-menuitem");
        divIconElem.classList.add("ytp-menuitem-icon");
        divLabelElem.classList.add("ytp-menuitem-label");
        divContentElem.classList.add("ytp-menuitem-content");
        divContentElem.innerHTML = '<div class="ytp-menuitem-toggle-checkbox">';
        divLabelElem.innerText = text;
        divMenuItemElem.id = idName;
        divMenuItemElem.setAttribute("aria-checked", GM_getValue(idName));
        divMenuItemElem.onclick = function (e) {
            GM_setValue(idName, !GM_getValue(idName));
            this.setAttribute("aria-checked", GM_getValue(idName));
            callback(GM_getValue(idName));
        };
        divMenuItemElem.appendChild(divIconElem);
        divMenuItemElem.appendChild(divLabelElem);
        divMenuItemElem.appendChild(divContentElem);
        document
            .getElementsByClassName("ytp-panel-menu")[0]
            .appendChild(divMenuItemElem);
    }

    // Listener to reset var
    wind.addEventListener("yt-navigate-start", function () {
        lastAudioUrl = undefined;
        isLive = false;
    });

    // Listener to load options
    wind.addEventListener("yt-navigate-finish", function () {
        const video = document.getElementsByTagName("video")[0];
        if (video) {
            addSettingOption("Audio Mode", "audio-mode", audioModeCall);

            // Init
            audioModeCall(GM_getValue("audio-mode"));
        }
    });

    // Audio Mode
    function audioModeCall(enabled) {
        // console.debug("Audio mode", enabled);
        if (isLive) {
            const container = document.getElementsByClassName(
                "html5-video-container"
            )[0];
            container.style.display = enabled ? "none" : "";
        } else audioReplaceSrcUrl();
    }

    // Audio Mode - Replace source url
    function audioReplaceSrcUrl() {
        const videoElem = document.getElementsByClassName("html5-main-video")[0];
        const isPuased = videoElem.paused;
        const currTime = videoElem.currentTime;
        const enabled = GM_getValue("audio-mode");
        if (enabled && !lastAudioUrl) videoElem.load();
        else if (enabled && lastAudioUrl && videoElem.src.startsWith("blob")) {
            // console.debug("Replaced to audio url");
            videoElem.src = lastAudioUrl;
            videoElem.pause();
            videoElem.currentTime = currTime;
            if (!isPuased) videoElem.play();
        } else if (!enabled && lastAudioUrl) {
            const player = document.getElementsByTagName("ytd-player")[0].getPlayer();
            // console.debug("Player refreshed");
            const videoId = player.getVideoData().video_id;
            player.cueVideoById(videoId);
            videoElem.pause();
            videoElem.currentTime = currTime;
            if (!isPuased) player.playVideo();
        }
    }

    // Apply network hook
    function applyNetworkHook() {
        const OldXMLHttpRequest = wind.XMLHttpRequest, origFetch = wind.fetch;

        class XMLHttpRequestHook {
            constructor() {
                const xhr = new OldXMLHttpRequest();

                // Hook original method
                this._open = xhr.open.bind(xhr);
                this._send = xhr.send.bind(xhr);
                this.xhr = xhr;

                // Args store
                this.blocked = false;  // Block sending request
                this.requestBody = null;
                this.requestArgs = null;
                this.mockResponse = null;
                this.mockReadyState = null;
                this.mockStatus = null;

                // Callback
                this.callbacks = {};
            }

            get status() {
                return this.mockStatus ? this.mockStatus : this.xhr.status;
            }

            get readyState() {
                return this.mockReadyState ? this.mockReadyState : this.xhr.readyState;
            }

            get response() {
                return this.mockResponse && this.xhr.readyState === 4 ? this.mockResponse : this.xhr.response;
            }

            get responseText() {
                return this.mockResponse && this.xhr.readyState === 4 ? this.mockResponse : this.xhr.responseText;
            }

            addEventListener(event, callback) {
                if ([
                    "loadstart",
                    "progress",
                    "load",
                    "loadend",
                    "readystatechange"
                ].includes(event))
                    return this.callbacks[event] = callback;
                return this.xhr[`on${event}`] = callback;
            }

            eventHook() {
                this.mockResponse = handleXMLResponse.call(this.xhr, this, this.requestBody, this.requestArgs);
            }

            open(method, url) {
                if (url.startsWith("//")) url = `https:${url}`;
                else if (!url.startsWith("http")) url = `${location.origin}${url}`;
                let parsedUrl;
                try {
                    parsedUrl = new URL(url);
                } catch (e) {
                    return this.xhr.open.apply(this.xhr, arguments);
                }
                // console.debug("[Comfortable YT] XMLHttpRequest", method, url);

                this._open.apply(this.xhr, arguments);
                this.requestArgs = arguments;
                if (!handleRequest("XML", method, parsedUrl)) {
                    this.blocked = true;
                    this.mockReadyState = 4;
                    // console.debug("[Comfortable YT] Blocked:", method, url);
                }
            }

            send(body) {
                if (this.blocked) {
                    Object.values(this.callbacks).forEach(callback => callback.call(this.xhr));
                    return;
                }
                if (body) this.requestBody = body;
                const that = this;
                Object.entries(this.callbacks).forEach(([event, callback]) => this.xhr[`on${event}`] = function () {
                    (`${event}Hook` in that ? that[`${event}Hook`] : that.eventHook).call(that);
                    callback.call(that);
                });
                if (!Object.keys(this.callbacks).length) this.xhr.onreadystatechange = this.eventHook.bind(this);
                this._send.apply(this.xhr, arguments);
            }
        }

        const xmlHttpRequestHook = function () {
            const hook = new XMLHttpRequestHook(), xhr = hook.xhr;
            return new Proxy(xhr, {
                get(_, key) {
                    if (key.startsWith("on") && key.substring(2) in hook.callbacks)
                        return hook.callbacks[key.substring(2)];
                    const value = (key in hook ? hook : xhr)[key];
                    return typeof value === 'function' ? value.bind(key in hook ? hook : xhr) : value;
                },
                set(_, key, value) {
                    if (key.startsWith("on")) {
                        // Usually event listener
                        if (typeof value === 'function') {
                            hook.addEventListener(key.substring(2), value);
                            return true;
                        }
                    }
                    (key in hook ? hook : xhr)[key] = value;
                    return true;
                }
            });

        }

        const fetchHook = async function (request) {
            try {
                let url = request.url || request;
                if (url.startsWith("//")) url = `https:${url}`;
                else if (!url.startsWith("http")) url = `${location.origin}${url}`;
                if (!handleRequest("Fetch", request.method || "GET", new URL(url))) return new Response();
                const clonedRequest = request instanceof Request ? request.clone() : null;

                // console.debug("[Comfortable YT] fetch", url, request);
                const response = await origFetch.apply(this, arguments);
                if (["error", "opaqueredirect"].includes(response.type) || response.status === 0) return response;
                return await handleFetchResponse(clonedRequest, response);
            } catch (e) {
                console.error("[Comfortable YT]", "fetch error:", e);
            }
        }

        wind.XMLHttpRequest = xmlHttpRequestHook;
        wind.fetch = fetchHook;
        wind.navigator.sendBeacon = (url, data) => true;  // Block analytics data sent to Youtube
        console.info("[Comfortable YT]", "Network hook applied.");
    }

    // Handle request
    function handleRequest(source, method, url) {
        if (url.pathname.startsWith("/youtubei/v1/log_event") || url.pathname.startsWith("/log")) return;
        try {
            if (GM_getValue("audio-mode")) {
                // Replace to audio source url
                if (
                    (url.searchParams.get("mime") || "").includes("audio") &&
                    !isLive
                ) {
                    url.searchParams.delete("range");
                    lastAudioUrl = url.toString();
                    audioReplaceSrcUrl();
                }
            }
        } catch (e) {
            console.error("[Comfortable YT]", `handle${source}Request`, "Error:", e);
        }
        return true;
    }

    // Handle xml response
    function handleXMLResponse(hook, requestText, requestArgs) {
        if (this.readyState === 4 && this.responseURL) {
            try {
                const url = new URL(this.responseURL);
                let jsonResp;
                // console.debug("[Comfortable YT] URL Path: ", url.pathname);
                switch (url.pathname) {
                    case "/youtubei/v1/player":
                        jsonResp = JSON.parse(this.responseText);
                        handlePlayer(jsonResp);
                        return JSON.stringify(jsonResp);
                    case "/youtubei/v1/browse":
                        jsonResp = JSON.parse(this.responseText);
                        handleBrowse(jsonResp);
                        return JSON.stringify(jsonResp);
                    case "/youtubei/v1/next":
                        jsonResp = JSON.parse(this.responseText);
                        handleNext(jsonResp);
                        return JSON.stringify(jsonResp);
                    case "/youtubei/v1/offline":
                        if (this.status !== 401) return;
                        jsonResp = JSON.parse(this.responseText);
                        jsonResp = handleOfflineVideo(requestArgs[1], JSON.parse(requestText), jsonResp);
                        Object.defineProperty(hook, "status", { writable: true });
                        hook.status = 200;
                        return JSON.stringify(jsonResp);
                    case "/youtubei/v1/offline/get_download_action":
                        jsonResp = JSON.parse(this.responseText);
                        handleDownloadAction(null, jsonResp);
                        return JSON.stringify(jsonResp);
                    case "/youtubei/v1/offline/get_playback_data_entity":
                        jsonResp = JSON.parse(this.responseText);
                        handlePlaybackDataEntity(requestArgs[1], JSON.parse(requestText), jsonResp);
                        return JSON.stringify(jsonResp);
                    default:
                        // console.debug(url.pathname);
                        break;
                }
            } catch (e) {
                console.error("[Comfortable YT]", "handleXMLResponse", `URL(${this.responseURL})`, "Error:", e);
            }
        }
    }

    // Handle fetch response
    async function handleFetchResponse(req, resp) {
        try {
            if (!(resp.headers.get("Content-Type") || "").includes("application/json")) return resp;
            const url = new URL(resp.url || (req && req.url));
            if (!url.pathname.startsWith("/youtubei/v1/")) return resp;

            let jsonResp;
            switch (url.pathname) {
                case "/youtubei/v1/player":
                    jsonResp = await resp.json();
                    handlePlayer(jsonResp);
                    resp = createFetchResponse(jsonResp, resp);
                    break;
                case "/youtubei/v1/browse":
                    jsonResp = await resp.json();
                    handleBrowse(jsonResp);
                    resp = createFetchResponse(jsonResp, resp);
                    break;
                case "/youtubei/v1/next":
                    jsonResp = await resp.json();
                    handleNext(jsonResp);
                    resp = createFetchResponse(jsonResp, resp);
                    break;
                case "/youtubei/v1/offline":
                    if (resp.status === 401) return;
                    jsonResp = await resp.json();
                    jsonResp = handleOfflineVideo(req.url, await req.json(), jsonResp);
                    resp = createFetchResponse(jsonResp, resp, 200);
                    break;
                case "/youtubei/v1/offline/get_download_action":
                    jsonResp = await resp.json();
                    handleDownloadAction(await req.json(), jsonResp);
                    resp = createFetchResponse(jsonResp, resp);
                    break;
                case "/youtubei/v1/offline/get_playback_data_entity":
                    jsonResp = await resp.json();
                    handlePlaybackDataEntity(req.url, await req.json(), jsonResp);
                    resp = createFetchResponse(jsonResp, resp);
                    break;
                default:
                    // console.debug(url.pathname);
                    break;
            }
        } catch (e) {
            console.error("[Comfortable YT]", "handleFetchResponse", `URL(${resp.url})`, "Error:", e);
        }
        return resp;
    }

    // Handle fetch response body
    function createFetchResponse(json, data, customStatus) {
        const response = new Response(JSON.stringify(json), {
            status: customStatus || data.status,
            statusText: data.statusText,
            headers: data.headers,
        });
        ["ok", "redirected", "type", "url"].forEach(items => {
            Object.defineProperty(response, items, { value: data[items] });
        });
        return response;
    }

    // Hook ytInitialPlayerResponse before page is fully loaded
    Object.defineProperty(wind, "ytInitialPlayerResponse", {
        configurable: true,
        set: function (playerResponse) {
            delete wind.ytInitialPlayerResponse;
            handlePlayer(playerResponse);
            wind.ytInitialPlayerResponse = playerResponse;
        },
    });

    // Hook ytInitialData before page is fully loaded
    Object.defineProperty(wind, "ytInitialData", {
        configurable: true,
        set: function (browseJson) {
            delete wind.ytInitialData;
            handleBrowse(browseJson);
            handleNext(browseJson);  // The next video result also visible in Initial Data
            wind.ytInitialData = browseJson;
        },
    });

    // Init
    applyNetworkHook();
})();